From 7496ec51b8e43f604865cedaf24712664adbbf2c Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 5 Aug 2003 22:54:23 +0000 Subject: [PATCH] "fix" coding style stuff Change some <>'s into <>'s git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7623 91177308-0d34-0410-b5e6-96231b3b80d8 --- docs/ProgrammersManual.html | 48 ++++++++++++++++++------------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/docs/ProgrammersManual.html b/docs/ProgrammersManual.html index 3536b538105..6c2659876b4 100644 --- a/docs/ProgrammersManual.html +++ b/docs/ProgrammersManual.html @@ -244,7 +244,7 @@ static bool isLoopInvariant(const Value *V, const Loop *L) return true; // Otherwise, it must be an instruction... - return !L->contains(cast<Instruction>(V)->getParent()); + return !L->contains(cast<Instruction>(V)->getParent());

Note that you should not use an isa<> test followed by a @@ -275,7 +275,7 @@ Another common example is:

   // Loop over all of the phi nodes in a basic block
-  BasicBlock::iterator BBI = BB->begin();
+  BasicBlock::iterator BBI = BB->begin();
   for (; PHINode *PN = dyn_cast<PHINode>(BBI); ++BBI)
     cerr << *PN;

@@ -560,7 +560,7 @@ contains: 

   // 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 Instruction class.  This is
 because the indirection operator is overloaded for the iterator
-classes.  In the above code, the expression i->size() is
+classes.  In the above code, the expression i->size() is
 exactly equivalent to (*i).size() just like you'd expect.
 
 
@@ -588,7 +588,7 @@ that prints out each instruction in a BasicBlock:
 
 
   // 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 (Note: Dereferencing an InstIterator yields an
 #include "llvm/Support/InstIterator.h"
 ...
 // 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";
 

 
@@ -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";
 }
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 @@ -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 (CallInst* callInst = dyn_cast<CallInst>(&*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 Users of a particular Value is called a 
 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
 
 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 BasicBlock, and a newly-created instruction
 we wish to insert before *pi, we do the following:
 
 
-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
 

 

 
@@ -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 BasicBlock by doing:
 
-Instruction* pi = ...;
-Instruction* newInst = new Instruction(...);
-pi->getParent()->getInstList().insert(pi, newInst);
+  Instruction *pi = ...;
+  Instruction *newInst = new Instruction(...);
+  pi->getParent()->getInstList().insert(pi, newInst);
 

 In fact, this sequence of steps occurs so frequently that the
 Instruction class and Instruction-derived classes
@@ -1689,11 +1689,11 @@ Important Subclasses of Constant

 
 
  • ConstantArray : This represents a constant array.
 
      
-	
    • const std::vector &getValues() const: Returns a Vecotr of component constants that makeup this array.
+	
    • const std::vector<Use> &getValues() const: Returns a Vecotr of component constants that makeup this array.
 
    
 
  • ConstantStruct : This represents a constant struct.
 
      
-	
    • const std::vector &getValues() const: Returns a Vecotr of component constants that makeup this array.
+	
    • const std::vector<Use> &getValues() const: Returns a Vecotr of component constants that makeup this array.
 
    
 
  • ConstantPointerRef : This represents a constant pointer value that is initialized to point to a global value, which lies at a constant fixed address.
 
      
@@ -1789,6 +1789,6 @@ pointer to the parent Function.
 Chris Lattner
 
 
-Last modified: Fri Aug  1 17:26:10 CDT 2003
+Last modified: Tue Aug  5 17:53:43 CDT 2003