6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-29 10:32:47 +00:00
Code Issues Projects Releases Wiki Activity

"fix" coding style stuff

Browse Source 
Change some <>'s into &lt;&gt;'s


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7623 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-08-05 22:54:23 +00:00
parent 5e8b77e375
commit 7496ec51b8
1 changed files with 24 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
docs/ProgrammersManual.html
View File

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