Tailoring Graph-coloring Register Allocation For Runtime Compilation

Proc. of the 2006 International Symposium on Code Generation and Optimization (CGO'06)

vselect
extractelement
insertelement
shufflevector
call
va_arg
shufflevector ( VEC1, VEC2, IDXMASK )
OPCODE ( LHS, RHS )
shufflevector
+  <result> = shufflevector <n x <ty>> <v1>, <n x <ty>> <v2>, <n x uint> <mask>    ; yields <n x <ty>>
+
shufflevector
shufflevector
+  %result = shufflevector <4 x int> %v1, <4 x int> %v2, <4 x uint>     ; yields <4 x int>
+  %result = shufflevector <4 x int> %v1, <4 x int> undef, <4 x uint>   ; yields <4 x int> - Identity shuffle.
+
-  %result = shufflevector <4 x int> %v1, <4 x int> %v2, <4 x uint>     ; yields <4 x int>
-  %result = shufflevector <4 x int> %v1, <4 x int> undef, <4 x uint>   ; yields <4 x int> - Identity shuffle.
+  %result = shufflevector <4 x int> %v1, <4 x int> %v2, <4 x uint> <uint 0, uint 4, uint 1, uint 5>    ; yields <4 x int>
+  %result = shufflevector <4 x int> %v1, <4 x int> undef, <4 x uint> <uint 0, uint 1, uint 2, uint 3>  ; yields <4 x int> - Identity shuffle.
 
-  %result = shufflevector <4 x int> %v1, <4 x int> %v2, <4 x uint> <uint 0, uint 4, uint 1, uint 5>    ; yields <4 x int>
-  %result = shufflevector <4 x int> %v1, <4 x int> undef, <4 x uint> <uint 0, uint 1, uint 2, uint 3>  ; yields <4 x int> - Identity shuffle.
+  %result = shufflevector <4 x int> %v1, <4 x int> %v2, 
+                          <4 x uint> <uint 0, uint 4, uint 1, uint 5>    ; yields <4 x int>
+  %result = shufflevector <4 x int> %v1, <4 x int> undef, 
+                          <4 x uint> <uint 0, uint 1, uint 2, uint 3>  ; yields <4 x int> - Identity shuffle.
 
shr
extractelement
insertelement
shufflevector
vsetint
vsetfp
vselect
malloc
phi
cast .. to
select
vsetint
vsetfp
vselect
extractelement
insertelement
shufflevector
call
va_arg
malloc
extractelement
-  <result> = malloc <type>[, uint <NumElements>][, align <alignment>]     ; yields {type*}:result
+  <result> = extractelement <n x <ty>> <val>, uint <idx>    ; yields <ty>
 
malloc
extractelement
malloc
sizeof(<type>)*NumElements
type
extractelement
malloc
val
idx
val
idx
val
-  %array  = malloc [4 x ubyte ]                    ; yields {[%4 x ubyte]*}:array
-
-  %size   = add uint 2, 2                          ; yields {uint}:size = uint 4
-  %array1 = malloc ubyte, uint 4                   ; yields {ubyte*}:array1
-  %array2 = malloc [12 x ubyte], uint %size        ; yields {[12 x ubyte]*}:array2
-  %array3 = malloc int, uint 4, align 1024         ; yields {int*}:array3
-  %array4 = malloc int, align 1024                 ; yields {int*}:array4
+  %result = extractelement <4 x int> %vec, uint 0    ; yields int
 
free
insertelement
-  free <type> <value>                              ; yields {void}
+  <result> = insertelement <n x <ty>> <val>, <ty> <elt>, uint <idx>    ; yields <n x <ty>>
 
free
insertelement
value
malloc
insertelement
val
val
idx
elt
idx
val
-  %array  = malloc [4 x ubyte]                    ; yields {[4 x ubyte]*}:array
-            free   [4 x ubyte]* %array
+  %result = insertelement <4 x int> %vec, int 1, uint 0    ; yields <4 x int>
 
alloca
shufflevector
-  <result> = alloca <type>[, uint <NumElements>][, align <alignment>]     ; yields {type*}:result
+  <result> = shufflevector <n x <ty>> <v1>, <n x <ty>> <v2>, <n x uint> <mask>    ; yields <n x <ty>>
 
alloca
shufflevector
alloca
sizeof(<type>)*NumElements
shufflevector
type
alloca
alloca
ret
unwind
-  %ptr = alloca int                              ; yields {int*}:ptr
-  %ptr = alloca int, uint 4                      ; yields {int*}:ptr
-  %ptr = alloca int, uint 4, align 1024          ; yields {int*}:ptr
-  %ptr = alloca int, align 1024                  ; yields {int*}:ptr
+  %result = shufflevector <4 x int> %v1, <4 x int> %v2, 
+                          <4 x uint> <uint 0, uint 4, uint 1, uint 5>    ; yields <4 x int>
+  %result = shufflevector <4 x int> %v1, <4 x int> undef, 
+                          <4 x uint> <uint 0, uint 1, uint 2, uint 3>  ; yields <4 x int> - Identity shuffle.
 
load
vsetint
  <result> = load <ty>* <pointer>
  <result> = volatile load <ty>* <pointer>

load
load
load
volatile
load
load
store
  %ptr = alloca int                               ; yields {int*}:ptr
-  store int 3, int* %ptr                          ; yields {void}
-  %val = load int* %ptr                           ; yields {int}:val = int 3
-
store
  store <ty> <value>, <ty>* <pointer>                   ; yields {void}
-  volatile store <ty> <value>, <ty>* <pointer>                   ; yields {void}
+<result> = vsetint <op>, <n x <ty>> <var1>, <var2>   ; yields <n x bool>
 
+
 Overview:
-The 'store' instruction is used to write to memory.
+
+The 'vsetint' instruction takes two integer vectors and
+returns a vector of boolean values representing, at each position, the
+result of the comparison between the values at that position in the
+two operands.
+
 Arguments:
-There are two arguments to the 'store' instruction: a value
-to store and an address in which to store it.  The type of the '<pointer>'
-operand must be a pointer to the type of the '<value>'
-operand. If the store is marked as volatile, then the
-optimizer is not allowed to modify the number or order of execution of
-this store with other volatile load and store instructions.
+
+The arguments to a 'vsetint' instruction are a comparison
+operation and two value arguments.  The value arguments must be of integral packed type,
+and they must have identical types.  The operation argument must be
+one of eq, ne, slt, sgt,
+sle, sge, ult, ugt, ule,
+uge, true, and false.  The result is a
+packed bool value with the same length as each operand.
+
 Semantics:
-The contents of memory are updated to contain '<value>'
-at the location specified by the '<pointer>' operand.
+
+The following table shows the semantics of 'vsetint'.  For
+each position of the result, the comparison is done on the
+corresponding positions of the two value arguments.  Note that the
+signedness of the comparison depends on the comparison opcode and
+not on the signedness of the value operands.  E.g., vsetint
+slt <4 x unsigned> %x, %y does an elementwise signed
+comparison of %x and %y.
+
+
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+Operation Result is true iff Comparison is
eq var1 == var2 --
ne var1 != var2 --
slt var1 < var2 signed
sgt var1 > var2 signed
sle var1 <= var2 signed
sge var1 >= var2 signed
ult var1 < var2 unsigned
ugt var1 > var2 unsigned
ule var1 <= var2 unsigned
uge var1 >= var2 unsigned
true always --
false never --
+
 Example:
-  %ptr = alloca int                               ; yields {int*}:ptr
-  store int 3, int* %ptr                          ; yields {void}
-  %val = load int* %ptr                           ; yields {int}:val = int 3
+  <result> = vsetint eq <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, false
+  <result> = vsetint ne <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, true
+  <result> = vsetint slt <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, false
+  <result> = vsetint sgt <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, true
+  <result> = vsetint sle <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, false
+  <result> = vsetint sge <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, true
 
-
-
-   'getelementptr' Instruction
 
 
+
+ 'vsetfp'
+Instruction 
 
 Syntax:
--  <result> = getelementptr <ty>* <ptrval>{, <ty> <idx>}*
+<result> = vsetfp <op>, <n x <ty>> <var1>, <var2>   ; yields <n x bool>
 
 
 Overview:
 
-
-The 'getelementptr' instruction is used to get the address of a
-subelement of an aggregate data structure.
+The 'vsetfp' instruction takes two floating point vector
+arguments and returns a vector of boolean values representing, at each
+position, the result of the comparison between the values at that
+position in the two operands.
 
 Arguments:
 
-This instruction takes a list of integer constants that indicate what
-elements of the aggregate object to index to.  The actual types of the arguments
-provided depend on the type of the first pointer argument.  The
-'getelementptr' instruction is used to index down through the type
-levels of a structure or to a specific index in an array.  When indexing into a
-structure, only uint
-integer constants are allowed.  When indexing into an array or pointer,
-int and long indexes are allowed of any sign.
+The arguments to a 'vsetfp' instruction are a comparison
+operation and two value arguments.  The value arguments must be of floating point packed
+type, and they must have identical types.  The operation argument must
+be one of eq, ne, lt, gt,
+le, ge, oeq, one, olt,
+ogt, ole, oge, ueq, une,
+ult, ugt, ule, uge, o,
+u, true, and false.  The result is a packed
+bool value with the same length as each operand.
 
-For example, let's consider a C code fragment and how it gets
-compiled to LLVM:
+Semantics:
 
--  struct RT {
-    char A;
-    int B[10][20];
-    char C;
-  };
-  struct ST {
-    int X;
-    double Y;
-    struct RT Z;
-  };
+The following table shows the semantics of 'vsetfp' for
+floating point types.  If either operand is a floating point Not a
+Number (NaN) value, the operation is unordered, and the value in the
+first column below is produced at that position.  Otherwise, the
+operation is ordered, and the value in the second column is
+produced.
 
-  int *foo(struct ST *s) {
-    return &s[1].Z.B[5][13];
-  }
+
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+Operation If unordered Otherwise true iff
eq undefined var1 == var2
ne undefined var1 != var2
lt undefined var1 < var2
gt undefined var1 > var2
le undefined var1 <= var2
ge undefined var1 >= var2
oeq false var1 == var2
one false var1 != var2
olt false var1 < var2
ogt false var1 > var2
ole false var1 <= var2
oge false var1 >= var2
ueq true var1 == var2
une true var1 != var2
ult true var1 < var2
ugt true var1 > var2
ule true var1 <= var2
uge true var1 >= var2
o false always
u true never
true true always
false false never
+
+Example:
+  <result> = vsetfp eq <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = false, false
+  <result> = vsetfp ne <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = true, true
+  <result> = vsetfp lt <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = true, false
+  <result> = vsetfp gt <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = false, true
+  <result> = vsetfp le <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = true, false
+  <result> = vsetfp ge <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = false, true
 
+
 
-The LLVM code generated by the GCC frontend is:
+
+
+   'vselect' Instruction
+
 
--  %RT = type { sbyte, [10 x [20 x int]], sbyte }
-  %ST = type { int, double, %RT }
+
 
-  implementation
+Syntax:
 
-  int* %foo(%ST* %s) {
-  entry:
-    %reg = getelementptr %ST* %s, int 1, uint 2, uint 1, int 5, int 13
-    ret int* %reg
-  }
++  <result> = vselect <n x bool> <cond>, <n x <ty>> <val1>, <n x <ty>> <val2> ; yields <n x <ty>>
 
 
-Semantics:
+Overview:
 
-The index types specified for the 'getelementptr' instruction depend
-on the pointer type that is being indexed into. Pointer
-and array types require uint, int,
-ulong, or long values, and structure
-types require uint constants.
+
+The 'vselect' instruction chooses one value at each position
+of a vector based on a condition.
+
 
-In the example above, the first index is indexing into the '%ST*'
-type, which is a pointer, yielding a '%ST' = '{ int, double, %RT
-}' type, a structure.  The second index indexes into the third element of
-the structure, yielding a '%RT' = '{ sbyte, [10 x [20 x int]],
-sbyte }' type, another structure.  The third index indexes into the second
-element of the structure, yielding a '[10 x [20 x int]]' type, an
-array.  The two dimensions of the array are subscripted into, yielding an
-'int' type.  The 'getelementptr' instruction returns a pointer
-to this element, thus computing a value of 'int*' type.
 
