[llvm-commits] [vector_llvm] CVS: llvm/docs/BytecodeFormat.html CFEBuildInstrs.html CodeGenerator.html CommandLine.html ExtendingLLVM.html GettingStarted.html GettingStartedVS.html LangRef.html MakefileGuide.html ProgrammersManual.html Projects.html ReleaseNotes.html TableGenFundamentals.html
Robert Bocchino
bocchino at cs.uiuc.edu
Wed Nov 16 10:31:19 PST 2005
Changes in directory llvm/docs:
BytecodeFormat.html updated: 1.41 -> 1.41.4.1
CFEBuildInstrs.html updated: 1.53 -> 1.53.2.1
CodeGenerator.html updated: 1.27 -> 1.27.2.1
CommandLine.html updated: 1.38 -> 1.38.2.1
ExtendingLLVM.html updated: 1.18 -> 1.18.4.1
GettingStarted.html updated: 1.120 -> 1.120.2.1
GettingStartedVS.html updated: 1.4 -> 1.4.4.1
LangRef.html updated: 1.112.2.1 -> 1.112.2.2
MakefileGuide.html updated: 1.25 -> 1.25.4.1
ProgrammersManual.html updated: 1.87 -> 1.87.2.1
Projects.html updated: 1.18 -> 1.18.4.1
ReleaseNotes.html updated: 1.333 -> 1.333.2.1
TableGenFundamentals.html updated: 1.13 -> 1.13.2.1
---
Log message:
Merged mainline into Vector LLVM branch
---
Diffs of the changes: (+569 -319)
BytecodeFormat.html | 428 +++++++++++++++++++++++++++++++---------------
CFEBuildInstrs.html | 7
CodeGenerator.html | 4
CommandLine.html | 4
ExtendingLLVM.html | 4
GettingStarted.html | 5
GettingStartedVS.html | 31 +--
LangRef.html | 195 ++++++++++++++++----
MakefileGuide.html | 4
ProgrammersManual.html | 70 +++----
Projects.html | 8
ReleaseNotes.html | 122 ++++---------
TableGenFundamentals.html | 6
13 files changed, 569 insertions(+), 319 deletions(-)
Index: llvm/docs/BytecodeFormat.html
diff -u llvm/docs/BytecodeFormat.html:1.41 llvm/docs/BytecodeFormat.html:1.41.4.1
--- llvm/docs/BytecodeFormat.html:1.41 Fri May 13 20:30:15 2005
+++ llvm/docs/BytecodeFormat.html Wed Nov 16 12:31:07 2005
@@ -39,8 +39,8 @@
<li><a href="#constantpool">Global Constant Pool</a></li>
<li><a href="#functiondefs">Function Definition</a></li>
<li><a href="#compactiontable">Compaction Table</a></li>
- <li><a href="#instructionlist">Instruction List</a></li>
- <li><a href="#opcodes">Instruction Opcodes</a></li>
+ <li><a href="#instructionlist">Instructions List</a></li>
+ <li><a href="#instructions">Instructions</a></li>
<li><a href="#symtab">Symbol Table</a></li>
</ol>
</li>
@@ -732,7 +732,7 @@
</table>
<p>
Of particular note, the bytecode format number is simply a 28-bit
-monotonically increase integer that identifies the version of the bytecode
+monotonically increasing integer that identifies the version of the bytecode
format (which is not directly related to the LLVM release number). The
bytecode versions defined so far are (note that this document only
describes the latest version, 1.3):</p>
@@ -740,7 +740,9 @@
<li>#0: LLVM 1.0 & 1.1</li>
<li>#1: LLVM 1.2</li>
<li>#2: LLVM 1.2.5 (not released)</li>
- <li>#3: LLVM 1.3<br>
+ <li>#3: LLVM 1.3</li>
+ <li>#4: LLVM 1.3.x (not released)</li>
+ <li>#5: LLVM 1.4, 1.5, 1.6</li>
</li>
</ul>
<p>Note that we plan to eventually expand the target description
@@ -967,22 +969,29 @@
occurring in the module.</td>
</tr>
<tr>
- <td style="vertical-align: top;"><a href="#llist">llist</a>(<a
- href="#string">string</a>)<br>
+ <td><a href="#llist">llist</a>(<a href="#string">string</a>)<br>
</td>
- <td style="vertical-align: top; text-align: left;">A length list
+ <td class="td_left">A length list
of strings that specify the names of the libraries that this module
depends upon.<br>
</td>
</tr>
<tr>
- <td style="vertical-align: top;"><a href="#string">string</a><br>
+ <td><a href="#string">string</a><br>
</td>
- <td style="vertical-align: top; text-align: left;">The target
+ <td class="td_left">The target
triple for the module (blank means no target triple specified, i.e. a
platform independent module).<br>
</td>
</tr>
+ <tr>
+ <td><a href="#llist">llist</a>(<a href="#string">string</a>)<br>
+ </td>
+ <td class="td_left">A length list
+of strings that defines a table of section strings for globals. A global's
+SectionID is an index into this table.<br>
+ </td>
+ </tr>
</tbody>
</table>
</div>
@@ -990,12 +999,16 @@
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection"><a name="globalvar">Global Variable Field</a>
</div>
+
<div class="doc_text">
+
<p>Global variables are written using an <a href="#uint32_vbr">uint32_vbr</a>
-that encodes information about the global variable and a list of the
-constant initializers for the global var, if any.</p>
+that encodes information about the global variable, an optional extension vbr,
+and a an optional initializers for the global var.</p>
+
<p>The table below provides the bit layout of the first <a
href="#uint32_vbr">uint32_vbr</a> that describes the global variable.</p>
+
<table>
<tbody>
<tr>
@@ -1023,8 +1036,65 @@
</tr>
</tbody>
</table>
-<p>The table below provides the format of the constant initializers for
-the global variable field, if it has one.</p>
+
+<p>When the Linkage type is set to 3 (internal) and the initializer field is set
+to 0 (an invalid combination), an extension word follows the first <a
+href="#uint32_vbr">uint32_vbr</a> which encodes the real linkage and init flag,
+and can includes more information:</p>
+
+<table>
+ <tbody>
+ <tr>
+ <th><b>Type</b></th>
+ <th class="td_left"><b>Description</b></th>
+ </tr>
+ <tr>
+ <td><a href="#bit">bit(0)</a></td>
+ <td class="td_left">Has initializer? Indicates the real value of the "Has
+ initializer" field for the global. </td>
+ </tr>
+ <tr>
+ <td><a href="#bit">bit(2-4)</a></td>
+ <td class="td_left">Linkage type: Indicates the real value of the "linkage
+ type" field for the global.</td>
+ </tr>
+ <tr>
+ <td><a href="#bit">bit(4-8)</a></td>
+ <td class="td_left">The log-base-2 of the alignment for the global.</td>
+ </tr>
+ <tr>
+ <td><a href="#bit">bit(9)</a></td>
+ <td class="td_left">If this bit is set, a SectionID follows this vbr.</td>
+ </tr>
+ <tr>
+ <td><a href="#bit">bit(10-31)</a></td>
+ <td class="td_left">Currently unassigned.</td>
+ </tr>
+ </tbody>
+</table>
+
+<p>If the SectionID bit is set above, the following field is included:</p>
+
+<table>
+ <tbody>
+ <tr>
+ <th><b>Type</b></th>
+ <th class="td_left"><b>Description</b></th>
+ </tr>
+ <tr>
+ <td><a href="#uint32_vbr">uint32_vbr</a>
+ </td>
+ <td class="td_left">An optional section ID number, specifying the string
+ to use for the section of the global. This an index (+1) of an entry
+ into the SectionID llist in the <a href="#globalinfo">Module Global
+ Info</a> block. If this value is 0 or not present, the global has an
+ empty section string.</td>
+ </tr>
+ </tbody>
+</table>
+
+<p>If the "Has initializer" field is set, the following field is included:</p>
+
<table>
<tbody>
<tr>
@@ -1032,10 +1102,10 @@
<th class="td_left"><b>Description</b></th>
</tr>
<tr>
- <td>(<a href="#zlist">zlist</a>(<a href="#uint32_vbr">uint32_vbr</a>))?
+ <td><a href="#uint32_vbr">uint32_vbr</a>
</td>
- <td class="td_left">An optional zero-terminated list of value slot
-numbers of the global variable's constant initializer.</td>
+ <td class="td_left">An optional value slot number for the global
+ variable's constant initializer.</td>
</tr>
</tbody>
</table>
@@ -1046,7 +1116,8 @@
</div>
<div class="doc_text">
<p>Functions are written using an <a href="#uint32_vbr">uint32_vbr</a>
-that encodes information about the function and a set of flags.</p>
+that encodes information about the function and a set of flags. If needed,
+an extension word may follow this first field.</p>
<p>The table below provides the bit layout of the <a
href="#uint32_vbr">uint32_vbr</a> that describes the function.</p>
@@ -1060,8 +1131,7 @@
<tr>
<td><a href="#bit">bit(0-3)</a></td>
<td class="td_left">
- Encodes the calling convention number of the function. If this number is
- zero, this field is followed by a vbr indicating the CC#. Otherwise, the
+ Encodes the calling convention number of the function. The
CC number of the function is the value of this field minus one.
</td>
</tr>
@@ -1072,9 +1142,61 @@
Block</a> in the bytecode file for the function.</td>
</tr>
<tr>
- <td><a href="#bit">bit(5-)</a></td>
+ <td><a href="#bit">bit(5-30)</a></td>
<td class="td_left">Type slot number of type for the function.</td>
</tr>
+ <tr>
+ <td><a href="#bit">bit(31)</a></td>
+ <td class="td_left">Indicates whether an extension word follows.</td>
+ </tr>
+ </tbody>
+</table>
+
+<p>If bit(31) is set, an additional <a href="#uint32_vbr">uint32_vbr</a> word
+follows with the following fields:</p>
+
+<table>
+ <tbody>
+ <tr>
+ <th><b>Type</b></th>
+ <th class="td_left"><b>Description</b></th>
+ </tr>
+ <tr>
+ <td><a href="#bit">bit(0-4)</a></td>
+ <td class="td_left">The log-base-2 of the alignment for the function.</td>
+ </tr>
+ <tr>
+ <td><a href="#bit">bit(5-9)</a></td>
+ <td class="td_left">The top nibble of the calling convention.</td>
+ </tr>
+ <tr>
+ <td><a href="#bit">bit(10)</a></td>
+ <td class="td_left">If this bit is set, a SectionID follows this vbr.</td>
+ </tr>
+ <tr>
+ <td><a href="#bit">bit(11-31)</a></td>
+ <td class="td_left">Currently unassigned.</td>
+ </tr>
+ </tbody>
+</table>
+
+<p>If the SectionID bit is set above, the following field is included:</p>
+
+<table>
+ <tbody>
+ <tr>
+ <th><b>Type</b></th>
+ <th class="td_left"><b>Description</b></th>
+ </tr>
+ <tr>
+ <td><a href="#uint32_vbr">uint32_vbr</a>
+ </td>
+ <td class="td_left">An optional section ID number, specifying the string
+ to use for the section of the function. This an index (+1) of an entry
+ into the SectionID llist in the <a href="#globalinfo">Module Global
+ Info</a> block. If this value is 0 or not present, the function has an
+ empty section string.</td>
+ </tr>
</tbody>
</table>
@@ -1361,8 +1483,155 @@
</tbody>
</table>
</div>
+
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsection"><a name="instructions">Instructions</a></div>
+
+<div class="doc_text">
+<p>Instructions are written out one at a time as distinct units. Each
+instruction
+record contains at least an <a href="#opcodes">opcode</a> and a type field,
+and may contain a <a href="#instoperands">list of operands</a> (whose
+interpretation depends on the opcode). Based on the number of operands, the
+<a href="#instencode">instruction is encoded</a> in a
+dense format that tries to encoded each instruction into 32-bits if
+possible. </p>
+</div>
+
<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection"><a name="instruction">Instructions</a></div>
+<div class="doc_subsubsection"><a name="opcodes">Instruction Opcodes</a></div>
+<div class="doc_text">
+ <p>Instructions encode an opcode that identifies the kind of instruction.
+ Opcodes are an enumerated integer value. The specific values used depend on
+ the version of LLVM you're using. The opcode values are defined in the
+ <a href="http://llvm.cs.uiuc.edu/cvsweb/cvsweb.cgi/llvm/include/llvm/Instruction.def">
+ <tt>include/llvm/Instruction.def</tt></a> file. You should check there for the
+ most recent definitions. The table below provides the opcodes defined as of
+ the writing of this document. The table associates each opcode mnemonic with
+ its enumeration value and the bytecode and LLVM version numbers in which the
+ opcode was introduced.</p>
+ <table>
+ <tbody>
+ <tr>
+ <th>Opcode</th>
+ <th>Number</th>
+ <th>Bytecode Version</th>
+ <th>LLVM Version</th>
+ </tr>
+ <tr><td colspan="4"><b>Terminator Instructions</b></td></tr>
+ <tr><td>Ret</td><td>1</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Br</td><td>2</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Switch</td><td>3</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Invoke</td><td>4</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Unwind</td><td>5</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Unreachable</td><td>6</td><td>1</td><td>1.4</td></tr>
+ <tr><td colspan="4"><b>Binary Operators</b></td></tr>
+ <tr><td>Add</td><td>7</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Sub</td><td>8</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Mul</td><td>9</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Div</td><td>10</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Rem</td><td>11</td><td>1</td><td>1.0</td></tr>
+ <tr><td colspan="4"><b>Logical Operators</b></td></tr>
+ <tr><td>And</td><td>12</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Or</td><td>13</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Xor</td><td>14</td><td>1</td><td>1.0</td></tr>
+ <tr><td colspan="4"><b>Binary Comparison Operators</b></td></tr>
+ <tr><td>SetEQ</td><td>15</td><td>1</td><td>1.0</td></tr>
+ <tr><td>SetNE</td><td>16</td><td>1</td><td>1.0</td></tr>
+ <tr><td>SetLE</td><td>17</td><td>1</td><td>1.0</td></tr>
+ <tr><td>SetGE</td><td>18</td><td>1</td><td>1.0</td></tr>
+ <tr><td>SetLT</td><td>19</td><td>1</td><td>1.0</td></tr>
+ <tr><td>SetGT</td><td>20</td><td>1</td><td>1.0</td></tr>
+ <tr><td colspan="4"><b>Memory Operators</b></td></tr>
+ <tr><td>Malloc</td><td>21</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Free</td><td>22</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Alloca</td><td>23</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Load</td><td>24</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Store</td><td>25</td><td>1</td><td>1.0</td></tr>
+ <tr><td>GetElementPtr</td><td>26</td><td>1</td><td>1.0</td></tr>
+ <tr><td colspan="4"><b>Other Operators</b></td></tr>
+ <tr><td>PHI</td><td>27</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Cast</td><td>28</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Call</td><td>29</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Shl</td><td>30</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Shr</td><td>31</td><td>1</td><td>1.0</td></tr>
+ <tr><td>VANext</td><td>32</td><td>1</td><td>1.0</td></tr>
+ <tr><td>VAArg</td><td>33</td><td>1</td><td>1.0</td></tr>
+ <tr><td>Select</td><td>34</td><td>2</td><td>1.2</td></tr>
+ <tr><td colspan="4">
+ <b>Pseudo Instructions<a href="#pi_note">*</a></b>
+ </td></tr>
+ <tr><td>Invoke+CC </td><td>56</td><td>5</td><td>1.5</td></tr>
+ <tr><td>Invoke+FastCC</td><td>57</td><td>5</td><td>1.5</td></tr>
+ <tr><td>Call+CC</td><td>58</td><td>5</td><td>1.5</td></tr>
+ <tr><td>Call+FastCC+TailCall</td><td>59</td><td>5</td><td>1.5</td></tr>
+ <tr><td>Call+FastCC</td><td>60</td><td>5</td><td>1.5</td></tr>
+ <tr><td>Call+CCC+TailCall</td><td>61</td><td>5</td><td>1.5</td></tr>
+ <tr><td>Load+Volatile</td><td>62</td><td>3</td><td>1.3</td></tr>
+ <tr><td>Store+Volatile</td><td>63</td><td>3</td><td>1.3</td></tr>
+ </tbody>
+ </table>
+
+<p><b><a name="pi_note">* Note: </a></b>
+These aren't really opcodes from an LLVM language perspective. They encode
+information into other opcodes without reserving space for that information.
+For example, opcode=63 is a Volatile Store. The opcode for this
+instruction is 25 (Store) but we encode it as 63 to indicate that is a Volatile
+Store. The same is done for the calling conventions and tail calls.
+In each of these entries in range 56-63, the opcode is documented as the base
+opcode (Invoke, Call, Store) plus some set of modifiers, as follows:</p>
+<dl>
+ <dt>CC</dt>
+ <dd>This means an arbitrary calling convention is specified
+ in a VBR that follows the opcode. This is used when the instruction cannot
+ be encoded with one of the more compact forms.
+ </dd>
+ <dt>FastCC</dt>
+ <dd>This indicates that the Call or Invoke is using the FastCC calling
+ convention.</dd>
+ <dt>CCC</dt>
+ <dd>This indicates that the Call or Invoke is using the native "C" calling
+ convention.</dd>
+ <dt>TailCall</dt>
+ <dd>This indicates that the Call has the 'tail' modifier.</dd>
+</dl>
+</div>
+
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection"><a name="instoperands">Instruction
+Operands</a></div>
+
+<div class="doc_text">
+<p>
+Based on the instruction opcode and type, the bytecode format implicitly (to
+save space) specifies the interpretation of the operand list. For most
+instructions, the type of each operand is implicit from the type of the
+instruction itself (e.g. the type of operands of a binary operator must match
+the type of the instruction). As such, the bytecode format generally only
+encodes the value number of the operand, not the type.</p>
+
+<p>In some cases, however, this is not sufficient. This section enumerates
+those cases:</p>
+
+<ul>
+<li>getelementptr: the slot numbers for sequential type indexes are shifted up
+two bits. This allows the low order bits will encode the type of index used,
+as follows: 0=uint, 1=int, 2=ulong, 3=long.</li>
+<li>cast: the result type number is encoded as the second operand.</li>
+<li>alloca/malloc: If the allocation has an explicit alignment, the log2 of the
+ alignment is encoded as the second operand.</li>
+<li>call: If the tail marker and calling convention cannot be <a
+ href="#pi_note">encoded into the opcode</a> of the call, it is passed as an
+ additional operand. The low bit of the operand is a flag indicating whether
+ the call is a tail call. The rest of the bits contain the calling
+ convention number (shifted left by one bit).</li>
+</ul>
+</div>
+
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection"><a name="instencode">Instruction
+Encoding</a></div>
+
<div class="doc_text">
<p>For brevity, instructions are written in one of four formats,
depending on the number of operands to the instruction. Each
@@ -1399,17 +1668,11 @@
<tr>
<td><a href="#uint32_vbr">uint32_vbr</a>+</td>
<td class="td_left">The slot number of the value(s) for the operand(s).
- <sup>1</sup></td>
+ </td>
</tr>
</tbody>
</table>
-Notes:
-<ol>
- <li>Note that if the instruction is a getelementptr and the type of
-the operand is a sequential type (array or pointer) then the slot
-number is shifted up two bits and the low order bits will encode the
-type of index used, as follows: 0=uint, 1=int, 2=ulong, 3=long.</li>
-</ol>
+
<p><b>Instruction Format 1</b></p>
<p>This format encodes the opcode, type and a single operand into a
single <a href="#uint32_vbr">uint32_vbr</a> as follows:</p>
@@ -1428,7 +1691,7 @@
</tr>
<tr>
<td>2-7</td>
- <td><a href="#opcode">opcode</a></td>
+ <td><a href="#instructions">opcode</a></td>
<td class="td_left">Specifies the opcode of the instruction. Note that
the maximum opcode value is 63.</td>
</tr>
@@ -1465,7 +1728,7 @@
</tr>
<tr>
<td>2-7</td>
- <td><a href="#opcodes">opcode</a></td>
+ <td><a href="#instructions">opcode</a></td>
<td class="td_left">Specifies the opcode of the instruction. Note that
the maximum opcode value is 63.</td>
</tr>
@@ -1507,7 +1770,7 @@
</tr>
<tr>
<td>2-7</td>
- <td><a href="#opcodes">opcode</a></td>
+ <td><a href="#instructions">opcode</a></td>
<td class="td_left">Specifies the opcode of the instruction. Note that
the maximum opcode value is 63.</td>
</tr>
@@ -1540,105 +1803,6 @@
</div>
<!-- _______________________________________________________________________ -->
-<div class="doc_subsection"><a name="opcodes">Instruction Opcodes</a></div>
-<div class="doc_text">
- <p>Instructions encode an opcode that identifies the kind of instruction.
- Opcodes are an enumerated integer value. The specific values used depend on
- the version of LLVM you're using. The opcode values are defined in the
- <a href="http://llvm.cs.uiuc.edu/cvsweb/cvsweb.cgi/llvm/include/llvm/Instruction.def">
- <tt>include/llvm/Instruction.def</tt></a> file. You should check there for the
- most recent definitions. The table below provides the opcodes defined as of
- the writing of this document. The table associates each opcode mnemonic with
- its enumeration value and the bytecode and LLVM version numbers in which the
- opcode was introduced.</p>
- <table>
- <tbody>
- <tr>
- <th>Opcode</th>
- <th>Number</th>
- <th>Bytecode Version</th>
- <th>LLVM Version</th>
- </tr>
- <tr><td colspan="4"><b>Terminator Instructions</b></td></tr>
- <tr><td>Ret</td><td>1</td><td>1</td><td>1.0</td></tr>
- <tr><td>Br</td><td>2</td><td>1</td><td>1.0</td></tr>
- <tr><td>Switch</td><td>3</td><td>1</td><td>1.0</td></tr>
- <tr><td>Invoke</td><td>4</td><td>1</td><td>1.0</td></tr>
- <tr><td>Unwind</td><td>5</td><td>1</td><td>1.0</td></tr>
- <tr><td>Unreachable</td><td>6</td><td>1</td><td>1.4</td></tr>
- <tr><td colspan="4"><b>Binary Operators</b></td></tr>
- <tr><td>Add</td><td>7</td><td>1</td><td>1.0</td></tr>
- <tr><td>Sub</td><td>8</td><td>1</td><td>1.0</td></tr>
- <tr><td>Mul</td><td>9</td><td>1</td><td>1.0</td></tr>
- <tr><td>Div</td><td>10</td><td>1</td><td>1.0</td></tr>
- <tr><td>Rem</td><td>11</td><td>1</td><td>1.0</td></tr>
- <tr><td colspan="4"><b>Logical Operators</b></td></tr>
- <tr><td>And</td><td>12</td><td>1</td><td>1.0</td></tr>
- <tr><td>Or</td><td>13</td><td>1</td><td>1.0</td></tr>
- <tr><td>Xor</td><td>14</td><td>1</td><td>1.0</td></tr>
- <tr><td colspan="4"><b>Binary Comparison Operators</b></td></tr>
- <tr><td>SetEQ</td><td>15</td><td>1</td><td>1.0</td></tr>
- <tr><td>SetNE</td><td>16</td><td>1</td><td>1.0</td></tr>
- <tr><td>SetLE</td><td>17</td><td>1</td><td>1.0</td></tr>
- <tr><td>SetGE</td><td>18</td><td>1</td><td>1.0</td></tr>
- <tr><td>SetLT</td><td>19</td><td>1</td><td>1.0</td></tr>
- <tr><td>SetGT</td><td>20</td><td>1</td><td>1.0</td></tr>
- <tr><td colspan="4"><b>Memory Operators</b></td></tr>
- <tr><td>Malloc</td><td>21</td><td>1</td><td>1.0</td></tr>
- <tr><td>Free</td><td>22</td><td>1</td><td>1.0</td></tr>
- <tr><td>Alloca</td><td>23</td><td>1</td><td>1.0</td></tr>
- <tr><td>Load</td><td>24</td><td>1</td><td>1.0</td></tr>
- <tr><td>Store</td><td>25</td><td>1</td><td>1.0</td></tr>
- <tr><td>GetElementPtr</td><td>26</td><td>1</td><td>1.0</td></tr>
- <tr><td colspan="4"><b>Other Operators</b></td></tr>
- <tr><td>PHI</td><td>27</td><td>1</td><td>1.0</td></tr>
- <tr><td>Cast</td><td>28</td><td>1</td><td>1.0</td></tr>
- <tr><td>Call</td><td>29</td><td>1</td><td>1.0</td></tr>
- <tr><td>Shl</td><td>30</td><td>1</td><td>1.0</td></tr>
- <tr><td>Shr</td><td>31</td><td>1</td><td>1.0</td></tr>
- <tr><td>VANext</td><td>32</td><td>1</td><td>1.0</td></tr>
- <tr><td>VAArg</td><td>33</td><td>1</td><td>1.0</td></tr>
- <tr><td>Select</td><td>34</td><td>2</td><td>1.2</td></tr>
- <tr><td colspan="4">
- <b>Pseudo Instructions<a href="#pi_note">*</a></b>
- </td></tr>
- <tr><td>Invoke+CC </td><td>56</td><td>5</td><td>1.5</td></tr>
- <tr><td>Invoke+FastCC</td><td>57</td><td>5</td><td>1.5</td></tr>
- <tr><td>Call+CC</td><td>58</td><td>5</td><td>1.5</td></tr>
- <tr><td>Call+FastCC+TailCall</td><td>59</td><td>5</td><td>1.5</td></tr>
- <tr><td>Call+FastCC</td><td>60</td><td>5</td><td>1.5</td></tr>
- <tr><td>Call+CCC+TailCall</td><td>61</td><td>5</td><td>1.5</td></tr>
- <tr><td>Load+Volatile</td><td>62</td><td>3</td><td>1.3</td></tr>
- <tr><td>Store+Volatile</td><td>63</td><td>3</td><td>1.3</td></tr>
- </tbody>
- </table>
-</div>
-
-<p><b><a name="pi_note">* Note: </a></b>
-These aren't really opcodes from an LLVM language prespeective. They encode
-information into other opcodes without reserving space for that information.
-For example, opcode=63 is a Volatile Store. The opcode for this
-instruction is 25 (Store) but we encode it as 63 to indicate that is a Volatile
-Store. The same is done for the calling conventions and tail calls.
-In each of these entries in range 56-63, the opcode is documented as the base
-opcode (Invoke, Call, Store) plus some set of modifiers, as follows:</p>
-<dl>
- <dt>CC</dt>
- <dd>This means an arbitrary calling convention is specified
- in a VBR that follows the opcode. This is used when the instruction cannot
- be encoded with one of the more compact forms.
- </dd>
- <dt>FastCC</dt>
- <dd>This indicates that the Call or Invoke is using the FastCC calling
- convention.</dd>
- <dt>CCC</dt>
- <dd>This indicates that the Call or Invoke is using the native "C" calling
- convention.</dd>
- <dt>TailCall</dt>
- <dd>This indicates that the Call has the 'tail' modifier.</dd>
-</dl>
-
-<!-- _______________________________________________________________________ -->
<div class="doc_subsection"><a name="symtab">Symbol Table</a> </div>
<div class="doc_text">
<p>A symbol table can be put out in conjunction with a module or a function. A
@@ -1935,7 +2099,7 @@
<a href="mailto:rspencer at x10sys.com">Reid Spencer</a> and <a
href="mailto:sabre at nondot.org">Chris Lattner</a><br>
<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a><br>
-Last modified: $Date: 2005/05/14 01:30:15 $
+Last modified: $Date: 2005/11/16 18:31:07 $
</address>
</body>
</html>
Index: llvm/docs/CFEBuildInstrs.html
diff -u llvm/docs/CFEBuildInstrs.html:1.53 llvm/docs/CFEBuildInstrs.html:1.53.2.1
--- llvm/docs/CFEBuildInstrs.html:1.53 Tue Sep 20 22:56:26 2005
+++ llvm/docs/CFEBuildInstrs.html Wed Nov 16 12:31:07 2005
@@ -68,9 +68,10 @@
and Settings" directory). We welcome patches to fix this issue.
</p>
<p>It has been found that the GCC 3.3.3 compiler provided with recent Cygwin
-versions is incapable of compiling the LLVM CFE correctly. If your Cygwin
+versions is incapable of compiling the LLVM GCC front-end correctly. If your
+Cygwin
installation includes GCC 3.3.3, we <i>strongly</i> recommend that you download
-GCC 3.4.3, build it separately, and use it for compiling LLVM CFE. This has been
+GCC 3.4.3, build it separately, and use it for compiling the LLVM GCC front-end. This has been
shown to work correctly.</p>
<p>Some versions of Cygwin utilize an experimental version of GNU binutils that
will cause the GNU <tt>ld</tt> linker to fail an assertion when linking
@@ -356,7 +357,7 @@
Brian Gaeke<br>
<a href="http://llvm.cs.uiuc.edu">LLVM Compiler Infrastructure</a><br>
- Last modified: $Date: 2005/09/21 03:56:26 $
+ Last modified: $Date: 2005/11/16 18:31:07 $
</address>
</body>
Index: llvm/docs/CodeGenerator.html
diff -u llvm/docs/CodeGenerator.html:1.27 llvm/docs/CodeGenerator.html:1.27.2.1
--- llvm/docs/CodeGenerator.html:1.27 Mon Oct 17 10:19:24 2005
+++ llvm/docs/CodeGenerator.html Wed Nov 16 12:31:07 2005
@@ -1117,7 +1117,7 @@
Selection DAG is destroyed.
</p>
-<p>Note that this phase is logically seperate from the instruction selection
+<p>Note that this phase is logically separate from the instruction selection
phase, but is tied to it closely in the code because it operates on
SelectionDAGs.</p>
@@ -1297,7 +1297,7 @@
<a href="mailto:sabre at nondot.org">Chris Lattner</a><br>
<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a><br>
- Last modified: $Date: 2005/10/17 15:19:24 $
+ Last modified: $Date: 2005/11/16 18:31:07 $
</address>
</body>
Index: llvm/docs/CommandLine.html
diff -u llvm/docs/CommandLine.html:1.38 llvm/docs/CommandLine.html:1.38.2.1
--- llvm/docs/CommandLine.html:1.38 Fri Aug 26 04:25:54 2005
+++ llvm/docs/CommandLine.html Wed Nov 16 12:31:07 2005
@@ -195,7 +195,7 @@
program:</p>
<div class="doc_code"><pre>
- #include "Support/CommandLine.h"
+ #include "llvm/Support/CommandLine.h"
</pre></div>
<p>Additionally, you need to add this as the first line of your main
@@ -1900,7 +1900,7 @@
<a href="mailto:sabre at nondot.org">Chris Lattner</a><br>
<a href="http://llvm.cs.uiuc.edu">LLVM Compiler Infrastructure</a><br>
- Last modified: $Date: 2005/08/26 09:25:54 $
+ Last modified: $Date: 2005/11/16 18:31:07 $
</address>
</body>
Index: llvm/docs/ExtendingLLVM.html
diff -u llvm/docs/ExtendingLLVM.html:1.18 llvm/docs/ExtendingLLVM.html:1.18.4.1
--- llvm/docs/ExtendingLLVM.html:1.18 Tue May 10 22:53:53 2005
+++ llvm/docs/ExtendingLLVM.html Wed Nov 16 12:31:07 2005
@@ -266,7 +266,7 @@
add enum for the new type; add a forward declaration of the type
also</li>
-<li><tt>llvm/include/llvm/DerivedType.h</tt>:
+<li><tt>llvm/include/llvm/DerivedTypes.h</tt>:
add new class to represent new class in the hierarchy; add forward
declaration to the TypeMap value type</li>
@@ -322,7 +322,7 @@
<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a>
<br>
- Last modified: $Date: 2005/05/11 03:53:53 $
+ Last modified: $Date: 2005/11/16 18:31:07 $
</address>
</body>
Index: llvm/docs/GettingStarted.html
diff -u llvm/docs/GettingStarted.html:1.120 llvm/docs/GettingStarted.html:1.120.2.1
--- llvm/docs/GettingStarted.html:1.120 Mon Sep 5 23:07:15 2005
+++ llvm/docs/GettingStarted.html Wed Nov 16 12:31:07 2005
@@ -362,7 +362,7 @@
<tr>
<td><a href="http://www.gnu.org/software/bison/bison.html">Bison</a></td>
- <td>1.35</td>
+ <td>1.28, 1.35, 1.75, or 2.0 (not 1.85)</td>
<td>YACC compiler</td>
</tr>
@@ -661,6 +661,7 @@
labels:</p>
<ul>
+<li>Release 1.6: <b>RELEASE_16</b></li>
<li>Release 1.5: <b>RELEASE_15</b></li>
<li>Release 1.4: <b>RELEASE_14</b></li>
<li>Release 1.3: <b>RELEASE_13</b></li>
@@ -1540,7 +1541,7 @@
<a href="mailto:sabre at nondot.org">Chris Lattner</a><br>
<a href="http://llvm.x10sys.com/rspencer/">Reid Spencer</a><br>
<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a><br>
- Last modified: $Date: 2005/09/06 04:07:15 $
+ Last modified: $Date: 2005/11/16 18:31:07 $
</address>
</body>
</html>
Index: llvm/docs/GettingStartedVS.html
diff -u llvm/docs/GettingStartedVS.html:1.4 llvm/docs/GettingStartedVS.html:1.4.4.1
--- llvm/docs/GettingStartedVS.html:1.4 Mon Mar 7 21:56:50 2005
+++ llvm/docs/GettingStartedVS.html Wed Nov 16 12:31:07 2005
@@ -170,15 +170,10 @@
beta, there are no guarantees and there is no support for it at this time.
It has been reported that VC++ Express also works.</p>
- <p>You will also need several open source packages: bison, flex, and sed.
- These must be installed in <tt>llvm/win32/tools</tt>. These can be found at
- <a href="http://gnuwin32.sourceforge.net">http://gnuwin32.sourceforge.net</a>
- or
- <a href="http://unxutils.sourceforge.net">http://unxutils.sourceforge.net</a>.
- Bison prefers that m4 be in the path. You must add it to the Visual Studio
- configuration under the menu Options -> Projects -> VC++ Directories.
- Alternatively, you can set the environment variable <tt>M4</tt> to point to
- <tt>m4</tt> executable.</p>
+ <p>If you plan to modify any .y or .l files, you will need to have bison
+ and/or flex installed where Visual Studio can find them. Otherwise, you do
+ not need them and the pre-generated files that come with the source tree
+ will be used.</p>
</div>
@@ -279,28 +274,26 @@
<p><b>Note: while you cannot do this step on Windows, you can do it on a
Unix system and transfer <tt>hello.bc</tt> to Windows.</b></p></li>
- <li><p>Run the program. To make sure the program ran, execute the
- following command:</p>
+ <li><p>Run the program using the just-in-time compiler:</p>
<p><tt>% lli hello.bc</tt></p></li>
<li><p>Use the <tt>llvm-dis</tt> utility to take a look at the LLVM assembly
code:</p>
- <p><tt>% llvm-dis < hello.bc | less</tt><p></li>
+ <p><tt>% llvm-dis < hello.bc | more</tt><p></li>
- <li><p>Compile the program to native assembly using the LLC code
- generator:</p>
+ <li><p>Compile the program to C using the LLC code generator:</p>
- <p><tt>% llc hello.bc -o hello.s</tt></p>
+ <p><tt>% llc -march=c hello.bc</tt></p></li>
- <li><p>Assemble the native assembly language file into a program:</p>
+ <li><p>Compile to binary using Microsoft C:</p>
- <p><b>Not currently possible, but eventually will use <tt>NASMW</tt>.</b></p>
+ <p><tt>% cl hello.cbe.c</tt></p></li>
<li><p>Execute the native code program:</p>
- <p><tt>% ./hello.native</tt></p></li>
+ <p><tt>% hello.cbe.exe</tt></p></li>
</ol>
@@ -354,7 +347,7 @@
<a href="mailto:jeffc at jolt-lang.org">Jeff Cohen</a><br>
<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a><br>
- Last modified: $Date: 2005/03/08 03:56:50 $
+ Last modified: $Date: 2005/11/16 18:31:07 $
</address>
</body>
</html>
Index: llvm/docs/LangRef.html
diff -u llvm/docs/LangRef.html:1.112.2.1 llvm/docs/LangRef.html:1.112.2.2
--- llvm/docs/LangRef.html:1.112.2.1 Tue Oct 18 14:21:55 2005
+++ llvm/docs/LangRef.html Wed Nov 16 12:31:07 2005
@@ -138,6 +138,7 @@
<li><a href="#i_frameaddress">'<tt>llvm.frameaddress</tt>' Intrinsic</a></li>
<li><a href="#i_prefetch">'<tt>llvm.prefetch</tt>' Intrinsic</a></li>
<li><a href="#i_pcmarker">'<tt>llvm.pcmarker</tt>' Intrinsic</a></li>
+ <li><a href="#i_readcyclecounter"><tt>llvm.readcyclecounter</tt>' Intrinsic</a></li>
</ol>
</li>
<li><a href="#int_os">Operating System Intrinsics</a>
@@ -505,12 +506,14 @@
<div class="doc_text">
<p>Global variables define regions of memory allocated at compilation time
-instead of run-time. Global variables may optionally be initialized. A
-variable may be defined as a global "constant", which indicates that the
+instead of run-time. Global variables may optionally be initialized, may have
+an explicit section to be placed in, and may
+have an optional explicit alignment specified. A
+variable may be defined as a global "constant," which indicates that the
contents of the variable will <b>never</b> be modified (enabling better
optimization, allowing the global data to be placed in the read-only section of
an executable, etc). Note that variables that need runtime initialization
-cannot be marked "constant", as there is a store to the variable.</p>
+cannot be marked "constant" as there is a store to the variable.</p>
<p>
LLVM explicitly allows <em>declarations</em> of global variables to be marked
@@ -527,6 +530,15 @@
describe a region of memory, and all memory objects in LLVM are
accessed through pointers.</p>
+<p>LLVM allows an explicit section to be specified for globals. If the target
+supports it, it will emit globals to the section specified.</p>
+
+<p>An explicit alignment may be specified for a global. If not present, or if
+the alignment is set to zero, the alignment of the global is set by the target
+to whatever it feels convenient. If an explicit alignment is specified, the
+global is forced to have at least that much alignment. All alignments must be
+a power of 2.</p>
+
</div>
@@ -539,11 +551,12 @@
<p>LLVM function definitions consist of an optional <a href="#linkage">linkage
type</a>, an optional <a href="#callingconv">calling convention</a>, a return
-type, a function name, a (possibly empty) argument list, an opening curly brace,
+type, a function name, a (possibly empty) argument list, an optional section,
+an optional alignment, an opening curly brace,
a list of basic blocks, and a closing curly brace. LLVM function declarations
are defined with the "<tt>declare</tt>" keyword, an optional <a
-href="#callingconv">calling convention</a>, a return type, a function name, and
-a possibly empty list of arguments.</p>
+href="#callingconv">calling convention</a>, a return type, a function name,
+a possibly empty list of arguments, and an optional alignment.</p>
<p>A function definition contains a list of basic blocks, forming the CFG for
the function. Each basic block may optionally start with a label (giving the
@@ -562,6 +575,15 @@
considered different functions, and LLVM will resolve references to each
appropriately.</p>
+<p>LLVM allows an explicit section to be specified for functions. If the target
+supports it, it will emit functions to the section specified.</p>
+
+<p>An explicit alignment may be specified for a function. If not present, or if
+the alignment is set to zero, the alignment of the function is set by the target
+to whatever it feels convenient. If an explicit alignment is specified, the
+function is forced to have at least that much alignment. All alignments must be
+a power of 2.</p>
+
</div>
@@ -732,8 +754,8 @@
</tr>
</table>
-<p>Note that 'variable sized arrays' can be implemented in LLVM With a zero
-length array. Normally accesses past the end of an array are undefined in
+<p>Note that 'variable sized arrays' can be implemented in LLVM with a zero
+length array. Normally, accesses past the end of an array are undefined in
LLVM (e.g. it is illegal to access the 5th element of a 3 element array).
As a special case, however, zero length arrays are recognized to be variable
length. This allows implementation of 'pascal style arrays' with the LLVM
@@ -755,7 +777,7 @@
</p>
<h5>Syntax:</h5>
<pre> <returntype> (<parameter list>)<br></pre>
-<p>Where '<tt><parameter list></tt>' is a comma-separated list of type
+<p>...where '<tt><parameter list></tt>' is a comma-separated list of type
specifiers. Optionally, the parameter list may include a type <tt>...</tt>,
which indicates that the function takes a variable number of arguments.
Variable argument functions can access their arguments with the <a
@@ -1051,7 +1073,7 @@
<dd>The string '<tt>zeroinitializer</tt>' can be used to zero initialize a
value to zero of <em>any</em> type, including scalar and aggregate types.
This is often used to avoid having to print large zero initializers (e.g. for
- large arrays), and is always exactly equivalent to using explicit zero
+ large arrays) and is always exactly equivalent to using explicit zero
initializers.
</dd>
</dl>
@@ -1540,7 +1562,7 @@
<p>This returns the <i>remainder</i> of a division (where the result
has the same sign as the divisor), not the <i>modulus</i> (where the
result has the same sign as the dividend) of a value. For more
-information about the difference, see: <a
+information about the difference, see <a
href="http://mathforum.org/dr.math/problems/anne.4.28.99.html">The
Math Forum</a>.</p>
<h5>Example:</h5>
@@ -1868,98 +1890,157 @@
<result> = shr sbyte -2, ubyte 1 <i>; yields {sbyte}:result = -1</i>
</pre>
</div>
+
<!-- ======================================================================= -->
-<div class="doc_subsection"> <a name="memoryops">Memory Access
-Operations</a></div>
+<div class="doc_subsection">
+ <a name="memoryops">Memory Access Operations</a>
+</div>
+
<div class="doc_text">
+
<p>A key design point of an SSA-based representation is how it
represents memory. In LLVM, no memory locations are in SSA form, which
makes things very simple. This section describes how to read, write,
allocate, and free memory in LLVM.</p>
+
</div>
+
<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection"> <a name="i_malloc">'<tt>malloc</tt>'
-Instruction</a> </div>
+<div class="doc_subsubsection">
+ <a name="i_malloc">'<tt>malloc</tt>' Instruction</a>
+</div>
+
<div class="doc_text">
+
<h5>Syntax:</h5>
-<pre> <result> = malloc <type>, uint <NumElements> <i>; yields {type*}:result</i>
- <result> = malloc <type> <i>; yields {type*}:result</i>
+
+<pre>
+ <result> = malloc <type>[, uint <NumElements>][, align <alignment>] <i>; yields {type*}:result</i>
</pre>
+
<h5>Overview:</h5>
+
<p>The '<tt>malloc</tt>' instruction allocates memory from the system
heap and returns a pointer to it.</p>
+
<h5>Arguments:</h5>
-<p>The '<tt>malloc</tt>' instruction allocates <tt>sizeof(<type>)*NumElements</tt>
+
+<p>The '<tt>malloc</tt>' instruction allocates
+<tt>sizeof(<type>)*NumElements</tt>
bytes of memory from the operating system and returns a pointer of the
-appropriate type to the program. The second form of the instruction is
-a shorter version of the first instruction that defaults to allocating
-one element.</p>
+appropriate type to the program. If "NumElements" is specified, it is the
+number of elements allocated. If an alignment is specified, the value result
+of the allocation is guaranteed to be aligned to at least that boundary. If
+not specified, or if zero, the target can choose to align the allocation on any
+convenient boundary.</p>
+
<p>'<tt>type</tt>' must be a sized type.</p>
+
<h5>Semantics:</h5>
+
<p>Memory is allocated using the system "<tt>malloc</tt>" function, and
a pointer is returned.</p>
+
<h5>Example:</h5>
-<pre> %array = malloc [4 x ubyte ] <i>; yields {[%4 x ubyte]*}:array</i>
- %size = <a
- href="#i_add">add</a> uint 2, 2 <i>; yields {uint}:size = uint 4</i>
+<pre>
+ %array = malloc [4 x ubyte ] <i>; yields {[%4 x ubyte]*}:array</i>
+
+ %size = <a href="#i_add">add</a> uint 2, 2 <i>; yields {uint}:size = uint 4</i>
%array1 = malloc ubyte, uint 4 <i>; yields {ubyte*}:array1</i>
%array2 = malloc [12 x ubyte], uint %size <i>; yields {[12 x ubyte]*}:array2</i>
+ %array3 = malloc int, uint 4, align 1024 <i>; yields {int*}:array3</i>
+ %array4 = malloc int, align 1024 <i>; yields {int*}:array4</i>
</pre>
</div>
+
<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection"> <a name="i_free">'<tt>free</tt>'
-Instruction</a> </div>
+<div class="doc_subsubsection">
+ <a name="i_free">'<tt>free</tt>' Instruction</a>
+</div>
+
<div class="doc_text">
+
<h5>Syntax:</h5>
-<pre> free <type> <value> <i>; yields {void}</i>
+
+<pre>
+ free <type> <value> <i>; yields {void}</i>
</pre>
+
<h5>Overview:</h5>
+
<p>The '<tt>free</tt>' instruction returns memory back to the unused
memory heap to be reallocated in the future.</p>
-<p> </p>
+
<h5>Arguments:</h5>
+
<p>'<tt>value</tt>' shall be a pointer value that points to a value
that was allocated with the '<tt><a href="#i_malloc">malloc</a></tt>'
instruction.</p>
+
<h5>Semantics:</h5>
+
<p>Access to the memory pointed to by the pointer is no longer defined
after this instruction executes.</p>
+
<h5>Example:</h5>
-<pre> %array = <a href="#i_malloc">malloc</a> [4 x ubyte] <i>; yields {[4 x ubyte]*}:array</i>
+
+<pre>
+ %array = <a href="#i_malloc">malloc</a> [4 x ubyte] <i>; yields {[4 x ubyte]*}:array</i>
free [4 x ubyte]* %array
</pre>
</div>
+
<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection"> <a name="i_alloca">'<tt>alloca</tt>'
-Instruction</a> </div>
+<div class="doc_subsubsection">
+ <a name="i_alloca">'<tt>alloca</tt>' Instruction</a>
+</div>
+
<div class="doc_text">
+
<h5>Syntax:</h5>
-<pre> <result> = alloca <type>, uint <NumElements> <i>; yields {type*}:result</i>
- <result> = alloca <type> <i>; yields {type*}:result</i>
+
+<pre>
+ <result> = alloca <type>[, uint <NumElements>][, align <alignment>] <i>; yields {type*}:result</i>
</pre>
+
<h5>Overview:</h5>
+
<p>The '<tt>alloca</tt>' instruction allocates memory on the current
stack frame of the procedure that is live until the current function
returns to its caller.</p>
+
<h5>Arguments:</h5>
+
<p>The '<tt>alloca</tt>' instruction allocates <tt>sizeof(<type>)*NumElements</tt>
bytes of memory on the runtime stack, returning a pointer of the
-appropriate type to the program. The second form of the instruction is
-a shorter version of the first that defaults to allocating one element.</p>
+appropriate type to the program. If "NumElements" is specified, it is the
+number of elements allocated. If an alignment is specified, the value result
+of the allocation is guaranteed to be aligned to at least that boundary. If
+not specified, or if zero, the target can choose to align the allocation on any
+convenient boundary.</p>
+
<p>'<tt>type</tt>' may be any sized type.</p>
+
<h5>Semantics:</h5>
+
<p>Memory is allocated; a pointer is returned. '<tt>alloca</tt>'d
memory is automatically released when the function returns. The '<tt>alloca</tt>'
instruction is commonly used to represent automatic variables that must
have an address available. When the function returns (either with the <tt><a
href="#i_ret">ret</a></tt> or <tt><a href="#i_unwind">unwind</a></tt>
instructions), the memory is reclaimed.</p>
+
<h5>Example:</h5>
-<pre> %ptr = alloca int <i>; yields {int*}:ptr</i>
+
+<pre>
+ %ptr = alloca int <i>; yields {int*}:ptr</i>
%ptr = alloca int, uint 4 <i>; yields {int*}:ptr</i>
+ %ptr = alloca int, uint 4, align 1024 <i>; yields {int*}:ptr</i>
+ %ptr = alloca int, align 1024 <i>; yields {int*}:ptr</i>
</pre>
</div>
+
<!-- _______________________________________________________________________ -->
<div class="doc_subsubsection"> <a name="i_load">'<tt>load</tt>'
Instruction</a> </div>
@@ -2955,7 +3036,7 @@
<p>This instruction takes a <tt>va_list*</tt> value and the type of
the argument. It returns a value of the specified argument type and
-increments the <tt>va_list</tt> to poin to the next argument. Again, the
+increments the <tt>va_list</tt> to point to the next argument. Again, the
actual type of <tt>va_list</tt> is target specific.</p>
<h5>Semantics:</h5>
@@ -3422,8 +3503,8 @@
(PC) in a region of
code to simulators and other tools. The method is target specific, but it is
expected that the marker will use exported symbols to transmit the PC of the marker.
-The marker makes no guaranties that it will remain with any specific instruction
-after optimizations. It is possible that the presense of a marker will inhibit
+The marker makes no guarantees that it will remain with any specific instruction
+after optimizations. It is possible that the presence of a marker will inhibit
optimizations. The intended use is to be inserted after optmizations to allow
correlations of simulation runs.
</p>
@@ -3443,6 +3524,39 @@
</div>
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection">
+ <a name="i_readcyclecounter">'<tt>llvm.readcyclecounter</tt>' Intrinsic</a>
+</div>
+
+<div class="doc_text">
+
+<h5>Syntax:</h5>
+<pre>
+ declare ulong %llvm.readcyclecounter( )
+</pre>
+
+<h5>Overview:</h5>
+
+
+<p>
+The '<tt>llvm.readcyclecounter</tt>' intrinsic provides access to the cycle
+counter register (or similar low latency, high accuracy clocks) on those targets
+that support it. On X86, it should map to RDTSC. On Alpha, it should map to RPCC.
+As the backing counters overflow quickly (on the order of 9 seconds on alpha), this
+should only be used for small timings.
+</p>
+
+<h5>Semantics:</h5>
+
+<p>
+When directly supported, reading the cycle counter should not modify any memory.
+Implementations are allowed to either return a application specific value or a
+system wide value. On backends without support, this is lowered to a constant 0.
+</p>
+
+</div>
+
<!-- ======================================================================= -->
<div class="doc_subsection">
@@ -4020,7 +4134,8 @@
<a href="mailto:sabre at nondot.org">Chris Lattner</a><br>
<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a><br>
- Last modified: $Date: 2005/10/18 19:21:55 $
+
+ Last modified: $Date: 2005/11/16 18:31:07 $
</address>
</body>
</html>
Index: llvm/docs/MakefileGuide.html
diff -u llvm/docs/MakefileGuide.html:1.25 llvm/docs/MakefileGuide.html:1.25.4.1
--- llvm/docs/MakefileGuide.html:1.25 Tue May 10 17:06:14 2005
+++ llvm/docs/MakefileGuide.html Wed Nov 16 12:31:08 2005
@@ -552,7 +552,7 @@
<div class="doc_text">
<p>This utility target, only available when <tt>$(PROJ_OBJ_ROOT)</tt> is not
the same as <tt>$(PROJ_SRC_ROOT)</tt>, will completely clean the
- <tt>$(PROJ_OBJ_ROOT)</tt> directoy by removing its content entirely and
+ <tt>$(PROJ_OBJ_ROOT)</tt> directory by removing its content entirely and
reconfiguring the directory. This returns the <tt>$(PROJ_OBJ_ROOT)</tt>
directory to a completely fresh state. All content in the directory except
configured files and top-level makefiles will be lost.</p>
@@ -999,7 +999,7 @@
<a href="mailto:rspencer at x10sys.com">Reid Spencer</a><br>
<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a><br>
- Last modified: $Date: 2005/05/10 22:06:14 $
+ Last modified: $Date: 2005/11/16 18:31:08 $
</address>
</body>
Index: llvm/docs/ProgrammersManual.html
diff -u llvm/docs/ProgrammersManual.html:1.87 llvm/docs/ProgrammersManual.html:1.87.2.1
--- llvm/docs/ProgrammersManual.html:1.87 Sun Oct 16 20:36:23 2005
+++ llvm/docs/ProgrammersManual.html Wed Nov 16 12:31:08 2005
@@ -28,7 +28,7 @@
<ul>
<li><a href="#isa">The <tt>isa<></tt>, <tt>cast<></tt>
and <tt>dyn_cast<></tt> templates</a> </li>
- <li><a href="#DEBUG">The <tt>DEBUG()</tt> macro & <tt>-debug</tt>
+ <li><a href="#DEBUG">The <tt>DEBUG()</tt> macro and <tt>-debug</tt>
option</a>
<ul>
<li><a href="#DEBUG_TYPE">Fine grained debug info with <tt>DEBUG_TYPE</tt>
@@ -264,7 +264,8 @@
<!-- ======================================================================= -->
<div class="doc_subsection">
- <a name="isa">The isa<>, cast<> and dyn_cast<> templates</a>
+ <a name="isa">The <tt>isa<></tt>, <tt>cast<></tt> and
+ <tt>dyn_cast<></tt> templates</a>
</div>
<div class="doc_text">
@@ -317,44 +318,45 @@
checks to see if the operand is of the specified type, and if so, returns a
pointer to it (this operator does not work with references). If the operand is
not of the correct type, a null pointer is returned. Thus, this works very
- much like the <tt>dynamic_cast</tt> operator in C++, and should be used in the
- same circumstances. Typically, the <tt>dyn_cast<></tt> operator is used
- in an <tt>if</tt> statement or some other flow control statement like this:
+ much like the <tt>dynamic_cast<></tt> operator in C++, and should be
+ used in the same circumstances. Typically, the <tt>dyn_cast<></tt>
+ operator is used in an <tt>if</tt> statement or some other flow control
+ statement like this:
- <pre>
+ <pre>
if (<a href="#AllocationInst">AllocationInst</a> *AI = dyn_cast<<a href="#AllocationInst">AllocationInst</a>>(Val)) {
...
}
- </pre>
+ </pre>
- <p> This form of the <tt>if</tt> statement effectively combines together a
- call to <tt>isa<></tt> and a call to <tt>cast<></tt> into one
- statement, which is very convenient.</p>
-
- <p>Note that the <tt>dyn_cast<></tt> operator, like C++'s
- <tt>dynamic_cast</tt> or Java's <tt>instanceof</tt> operator, can be abused.
- In particular you should not use big chained <tt>if/then/else</tt> blocks to
- check for lots of different variants of classes. If you find yourself
- wanting to do this, it is much cleaner and more efficient to use the
- <tt>InstVisitor</tt> class to dispatch over the instruction type directly.</p>
+ <p>This form of the <tt>if</tt> statement effectively combines together a call
+ to <tt>isa<></tt> and a call to <tt>cast<></tt> into one
+ statement, which is very convenient.</p>
+
+ <p>Note that the <tt>dyn_cast<></tt> operator, like C++'s
+ <tt>dynamic_cast<></tt> or Java's <tt>instanceof</tt> operator, can be
+ abused. In particular, you should not use big chained <tt>if/then/else</tt>
+ blocks to check for lots of different variants of classes. If you find
+ yourself wanting to do this, it is much cleaner and more efficient to use the
+ <tt>InstVisitor</tt> class to dispatch over the instruction type directly.</p>
- </dd>
+ </dd>
- <dt><tt>cast_or_null<></tt>: </dt>
-
- <dd>The <tt>cast_or_null<></tt> operator works just like the
- <tt>cast<></tt> operator, except that it allows for a null pointer as
- an argument (which it then propagates). This can sometimes be useful,
- allowing you to combine several null checks into one.</dd>
-
- <dt><tt>dyn_cast_or_null<></tt>: </dt>
-
- <dd>The <tt>dyn_cast_or_null<></tt> operator works just like the
- <tt>dyn_cast<></tt> operator, except that it allows for a null pointer
- as an argument (which it then propagates). This can sometimes be useful,
- allowing you to combine several null checks into one.</dd>
+ <dt><tt>cast_or_null<></tt>: </dt>
+
+ <dd>The <tt>cast_or_null<></tt> operator works just like the
+ <tt>cast<></tt> operator, except that it allows for a null pointer as an
+ argument (which it then propagates). This can sometimes be useful, allowing
+ you to combine several null checks into one.</dd>
+
+ <dt><tt>dyn_cast_or_null<></tt>: </dt>
+
+ <dd>The <tt>dyn_cast_or_null<></tt> operator works just like the
+ <tt>dyn_cast<></tt> operator, except that it allows for a null pointer
+ as an argument (which it then propagates). This can sometimes be useful,
+ allowing you to combine several null checks into one.</dd>
- </dl>
+</dl>
<p>These five templates can be used with any classes, whether they have a
v-table or not. To add support for these templates, you simply need to add
@@ -366,7 +368,7 @@
<!-- ======================================================================= -->
<div class="doc_subsection">
- <a name="DEBUG">The <tt>DEBUG()</tt> macro & <tt>-debug</tt> option</a>
+ <a name="DEBUG">The <tt>DEBUG()</tt> macro and <tt>-debug</tt> option</a>
</div>
<div class="doc_text">
@@ -2275,7 +2277,7 @@
<a href="mailto:dhurjati at cs.uiuc.edu">Dinakar Dhurjati</a> and
<a href="mailto:sabre at nondot.org">Chris Lattner</a><br>
<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a><br>
- Last modified: $Date: 2005/10/17 01:36:23 $
+ Last modified: $Date: 2005/11/16 18:31:08 $
</address>
</body>
Index: llvm/docs/Projects.html
diff -u llvm/docs/Projects.html:1.18 llvm/docs/Projects.html:1.18.4.1
--- llvm/docs/Projects.html:1.18 Sun Feb 27 19:10:48 2005
+++ llvm/docs/Projects.html Wed Nov 16 12:31:08 2005
@@ -87,6 +87,12 @@
choosing. You can place it anywhere you like. Rename the directory to match
the name of your project.</li>
+<li>
+If you downloaded LLVM using CVS, remove all the directories named CVS (and all
+the files therein) from your project's new source tree. This will keep CVS
+from thinking that your project is inside <tt>llvm/projects/sample</tt>.
+</li>
+
<li>Add your source code and Makefiles to your source tree.</li>
<li>If you want your project to be configured with the <tt>configure</tt> script
@@ -447,7 +453,7 @@
<a href="mailto:criswell at uiuc.edu">John Criswell</a><br>
<a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a>
<br>
- Last modified: $Date: 2005/02/28 01:10:48 $
+ Last modified: $Date: 2005/11/16 18:31:08 $
</address>
</body>
Index: llvm/docs/ReleaseNotes.html
diff -u llvm/docs/ReleaseNotes.html:1.333 llvm/docs/ReleaseNotes.html:1.333.2.1
--- llvm/docs/ReleaseNotes.html:1.333 Tue Jul 12 11:36:24 2005
+++ llvm/docs/ReleaseNotes.html Wed Nov 16 12:31:08 2005
@@ -4,11 +4,11 @@
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link rel="stylesheet" href="llvm.css" type="text/css">
- <title>LLVM 1.6 Release Notes</title>
+ <title>LLVM 1.7cvs Release Notes</title>
</head>
<body>
-<div class="doc_title">LLVM 1.6 Release Notes</div>
+<div class="doc_title">LLVM 1.7 Release Notes</div>
<ol>
<li><a href="#intro">Introduction</a></li>
@@ -20,7 +20,7 @@
</ol>
<div class="doc_author">
- <p>Written by the <a href="http://llvm.cs.uiuc.edu">LLVM Team</a><p>
+ <p>Written by the <a href="http://llvm.org">LLVM Team</a><p>
</div>
<!-- *********************************************************************** -->
@@ -32,15 +32,15 @@
<div class="doc_text">
<p>This document contains the release notes for the LLVM compiler
-infrastructure, release 1.6. Here we describe the status of LLVM, including any
+infrastructure, release 1.7. Here we describe the status of LLVM, including any
known problems and major improvements from the previous release. The most
up-to-date version of this document can be found on the <a
-href="http://llvm.cs.uiuc.edu/releases/1.6/">LLVM 1.6 web site</a>. If you are
+href="http://llvm.org/releases/">LLVM releases web site</a>. If you are
not reading this on the LLVM web pages, you should probably go there because
this document may be updated after the release.</p>
<p>For more information about LLVM, including information about the latest
-release, please check out the <a href="http://llvm.cs.uiuc.edu">main LLVM
+release, please check out the <a href="http://llvm.org/">main LLVM
web site</a>. If you have questions or comments, the <a
href="http://mail.cs.uiuc.edu/mailman/listinfo/llvmdev">LLVM developer's mailing
list</a> is a good place to send them.</p>
@@ -48,7 +48,7 @@
<p>Note that if you are reading this file from CVS or the main LLVM web page,
this document applies to the <i>next</i> release, not the current one. To see
the release notes for the current or previous releases, see the <a
-href="http://llvm.cs.uiuc.edu/releases/">releases page</a>.</p>
+href="http://llvm.org/releases/">releases page</a>.</p>
</div>
@@ -60,53 +60,20 @@
<div class="doc_text">
-<p>This is the seventh public release of the LLVM Compiler Infrastructure.</p>
+<p>This is the seventh public release of the LLVM Compiler Infrastructure. This
+release incorporates a large number of enhancements and additions (primarily in
+the code generator), which combine to improve the quality of the code generated
+by LLVM by up to 30% in some cases. This release is also the first release to
+have first-class support for Mac OS X: all of the major bugs have been shaken
+out and it is now as well supported as Linux on X86.</p>
-<p>LLVM 1.6 is known to correctly compile a wide range of C and C++ programs,
-includes bug fixes for those problems found since the 1.5 release, and includes
-a large number of new features and enhancements, described below.</p>
-
-</div>
-
-<!--=========================================================================-->
-<div class="doc_subsection">
-<a name="newfeatures">New Features in LLVM 1.6</a>
-</div>
-
-<div class="doc_text">
-<h1>
- See <a href="/releases/1.5/docs/ReleaseNotes.html">LLVM 1.5 Release Notes</a>
-</h1>
-<ol>
- <li>The JIT now uses mutexes to protect its internal data structures. This
- allows multi-threaded programs to be run from the JIT or interpreter without
- corruption of the internal data structures. See
- <a href="http://llvm.cs.uiuc.edu/PR418">PR418</a> and
- <a href="http://llvm.cs.uiuc.edu/PR540">PR540</a> for the details.
- </li>
-</ol>
</div>
<!--=========================================================================-->
<div class="doc_subsection">
-<a name="codequality">Code Quality Improvements in LLVM 1.6</a>
+<a name="newfeatures">New Features in LLVM 1.7cvs</a>
</div>
-<!--=========================================================================-->
-<div class="doc_subsection">
-<a name="codequality">Code Generator Improvements in LLVM 1.6</a>
-</div>
-
-<!--=========================================================================-->
-<div class="doc_subsection">
-<a name="bugfix">Significant Bugs Fixed in LLVM 1.6</a>
-</div>
-
-<div class="doc_text">
-<ol>
- <li><a href="http://llvm.cs.uiuc.edu/PR591">[simplify-libcalls] The simplify-libcalls pass generates ill-formed LLVM code</a>.</li>
-</ol>
-</div>
<!-- *********************************************************************** -->
<div class="doc_section">
@@ -124,7 +91,7 @@
<li>Sun UltraSPARC workstations running Solaris 8.</li>
<li>Intel and AMD machines running on Win32 with the Cygwin libraries (limited
support is available for native builds with Visual C++).</li>
-<li>PowerPC-based Mac OS X systems, running 10.2 and above.</li>
+<li>PowerPC and X86-based Mac OS X systems, running 10.2 and above.</li>
<li>Alpha-based machines running Debian GNU/Linux.</li>
<li>Itanium-based machines running Linux and HP-UX.</li>
</ul>
@@ -148,7 +115,7 @@
<p>This section contains all known problems with the LLVM system, listed by
component. As new problems are discovered, they will be added to these
sections. If you run into a problem, please check the <a
-href="http://llvm.cs.uiuc.edu/bugs/">LLVM bug database</a> and submit a bug if
+href="http://llvm.org/bugs/">LLVM bug database</a> and submit a bug if
there isn't already one.</p>
</div>
@@ -168,18 +135,30 @@
<ul>
<li>The following passes are incomplete or buggy, and may be removed in future
- releases: <tt>-cee, -branch-combine, -instloops, -paths, -pre</tt></li>
+ releases: <tt>-cee, -pre</tt></li>
<li>The <tt>llvm-db</tt> tool is in a very early stage of development, but can
be used to step through programs and inspect the stack.</li>
-<li>The "iterative scan" register allocator (enabled with
- <tt>-regalloc=iterativescan</tt>) is not stable.</li>
-<li>The SparcV8, Alpha, and IA64 code generators are experimental.</li>
+<li>The SparcV8 and IA64 code generators are experimental.</li>
+<li>The Alpha JIT is experimental.</li>
</ul>
</div>
<!-- ======================================================================= -->
<div class="doc_subsection">
+ <a name="build">Known problems with the Build System</a>
+</div>
+
+<div class="doc_text">
+
+<ul>
+ <li>The <a href="http://llvm.org/PR656">configure script sometimes fails on Solaris/Sparc</a>. A work around is documented in <a href="http://llvm.org/PR656">PR656.</a></li>
+</ul>
+</div>
+
+
+<!-- ======================================================================= -->
+<div class="doc_subsection">
<a name="core">Known problems with the LLVM Core</a>
</div>
@@ -188,10 +167,6 @@
<ul>
<li>In the JIT, <tt>dlsym()</tt> on a symbol compiled by the JIT will not
work.</li>
- <li><a href="http://llvm.cs.uiuc.edu/PR240">The lower-invoke pass does not
- mark values live across a setjmp as volatile</a>. This missing feature
- only affects targets whose setjmp/longjmp libraries do not save and restore
- the entire register file.</li>
</ul>
</div>
@@ -215,7 +190,7 @@
</pre></li>
<li>Initialization of global union variables can only be done <a
-href="http://llvm.cs.uiuc.edu/PR162">with the largest union member</a>.</li>
+href="http://llvm.org/PR162">with the largest union member</a>.</li>
</ul>
</div>
@@ -440,7 +415,7 @@
(for example, GCC requires the <tt>-fno-strict-aliasing</tt> option). This
problem probably cannot be fixed.</li>
-<li><a href="http://llvm.cs.uiuc.edu/PR56">Zero arg vararg functions are not
+<li><a href="http://llvm.org/PR56">Zero arg vararg functions are not
supported</a>. This should not affect LLVM produced by the C or C++
frontends.</li>
@@ -456,7 +431,8 @@
<div class="doc_text">
<ul>
-<li><a href="http://llvm.cs.uiuc.edu/PR566">Memory Mapped I/O Intrinsics do not fence memory</a></li>
+<li><a href="http://llvm.org/PR566">Memory Mapped I/O Intrinsics do not fence
+memory</a></li>
</ul>
</div>
@@ -482,7 +458,7 @@
<div class="doc_text">
<ul>
-<li><a href="http://llvm.cs.uiuc.edu/PR60">[sparcv9] SparcV9 backend miscompiles
+<li><a href="http://llvm.org/PR60">[sparcv9] SparcV9 backend miscompiles
several programs in the LLVM test suite</a></li>
</ul>
@@ -500,10 +476,6 @@
<li>On 21164s, some rare FP arithmetic sequences which may trap do not have the
appropriate nops inserted to ensure restartability.</li>
-<li>Defining vararg functions is not supported (but calling them is ok).</li>
-
-<li>Due to the vararg problems, C++ exceptions do not work. Small changes are required to the CFE (which break correctness in the exception handler) to compile the exception handling library (and thus the C++ standard library).</li>
-
</ul>
</div>
@@ -522,7 +494,7 @@
speaking this is not a bug in the IA64 back-end; it will also be encountered
when building C++ programs using the C back-end.)</li>
-<li>The C++ front-end does not use <a href="http://llvm.cs.uiuc.edu/PR406">IA64
+<li>The C++ front-end does not use <a href="http://llvm.org/PR406">IA64
ABI compliant layout of v-tables</a>. In particular, it just stores function
pointers instead of function descriptors in the vtable. This bug prevents
mixing C++ code compiled with LLVM with C++ objects compiled by other C++
@@ -547,12 +519,8 @@
<ul>
<li>Many features are still missing (e.g. support for 64-bit integer
-arithmetic).</li>
-
-<li>This backend needs to be updated to use the SelectionDAG instruction
-selection framework.</li>
+arithmetic). This back-end is in pre-beta state.</li>
</ul>
-
</div>
<!-- *********************************************************************** -->
@@ -564,16 +532,16 @@
<div class="doc_text">
<p>A wide variety of additional information is available on the <a
-href="http://llvm.cs.uiuc.edu">LLVM web page</a>, including <a
-href="http://llvm.cs.uiuc.edu/docs/">documentation</a> and <a
-href="http://llvm.cs.uiuc.edu/pubs/">publications describing algorithms and
+href="http://llvm.org">LLVM web page</a>, including <a
+href="http://llvm.org/docs/">documentation</a> and <a
+href="http://llvm.org/pubs/">publications describing algorithms and
components implemented in LLVM</a>. The web page also contains versions of the
API documentation which is up-to-date with the CVS version of the source code.
You can access versions of these documents specific to this release by going
into the "<tt>llvm/doc/</tt>" directory in the LLVM tree.</p>
<p>If you have any questions or comments about LLVM, please feel free to contact
-us via the <a href="http://llvm.cs.uiuc.edu/docs/#maillist"> mailing
+us via the <a href="http://llvm.org/docs/#maillist"> mailing
lists</a>.</p>
</div>
@@ -587,8 +555,8 @@
<a href="http://validator.w3.org/check/referer"><img
src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /></a>
- <a href="http://llvm.cs.uiuc.edu">The LLVM Compiler Infrastructure</a><br>
- Last modified: $Date: 2005/07/12 16:36:24 $
+ <a href="http://llvm.org/">The LLVM Compiler Infrastructure</a><br>
+ Last modified: $Date: 2005/11/16 18:31:08 $
</address>
</body>
Index: llvm/docs/TableGenFundamentals.html
diff -u llvm/docs/TableGenFundamentals.html:1.13 llvm/docs/TableGenFundamentals.html:1.13.2.1
--- llvm/docs/TableGenFundamentals.html:1.13 Thu Sep 8 13:47:21 2005
+++ llvm/docs/TableGenFundamentals.html Wed Nov 16 12:31:08 2005
@@ -337,7 +337,7 @@
information that TableGen collects. Records are defined with a <tt>def</tt> or
<tt>class</tt> keyword, the record name, and an optional list of "<a
href="#templateargs">template arguments</a>". If the record has superclasses,
-they are specified as a comma seperated list that starts with a colon character
+they are specified as a comma separated list that starts with a colon character
(":"). If <a href="#valuedef">value definitions</a> or <a href="#recordlet">let
expressions</a> are needed for the class, they are enclosed in curly braces
("{}"); otherwise, the record ends with a semicolon. Here is a simple TableGen
@@ -517,7 +517,7 @@
File-scope let expressions are really just another way that TableGen allows the
end-user to factor out commonality from the records.</p>
-<p>File-scope "let" expressions take a comma-seperated list of bindings to
+<p>File-scope "let" expressions take a comma-separated list of bindings to
apply, and one of more records to bind the values in. Here are some
examples:</p>
@@ -560,7 +560,7 @@
<a href="mailto:sabre at nondot.org">Chris Lattner</a><br>
<a href="http://llvm.cs.uiuc.edu">LLVM Compiler Infrastructure</a><br>
- Last modified: $Date: 2005/09/08 18:47:21 $
+ Last modified: $Date: 2005/11/16 18:31:08 $
</address>
</body>
More information about the llvm-commits
mailing list