diff options
Diffstat (limited to 'docs')
| -rw-r--r-- | docs/ProgrammersManual.html | 48 |
1 files changed, 24 insertions, 24 deletions
diff --git a/docs/ProgrammersManual.html b/docs/ProgrammersManual.html index 3536b53..6c26598 100644 --- a/docs/ProgrammersManual.html +++ b/docs/ProgrammersManual.html @@ -244,7 +244,7 @@ static bool isLoopInvariant(const <a href="#Value">Value</a> *V, const Loop *L) return true; <i>// Otherwise, it must be an instruction...</i> - return !L->contains(cast<<a href="#Instruction">Instruction</a>>(V)->getParent()); + return !L->contains(cast<<a href="#Instruction">Instruction</a>>(V)->getParent()); </pre><p> Note that you should <b>not</b> use an <tt>isa<></tt> test followed by a @@ -275,7 +275,7 @@ Another common example is:<p> <pre> <i>// Loop over all of the phi nodes in a basic block</i> - BasicBlock::iterator BBI = BB->begin(); + BasicBlock::iterator BBI = BB->begin(); for (; <a href="#PhiNode">PHINode</a> *PN = dyn_cast<<a href="#PHINode">PHINode</a>>(BBI); ++BBI) cerr << *PN; </pre><p> @@ -560,7 +560,7 @@ contains: <pre> // func is a pointer to a Function instance - for(Function::iterator i = func->begin(), e = func->end(); i != e; ++i) { + for (Function::iterator i = func->begin(), e = func->end(); i != e; ++i) { // print out the name of the basic block if it has one, and then the // number of instructions that it contains @@ -573,7 +573,7 @@ contains: Note that i can be used as if it were a pointer for the purposes of invoking member functions of the <tt>Instruction</tt> class. This is because the indirection operator is overloaded for the iterator -classes. In the above code, the expression <tt>i->size()</tt> is +classes. In the above code, the expression <tt>i->size()</tt> is exactly equivalent to <tt>(*i).size()</tt> just like you'd expect. <!-- _______________________________________________________________________ --> @@ -588,7 +588,7 @@ that prints out each instruction in a <tt>BasicBlock</tt>: <pre> // blk is a pointer to a BasicBlock instance - for(BasicBlock::iterator i = blk->begin(), e = blk->end(); i != e; ++i) + for (BasicBlock::iterator i = blk->begin(), e = blk->end(); i != e; ++i) // the next statement works since operator<<(ostream&,...) // is overloaded for Instruction& cerr << *i << "\n"; @@ -625,7 +625,7 @@ stderr (<b>Note:</b> Dereferencing an <tt>InstIterator</tt> yields an #include "<a href="/doxygen/InstIterator_8h-source.html">llvm/Support/InstIterator.h</a>" ... // Suppose F is a ptr to a function -for(inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i) +for (inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i) cerr << **i << "\n"; </pre> @@ -683,7 +683,7 @@ over some structure: void printNextInstruction(Instruction* inst) { BasicBlock::iterator it(inst); ++it; // after this line, it refers to the instruction after *inst. - if(it != inst->getParent()->end()) cerr << *it << "\n"; + if (it != inst->getParent()->end()) cerr << *it << "\n"; } </pre> Of course, this example is strictly pedagogical, because it'd be much @@ -708,7 +708,7 @@ initialize callCounter to zero for each Function f in the Module for each BasicBlock b in f for each Instruction i in b - if(i is a CallInst and calls the given function) + if (i is a CallInst and calls the given function) increment callCounter </pre> @@ -724,14 +724,14 @@ class OurFunctionPass : public FunctionPass { OurFunctionPass(): callCounter(0) { } virtual runOnFunction(Function& F) { - for(Function::iterator b = F.begin(), be = F.end(); b != be; ++b) { - for(BasicBlock::iterator i = b->begin(); ie = b->end(); i != ie; ++i) { + for (Function::iterator b = F.begin(), be = F.end(); b != be; ++b) { + for (BasicBlock::iterator i = b->begin(); ie = b->end(); i != ie; ++i) { if (<a href="#CallInst">CallInst</a>* callInst = <a href="#isa">dyn_cast</a><<a href="#CallInst">CallInst</a>>(&*i)) { // we know we've encountered a call instruction, so we // need to determine if it's a call to the // function pointed to by m_func or not. - if(callInst->getCalledFunction() == targetFunc) + if (callInst->getCalledFunction() == targetFunc) ++callCounter; } } @@ -759,8 +759,8 @@ all <tt>User</tt>s of a particular <tt>Value</tt> is called a <pre> Function* F = ...; -for(Value::use_iterator i = F->use_begin(), e = F->use_end(); i != e; ++i) { - if(Instruction* Inst = dyn_cast<Instruction>(*i)) { +for (Value::use_iterator i = F->use_begin(), e = F->use_end(); i != e; ++i) { + if (Instruction *Inst = dyn_cast<Instruction>(*i)) { cerr << "F is used in instruction:\n"; cerr << *Inst << "\n"; } @@ -778,7 +778,7 @@ to iterate over all of the values that a particular instruction uses <pre> Instruction* pi = ...; -for(User::op_iterator i = pi->op_begin(), e = pi->op_end(); i != e; ++i) { +for (User::op_iterator i = pi->op_begin(), e = pi->op_end(); i != e; ++i) { Value* v = *i; ... } @@ -861,10 +861,10 @@ that <tt>BasicBlock</tt>, and a newly-created instruction we wish to insert before <tt>*pi</tt>, we do the following: <pre> -BasicBlock* pb = ...; -Instruction* pi = ...; -Instruction* newInst = new Instruction(...); -pb->getInstList().insert(pi, newInst); // inserts newInst before pi in pb + BasicBlock *pb = ...; + Instruction *pi = ...; + Instruction *newInst = new Instruction(...); + pb->getInstList().insert(pi, newInst); // inserts newInst before pi in pb </pre> </p> @@ -875,9 +875,9 @@ instruction list: the instruction list of the enclosing basic block. Thus, we could have accomplished the same thing as the above code without being given a <tt>BasicBlock</tt> by doing: <pre> -Instruction* pi = ...; -Instruction* newInst = new Instruction(...); -pi->getParent()->getInstList().insert(pi, newInst); + Instruction *pi = ...; + Instruction *newInst = new Instruction(...); + pi->getParent()->getInstList().insert(pi, newInst); </pre> In fact, this sequence of steps occurs so frequently that the <tt>Instruction</tt> class and <tt>Instruction</tt>-derived classes @@ -1689,11 +1689,11 @@ Important Subclasses of Constant<p> </ul> <li>ConstantArray : This represents a constant array. <ul> - <li><tt>const std::vector<Use> &getValues() const</tt>: Returns a Vecotr of component constants that makeup this array. + <li><tt>const std::vector<Use> &getValues() const</tt>: Returns a Vecotr of component constants that makeup this array. </ul> <li>ConstantStruct : This represents a constant struct. <ul> - <li><tt>const std::vector<Use> &getValues() const</tt>: Returns a Vecotr of component constants that makeup this array. + <li><tt>const std::vector<Use> &getValues() const</tt>: Returns a Vecotr of component constants that makeup this array. </ul> <li>ConstantPointerRef : This represents a constant pointer value that is initialized to point to a global value, which lies at a constant fixed address. <ul> @@ -1789,6 +1789,6 @@ pointer to the parent Function. <a href="mailto:sabre@nondot.org">Chris Lattner</a></address> <!-- Created: Tue Aug 6 15:00:33 CDT 2002 --> <!-- hhmts start --> -Last modified: Fri Aug 1 17:26:10 CDT 2003 +Last modified: Tue Aug 5 17:53:43 CDT 2003 <!-- hhmts end --> </font></body></html> |