-Note that it is perfectly legal to index partially through a
-structure, returning a pointer to an inner element.  Because of this,
-the LLVM code for the given testcase is equivalent to:
+Arguments:
 
--  int* %foo(%ST* %s) {
-    %t1 = getelementptr %ST* %s, int 1                        ; yields %ST*:%t1
-    %t2 = getelementptr %ST* %t1, int 0, uint 2               ; yields %RT*:%t2
-    %t3 = getelementptr %RT* %t2, int 0, uint 1               ; yields [10 x [20 x int]]*:%t3
-    %t4 = getelementptr [10 x [20 x int]]* %t3, int 0, int 5  ; yields [20 x int]*:%t4
-    %t5 = getelementptr [20 x int]* %t4, int 0, int 13        ; yields int*:%t5
-    ret int* %t5
-  }
-
+
+The 'vselect' instruction requires a packed bool value indicating the
+condition at each vector position, and two values of the same packed
+type.  All three operands must have the same length.  The type of the
+result is the same as the type of the two value operands.
 
-Note that it is undefined to access an array out of bounds: array and 
-pointer indexes must always be within the defined bounds of the array type.
-The one exception for this rules is zero length arrays.  These arrays are
-defined to be accessible as variable length arrays, which requires access
-beyond the zero'th element.
+Semantics:
+
+
+At each position where the bool vector is true, that position
+of the result gets its value from the first value argument; otherwise,
+it gets its value from the second value argument.
+
 
 Example:
 
 -    ; yields [12 x ubyte]*:aptr
-    %aptr = getelementptr {int, [12 x ubyte]}* %sptr, long 0, uint 1
+  %X = vselect bool <2 x bool> <bool true, bool false>, <2 x ubyte> <ubyte 17, ubyte 17>, 
+    <2 x ubyte> <ubyte 42, ubyte 42>      ; yields <2 x ubyte>:17, 42
 
-
 
+
+
+
 
- Other Operations 
-
-The instructions in this category are the "miscellaneous"
-instructions, which defy better classification.
+ 
+  Memory Access Operations
 
-
- 'phi'
-Instruction 
+
 
-Syntax:
-  <result> = phi <ty> [ <val0>, <label0>], ...

-Overview:
-The 'phi' instruction is used to implement the φ node in
-the SSA graph representing the function.
-Arguments:
-The type of the incoming values are specified with the first type
-field. After this, the 'phi' instruction takes a list of pairs
-as arguments, with one pair for each predecessor basic block of the
-current block.  Only values of first class
-type may be used as the value arguments to the PHI node.  Only labels
-may be used as the label arguments.
-There must be no non-phi instructions between the start of a basic
-block and the PHI instructions: i.e. PHI instructions must be first in
-a basic block.
-Semantics:
-At runtime, the 'phi' instruction logically takes on the
-value specified by the parameter, depending on which basic block we
-came from in the last terminator instruction.
-Example:
-Loop:       ; Infinite loop that counts from 0 on up...
  %indvar = phi uint [ 0, %LoopHeader ], [ %nextindvar, %Loop ]
  %nextindvar = add uint %indvar, 1
  br label %Loop

