Add constants block to PNaCl bitcode reader.

tests_lit/reader_tests/constants.ll

Index: tests_lit/reader_tests/constants.ll
diff --git a/tests_lit/reader_tests/constants.ll b/tests_lit/reader_tests/constants.ll
new file mode 100644
index 0000000000000000000000000000000000000000..e876ae9715bba499c4ed758f4b2752f34614628d
--- /dev/null
+++ b/tests_lit/reader_tests/constants.ll
@@ -0,0 +1,123 @@
+; Test handling of constants in function blocks.
+
+; RUN: llvm-as < %s | pnacl-freeze \
+; RUN:              | %llvm2ice -notranslate -verbose=inst -build-on-read \
+; RUN:                -allow-pnacl-reader-error-recovery \
+; RUN:              | FileCheck %s
+
+

[Jim Stichnoth, 2014/09/05 23:34:29]

A lot of blank lines here...

[Karl, 2014/09/08 20:41:39]

Removed.

+
+
+
+
+
+
+define void @TestIntegers() {

[Jim Stichnoth, 2014/09/05 23:34:29]

I should point out that Subzero is not checking that the constant value fits
within the bounds of its corresponding type.  It sort of gets checked by the
assembler after code emission.  There should probably be checks in
GlobalContext::getConstant{Int,Float,Double}().

[Karl, 2014/09/08 20:41:39]

Note that we are already using APInt and APFloat (with the correct number of
bits argument) when we pars constants, we shouldn't be passing in illegal values
to GlobalContext::getConstant in the constants parser. So, for now, I don't see
a problem.

+; CHECK: __0:
+
+  ; Test various sized integers
+  %v0 = or i1 true, false
+; CHECK-NEXT:   %__0 = or i1 true, false
+
+  %v1 = add i8 0, 0
+; CHECK-NEXT:   %__1 = add i8 0, 0
+
+  %v2 = add i8 5, 0
+; CHECK-NEXT:   %__2 = add i8 5, 0
+
+  %v3 = add i8 -5, 0
+; CHECK-NEXT:   %__3 = add i8 -5, 0
+
+  %v4 = and i16 10, 0
+; CHECK-NEXT:   %__4 = and i16 10, 0
+
+  %v5 = add i16 -10, 0
+; CHECK-NEXT:   %__5 = add i16 -10, 0
+
+  %v6 = add i32 20, 0
+; CHECK-NEXT:   %__6 = add i32 20, 0
+
+  %v7 = add i32 -20, 0
+; CHECK-NEXT:   %__7 = add i32 -20, 0
+
+  %v8 = add i64 30, 0
+; CHECK-NEXT:   %__8 = add i64 30, 0
+
+  %v9 = add i64 -30, 0
+; CHECK-NEXT:   %__9 = add i64 -30, 0
+
+  ; Test undefined integer values.
+  %v10 = xor i1 undef, false
+; CHECK-NEXT:   %__10 = xor i1 undef, false
+
+  %v11 = add i8 undef, 0
+; CHECK-NEXT:   %__11 = add i8 undef, 0
+
+  %v12 = add i16 undef, 0
+; CHECK-NEXT:   %__12 = add i16 undef, 0
+
+  %v13 = add i32 undef, 0
+; CHECK-NEXT:   %__13 = add i32 undef, 0
+
+  %v14 = add i64 undef, 0
+; CHECK-NEXT:   %__14 = add i64 undef, 0
+
+  ret void
+; CHECK-NEXT:   ret void
+
+}
+
+define void @TestFloats() {
+; CHECK: __0:
+
+  ; Test float and double constants
+  %v0 = fadd float 1.0, 0.0
+; CHECK-NEXT:   %__0 = fadd float 1.000000e+00, 0.000000e+00

[Jim Stichnoth, 2014/09/05 23:34:29]

Subzero's FP dump routines don't try to be precise like LLVM's, but it's
probably OK for a smoke test.

[Karl, 2014/09/08 20:41:39]

Agreed. Not changing since this test is for parsing constant blocks, not
printing values.

+
+  %v1 = fadd double 1.0, 0.0
+; CHECK-NEXT:   %__1 = fadd double 1.000000e+00, 0.000000e+00
+
+  %v2 = fsub float 7.000000e+00, 8.000000e+00
+; CHECK-NEXT:   %__2 = fsub float 7.000000e+00, 8.000000e+00
+
+  %v3 = fsub double 5.000000e+00, 6.000000e+00
+; CHECK-NEXT:   %__3 = fsub double 5.000000e+00, 6.000000e+00
+
+  ; Test undefined float and double.
+  %v4 = fadd float undef, 0.0
+; CHECK-NEXT:   %__4 = fadd float undef, 0.000000e+00
+
+  %v5 = fsub double undef, 6.000000e+00
+; CHECK-NEXT:   %__5 = fsub double undef, 6.000000e+00
+
+  ; Test special floating point constants. Note: LLVM assembly appears
+  ; to use 64-bit integer constants for both float and double.
+
+  ; Generated from NAN in <math.h>
+  %v6 = fadd float 0x7FF8000000000000, 0.0
+; CHECK-NEXT:   %__6 = fadd float nan, 0.000000e+00
+
+  ; Generated from INFINITY in <math.h>
+  %v7 = fadd float 0x7FF0000000000000, 0.0
+; CHECK-NEXT:   %__7 = fadd float inf, 0.000000e+00
+
+  ; Generated from -INFINITY in <math.h>
+  %v8 = fadd float 0xFFF0000000000000, 0.0
+; CHECK-NEXT:   %__8 = fadd float -inf, 0.000000e+00
+
+  ; Generated from NAN in <math.h>
+  %v9 = fadd double 0x7FF8000000000000, 0.0
+; CHECK-NEXT:   %__9 = fadd double nan, 0.000000e+00
+
+  ; Generated from INFINITY in <math.h>
+  %v10 = fadd double 0x7FF0000000000000, 0.0
+; CHECK-NEXT:   %__10 = fadd double inf, 0.000000e+00
+
+  ; Generated from -INFINITY in <math.h>
+  %v11 = fadd double 0xFFF0000000000000, 0.0
+; CHECK-NEXT:   %__11 = fadd double -inf, 0.000000e+00

[Jim Stichnoth, 2014/09/05 23:34:29]

Other interesting FP constants include negative NaN, negative zero, FLT_MIN,
FLT_MAX, DBL_MIN, DBL_MAX.

[Karl, 2014/09/08 20:41:39]

Done.

+
+  ret void
+; CHECK-NEXT:   ret void
+}
+