+ %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>
+</pre>
+</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>
+<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 not 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>
+ free [4 x ubyte]* %array
+</pre>
+</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>
+<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 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>
+<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_invoke">invoke</a></tt>
+instructions), the memory is reclaimed.</p>
+<h5>Example:</h5>
+<pre> %ptr = alloca int <i>; yields {int*}:ptr</i>
+ %ptr = alloca int, uint 4 <i>; yields {int*}:ptr</i>
+</pre>
+</div>
+<!-- _______________________________________________________________________ -->
+<div class="doc_subsubsection"> <a name="i_load">'<tt>load</tt>'
+Instruction</a> </div>
+<div class="doc_text">
+<h5>Syntax:</h5>
+<pre> <result> = load <ty>* <pointer><br> <result> = volatile load <ty>* <pointer><br></pre>
+<h5>Overview:</h5>
+<p>The '<tt>load</tt>' instruction is used to read from memory.</p>
+<h5>Arguments:</h5>
+<p>The argument to the '<tt>load</tt>' instruction specifies the memory
+address to load from. The pointer must point to a <a
+ href="t_firstclass">first class</a> type. If the <tt>load</tt> is
+marked as <tt>volatile</tt> then the optimizer is not allowed to modify
+the number or order of execution of this <tt>load</tt> with other
+volatile <tt>load</tt> and <tt><a href="#i_store">store</a></tt>
+instructions. </p>
+<h5>Semantics:</h5>
+<p>The location of memory pointed to is loaded.</p>
+<h5>Examples:</h5>
+<pre> %ptr = <a href="#i_alloca">alloca</a> int <i>; yields {int*}:ptr</i>
+ <a
+ href="#i_store">store</a> int 3, int* %ptr <i>; yields {void}</i>
+ %val = load int* %ptr <i>; yields {int}:val = int 3</i>
+</pre>
+</div>