+
+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.
+
 
 
 
 
-   'cast .. to' Instruction
+  'malloc' Instruction
 
 
 
@@ -2248,58 +2272,48 @@
 Syntax:
 
 -  <result> = cast <ty> <value> to <ty2>             ; yields ty2
+  <result> = malloc <type>[, uint <NumElements>][, align <alignment>]     ; yields {type*}:result
 
 
 Overview:
 
-
-The 'cast' instruction is used as the primitive means to convert
-integers to floating point, change data type sizes, and break type safety (by
-casting pointers).
-
-
+The 'malloc' instruction allocates memory from the system
+heap and returns a pointer to it.
 
 Arguments:
 
-
-The 'cast' instruction takes a value to cast, which must be a first
-class value, and a type to cast it to, which must also be a first class type.
-
-
-Semantics:
+The 'malloc' instruction allocates
+sizeof(<type>)*NumElements
+bytes of memory from the operating system and returns a pointer of the
+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.
 
-
-This instruction follows the C rules for explicit casts when determining how the
-data being cast must change to fit in its new container.
-
+'type' must be a sized type.
 
-
-When casting to bool, any value that would be considered true in the context of
-a C 'if' condition is converted to the boolean 'true' values,
-all else are 'false'.
-
+Semantics:
 
-
-When extending an integral value from a type of one signness to another (for
-example 'sbyte' to 'ulong'), the value is sign-extended if the
-source value is signed, and zero-extended if the source value is
-unsigned. bool values are always zero extended into either zero or
-one.
-
+Memory is allocated using the system "malloc" function, and
+a pointer is returned.
 
 Example:
 
 -  %X = cast int 257 to ubyte              ; yields ubyte:1
-  %Y = cast int 123 to bool               ; yields bool:true
+  %array  = malloc [4 x ubyte ]                    ; yields {[%4 x ubyte]*}:array
+
+  %size   = add uint 2, 2                          ; yields {uint}:size = uint 4
+  %array1 = malloc ubyte, uint 4                   ; yields {ubyte*}:array1
+  %array2 = malloc [12 x ubyte], uint %size        ; yields {[12 x ubyte]*}:array2
+  %array3 = malloc int, uint 4, align 1024         ; yields {int*}:array3
+  %array4 = malloc int, align 1024                 ; yields {int*}:array4
 
 
 
 
 
-   'select' Instruction
+  'free' Instruction
 
 
 
@@ -2307,271 +2321,280 @@
 Syntax:
 
 -  <result> = select bool <cond>, <ty> <val1>, <ty> <val2>             ; yields ty
+  free <type> <value>                              ; yields {void}
 
 
 Overview:
 
-
-The 'select' instruction is used to choose one value based on a
-condition, without branching.
-
-
+The 'free' instruction returns memory back to the unused
+memory heap to be reallocated in the future.
 
 Arguments:
 
-
-The 'select' instruction requires a boolean value indicating the condition, and two values of the same first class type.
-
+'value' shall be a pointer value that points to a value
+that was allocated with the 'malloc'
+instruction.
 
 Semantics:
 
-
-If the boolean condition evaluates to true, the instruction returns the first
-value argument; otherwise, it returns the second value argument.
-
+Access to the memory pointed to by the pointer is no longer defined
+after this instruction executes.
 
 Example:
 
 -  %X = select bool true, ubyte 17, ubyte 42          ; yields ubyte:17
+  %array  = malloc [4 x ubyte]                    ; yields {[4 x ubyte]*}:array
+            free   [4 x ubyte]* %array
 
 
 
 
- 'vsetint'
-Instruction 
+
+  'alloca' Instruction
+
+
 
+
 Syntax:
-<result> = vsetint <op>, <n x <ty>> <var1>, <var2>   ; yields <n x bool>
+
++  <result> = alloca <type>[, uint <NumElements>][, align <alignment>]     ; yields {type*}:result
 
 
 Overview:
 
-The 'vsetint' instruction takes two integer vectors and
-returns a vector of boolean values representing, at each position, the
-result of the comparison between the values at that position in the
-two operands.
+The 'alloca' instruction allocates memory on the current
+stack frame of the procedure that is live until the current function
+returns to its caller.
 
 Arguments:
 
-The arguments to a 'vsetint' instruction are a comparison
-operation and two value arguments.  The value arguments must be of integral packed type,
-and they must have identical types.  The operation argument must be
-one of eq, ne, slt, sgt,
-sle, sge, ult, ugt, ule,
-uge, true, and false.  The result is a
-packed bool value with the same length as each operand.
+The 'alloca' instruction allocates sizeof(<type>)*NumElements
+bytes of memory on the runtime stack, returning a pointer of the
+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.
 
-Semantics:
+'type' may be any sized type.
 
-The following table shows the semantics of 'vsetint'.  For
-each position of the result, the comparison is done on the
-corresponding positions of the two value arguments.  Note that the
-signedness of the comparison depends on the comparison opcode and
-not on the signedness of the value operands.  E.g., vsetint
-slt <4 x unsigned> %x, %y does an elementwise signed
-comparison of %x and %y.
+Semantics:
 
-
-  
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-  
-Operation Result is true iff Comparison is
eq var1 == var2 --
ne var1 != var2 --
slt var1 < var2 signed
sgt var1 > var2 signed
sle var1 <= var2 signed
sge var1 >= var2 signed
ult var1 < var2 unsigned
ugt var1 > var2 unsigned
ule var1 <= var2 unsigned
uge var1 >= var2 unsigned
true always --
false never --
+Memory is allocated; a pointer is returned.  'alloca'd
+memory is automatically released when the function returns.  The 'alloca'
+instruction is commonly used to represent automatic variables that must
+have an address available.  When the function returns (either with the ret or unwind
+instructions), the memory is reclaimed.
 
 Example:
-  <result> = vsetint eq <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, false
-  <result> = vsetint ne <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, true
-  <result> = vsetint slt <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, false
-  <result> = vsetint sgt <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, true
-  <result> = vsetint sle <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = true, false
-  <result> = vsetint sge <2 x int> <int 0, int 1>, <int 1, int 0>      ; yields {<2 x bool>}:result = false, true
+
++  %ptr = alloca int                              ; yields {int*}:ptr
+  %ptr = alloca int, uint 4                      ; yields {int*}:ptr
+  %ptr = alloca int, uint 4, align 1024          ; yields {int*}:ptr
+  %ptr = alloca int, align 1024                  ; yields {int*}:ptr
 
 
 
 
- 'vsetfp'
+ 'load'
 Instruction 
 
 Syntax:
-<result> = vsetfp <op>, <n x <ty>> <var1>, <var2>   ; yields <n x bool>
-
-
+  <result> = load <ty>* <pointer>
  <result> = volatile load <ty>* <pointer>

 Overview:
-
-The 'vsetfp' instruction takes two floating point vector
-arguments and returns a vector of boolean values representing, at each
-position, the result of the comparison between the values at that
-position in the two operands.
-
+The 'load' instruction is used to read from memory.
 Arguments:
