RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-18 18:42:46 +02:00
Code Issues Projects Releases Wiki Activity

Fix whitespace to be more consistent with AsmPrinter's style.

Browse Source 
llvm-svn: 104962
This commit is contained in:
Dan Gohman 2010-05-28 17:07:41 +00:00
parent f58cd7c838
commit 49590bf7cd
12 changed files with 139 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/ExceptionHandling.html
View File

@ -404,7 +404,7 @@
<div class="doc_text"> <div class="doc_text">
<pre> <pre>
i8* %<a href="#llvm_eh_exception">llvm.eh.exception</a>( ) i8* %<a href="#llvm_eh_exception">llvm.eh.exception</a>()
</pre> </pre>
<p>This intrinsic returns a pointer to the exception structure.</p> <p>This intrinsic returns a pointer to the exception structure.</p>
@ -518,7 +518,7 @@
<div class="doc_text"> <div class="doc_text">
<pre> <pre>
i8* %<a href="#llvm_eh_sjlj_lsda">llvm.eh.sjlj.lsda</a>( ) i8* %<a href="#llvm_eh_sjlj_lsda">llvm.eh.sjlj.lsda</a>()
</pre> </pre>
<p>Used for SJLJ based exception handling, the <a href="#llvm_eh_sjlj_lsda"> <p>Used for SJLJ based exception handling, the <a href="#llvm_eh_sjlj_lsda">

2
docs/FAQ.html
View File

@ -803,7 +803,7 @@ define fastcc void @foo() {
ret void ret void
} }
define void @bar() { define void @bar() {
call void @foo( ) call void @foo()
ret void ret void
} }
</pre> </pre>

204
docs/LangRef.html
View File

