RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-11-26 13:10:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

document alignment on globals, functions, and allocation instructions.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@24221 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2005-11-06 08:02:57 +00:00
parent 52942b5a32
commit 2cbdc45f35
1 changed files with 103 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
docs/LangRef.html
View File

@ -494,7 +494,8 @@ convention.</p>
<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
instead of run-time. Global variables may optionally be initialized, 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
@ -516,6 +517,12 @@ variables always define a pointer to their "content" type because they
describe a region of memory, and all memory objects in LLVM are
accessed through pointers.</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>
@ -528,11 +535,12 @@ accessed through pointers.</p>
<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 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
@ -551,6 +559,12 @@ functions with the same name but different parameter lists or return values are
considered different functions, and LLVM will resolve references to each
appropriately.</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>
@ -1761,98 +1775,157 @@ positions.</p>
&lt;result&gt; = 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> &lt;result&gt; = malloc &lt;type&gt;, uint &lt;NumElements&gt; <i>; yields {type*}:result</i>
&lt;result&gt; = malloc &lt;type&gt; <i>; yields {type*}:result</i>
<pre>
&lt;result&gt; = malloc &lt;type&gt;[, uint &lt;NumElements&gt;][, align &lt;alignment&gt;] <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(&lt;type&gt;)*NumElements</tt>
<p>The '<tt>malloc</tt>' instruction allocates
<tt>sizeof(&lt;type&gt;)*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>
<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>
%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 &lt;type&gt; &lt;value&gt; <i>; yields {void}</i>
<pre>
free &lt;type&gt; &lt;value&gt; <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> &lt;result&gt; = alloca &lt;type&gt;, uint &lt;NumElements&gt; <i>; yields {type*}:result</i>
&lt;result&gt; = alloca &lt;type&gt; <i>; yields {type*}:result</i>
<pre>
&lt;result&gt; = alloca &lt;type&gt;[, uint &lt;NumElements&gt;][, align &lt;alignment&gt;] <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(&lt;type&gt;)*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>