-
-The arguments to a 'vsetfp' instruction are a comparison
-operation and two value arguments.  The value arguments must be of floating point packed
-type, and they must have identical types.  The operation argument must
-be one of eq, ne, lt, gt,
-le, ge, oeq, one, olt,
-ogt, ole, oge, ueq, une,
-ult, ugt, ule, uge, o,
-u, true, and false.  The result is a packed
-bool value with the same length as each operand.
-
+The argument to the 'load' instruction specifies the memory
+address from which to load.  The pointer must point to a first class type.  If the load is
+marked as volatile, then the optimizer is not allowed to modify
+the number or order of execution of this load with other
+volatile load and store
+instructions. 
 Semantics:
-
-The following table shows the semantics of 'vsetfp' for
-floating point types.  If either operand is a floating point Not a
-Number (NaN) value, the operation is unordered, and the value in the
-first column below is produced at that position.  Otherwise, the
-operation is ordered, and the value in the second column is
-produced.
-
-
-  
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-    
-  
-Operation If unordered Otherwise true iff
eq undefined var1 == var2
ne undefined var1 != var2
lt undefined var1 < var2
gt undefined var1 > var2
le undefined var1 <= var2
ge undefined var1 >= var2
oeq false var1 == var2
one false var1 != var2
olt false var1 < var2
ogt false var1 > var2
ole false var1 <= var2
oge false var1 >= var2
ueq true var1 == var2
une true var1 != var2
ult true var1 < var2
ugt true var1 > var2
ule true var1 <= var2
uge true var1 >= var2
o false always
u true never
true true always
false false never
-
+The location of memory pointed to is loaded.
+Examples:
+  %ptr = alloca int                               ; yields {int*}:ptr
+  store int 3, int* %ptr                          ; yields {void}
+  %val = load int* %ptr                           ; yields {int}:val = int 3
+
+
+
+ 'store'
+Instruction 
+Syntax:
+  store <ty> <value>, <ty>* <pointer>                   ; yields {void}
+  volatile store <ty> <value>, <ty>* <pointer>                   ; yields {void}
+
+Overview:
+The 'store' instruction is used to write to memory.
+Arguments:
+There are two arguments to the 'store' instruction: a value
+to store and an address in which to store it.  The type of the '<pointer>'
+operand must be a pointer to the type of the '<value>'
+operand. If the store is marked as volatile, then the
+optimizer is not allowed to modify the number or order of execution of
+this store with other volatile load and store instructions.
+Semantics:
+The contents of memory are updated to contain '<value>'
+at the location specified by the '<pointer>' operand.
 Example:
-  <result> = vsetfp eq <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = false, false
-  <result> = vsetfp ne <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = true, true
-  <result> = vsetfp lt <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = true, false
-  <result> = vsetfp gt <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = false, true
-  <result> = vsetfp le <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = true, false
-  <result> = vsetfp ge <2 x float> <float 0.0, float 1.0>, <float 1.0, float 0.0>      ; yields {<2 x bool>}:result = false, true
+  %ptr = alloca int                               ; yields {int*}:ptr
+  store int 3, int* %ptr                          ; yields {void}
+  %val = load int* %ptr                           ; yields {int}:val = int 3
 
-
-
 
 
-   'vselect' Instruction
+   'getelementptr' Instruction
 
 
 
-
 Syntax:
-
 -  <result> = vselect <n x bool> <cond>, <n x <ty>> <val1>, <n x <ty>> <val2> ; yields <n x <ty>>
+  <result> = getelementptr <ty>* <ptrval>{, <ty> <idx>}*
 
 
 Overview:
 
 
-The 'vselect' instruction chooses one value at each position
-of a vector based on a condition.
-
-
+The 'getelementptr' instruction is used to get the address of a
+subelement of an aggregate data structure.
 
 Arguments:
 
-
-The 'vselect' instruction requires a packed bool value indicating the
-condition at each vector position, and two values of the same packed
-type.  All three operands must have the same length.  The type of the
-result is the same as the type of the two value operands.
-
-Semantics:
-
-
-At each position where the bool vector is true, that position
-of the result gets its value from the first value argument; otherwise,
-it gets its value from the second value argument.
-
+This instruction takes a list of integer constants that indicate what
+elements of the aggregate object to index to.  The actual types of the arguments
+provided depend on the type of the first pointer argument.  The
+'getelementptr' instruction is used to index down through the type
+levels of a structure or to a specific index in an array.  When indexing into a
+structure, only uint
+integer constants are allowed.  When indexing into an array or pointer,
+int and long indexes are allowed of any sign.
 
-Example:
+For example, let's consider a C code fragment and how it gets
+compiled to LLVM:
 
 -  %X = vselect bool <2 x bool> <bool true, bool false>, <2 x ubyte> <ubyte 17, ubyte 17>, 
-    <2 x ubyte> <ubyte 42, ubyte 42>      ; yields <2 x ubyte>:17, 42
+  struct RT {
+    char A;
+    int B[10][20];
+    char C;
+  };
+  struct ST {
+    int X;
+    double Y;
+    struct RT Z;
+  };
+
+  int *foo(struct ST *s) {
+    return &s[1].Z.B[5][13];
+  }
 
-
 
-
-
-   'extractelement' Instruction
-
+The LLVM code generated by the GCC frontend is:
 
-
++  %RT = type { sbyte, [10 x [20 x int]], sbyte }
+  %ST = type { int, double, %RT }
 
-Syntax:
+  implementation
 
--  <result> = extractelement <n x <ty>> <val>, uint <idx>    ; yields <ty>
+  int* %foo(%ST* %s) {
+  entry:
+    %reg = getelementptr %ST* %s, int 1, uint 2, uint 1, int 5, int 13
+    ret int* %reg
+  }
 
 
-Overview:
-
-
-The 'extractelement' instruction extracts a single scalar
-element from a packed vector at a specified index.
-
+Semantics:
 
+The index types specified for the 'getelementptr' instruction depend
+on the pointer type that is being indexed into. Pointer
+and array types require uint, int,
+ulong, or long values, and structure
+types require uint constants.
 
-Arguments:
+In the example above, the first index is indexing into the '%ST*'
+type, which is a pointer, yielding a '%ST' = '{ int, double, %RT
+}' type, a structure.  The second index indexes into the third element of
+the structure, yielding a '%RT' = '{ sbyte, [10 x [20 x int]],
+sbyte }' type, another structure.  The third index indexes into the second
+element of the structure, yielding a '[10 x [20 x int]]' type, an
+array.  The two dimensions of the array are subscripted into, yielding an
+'int' type.  The 'getelementptr' instruction returns a pointer
+to this element, thus computing a value of 'int*' type.
 
-
-The first operand of an 'extractelement' instruction is a
-value of packed type.  The second operand is
-an index indicating the position from which to extract the element.
-The index may be a variable.
+Note that it is perfectly legal to index partially through a
+structure, returning a pointer to an inner element.  Because of this,
+the LLVM code for the given testcase is equivalent to:
 
-Semantics:
++  int* %foo(%ST* %s) {
+    %t1 = getelementptr %ST* %s, int 1                        ; yields %ST*:%t1
+    %t2 = getelementptr %ST* %t1, int 0, uint 2               ; yields %RT*:%t2
+    %t3 = getelementptr %RT* %t2, int 0, uint 1               ; yields [10 x [20 x int]]*:%t3
+    %t4 = getelementptr [10 x [20 x int]]* %t3, int 0, int 5  ; yields [20 x int]*:%t4
+    %t5 = getelementptr [20 x int]* %t4, int 0, int 13        ; yields int*:%t5
+    ret int* %t5
+  }
+
 