@ -2475,104 +2475,104 @@ end:
supported). The following is the syntax for constant expressions:</p> supported). The following is the syntax for constant expressions:</p>
<dl> <dl>
<dt><b><tt>trunc ( CST to TYPE )</tt></b></dt> <dt><b><tt>trunc (CST to TYPE)</tt></b></dt>
<dd>Truncate a constant to another type. The bit size of CST must be larger <dd>Truncate a constant to another type. The bit size of CST must be larger
than the bit size of TYPE. Both types must be integers.</dd> than the bit size of TYPE. Both types must be integers.</dd>
<dt><b><tt>zext ( CST to TYPE )</tt></b></dt> <dt><b><tt>zext (CST to TYPE)</tt></b></dt>
<dd>Zero extend a constant to another type. The bit size of CST must be <dd>Zero extend a constant to another type. The bit size of CST must be
smaller or equal to the bit size of TYPE. Both types must be smaller or equal to the bit size of TYPE. Both types must be
integers.</dd> integers.</dd>
<dt><b><tt>sext ( CST to TYPE )</tt></b></dt> <dt><b><tt>sext (CST to TYPE)</tt></b></dt>
<dd>Sign extend a constant to another type. The bit size of CST must be <dd>Sign extend a constant to another type. The bit size of CST must be
smaller or equal to the bit size of TYPE. Both types must be smaller or equal to the bit size of TYPE. Both types must be
integers.</dd> integers.</dd>
<dt><b><tt>fptrunc ( CST to TYPE )</tt></b></dt> <dt><b><tt>fptrunc (CST to TYPE)</tt></b></dt>
<dd>Truncate a floating point constant to another floating point type. The <dd>Truncate a floating point constant to another floating point type. The
size of CST must be larger than the size of TYPE. Both types must be size of CST must be larger than the size of TYPE. Both types must be
floating point.</dd> floating point.</dd>
<dt><b><tt>fpext ( CST to TYPE )</tt></b></dt> <dt><b><tt>fpext (CST to TYPE)</tt></b></dt>
<dd>Floating point extend a constant to another type. The size of CST must be <dd>Floating point extend a constant to another type. The size of CST must be
smaller or equal to the size of TYPE. Both types must be floating smaller or equal to the size of TYPE. Both types must be floating
point.</dd> point.</dd>
<dt><b><tt>fptoui ( CST to TYPE )</tt></b></dt> <dt><b><tt>fptoui (CST to TYPE)</tt></b></dt>
<dd>Convert a floating point constant to the corresponding unsigned integer <dd>Convert a floating point constant to the corresponding unsigned integer
constant. TYPE must be a scalar or vector integer type. CST must be of constant. TYPE must be a scalar or vector integer type. CST must be of
scalar or vector floating point type. Both CST and TYPE must be scalars, scalar or vector floating point type. Both CST and TYPE must be scalars,
or vectors of the same number of elements. If the value won't fit in the or vectors of the same number of elements. If the value won't fit in the
integer type, the results are undefined.</dd> integer type, the results are undefined.</dd>
<dt><b><tt>fptosi ( CST to TYPE )</tt></b></dt> <dt><b><tt>fptosi (CST to TYPE)</tt></b></dt>
<dd>Convert a floating point constant to the corresponding signed integer <dd>Convert a floating point constant to the corresponding signed integer
constant. TYPE must be a scalar or vector integer type. CST must be of constant. TYPE must be a scalar or vector integer type. CST must be of
scalar or vector floating point type. Both CST and TYPE must be scalars, scalar or vector floating point type. Both CST and TYPE must be scalars,
or vectors of the same number of elements. If the value won't fit in the or vectors of the same number of elements. If the value won't fit in the
integer type, the results are undefined.</dd> integer type, the results are undefined.</dd>
<dt><b><tt>uitofp ( CST to TYPE )</tt></b></dt> <dt><b><tt>uitofp (CST to TYPE)</tt></b></dt>
<dd>Convert an unsigned integer constant to the corresponding floating point <dd>Convert an unsigned integer constant to the corresponding floating point
constant. TYPE must be a scalar or vector floating point type. CST must be constant. TYPE must be a scalar or vector floating point type. CST must be
of scalar or vector integer type. Both CST and TYPE must be scalars, or of scalar or vector integer type. Both CST and TYPE must be scalars, or
vectors of the same number of elements. If the value won't fit in the vectors of the same number of elements. If the value won't fit in the
floating point type, the results are undefined.</dd> floating point type, the results are undefined.</dd>
<dt><b><tt>sitofp ( CST to TYPE )</tt></b></dt> <dt><b><tt>sitofp (CST to TYPE)</tt></b></dt>
<dd>Convert a signed integer constant to the corresponding floating point <dd>Convert a signed integer constant to the corresponding floating point
constant. TYPE must be a scalar or vector floating point type. CST must be constant. TYPE must be a scalar or vector floating point type. CST must be
of scalar or vector integer type. Both CST and TYPE must be scalars, or of scalar or vector integer type. Both CST and TYPE must be scalars, or
vectors of the same number of elements. If the value won't fit in the vectors of the same number of elements. If the value won't fit in the
floating point type, the results are undefined.</dd> floating point type, the results are undefined.</dd>
<dt><b><tt>ptrtoint ( CST to TYPE )</tt></b></dt> <dt><b><tt>ptrtoint (CST to TYPE)</tt></b></dt>
<dd>Convert a pointer typed constant to the corresponding integer constant <dd>Convert a pointer typed constant to the corresponding integer constant
<tt>TYPE</tt> must be an integer type. <tt>CST</tt> must be of pointer <tt>TYPE</tt> must be an integer type. <tt>CST</tt> must be of pointer
type. The <tt>CST</tt> value is zero extended, truncated, or unchanged to type. The <tt>CST</tt> value is zero extended, truncated, or unchanged to
make it fit in <tt>TYPE</tt>.</dd> make it fit in <tt>TYPE</tt>.</dd>
<dt><b><tt>inttoptr ( CST to TYPE )</tt></b></dt> <dt><b><tt>inttoptr (CST to TYPE)</tt></b></dt>
<dd>Convert a integer constant to a pointer constant. TYPE must be a pointer <dd>Convert a integer constant to a pointer constant. TYPE must be a pointer
type. CST must be of integer type. The CST value is zero extended, type. CST must be of integer type. The CST value is zero extended,
truncated, or unchanged to make it fit in a pointer size. This one is truncated, or unchanged to make it fit in a pointer size. This one is
<i>really</i> dangerous!</dd> <i>really</i> dangerous!</dd>
<dt><b><tt>bitcast ( CST to TYPE )</tt></b></dt> <dt><b><tt>bitcast (CST to TYPE)</tt></b></dt>
<dd>Convert a constant, CST, to another TYPE. The constraints of the operands <dd>Convert a constant, CST, to another TYPE. The constraints of the operands
are the same as those for the <a href="#i_bitcast">bitcast are the same as those for the <a href="#i_bitcast">bitcast
instruction</a>.</dd> instruction</a>.</dd>
<dt><b><tt>getelementptr ( CSTPTR, IDX0, IDX1, ... )</tt></b></dt> <dt><b><tt>getelementptr (CSTPTR, IDX0, IDX1, ...)</tt></b></dt>
<dt><b><tt>getelementptr inbounds ( CSTPTR, IDX0, IDX1, ... )</tt></b></dt> <dt><b><tt>getelementptr inbounds (CSTPTR, IDX0, IDX1, ...)</tt></b></dt>
<dd>Perform the <a href="#i_getelementptr">getelementptr operation</a> on <dd>Perform the <a href="#i_getelementptr">getelementptr operation</a> on
constants. As with the <a href="#i_getelementptr">getelementptr</a> constants. As with the <a href="#i_getelementptr">getelementptr</a>
instruction, the index list may have zero or more indexes, which are instruction, the index list may have zero or more indexes, which are
required to make sense for the type of "CSTPTR".</dd> required to make sense for the type of "CSTPTR".</dd>
<dt><b><tt>select ( COND, VAL1, VAL2 )</tt></b></dt> <dt><b><tt>select (COND, VAL1, VAL2)</tt></b></dt>
<dd>Perform the <a href="#i_select">select operation</a> on constants.</dd> <dd>Perform the <a href="#i_select">select operation</a> on constants.</dd>
<dt><b><tt>icmp COND ( VAL1, VAL2 )</tt></b></dt> <dt><b><tt>icmp COND (VAL1, VAL2)</tt></b></dt>
<dd>Performs the <a href="#i_icmp">icmp operation</a> on constants.</dd> <dd>Performs the <a href="#i_icmp">icmp operation</a> on constants.</dd>
<dt><b><tt>fcmp COND ( VAL1, VAL2 )</tt></b></dt> <dt><b><tt>fcmp COND (VAL1, VAL2)</tt></b></dt>
<dd>Performs the <a href="#i_fcmp">fcmp operation</a> on constants.</dd> <dd>Performs the <a href="#i_fcmp">fcmp operation</a> on constants.</dd>
<dt><b><tt>extractelement ( VAL, IDX )</tt></b></dt> <dt><b><tt>extractelement (VAL, IDX)</tt></b></dt>
<dd>Perform the <a href="#i_extractelement">extractelement operation</a> on <dd>Perform the <a href="#i_extractelement">extractelement operation</a> on
constants.</dd> constants.</dd>
<dt><b><tt>insertelement ( VAL, ELT, IDX )</tt></b></dt> <dt><b><tt>insertelement (VAL, ELT, IDX)</tt></b></dt>
<dd>Perform the <a href="#i_insertelement">insertelement operation</a> on <dd>Perform the <a href="#i_insertelement">insertelement operation</a> on
constants.</dd> constants.</dd>
<dt><b><tt>shufflevector ( VEC1, VEC2, IDXMASK )</tt></b></dt> <dt><b><tt>shufflevector (VEC1, VEC2, IDXMASK)</tt></b></dt>
<dd>Perform the <a href="#i_shufflevector">shufflevector operation</a> on <dd>Perform the <a href="#i_shufflevector">shufflevector operation</a> on
constants.</dd> constants.</dd>
<dt><b><tt>OPCODE ( LHS, RHS )</tt></b></dt> <dt><b><tt>OPCODE (LHS, RHS)</tt></b></dt>
<dd>Perform the specified operation of the LHS and RHS constants. OPCODE may <dd>Perform the specified operation of the LHS and RHS constants. OPCODE may
be any of the <a href="#binaryops">binary</a> be any of the <a href="#binaryops">binary</a>
or <a href="#bitwiseops">bitwise binary</a> operations. The constraints or <a href="#bitwiseops">bitwise binary</a> operations. The constraints
@ -5992,7 +5992,7 @@ LLVM</a>.</p>
<h5>Syntax:</h5> <h5>Syntax:</h5>
<pre> <pre>
declare i64 @llvm.readcyclecounter( ) declare i64 @llvm.readcyclecounter()
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>
@ -6938,13 +6938,13 @@ LLVM</a>.</p>
<pre> <pre>
%tramp = alloca [10 x i8], align 4 ; size and alignment only correct for X86 %tramp = alloca [10 x i8], align 4 ; size and alignment only correct for X86
%tramp1 = getelementptr [10 x i8]* %tramp, i32 0, i32 0 %tramp1 = getelementptr [10 x i8]* %tramp, i32 0, i32 0
%p = call i8* @llvm.init.trampoline( i8* %tramp1, i8* bitcast (i32 (i8* nest , i32, i32)* @f to i8*), i8* %nval ) %p = call i8* @llvm.init.trampoline(i8* %tramp1, i8* bitcast (i32 (i8* nest , i32, i32)* @f to i8*), i8* %nval)
%fp = bitcast i8* %p to i32 (i32, i32)* %fp = bitcast i8* %p to i32 (i32, i32)*
</pre> </pre>
</div> </div>
<p>The call <tt>%val = call i32 %fp( i32 %x, i32 %y )</tt> is then equivalent <p>The call <tt>%val = call i32 %fp(i32 %x, i32 %y)</tt> is then equivalent
to <tt>%val = call i32 %f( i8* %nval, i32 %x, i32 %y )</tt>.</p> to <tt>%val = call i32 %f(i8* %nval, i32 %x, i32 %y)</tt>.</p>
</div> </div>
@ -7024,7 +7024,7 @@ LLVM</a>.</p>
<div class="doc_text"> <div class="doc_text">
<h5>Syntax:</h5> <h5>Syntax:</h5>
<pre> <pre>
declare void @llvm.memory.barrier( i1 &lt;ll&gt;, i1 &lt;ls&gt;, i1 &lt;sl&gt;, i1 &lt;ss&gt;, i1 &lt;device&gt; ) declare void @llvm.memory.barrier(i1 &lt;ll&gt;, i1 &lt;ls&gt;, i1 &lt;sl&gt;, i1 &lt;ss&gt;, i1 &lt;device&gt;)
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>
@ -7081,7 +7081,7 @@ LLVM</a>.</p>
store i32 4, %ptr store i32 4, %ptr
%result1 = load i32* %ptr <i>; yields {i32}:result1 = 4</i> %result1 = load i32* %ptr <i>; yields {i32}:result1 = 4</i>
call void @llvm.memory.barrier( i1 false, i1 true, i1 false, i1 false ) call void @llvm.memory.barrier(i1 false, i1 true, i1 false, i1 false)
<i>; guarantee the above finishes</i> <i>; guarantee the above finishes</i>
store i32 8, %ptr <i>; before this begins</i> store i32 8, %ptr <i>; before this begins</i>
</pre> </pre>
@ -7101,10 +7101,10 @@ LLVM</a>.</p>
support all bit widths however.</p> support all bit widths however.</p>
<pre> <pre>
declare i8 @llvm.atomic.cmp.swap.i8.p0i8( i8* &lt;ptr&gt;, i8 &lt;cmp&gt;, i8 &lt;val&gt; ) declare i8 @llvm.atomic.cmp.swap.i8.p0i8(i8* &lt;ptr&gt;, i8 &lt;cmp&gt;, i8 &lt;val&gt;)
declare i16 @llvm.atomic.cmp.swap.i16.p0i16( i16* &lt;ptr&gt;, i16 &lt;cmp&gt;, i16 &lt;val&gt; ) declare i16 @llvm.atomic.cmp.swap.i16.p0i16(i16* &lt;ptr&gt;, i16 &lt;cmp&gt;, i16 &lt;val&gt;)
declare i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;cmp&gt;, i32 &lt;val&gt; ) declare i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;cmp&gt;, i32 &lt;val&gt;)
declare i64 @llvm.atomic.cmp.swap.i64.p0i64( i64* &lt;ptr&gt;, i64 &lt;cmp&gt;, i64 &lt;val&gt; ) declare i64 @llvm.atomic.cmp.swap.i64.p0i64(i64* &lt;ptr&gt;, i64 &lt;cmp&gt;, i64 &lt;val&gt;)
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>
@ -7133,13 +7133,13 @@ LLVM</a>.</p>
store i32 4, %ptr store i32 4, %ptr
%val1 = add i32 4, 4 %val1 = add i32 4, 4
%result1 = call i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* %ptr, i32 4, %val1 ) %result1 = call i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* %ptr, i32 4, %val1)
<i>; yields {i32}:result1 = 4</i> <i>; yields {i32}:result1 = 4</i>
%stored1 = icmp eq i32 %result1, 4 <i>; yields {i1}:stored1 = true</i> %stored1 = icmp eq i32 %result1, 4 <i>; yields {i1}:stored1 = true</i>
%memval1 = load i32* %ptr <i>; yields {i32}:memval1 = 8</i> %memval1 = load i32* %ptr <i>; yields {i32}:memval1 = 8</i>
%val2 = add i32 1, 1 %val2 = add i32 1, 1
%result2 = call i32 @llvm.atomic.cmp.swap.i32.p0i32( i32* %ptr, i32 5, %val2 ) %result2 = call i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* %ptr, i32 5, %val2)
<i>; yields {i32}:result2 = 8</i> <i>; yields {i32}:result2 = 8</i>
%stored2 = icmp eq i32 %result2, 5 <i>; yields {i1}:stored2 = false</i> %stored2 = icmp eq i32 %result2, 5 <i>; yields {i1}:stored2 = false</i>
@ -7159,10 +7159,10 @@ LLVM</a>.</p>
integer bit width. Not all targets support all bit widths however.</p> integer bit width. Not all targets support all bit widths however.</p>
<pre> <pre>
declare i8 @llvm.atomic.swap.i8.p0i8( i8* &lt;ptr&gt;, i8 &lt;val&gt; ) declare i8 @llvm.atomic.swap.i8.p0i8(i8* &lt;ptr&gt;, i8 &lt;val&gt;)
declare i16 @llvm.atomic.swap.i16.p0i16( i16* &lt;ptr&gt;, i16 &lt;val&gt; ) declare i16 @llvm.atomic.swap.i16.p0i16(i16* &lt;ptr&gt;, i16 &lt;val&gt;)
declare i32 @llvm.atomic.swap.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;val&gt; ) declare i32 @llvm.atomic.swap.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;val&gt;)
declare i64 @llvm.atomic.swap.i64.p0i64( i64* &lt;ptr&gt;, i64 &lt;val&gt; ) declare i64 @llvm.atomic.swap.i64.p0i64(i64* &lt;ptr&gt;, i64 &lt;val&gt;)
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>
@ -7189,13 +7189,13 @@ LLVM</a>.</p>
store i32 4, %ptr store i32 4, %ptr
%val1 = add i32 4, 4 %val1 = add i32 4, 4
%result1 = call i32 @llvm.atomic.swap.i32.p0i32( i32* %ptr, i32 %val1 ) %result1 = call i32 @llvm.atomic.swap.i32.p0i32(i32* %ptr, i32 %val1)
<i>; yields {i32}:result1 = 4</i> <i>; yields {i32}:result1 = 4</i>
%stored1 = icmp eq i32 %result1, 4 <i>; yields {i1}:stored1 = true</i> %stored1 = icmp eq i32 %result1, 4 <i>; yields {i1}:stored1 = true</i>
%memval1 = load i32* %ptr <i>; yields {i32}:memval1 = 8</i> %memval1 = load i32* %ptr <i>; yields {i32}:memval1 = 8</i>
%val2 = add i32 1, 1 %val2 = add i32 1, 1
%result2 = call i32 @llvm.atomic.swap.i32.p0i32( i32* %ptr, i32 %val2 ) %result2 = call i32 @llvm.atomic.swap.i32.p0i32(i32* %ptr, i32 %val2)
<i>; yields {i32}:result2 = 8</i> <i>; yields {i32}:result2 = 8</i>
%stored2 = icmp eq i32 %result2, 8 <i>; yields {i1}:stored2 = true</i> %stored2 = icmp eq i32 %result2, 8 <i>; yields {i1}:stored2 = true</i>
@ -7217,10 +7217,10 @@ LLVM</a>.</p>
any integer bit width. Not all targets support all bit widths however.</p> any integer bit width. Not all targets support all bit widths however.</p>
<pre> <pre>
declare i8 @llvm.atomic.load.add.i8.p0i8( i8* &lt;ptr&gt;, i8 &lt;delta&gt; ) declare i8 @llvm.atomic.load.add.i8.p0i8(i8* &lt;ptr&gt;, i8 &lt;delta&gt;)
declare i16 @llvm.atomic.load.add.i16.p0i16( i16* &lt;ptr&gt;, i16 &lt;delta&gt; ) declare i16 @llvm.atomic.load.add.i16.p0i16(i16* &lt;ptr&gt;, i16 &lt;delta&gt;)
declare i32 @llvm.atomic.load.add.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;delta&gt; ) declare i32 @llvm.atomic.load.add.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;delta&gt;)
declare i64 @llvm.atomic.load.add.i64.p0i64( i64* &lt;ptr&gt;, i64 &lt;delta&gt; ) declare i64 @llvm.atomic.load.add.i64.p0i64(i64* &lt;ptr&gt;, i64 &lt;delta&gt;)
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>
@ -7243,11 +7243,11 @@ LLVM</a>.</p>
%mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32)) %mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
%ptr = bitcast i8* %mallocP to i32* %ptr = bitcast i8* %mallocP to i32*
store i32 4, %ptr store i32 4, %ptr
%result1 = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 4 ) %result1 = call i32 @llvm.atomic.load.add.i32.p0i32(i32* %ptr, i32 4)
<i>; yields {i32}:result1 = 4</i> <i>; yields {i32}:result1 = 4</i>
%result2 = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 2 ) %result2 = call i32 @llvm.atomic.load.add.i32.p0i32(i32* %ptr, i32 2)
<i>; yields {i32}:result2 = 8</i> <i>; yields {i32}:result2 = 8</i>
%result3 = call i32 @llvm.atomic.load.add.i32.p0i32( i32* %ptr, i32 5 ) %result3 = call i32 @llvm.atomic.load.add.i32.p0i32(i32* %ptr, i32 5)
<i>; yields {i32}:result3 = 10</i> <i>; yields {i32}:result3 = 10</i>
%memval1 = load i32* %ptr <i>; yields {i32}:memval1 = 15</i> %memval1 = load i32* %ptr <i>; yields {i32}:memval1 = 15</i>
</pre> </pre>
@ -7268,10 +7268,10 @@ LLVM</a>.</p>
support all bit widths however.</p> support all bit widths however.</p>
<pre> <pre>
declare i8 @llvm.atomic.load.sub.i8.p0i32( i8* &lt;ptr&gt;, i8 &lt;delta&gt; ) declare i8 @llvm.atomic.load.sub.i8.p0i32(i8* &lt;ptr&gt;, i8 &lt;delta&gt;)
declare i16 @llvm.atomic.load.sub.i16.p0i32( i16* &lt;ptr&gt;, i16 &lt;delta&gt; ) declare i16 @llvm.atomic.load.sub.i16.p0i32(i16* &lt;ptr&gt;, i16 &lt;delta&gt;)
declare i32 @llvm.atomic.load.sub.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;delta&gt; ) declare i32 @llvm.atomic.load.sub.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;delta&gt;)
declare i64 @llvm.atomic.load.sub.i64.p0i32( i64* &lt;ptr&gt;, i64 &lt;delta&gt; ) declare i64 @llvm.atomic.load.sub.i64.p0i32(i64* &lt;ptr&gt;, i64 &lt;delta&gt;)
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>
@ -7295,11 +7295,11 @@ LLVM</a>.</p>
%mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32)) %mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
%ptr = bitcast i8* %mallocP to i32* %ptr = bitcast i8* %mallocP to i32*
store i32 8, %ptr store i32 8, %ptr
%result1 = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 4 ) %result1 = call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %ptr, i32 4)
<i>; yields {i32}:result1 = 8</i> <i>; yields {i32}:result1 = 8</i>
%result2 = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 2 ) %result2 = call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %ptr, i32 2)
<i>; yields {i32}:result2 = 4</i> <i>; yields {i32}:result2 = 4</i>
%result3 = call i32 @llvm.atomic.load.sub.i32.p0i32( i32* %ptr, i32 5 ) %result3 = call i32 @llvm.atomic.load.sub.i32.p0i32(i32* %ptr, i32 5)
<i>; yields {i32}:result3 = 2</i> <i>; yields {i32}:result3 = 2</i>
%memval1 = load i32* %ptr <i>; yields {i32}:memval1 = -3</i> %memval1 = load i32* %ptr <i>; yields {i32}:memval1 = -3</i>
</pre> </pre>
@ -7324,31 +7324,31 @@ LLVM</a>.</p>
widths however.</p> widths however.</p>
<pre> <pre>
declare i8 @llvm.atomic.load.and.i8.p0i8( i8* &lt;ptr&gt;, i8 &lt;delta&gt; ) declare i8 @llvm.atomic.load.and.i8.p0i8(i8* &lt;ptr&gt;, i8 &lt;delta&gt;)
declare i16 @llvm.atomic.load.and.i16.p0i16( i16* &lt;ptr&gt;, i16 &lt;delta&gt; ) declare i16 @llvm.atomic.load.and.i16.p0i16(i16* &lt;ptr&gt;, i16 &lt;delta&gt;)
declare i32 @llvm.atomic.load.and.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;delta&gt; ) declare i32 @llvm.atomic.load.and.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;delta&gt;)
declare i64 @llvm.atomic.load.and.i64.p0i64( i64* &lt;ptr&gt;, i64 &lt;delta&gt; ) declare i64 @llvm.atomic.load.and.i64.p0i64(i64* &lt;ptr&gt;, i64 &lt;delta&gt;)
</pre> </pre>
<pre> <pre>
declare i8 @llvm.atomic.load.or.i8.p0i8( i8* &lt;ptr&gt;, i8 &lt;delta&gt; ) declare i8 @llvm.atomic.load.or.i8.p0i8(i8* &lt;ptr&gt;, i8 &lt;delta&gt;)
declare i16 @llvm.atomic.load.or.i16.p0i16( i16* &lt;ptr&gt;, i16 &lt;delta&gt; ) declare i16 @llvm.atomic.load.or.i16.p0i16(i16* &lt;ptr&gt;, i16 &lt;delta&gt;)
declare i32 @llvm.atomic.load.or.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;delta&gt; ) declare i32 @llvm.atomic.load.or.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;delta&gt;)
declare i64 @llvm.atomic.load.or.i64.p0i64( i64* &lt;ptr&gt;, i64 &lt;delta&gt; ) declare i64 @llvm.atomic.load.or.i64.p0i64(i64* &lt;ptr&gt;, i64 &lt;delta&gt;)
</pre> </pre>
<pre> <pre>
declare i8 @llvm.atomic.load.nand.i8.p0i32( i8* &lt;ptr&gt;, i8 &lt;delta&gt; ) declare i8 @llvm.atomic.load.nand.i8.p0i32(i8* &lt;ptr&gt;, i8 &lt;delta&gt;)
declare i16 @llvm.atomic.load.nand.i16.p0i32( i16* &lt;ptr&gt;, i16 &lt;delta&gt; ) declare i16 @llvm.atomic.load.nand.i16.p0i32(i16* &lt;ptr&gt;, i16 &lt;delta&gt;)
declare i32 @llvm.atomic.load.nand.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;delta&gt; ) declare i32 @llvm.atomic.load.nand.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;delta&gt;)
declare i64 @llvm.atomic.load.nand.i64.p0i32( i64* &lt;ptr&gt;, i64 &lt;delta&gt; ) declare i64 @llvm.atomic.load.nand.i64.p0i32(i64* &lt;ptr&gt;, i64 &lt;delta&gt;)
</pre> </pre>
<pre> <pre>
declare i8 @llvm.atomic.load.xor.i8.p0i32( i8* &lt;ptr&gt;, i8 &lt;delta&gt; ) declare i8 @llvm.atomic.load.xor.i8.p0i32(i8* &lt;ptr&gt;, i8 &lt;delta&gt;)
declare i16 @llvm.atomic.load.xor.i16.p0i32( i16* &lt;ptr&gt;, i16 &lt;delta&gt; ) declare i16 @llvm.atomic.load.xor.i16.p0i32(i16* &lt;ptr&gt;, i16 &lt;delta&gt;)
declare i32 @llvm.atomic.load.xor.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;delta&gt; ) declare i32 @llvm.atomic.load.xor.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;delta&gt;)
declare i64 @llvm.atomic.load.xor.i64.p0i32( i64* &lt;ptr&gt;, i64 &lt;delta&gt; ) declare i64 @llvm.atomic.load.xor.i64.p0i32(i64* &lt;ptr&gt;, i64 &lt;delta&gt;)
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>
@ -7373,13 +7373,13 @@ LLVM</a>.</p>
%mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32)) %mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
%ptr = bitcast i8* %mallocP to i32* %ptr = bitcast i8* %mallocP to i32*
store i32 0x0F0F, %ptr store i32 0x0F0F, %ptr
%result0 = call i32 @llvm.atomic.load.nand.i32.p0i32( i32* %ptr, i32 0xFF ) %result0 = call i32 @llvm.atomic.load.nand.i32.p0i32(i32* %ptr, i32 0xFF)
<i>; yields {i32}:result0 = 0x0F0F</i> <i>; yields {i32}:result0 = 0x0F0F</i>
%result1 = call i32 @llvm.atomic.load.and.i32.p0i32( i32* %ptr, i32 0xFF ) %result1 = call i32 @llvm.atomic.load.and.i32.p0i32(i32* %ptr, i32 0xFF)
<i>; yields {i32}:result1 = 0xFFFFFFF0</i> <i>; yields {i32}:result1 = 0xFFFFFFF0</i>
%result2 = call i32 @llvm.atomic.load.or.i32.p0i32( i32* %ptr, i32 0F ) %result2 = call i32 @llvm.atomic.load.or.i32.p0i32(i32* %ptr, i32 0F)
<i>; yields {i32}:result2 = 0xF0</i> <i>; yields {i32}:result2 = 0xF0</i>
%result3 = call i32 @llvm.atomic.load.xor.i32.p0i32( i32* %ptr, i32 0F ) %result3 = call i32 @llvm.atomic.load.xor.i32.p0i32(i32* %ptr, i32 0F)
<i>; yields {i32}:result3 = FF</i> <i>; yields {i32}:result3 = FF</i>
%memval1 = load i32* %ptr <i>; yields {i32}:memval1 = F0</i> %memval1 = load i32* %ptr <i>; yields {i32}:memval1 = F0</i>
</pre> </pre>
@ -7403,31 +7403,31 @@ LLVM</a>.</p>
address spaces. Not all targets support all bit widths however.</p> address spaces. Not all targets support all bit widths however.</p>
<pre> <pre>
declare i8 @llvm.atomic.load.max.i8.p0i8( i8* &lt;ptr&gt;, i8 &lt;delta&gt; ) declare i8 @llvm.atomic.load.max.i8.p0i8(i8* &lt;ptr&gt;, i8 &lt;delta&gt;)
declare i16 @llvm.atomic.load.max.i16.p0i16( i16* &lt;ptr&gt;, i16 &lt;delta&gt; ) declare i16 @llvm.atomic.load.max.i16.p0i16(i16* &lt;ptr&gt;, i16 &lt;delta&gt;)
declare i32 @llvm.atomic.load.max.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;delta&gt; ) declare i32 @llvm.atomic.load.max.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;delta&gt;)
declare i64 @llvm.atomic.load.max.i64.p0i64( i64* &lt;ptr&gt;, i64 &lt;delta&gt; ) declare i64 @llvm.atomic.load.max.i64.p0i64(i64* &lt;ptr&gt;, i64 &lt;delta&gt;)
</pre> </pre>
<pre> <pre>
declare i8 @llvm.atomic.load.min.i8.p0i8( i8* &lt;ptr&gt;, i8 &lt;delta&gt; ) declare i8 @llvm.atomic.load.min.i8.p0i8(i8* &lt;ptr&gt;, i8 &lt;delta&gt;)
declare i16 @llvm.atomic.load.min.i16.p0i16( i16* &lt;ptr&gt;, i16 &lt;delta&gt; ) declare i16 @llvm.atomic.load.min.i16.p0i16(i16* &lt;ptr&gt;, i16 &lt;delta&gt;)
declare i32 @llvm.atomic.load.min.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;delta&gt; ) declare i32 @llvm.atomic.load.min.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;delta&gt;)
declare i64 @llvm.atomic.load.min.i64.p0i64( i64* &lt;ptr&gt;, i64 &lt;delta&gt; ) declare i64 @llvm.atomic.load.min.i64.p0i64(i64* &lt;ptr&gt;, i64 &lt;delta&gt;)
</pre> </pre>
<pre> <pre>
declare i8 @llvm.atomic.load.umax.i8.p0i8( i8* &lt;ptr&gt;, i8 &lt;delta&gt; ) declare i8 @llvm.atomic.load.umax.i8.p0i8(i8* &lt;ptr&gt;, i8 &lt;delta&gt;)
declare i16 @llvm.atomic.load.umax.i16.p0i16( i16* &lt;ptr&gt;, i16 &lt;delta&gt; ) declare i16 @llvm.atomic.load.umax.i16.p0i16(i16* &lt;ptr&gt;, i16 &lt;delta&gt;)
declare i32 @llvm.atomic.load.umax.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;delta&gt; ) declare i32 @llvm.atomic.load.umax.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;delta&gt;)
declare i64 @llvm.atomic.load.umax.i64.p0i64( i64* &lt;ptr&gt;, i64 &lt;delta&gt; ) declare i64 @llvm.atomic.load.umax.i64.p0i64(i64* &lt;ptr&gt;, i64 &lt;delta&gt;)
</pre> </pre>
<pre> <pre>
declare i8 @llvm.atomic.load.umin.i8.p0i8( i8* &lt;ptr&gt;, i8 &lt;delta&gt; ) declare i8 @llvm.atomic.load.umin.i8.p0i8(i8* &lt;ptr&gt;, i8 &lt;delta&gt;)
declare i16 @llvm.atomic.load.umin.i16.p0i16( i16* &lt;ptr&gt;, i16 &lt;delta&gt; ) declare i16 @llvm.atomic.load.umin.i16.p0i16(i16* &lt;ptr&gt;, i16 &lt;delta&gt;)
declare i32 @llvm.atomic.load.umin.i32.p0i32( i32* &lt;ptr&gt;, i32 &lt;delta&gt; ) declare i32 @llvm.atomic.load.umin.i32.p0i32(i32* &lt;ptr&gt;, i32 &lt;delta&gt;)
declare i64 @llvm.atomic.load.umin.i64.p0i64( i64* &lt;ptr&gt;, i64 &lt;delta&gt; ) declare i64 @llvm.atomic.load.umin.i64.p0i64(i64* &lt;ptr&gt;, i64 &lt;delta&gt;)
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>
@ -7452,13 +7452,13 @@ LLVM</a>.</p>
%mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32)) %mallocP = tail call i8* @malloc(i32 ptrtoint (i32* getelementptr (i32* null, i32 1) to i32))
%ptr = bitcast i8* %mallocP to i32* %ptr = bitcast i8* %mallocP to i32*
store i32 7, %ptr store i32 7, %ptr
%result0 = call i32 @llvm.atomic.load.min.i32.p0i32( i32* %ptr, i32 -2 ) %result0 = call i32 @llvm.atomic.load.min.i32.p0i32(i32* %ptr, i32 -2)
<i>; yields {i32}:result0 = 7</i> <i>; yields {i32}:result0 = 7</i>
%result1 = call i32 @llvm.atomic.load.max.i32.p0i32( i32* %ptr, i32 8 ) %result1 = call i32 @llvm.atomic.load.max.i32.p0i32(i32* %ptr, i32 8)
<i>; yields {i32}:result1 = -2</i> <i>; yields {i32}:result1 = -2</i>
%result2 = call i32 @llvm.atomic.load.umin.i32.p0i32( i32* %ptr, i32 10 ) %result2 = call i32 @llvm.atomic.load.umin.i32.p0i32(i32* %ptr, i32 10)
<i>; yields {i32}:result2 = 8</i> <i>; yields {i32}:result2 = 8</i>
%result3 = call i32 @llvm.atomic.load.umax.i32.p0i32( i32* %ptr, i32 30 ) %result3 = call i32 @llvm.atomic.load.umax.i32.p0i32(i32* %ptr, i32 30)
<i>; yields {i32}:result3 = 8</i> <i>; yields {i32}:result3 = 8</i>
%memval1 = load i32* %ptr <i>; yields {i32}:memval1 = 30</i> %memval1 = load i32* %ptr <i>; yields {i32}:memval1 = 30</i>
</pre> </pre>
@ -7613,7 +7613,7 @@ LLVM</a>.</p>
<h5>Syntax:</h5> <h5>Syntax:</h5>
<pre> <pre>
declare void @llvm.var.annotation(i8* &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt; ) declare void @llvm.var.annotation(i8* &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt;)
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>
@ -7644,11 +7644,11 @@ LLVM</a>.</p>
any integer bit width.</p> any integer bit width.</p>
<pre> <pre>
declare i8 @llvm.annotation.i8(i8 &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt; ) declare i8 @llvm.annotation.i8(i8 &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt;)
declare i16 @llvm.annotation.i16(i16 &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt; ) declare i16 @llvm.annotation.i16(i16 &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt;)
declare i32 @llvm.annotation.i32(i32 &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt; ) declare i32 @llvm.annotation.i32(i32 &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt;)
declare i64 @llvm.annotation.i64(i64 &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt; ) declare i64 @llvm.annotation.i64(i64 &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt;)
declare i256 @llvm.annotation.i256(i256 &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt; ) declare i256 @llvm.annotation.i256(i256 &lt;val&gt;, i8* &lt;str&gt;, i8* &lt;str&gt;, i32 &lt;int&gt;)
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>
@ -7702,7 +7702,7 @@ LLVM</a>.</p>
<h5>Syntax:</h5> <h5>Syntax:</h5>
<pre> <pre>
declare void @llvm.stackprotector( i8* &lt;guard&gt;, i8** &lt;slot&gt; ) declare void @llvm.stackprotector(i8* &lt;guard&gt;, i8** &lt;slot&gt;)
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>
@ -7736,8 +7736,8 @@ LLVM</a>.</p>
<h5>Syntax:</h5> <h5>Syntax:</h5>
<pre> <pre>
declare i32 @llvm.objectsize.i32( i8* &lt;object&gt;, i1 &lt;type&gt; ) declare i32 @llvm.objectsize.i32(i8* &lt;object&gt;, i1 &lt;type&gt;)
declare i64 @llvm.objectsize.i64( i8* &lt;object&gt;, i1 &lt;type&gt; ) declare i64 @llvm.objectsize.i64(i8* &lt;object&gt;, i1 &lt;type&gt;)
</pre> </pre>
<h5>Overview:</h5> <h5>Overview:</h5>