-
-The result is a scalar of the same type as the element type of
-val.  Its value is the value at position idx of
-val.  If idx exceeds the length of val, the
-results are undefined.
-
+Note that it is undefined to access an array out of bounds: array and 
+pointer indexes must always be within the defined bounds of the array type.
+The one exception for this rules is zero length arrays.  These arrays are
+defined to be accessible as variable length arrays, which requires access
+beyond the zero'th element.
 
 Example:
 
 -  %result = extractelement <4 x int> %vec, uint 0    ; yields int
+    ; yields [12 x ubyte]*:aptr
+    %aptr = getelementptr {int, [12 x ubyte]}* %sptr, long 0, uint 1
 
-
 
+
+
+ Other Operations 
+
+The instructions in this category are the "miscellaneous"
+instructions, which defy better classification.
+
+
+ 'phi'
+Instruction 
+
+Syntax:
+  <result> = phi <ty> [ <val0>, <label0>], ...

+Overview:
+The 'phi' instruction is used to implement the φ node in
+the SSA graph representing the function.
+Arguments:
+The type of the incoming values are specified with the first type
+field. After this, the 'phi' instruction takes a list of pairs
+as arguments, with one pair for each predecessor basic block of the
+current block.  Only values of first class
+type may be used as the value arguments to the PHI node.  Only labels
+may be used as the label arguments.
+There must be no non-phi instructions between the start of a basic
+block and the PHI instructions: i.e. PHI instructions must be first in
+a basic block.
+Semantics:
+At runtime, the 'phi' instruction logically takes on the
+value specified by the parameter, depending on which basic block we
+came from in the last terminator instruction.
+Example:
+Loop:       ; Infinite loop that counts from 0 on up...
  %indvar = phi uint [ 0, %LoopHeader ], [ %nextindvar, %Loop ]
  %nextindvar = add uint %indvar, 1
  br label %Loop

+
 
 
 
-   'insertelement' Instruction
+   'cast .. to' Instruction
 
 
 
@@ -2579,45 +2602,58 @@
 Syntax:
 
 -  <result> = insertelement <n x <ty>> <val>, <ty> <elt>, uint <idx>    ; yields <n x <ty>>
+  <result> = cast <ty> <value> to <ty2>             ; yields ty2
 
 
 Overview:
 
 
-The 'insertelement' instruction inserts a scalar
-element into a packed vector at a specified index.
+The 'cast' instruction is used as the primitive means to convert
+integers to floating point, change data type sizes, and break type safety (by
+casting pointers).
 
 
 
 Arguments:
 
 
-The first operand of an 'insertelement' instruction is a
-value of packed type.  The second operand is a
-scalar value whose type must equal the element type of the first
-operand.  The third operand is an index indicating the position at
-which to insert the value.  The index may be a variable.
+The 'cast' instruction takes a value to cast, which must be a first
+class value, and a type to cast it to, which must also be a first class type.
+
 
 Semantics:
 
 
-The result is a packed vector of the same type as val.  Its
-element values are those of val except at position
-idx, where it gets the value elt.  If idx
-exceeds the length of val, the results are undefined.
+This instruction follows the C rules for explicit casts when determining how the
+data being cast must change to fit in its new container.
+
+
+
+When casting to bool, any value that would be considered true in the context of
+a C 'if' condition is converted to the boolean 'true' values,
+all else are 'false'.
+
+
+
+When extending an integral value from a type of one signness to another (for
+example 'sbyte' to 'ulong'), the value is sign-extended if the
+source value is signed, and zero-extended if the source value is
+unsigned. bool values are always zero extended into either zero or
+one.
 
 
 Example:
 
 -  %result = insertelement <4 x int> %vec, int 1, uint 0    ; yields <4 x int>
+  %X = cast int 257 to ubyte              ; yields ubyte:1
+  %Y = cast int 123 to bool               ; yields bool:true
 
 
 
 
 
-   'shufflevector' Instruction
+   'select' Instruction
 
 
 
@@ -2625,47 +2661,34 @@
 Syntax:
 
 -  <result> = shufflevector <n x <ty>> <v1>, <n x <ty>> <v2>, <n x uint> <mask>    ; yields <n x <ty>>
+  <result> = select bool <cond>, <ty> <val1>, <ty> <val2>             ; yields ty
 
 
 Overview:
 
 
-The 'shufflevector' instruction constructs a permutation of elements
-from two input vectors, returning a vector of the same type.
+The 'select' instruction is used to choose one value based on a
+condition, without branching.
 
 
-Arguments:
 
-
-The first two operands of a 'shufflevector' instruction are vectors
-with types that match each other and types that match the result of the
-instruction.  The third argument is a shuffle mask, which has the same number
-of elements as the other vector type, but whose element type is always 'uint'.
-
+Arguments:
 
 
-The shuffle mask operand is required to be a constant vector with either
-constant integer or undef values.
+The 'select' instruction requires a boolean value indicating the condition, and two values of the same first class type.
 
 
 Semantics:
 
 
-The elements of the two input vectors are numbered from left to right across
-both of the vectors.  The shuffle mask operand specifies, for each element of
-the result vector, which element of the two input registers the result element
-gets.  The element selector may be undef (meaning "don't care") and the second
-operand may be undef if performing a shuffle from only one vector.
+If the boolean condition evaluates to true, the instruction returns the first
+value argument; otherwise, it returns the second value argument.
 
 
 Example:
 
 -  %result = shufflevector <4 x int> %v1, <4 x int> %v2, 
-                          <4 x uint> <uint 0, uint 4, uint 1, uint 5>    ; yields <4 x int>
-  %result = shufflevector <4 x int> %v1, <4 x int> undef, 
-                          <4 x uint> <uint 0, uint 1, uint 2, uint 3>  ; yields <4 x int> - Identity shuffle.
+  %X = select bool true, ubyte 17, ubyte 42          ; yields ubyte:17
 
 
 
@@ -3794,7 +3817,7 @@
 
   Chris Lattner

   The LLVM Compiler Infrastructure

-  Last modified: $Date: 2006/04/08 04:40:53 $
+  Last modified: $Date: 2006/04/08 23:07:04 $
 
 
 





From reid at x10sys.com  Sun Apr  9 02:18:13 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 9 Apr 2006 02:18:13 -0500
Subject: [llvm-commits] CVS: llvm-test/Makefile.rules 
Message-ID: <200604090718.CAA10296@zion.cs.uiuc.edu>



Changes in directory llvm-test:

Makefile.rules updated: 1.9 -> 1.10
---
Log message:

Make sure the CONFIGURATION variable is set correctly in light of changes
in LLVM's Makefile.rules. Basically when Assertion checking is on, it 
needs to be set to Release+Asserts, or when off to Debug-Asserts, as is the
case for LLVM.


---
Diffs of the changes:  (+13 -0)

 Makefile.rules |   13 +++++++++++++
 1 files changed, 13 insertions(+)


Index: llvm-test/Makefile.rules
diff -u llvm-test/Makefile.rules:1.9 llvm-test/Makefile.rules:1.10

--- llvm-test/Makefile.rules:1.9	Tue Feb 28 12:22:24 2006
+++ llvm-test/Makefile.rules	Sun Apr  9 02:18:00 2006
@@ -104,6 +104,7 @@
 	@${ECHO} "Build Object Dir : " $(PROJ_OBJ_DIR)
 	@${ECHO} "LLVM  Source Root: " $(LLVM_SRC_ROOT)
 	@${ECHO} "LLVM  Object Root: " $(LLVM_OBJ_ROOT)
+	@${ECHO} "CONFIGURATION    : " $(CONFIGURATION)
 
 ###########################################################################
 # Suffixes and implicit rules:
@@ -147,6 +148,18 @@
   endif
 endif
 
+# If ENABLE_ASSERTIONS=1 is specified (make command line or configured),
+# then adjust the CONFIGURATION name appropriately (to match LLVM makefiles)
+ifdef ENABLE_ASSERTIONS
+  ifdef ENABLE_OPTIMIZED
+  CONFIGURATION := $(CONFIGURATION)+Asserts
+  endif
+else
+  ifndef ENABLE_OPTIMIZED
+  CONFIGURATION := $(CONFIGURATION)-Asserts
+  endif
+endif
+
 #
 # Enable this for profiling support with 'gprof'
 # This automatically enables optimized builds.





From lattner at cs.uiuc.edu  Sun Apr  9 02:18:35 2006
From: lattner at cs.uiuc.edu (Chris Lattner)
Date: Sun, 9 Apr 2006 02:18:35 -0500
Subject: [llvm-commits] CVS: llvm-test/SingleSource/UnitTests/Makefile 
Message-ID: <200604090718.CAA10398@zion.cs.uiuc.edu>



Changes in directory llvm-test/SingleSource/UnitTests:

Makefile updated: 1.6 -> 1.7
---
Log message:

Don't run vector tests if we just have llvmgcc3


---
Diffs of the changes:  (+9 -2)

 Makefile |   11 +++++++++--
 1 files changed, 9 insertions(+), 2 deletions(-)


Index: llvm-test/SingleSource/UnitTests/Makefile
diff -u llvm-test/SingleSource/UnitTests/Makefile:1.6 llvm-test/SingleSource/UnitTests/Makefile:1.7
--- llvm-test/SingleSource/UnitTests/Makefile:1.6	Wed Mar 22 00:14:10 2006
+++ llvm-test/SingleSource/UnitTests/Makefile	Sun Apr  9 02:18:21 2006
@@ -1,6 +1,13 @@
 # SingleSource/UnitTests/Makefile
-
-DIRS = Vector SetjmpLongjmp
 LEVEL = ../..
+include $(LEVEL)/Makefile.config
+
+DIRS := SetjmpLongjmp
+
+# llvm-gcc3 does not support any vector tests.
+ifneq ($(LLVMGCC_MAJVERS),3)
+DIRS += Vector
+endif
+
 include $(LEVEL)/SingleSource/Makefile.singlesrc
 





From reid at x10sys.com  Sun Apr  9 15:42:28 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 9 Apr 2006 15:42:28 -0500
Subject: [llvm-commits] CVS: llvm/autoconf/configure.ac 
Message-ID: <200604092042.PAA07708@zion.cs.uiuc.edu>



Changes in directory llvm/autoconf:

configure.ac updated: 1.216 -> 1.217
---
Log message:

Change the assertions defaults:
1. Assertions now default to on for all builds
2. If you want them disabled you must (a) --disable-assertions to configure
   or DISABLE_ASSERTIONS=1 to make.


---
Diffs of the changes:  (+4 -6)

 configure.ac |   10 ++++------
 1 files changed, 4 insertions(+), 6 deletions(-)


Index: llvm/autoconf/configure.ac
diff -u llvm/autoconf/configure.ac:1.216 llvm/autoconf/configure.ac:1.217
--- llvm/autoconf/configure.ac:1.216	Fri Apr  7 20:41:26 2006
+++ llvm/autoconf/configure.ac	Sun Apr  9 15:42:14 2006
@@ -193,12 +193,10 @@
 if test -d "CVS" -o -d "${srcdir}/CVS"; then
   cvsbuild="yes"
   optimize="no"
-  asserts="yes"
   AC_SUBST(CVSBUILD,[[CVSBUILD=1]])
 else
   cvsbuild="no"
   optimize="yes"
-  asserts="no"
 fi
 
 dnl===-----------------------------------------------------------------------===
@@ -218,11 +216,11 @@
 
 dnl --enable-assertions : check whether they want to turn on assertions or not:
 AC_ARG_ENABLE(assertions,AS_HELP_STRING(
-  [--enable-assertions,Compile with assertion checks enabled (default is NO)]),, enableval=$asserts)
-if test ${enableval} = "no" ; then
-  AC_SUBST(ENABLE_ASSERTIONS,[[]])
+  [--enable-assertions,Compile with assertion checks enabled (default is YES)]),, enableval="yes")
+if test ${enableval} = "yes" ; then
+  AC_SUBST(DISABLE_ASSERTIONS,[[]])
 else
-  AC_SUBST(ENABLE_ASSERTIONS,[[ENABLE_ASSERTIONS=1]])
+  AC_SUBST(DISABLE_ASSERTIONS,[[DISABLE_ASSERTIONS=1]])
 fi
 
 dnl --enable-debug-runtime : should runtime libraries have debug symbols?





From reid at x10sys.com  Sun Apr  9 15:42:28 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 9 Apr 2006 15:42:28 -0500
Subject: [llvm-commits] CVS: llvm/configure Makefile.config.in 
Message-ID: <200604092042.PAA07704@zion.cs.uiuc.edu>



Changes in directory llvm:

configure updated: 1.218 -> 1.219
Makefile.config.in updated: 1.55 -> 1.56
---
Log message:

Change the assertions defaults:
1. Assertions now default to on for all builds
2. If you want them disabled you must (a) --disable-assertions to configure
   or DISABLE_ASSERTIONS=1 to make.


---
Diffs of the changes:  (+37 -39)

 Makefile.config.in |    4 +-
 configure          |   72 +++++++++++++++++++++++++----------------------------
 2 files changed, 37 insertions(+), 39 deletions(-)


Index: llvm/configure
diff -u llvm/configure:1.218 llvm/configure:1.219
--- llvm/configure:1.218	Fri Apr  7 20:41:26 2006
+++ llvm/configure	Sun Apr  9 15:42:14 2006
@@ -476,7 +476,7 @@
 # include 
 #endif"
 
-ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS LLVM_COPYRIGHT subdirs build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os OS LLVM_ON_UNIX LLVM_ON_WIN32 ARCH ENDIAN CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CVSBUILD ENABLE_OPTIMIZED ENABLE_ASSERTIONS DEBUG_RUNTIME JIT TARGET_HAS_JIT ENABLE_DOXYGEN ENABLE_THREADS TARGETS_TO_BUILD CPP CXX CXXFLAGS ac_ct_CXX LEX LEXLIB LEX_OUTPUT_ROOT FLEX YACC BISON ifGNUmake LN_S CMP CP DATE FIND GREP MKDIR MV RANLIB ac_ct_RANLIB RM SED TAR GRAPHVIZ GV PERL HAVE_PERL INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA BZIP2 DOT DOXYGEN ETAGS GROFF GZIP POD2HTML POD2MAN RUNTEST TCLSH ZIP EGR!
 EP INSTALL_LTDL_TRUE INSTALL_LTDL_FALSE CONVENIENCE_LTDL_TRUE CONVENIENCE_LTDL_FALSE LIBADD_DL ECHO AR ac_ct_AR STRIP ac_ct_STRIP CXXCPP F77 FFLAGS ac_ct_F77 LIBTOOL ETAGSFLAGS LLVMGCC LLVMGXX ALLOCA MMAP_FILE LLVMCC1 LLVMCC1PLUS LLVMGCCDIR LLVMGCC_VERSION LLVMGCC_MAJVERS SHLIBEXT LLVM_PREFIX LLVM_BINDIR LLVM_LIBDIR LLVM_DATADIR LLVM_DOCSDIR LLVM_ETCDIR LLVM_INCLUDEDIR LLVM_INFODIR LLVM_MANDIR LLVM_CONFIGTIME LIBOBJS LTLIBOBJS'
+ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS LLVM_COPYRIGHT subdirs build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os OS LLVM_ON_UNIX LLVM_ON_WIN32 ARCH ENDIAN CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CVSBUILD ENABLE_OPTIMIZED DISABLE_ASSERTIONS DEBUG_RUNTIME JIT TARGET_HAS_JIT ENABLE_DOXYGEN ENABLE_THREADS TARGETS_TO_BUILD CPP CXX CXXFLAGS ac_ct_CXX LEX LEXLIB LEX_OUTPUT_ROOT FLEX YACC BISON ifGNUmake LN_S CMP CP DATE FIND GREP MKDIR MV RANLIB ac_ct_RANLIB RM SED TAR GRAPHVIZ GV PERL HAVE_PERL INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA BZIP2 DOT DOXYGEN ETAGS GROFF GZIP POD2HTML POD2MAN RUNTEST TCLSH ZIP EG!
 REP INSTALL_LTDL_TRUE INSTALL_LTDL_FALSE CONVENIENCE_LTDL_TRUE CONVENIENCE_LTDL_FALSE LIBADD_DL ECHO AR ac_ct_AR STRIP ac_ct_STRIP CXXCPP F77 FFLAGS ac_ct_F77 LIBTOOL ETAGSFLAGS LLVMGCC LLVMGXX ALLOCA MMAP_FILE LLVMCC1 LLVMCC1PLUS LLVMGCCDIR LLVMGCC_VERSION LLVMGCC_MAJVERS SHLIBEXT LLVM_PREFIX LLVM_BINDIR LLVM_LIBDIR LLVM_DATADIR LLVM_DOCSDIR LLVM_ETCDIR LLVM_INCLUDEDIR LLVM_INFODIR LLVM_MANDIR LLVM_CONFIGTIME LIBOBJS LTLIBOBJS'
 ac_subst_files=''
 
 # Initialize some variables set by options.
@@ -2971,13 +2971,11 @@
 if test -d "CVS" -o -d "${srcdir}/CVS"; then
   cvsbuild="yes"
   optimize="no"
-  asserts="yes"
   CVSBUILD=CVSBUILD=1
 
 else
   cvsbuild="no"
   optimize="yes"
-  asserts="no"
 fi
 
 
@@ -3001,13 +2999,13 @@
   enableval="$enable_assertions"
 
 else
-  enableval=$asserts
+  enableval="yes"
 fi;
-if test ${enableval} = "no" ; then
-  ENABLE_ASSERTIONS=
+if test ${enableval} = "yes" ; then
+  DISABLE_ASSERTIONS=
 
 else
-  ENABLE_ASSERTIONS=ENABLE_ASSERTIONS=1
+  DISABLE_ASSERTIONS=DISABLE_ASSERTIONS=1
 
 fi
 
@@ -8467,7 +8465,7 @@
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext < conftest.$ac_ext
+  echo '#line 10459 "configure"' > conftest.$ac_ext
   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
   (eval $ac_compile) 2>&5
   ac_status=$?
@@ -10943,7 +10941,7 @@
 
 
 # Provide some information about the compiler.
-echo "$as_me:10946:" \
+echo "$as_me:10944:" \
      "checking for Fortran 77 compiler version" >&5
 ac_compiler=`set X $ac_compile; echo $2`
 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version &5\"") >&5
@@ -12000,11 +11998,11 @@
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:12003: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:12001: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:12007: \$? = $ac_status" >&5
+   echo "$as_me:12005: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -12243,11 +12241,11 @@
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:12246: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:12244: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:12250: \$? = $ac_status" >&5
+   echo "$as_me:12248: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -12303,11 +12301,11 @@
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:12306: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:12304: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>out/conftest.err)
    ac_status=$?
    cat out/conftest.err >&5
-   echo "$as_me:12310: \$? = $ac_status" >&5
+   echo "$as_me:12308: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s out/conftest2.$ac_objext
    then
      # The compiler can only warn and ignore the option if not recognized
@@ -14488,7 +14486,7 @@
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext < conftest.$ac_ext <&5)
+   (eval echo "\"\$as_me:16780: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:16786: \$? = $ac_status" >&5
+   echo "$as_me:16784: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -16839,11 +16837,11 @@
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:16842: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:16840: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>out/conftest.err)
    ac_status=$?
    cat out/conftest.err >&5
-   echo "$as_me:16846: \$? = $ac_status" >&5
+   echo "$as_me:16844: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s out/conftest2.$ac_objext
    then
      # The compiler can only warn and ignore the option if not recognized
@@ -18200,7 +18198,7 @@
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext < conftest.$ac_ext <&5)
+   (eval echo "\"\$as_me:19136: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:19142: \$? = $ac_status" >&5
+   echo "$as_me:19140: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -19195,11 +19193,11 @@
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:19198: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:19196: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>out/conftest.err)
    ac_status=$?
    cat out/conftest.err >&5
-   echo "$as_me:19202: \$? = $ac_status" >&5
+   echo "$as_me:19200: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s out/conftest2.$ac_objext
    then
      # The compiler can only warn and ignore the option if not recognized
@@ -21234,11 +21232,11 @@
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:21237: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:21235: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:21241: \$? = $ac_status" >&5
+   echo "$as_me:21239: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -21477,11 +21475,11 @@
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:21480: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:21478: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>conftest.err)
    ac_status=$?
    cat conftest.err >&5
-   echo "$as_me:21484: \$? = $ac_status" >&5
+   echo "$as_me:21482: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s "$ac_outfile"; then
      # The compiler can only warn and ignore the option if not recognized
      # So say no if there are warnings