4
docs/SourceLevelDebugging.html
View File

@ -782,7 +782,7 @@ DW_TAG_return_variable = 258
<div class="doc_text"> <div class="doc_text">
<pre> <pre>
void %<a href="#format_common_declare">llvm.dbg.declare</a>( { } *, metadata ) void %<a href="#format_common_declare">llvm.dbg.declare</a>({ }*, metadata)
</pre> </pre>
<p>This intrinsic provides information about a local element (ex. variable.) The <p>This intrinsic provides information about a local element (ex. variable.) The
@ -800,7 +800,7 @@ DW_TAG_return_variable = 258
<div class="doc_text"> <div class="doc_text">
<pre> <pre>
void %<a href="#format_common_value">llvm.dbg.value</a>( metadata, i64, metadata ) void %<a href="#format_common_value">llvm.dbg.value</a>(metadata, i64, metadata)
</pre> </pre>
<p>This intrinsic provides information when a user source variable is set to a <p>This intrinsic provides information when a user source variable is set to a

12
docs/tutorial/LangImpl3.html
View File

@ -574,8 +574,8 @@ ready&gt; <b>def bar(a) foo(a, 4.0) + bar(31337);</b>
Read function definition: Read function definition:
define double @bar(double %a) { define double @bar(double %a) {
entry: entry:
%calltmp = call double @foo( double %a, double 4.000000e+00 ) %calltmp = call double @foo(double %a, double 4.000000e+00)
%calltmp1 = call double @bar( double 3.133700e+04 ) %calltmp1 = call double @bar(double 3.133700e+04)
%addtmp = fadd double %calltmp, %calltmp1 %addtmp = fadd double %calltmp, %calltmp1
ret double %addtmp ret double %addtmp
} }
@ -596,7 +596,7 @@ ready&gt; <b>cos(1.234);</b>
Read top-level expression: Read top-level expression:
define double @""() { define double @""() {
entry: entry:
%calltmp = call double @cos( double 1.234000e+00 ) %calltmp = call double @cos(double 1.234000e+00)
ret double %calltmp ret double %calltmp
} }
</pre> </pre>
@ -629,8 +629,8 @@ entry:
define double @bar(double %a) { define double @bar(double %a) {
entry: entry:
%calltmp = call double @foo( double %a, double 4.000000e+00 ) %calltmp = call double @foo(double %a, double 4.000000e+00)
%calltmp1 = call double @bar( double 3.133700e+04 ) %calltmp1 = call double @bar(double 3.133700e+04)
%addtmp = fadd double %calltmp, %calltmp1 %addtmp = fadd double %calltmp, %calltmp1
ret double %addtmp ret double %addtmp
} }
@ -639,7 +639,7 @@ declare double @cos(double)
define double @""() { define double @""() {
entry: entry:
%calltmp = call double @cos( double 1.234000e+00 ) %calltmp = call double @cos(double 1.234000e+00)
ret double %calltmp ret double %calltmp
} }
</pre> </pre>

6
docs/tutorial/LangImpl4.html
View File

@ -371,7 +371,7 @@ entry:
ready&gt; <b>testfunc(4, 10);</b> ready&gt; <b>testfunc(4, 10);</b>
define double @""() { define double @""() {
entry: entry:
%calltmp = call double @testfunc( double 4.000000e+00, double 1.000000e+01 ) %calltmp = call double @testfunc(double 4.000000e+00, double 1.000000e+01)
ret double %calltmp ret double %calltmp
} }
@ -410,9 +410,9 @@ ready&gt; <b>def foo(x) sin(x)*sin(x) + cos(x)*cos(x);</b>
Read function definition: Read function definition:
define double @foo(double %x) { define double @foo(double %x) {
entry: entry:
%calltmp = call double @sin( double %x ) %calltmp = call double @sin(double %x)
%multmp = fmul double %calltmp, %calltmp %multmp = fmul double %calltmp, %calltmp
%calltmp2 = call double @cos( double %x ) %calltmp2 = call double @cos(double %x)
%multmp4 = fmul double %calltmp2, %calltmp2 %multmp4 = fmul double %calltmp2, %calltmp2
%addtmp = fadd double %multmp, %multmp4 %addtmp = fadd double %multmp, %multmp4
ret double %addtmp ret double %addtmp

2
docs/tutorial/LangImpl5.html
View File

@ -676,7 +676,7 @@ entry:
loop: ; preds = %loop, %entry loop: ; preds = %loop, %entry
%i = phi double [ 1.000000e+00, %entry ], [ %nextvar, %loop ] %i = phi double [ 1.000000e+00, %entry ], [ %nextvar, %loop ]
; body ; body
%calltmp = call double @putchard( double 4.200000e+01 ) %calltmp = call double @putchard(double 4.200000e+01)
; increment ; increment
%nextvar = fadd double %i, 1.000000e+00 %nextvar = fadd double %i, 1.000000e+00

12
docs/tutorial/LangImpl7.html
View File

@ -558,10 +558,10 @@ then: ; preds = %entry
else: ; preds = %entry else: ; preds = %entry
<b>%x3 = load double* %x1</b> <b>%x3 = load double* %x1</b>
%subtmp = fsub double %x3, 1.000000e+00 %subtmp = fsub double %x3, 1.000000e+00
%calltmp = call double @fib( double %subtmp ) %calltmp = call double @fib(double %subtmp)
<b>%x4 = load double* %x1</b> <b>%x4 = load double* %x1</b>
%subtmp5 = fsub double %x4, 2.000000e+00 %subtmp5 = fsub double %x4, 2.000000e+00
%calltmp6 = call double @fib( double %subtmp5 ) %calltmp6 = call double @fib(double %subtmp5)
%addtmp = fadd double %calltmp, %calltmp6 %addtmp = fadd double %calltmp, %calltmp6
br label %ifcont br label %ifcont
@ -596,9 +596,9 @@ then:
else: else:
%subtmp = fsub double <b>%x</b>, 1.000000e+00 %subtmp = fsub double <b>%x</b>, 1.000000e+00
%calltmp = call double @fib( double %subtmp ) %calltmp = call double @fib(double %subtmp)
%subtmp5 = fsub double <b>%x</b>, 2.000000e+00 %subtmp5 = fsub double <b>%x</b>, 2.000000e+00
%calltmp6 = call double @fib( double %subtmp5 ) %calltmp6 = call double @fib(double %subtmp5)
%addtmp = fadd double %calltmp, %calltmp6 %addtmp = fadd double %calltmp, %calltmp6
br label %ifcont br label %ifcont
@ -626,9 +626,9 @@ entry:
else: else:
%subtmp = fsub double %x, 1.000000e+00 %subtmp = fsub double %x, 1.000000e+00
%calltmp = call double @fib( double %subtmp ) %calltmp = call double @fib(double %subtmp)
%subtmp5 = fsub double %x, 2.000000e+00 %subtmp5 = fsub double %x, 2.000000e+00
%calltmp6 = call double @fib( double %subtmp5 ) %calltmp6 = call double @fib(double %subtmp5)
%addtmp = fadd double %calltmp, %calltmp6 %addtmp = fadd double %calltmp, %calltmp6
ret double %addtmp ret double %addtmp

12
docs/tutorial/OCamlLangImpl3.html
View File

@ -524,8 +524,8 @@ ready&gt; <b>def bar(a) foo(a, 4.0) + bar(31337);</b>
Read function definition: Read function definition:
define double @bar(double %a) { define double @bar(double %a) {
entry: entry:
%calltmp = call double @foo( double %a, double 4.000000e+00 ) %calltmp = call double @foo(double %a, double 4.000000e+00)
%calltmp1 = call double @bar( double 3.133700e+04 ) %calltmp1 = call double @bar(double 3.133700e+04)
%addtmp = fadd double %calltmp, %calltmp1 %addtmp = fadd double %calltmp, %calltmp1
ret double %addtmp ret double %addtmp
} }
@ -546,7 +546,7 @@ ready&gt; <b>cos(1.234);</b>
Read top-level expression: Read top-level expression:
define double @""() { define double @""() {
entry: entry:
%calltmp = call double @cos( double 1.234000e+00 ) %calltmp = call double @cos(double 1.234000e+00)
ret double %calltmp ret double %calltmp
} }
</pre> </pre>
@ -579,8 +579,8 @@ entry:
define double @bar(double %a) { define double @bar(double %a) {
entry: entry:
%calltmp = call double @foo( double %a, double 4.000000e+00 ) %calltmp = call double @foo(double %a, double 4.000000e+00)
%calltmp1 = call double @bar( double 3.133700e+04 ) %calltmp1 = call double @bar(double 3.133700e+04)
%addtmp = fadd double %calltmp, %calltmp1 %addtmp = fadd double %calltmp, %calltmp1
ret double %addtmp ret double %addtmp
} }
@ -589,7 +589,7 @@ declare double @cos(double)
define double @""() { define double @""() {
entry: entry:
%calltmp = call double @cos( double 1.234000e+00 ) %calltmp = call double @cos(double 1.234000e+00)
ret double %calltmp ret double %calltmp
} }
</pre> </pre>

6
docs/tutorial/OCamlLangImpl4.html
View File

@ -387,7 +387,7 @@ entry:
ready&gt; <b>testfunc(4, 10);</b> ready&gt; <b>testfunc(4, 10);</b>
define double @""() { define double @""() {
entry: entry:
%calltmp = call double @testfunc( double 4.000000e+00, double 1.000000e+01 ) %calltmp = call double @testfunc(double 4.000000e+00, double 1.000000e+01)
ret double %calltmp ret double %calltmp
} }
@ -426,9 +426,9 @@ ready&gt; <b>def foo(x) sin(x)*sin(x) + cos(x)*cos(x);</b>
Read function definition: Read function definition:
define double @foo(double %x) { define double @foo(double %x) {
entry: entry:
%calltmp = call double @sin( double %x ) %calltmp = call double @sin(double %x)
%multmp = fmul double %calltmp, %calltmp %multmp = fmul double %calltmp, %calltmp
%calltmp2 = call double @cos( double %x ) %calltmp2 = call double @cos(double %x)
%multmp4 = fmul double %calltmp2, %calltmp2 %multmp4 = fmul double %calltmp2, %calltmp2
%addtmp = fadd double %multmp, %multmp4 %addtmp = fadd double %multmp, %multmp4
ret double %addtmp ret double %addtmp

2
docs/tutorial/OCamlLangImpl5.html
View File

@ -651,7 +651,7 @@ entry:
loop: ; preds = %loop, %entry loop: ; preds = %loop, %entry
%i = phi double [ 1.000000e+00, %entry ], [ %nextvar, %loop ] %i = phi double [ 1.000000e+00, %entry ], [ %nextvar, %loop ]
; body ; body
%calltmp = call double @putchard( double 4.200000e+01 ) %calltmp = call double @putchard(double 4.200000e+01)
; increment ; increment
%nextvar = fadd double %i, 1.000000e+00 %nextvar = fadd double %i, 1.000000e+00

12
docs/tutorial/OCamlLangImpl7.html
View File

@ -582,10 +582,10 @@ then: ; preds = %entry
else: ; preds = %entry else: ; preds = %entry
<b>%x3 = load double* %x1</b> <b>%x3 = load double* %x1</b>
%subtmp = fsub double %x3, 1.000000e+00 %subtmp = fsub double %x3, 1.000000e+00
%calltmp = call double @fib( double %subtmp ) %calltmp = call double @fib(double %subtmp)
<b>%x4 = load double* %x1</b> <b>%x4 = load double* %x1</b>
%subtmp5 = fsub double %x4, 2.000000e+00 %subtmp5 = fsub double %x4, 2.000000e+00
%calltmp6 = call double @fib( double %subtmp5 ) %calltmp6 = call double @fib(double %subtmp5)
%addtmp = fadd double %calltmp, %calltmp6 %addtmp = fadd double %calltmp, %calltmp6
br label %ifcont br label %ifcont
@ -620,9 +620,9 @@ then:
else: else:
%subtmp = fsub double <b>%x</b>, 1.000000e+00 %subtmp = fsub double <b>%x</b>, 1.000000e+00
%calltmp = call double @fib( double %subtmp ) %calltmp = call double @fib(double %subtmp)
%subtmp5 = fsub double <b>%x</b>, 2.000000e+00 %subtmp5 = fsub double <b>%x</b>, 2.000000e+00
%calltmp6 = call double @fib( double %subtmp5 ) %calltmp6 = call double @fib(double %subtmp5)
%addtmp = fadd double %calltmp, %calltmp6 %addtmp = fadd double %calltmp, %calltmp6
br label %ifcont br label %ifcont
@ -650,9 +650,9 @@ entry:
else: else:
%subtmp = fsub double %x, 1.000000e+00 %subtmp = fsub double %x, 1.000000e+00
%calltmp = call double @fib( double %subtmp ) %calltmp = call double @fib(double %subtmp)
%subtmp5 = fsub double %x, 2.000000e+00 %subtmp5 = fsub double %x, 2.000000e+00
%calltmp6 = call double @fib( double %subtmp5 ) %calltmp6 = call double @fib(double %subtmp5)
%addtmp = fadd double %calltmp, %calltmp6 %addtmp = fadd double %calltmp, %calltmp6
ret double %addtmp ret double %addtmp