@@ -21537,11 +21535,11 @@
    -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
    -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
    -e 's:$: $lt_compiler_flag:'`
-   (eval echo "\"\$as_me:21540: $lt_compile\"" >&5)
+   (eval echo "\"\$as_me:21538: $lt_compile\"" >&5)
    (eval "$lt_compile" 2>out/conftest.err)
    ac_status=$?
    cat out/conftest.err >&5
-   echo "$as_me:21544: \$? = $ac_status" >&5
+   echo "$as_me:21542: \$? = $ac_status" >&5
    if (exit $ac_status) && test -s out/conftest2.$ac_objext
    then
      # The compiler can only warn and ignore the option if not recognized
@@ -23722,7 +23720,7 @@
   lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
   lt_status=$lt_dlunknown
   cat > conftest.$ac_ext < conftest.$ac_ext <



Changes in directory llvm-test:

Makefile.rules updated: 1.10 -> 1.11
---
Log message:

Adjust to reversed logic in LLVM's Makefile.rules. We now use the
make variable DISABLE_ASSERTIONS instead of ENABLE_ASSERTIONS.


---
Diffs of the changes:  (+1 -7)

 Makefile.rules |    8 +-------
 1 files changed, 1 insertion(+), 7 deletions(-)


Index: llvm-test/Makefile.rules
diff -u llvm-test/Makefile.rules:1.10 llvm-test/Makefile.rules:1.11
--- llvm-test/Makefile.rules:1.10	Sun Apr  9 02:18:00 2006
+++ llvm-test/Makefile.rules	Sun Apr  9 15:43:17 2006
@@ -150,14 +150,8 @@
 
 # If ENABLE_ASSERTIONS=1 is specified (make command line or configured),
 # then adjust the CONFIGURATION name appropriately (to match LLVM makefiles)
-ifdef ENABLE_ASSERTIONS
-  ifdef ENABLE_OPTIMIZED
-  CONFIGURATION := $(CONFIGURATION)+Asserts
-  endif
-else
-  ifndef ENABLE_OPTIMIZED
+ifdef DISABLE_ASSERTIONS
   CONFIGURATION := $(CONFIGURATION)-Asserts
-  endif
 endif
 
 #





From reid at x10sys.com  Sun Apr  9 18:39:56 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 9 Apr 2006 18:39:56 -0500
Subject: [llvm-commits] CVS: llvm/Makefile.config.in 
Message-ID: <200604092339.SAA08372@zion.cs.uiuc.edu>



Changes in directory llvm:

Makefile.config.in updated: 1.56 -> 1.57
---
Log message:

Fix a comment.


---
Diffs of the changes:  (+2 -2)

 Makefile.config.in |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)


Index: llvm/Makefile.config.in
diff -u llvm/Makefile.config.in:1.56 llvm/Makefile.config.in:1.57
--- llvm/Makefile.config.in:1.56	Sun Apr  9 15:42:14 2006
+++ llvm/Makefile.config.in	Sun Apr  9 18:39:43 2006
@@ -184,8 +184,8 @@
 #ENABLE_OPTIMIZED = 1
 @ENABLE_OPTIMIZED@
 
-# When ENABLE_ASSERTIONS is enabled, builds of all of the LLVM code will include
-# assertion checks, otherwise they are not included.
+# When DISABLE_ASSERTIONS is enabled, builds of all of the LLVM code will 
+# exclude assertion checks, otherwise they are included.
 #DISABLE_ASSERTIONS = 1
 @DISABLE_ASSERTIONS@
 





From reid at x10sys.com  Sun Apr  9 18:41:26 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 9 Apr 2006 18:41:26 -0500
Subject: [llvm-commits] CVS: llvm/Makefile.rules 
Message-ID: <200604092341.SAA08394@zion.cs.uiuc.edu>



Changes in directory llvm:

Makefile.rules updated: 1.358 -> 1.359
---
Log message:

Check for DISABLE_ASSERTIONS, not ENABLE_ASSERTIONS


---
Diffs of the changes:  (+5 -9)

 Makefile.rules |   14 +++++---------
 1 files changed, 5 insertions(+), 9 deletions(-)


Index: llvm/Makefile.rules
diff -u llvm/Makefile.rules:1.358 llvm/Makefile.rules:1.359
--- llvm/Makefile.rules:1.358	Fri Apr  7 11:06:18 2006
+++ llvm/Makefile.rules	Sun Apr  9 18:41:14 2006
@@ -224,18 +224,13 @@
 
 # If ENABLE_ASSERTIONS=1 is specified (make command line or configured),
 # then enable assertions by defining the appropriate preprocessor symbols.
-ifdef ENABLE_ASSERTIONS
-  ifdef ENABLE_OPTIMIZED
-  BuildMode := $(BuildMode)+Asserts
-  endif
-  CXX.Flags += -D_DEBUG
-  C.Flags   += -D_DEBUG
-else
-  ifndef ENABLE_OPTIMIZED
+ifdef DISABLE_ASSERTIONS
   BuildMode := $(BuildMode)-Asserts
-  endif
   CXX.Flags += -DNDEBUG
   C.Flags   += -DNDEBUG
+else
+  CXX.Flags += -D_DEBUG
+  C.Flags   += -D_DEBUG
 endif
 
 CXX.Flags     += $(CXXFLAGS)
@@ -1699,3 +1694,4 @@
 	$(Echo) "LexFiles     : " '$(LexFiles)'
 	$(Echo) "Module       : " '$(Module)'
 	$(Echo) "FilesToConfig: " '$(FilesToConfigPATH)'
+	$(Echo) "SubDirs      : " '$(SubDirs)'





From reid at x10sys.com  Sun Apr  9 18:45:50 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 9 Apr 2006 18:45:50 -0500
Subject: [llvm-commits] CVS: llvm/docs/GettingStarted.html
	MakefileGuide.html 
Message-ID: <200604092345.SAA08483@zion.cs.uiuc.edu>



Changes in directory llvm/docs:

GettingStarted.html updated: 1.127 -> 1.128
MakefileGuide.html updated: 1.30 -> 1.31
---
Log message:

Update docs for ENABLE_ASSERTIONS -> DISABLE_ASSERTIONS


---
Diffs of the changes:  (+9 -8)

 GettingStarted.html |    6 +++---
 MakefileGuide.html  |   11 ++++++-----
 2 files changed, 9 insertions(+), 8 deletions(-)


Index: llvm/docs/GettingStarted.html
diff -u llvm/docs/GettingStarted.html:1.127 llvm/docs/GettingStarted.html:1.128
--- llvm/docs/GettingStarted.html:1.127	Mon Mar 20 19:10:57 2006
+++ llvm/docs/GettingStarted.html	Sun Apr  9 18:45:37 2006
@@ -955,9 +955,9 @@
   Perform a Release (Optimized) build.
   
 
-  
gmake ENABLE_OPTIMIZED=1 ENABLE_ASSERTIONS=1
+  
gmake ENABLE_OPTIMIZED=1 DISABLE_ASSERTIONS=1
   

-  Perform a Release (Optimized) build with assertions enabled.
+  Perform a Release (Optimized) build without assertions enabled.
   
 
   
gmake ENABLE_PROFILING=1
@@ -1551,7 +1551,7 @@
   Chris Lattner

   Reid Spencer

   The LLVM Compiler Infrastructure

-  Last modified: $Date: 2006/03/21 01:10:57 $
+  Last modified: $Date: 2006/04/09 23:45:37 $
 
 
 


Index: llvm/docs/MakefileGuide.html
diff -u llvm/docs/MakefileGuide.html:1.30 llvm/docs/MakefileGuide.html:1.31
--- llvm/docs/MakefileGuide.html:1.30	Thu Mar 23 00:19:04 2006
+++ llvm/docs/MakefileGuide.html	Sun Apr  9 18:45:38 2006
@@ -632,10 +632,11 @@
     to the compilers and linkers to ensure that profile data can be collected
     from the tools built. Use the gprof tool to analyze the output from
     the profiled tools (gmon.out).
ENABLE_ASSERTIONS
DISABLE_ASSERTIONS
EXPERIMENTAL_DIRS

Operation	Result is true iff	Comparison is
`eq`	var1 == var2	--
`ne`	var1 != var2	--
`slt`	var1 < var2	signed
`sgt`	var1 > var2	signed
`sle`	var1 <= var2	signed
`sge`	var1 >= var2	signed
`ult`	var1 < var2	unsigned
`ugt`	var1 > var2	unsigned
`ule`	var1 <= var2	unsigned
`uge`	var1 >= var2	unsigned
`true`	always	--
`false`	never	--

Operation	If unordered	Otherwise true iff
`eq`	undefined	var1 == var2
`ne`	undefined	var1 != var2
`lt`	undefined	var1 < var2
`gt`	undefined	var1 > var2
`le`	undefined	var1 <= var2
`ge`	undefined	var1 >= var2
`oeq`	false	var1 == var2
`one`	false	var1 != var2
`olt`	false	var1 < var2
`ogt`	false	var1 > var2
`ole`	false	var1 <= var2
`oge`	false	var1 >= var2
`ueq`	true	var1 == var2
`une`	true	var1 != var2
`ult`	true	var1 < var2
`ugt`	true	var1 > var2
`ule`	true	var1 <= var2
`uge`	true	var1 >= var2
`o`	false	always
`u`	true	never
`true`	true	always
`false`	false	never

Abstract:

Published:

Download:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Example:

Example:

Syntax:

Overview:

Arguments:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Examples:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Semantics:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Examples:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax: