Use separate random number generator for each randomization pass

tests_lit/llvm2ice_tests/rng.ll

Index: tests_lit/llvm2ice_tests/rng.ll
diff --git a/tests_lit/llvm2ice_tests/rng.ll b/tests_lit/llvm2ice_tests/rng.ll
new file mode 100644
index 0000000000000000000000000000000000000000..a3e831d36d553ddeaabec093e5110e4f1c92d17a
--- /dev/null
+++ b/tests_lit/llvm2ice_tests/rng.ll
@@ -0,0 +1,258 @@
+; This is a smoke test of random number generator.
+; The random number generators for different randomization passes should be
+; decoupled. The random number used in one randomization pass should not be
+; influenced by the existence of other randomization passes.
+
+; REQUIRES: allow_dump
+
+; Command for checking constant blinding (Need to turn off nop-insertion)
+; RUN: %p2i -i %s --filetype=obj --disassemble --args -O2 \
+; RUN:    -sz-seed=1 -randomize-pool-immediates=randomize \
+; RUN:    -randomize-pool-threshold=0x1 \
+; RUN:	  -reorder-global-variables \
+; RUN:    -reorder-basic-blocks \
+; RUN:    -reorder-functions \
+; RUN:    -randomize-regalloc \
+; RUN:    -nop-insertion=false \

[Jim Stichnoth, 2015/08/20 04:04:41]

For consistency with other .ll files, probably use 0 instead of false.  (here
and below)

[qining, 2015/08/20 16:19:33]

Done.

+; RUN:    -reorder-pooled-constants \
+; RUN:    | FileCheck %s --check-prefix=BLINDINGO2
+
+; Command for checking global variable reordering
+; RUN: %if --need=target_X8632 --command %p2i -i %s \

[jvoung (off chromium), 2015/08/20 13:43:30]

This appears to be the only command  that does "%if --need=target_X8632 ...".

If they all rely on X8632 maybe just put it in REQUIRES: ... (not sure the
syntax for multiple requirements).

Or make a randomization-related subdirectory where the lit.local.cfg checks for
allow_dump (e.g.,
toolchain_build/src/subzero/tests_lit/reader_tests/lit.local.cfg), to avoid
having multiple REQUIRES for this particular test. Not all of the randomization
tests require allow_dump though...

[Jim Stichnoth, 2015/08/20 15:14:26]

Yeah, it seems to me that at least for now, require x8632 and add -target=x8632
to all the RUN commands.

In the future, I suppose we might end up with some non-x86 target-specific pass
that allows randomization, but it doesn't necessarily need to be tested in this
file.

[qining, 2015/08/20 16:19:33]

Done. Add:
REQUIRES: allow_dump, target_X8632.
--target x8632

+; RUN:    --filetype=obj --disassemble --dis-flags=-rD \
+; RUN:    --args -O2 -sz-seed=1 \
+; RUN:    -randomize-pool-immediates=randomize \
+; RUN:    -randomize-pool-threshold=0x1 \
+; RUN:	  -reorder-global-variables \
+; RUN:    -reorder-basic-blocks \
+; RUN:    -reorder-functions \
+; RUN:    -randomize-regalloc \
+; RUN:    -nop-insertion \
+; RUN:    -reorder-pooled-constants \
+; RUN:    | FileCheck %s --check-prefix=GLOBALVARS
+
+; Command for checking basic block reordering
+; RUN: %p2i -i %s --filetype=asm --args -O2 -sz-seed=1\
+; RUN:    -randomize-pool-immediates=randomize \
+; RUN:    -randomize-pool-threshold=0x1 \
+; RUN:	  -reorder-global-variables \
+; RUN:    -reorder-basic-blocks \
+; RUN:    -reorder-functions \
+; RUN:    -randomize-regalloc \
+; RUN:    -nop-insertion \
+; RUN:    -reorder-pooled-constants \
+; RUN:    | FileCheck %s --check-prefix=BBREORDERING
+
+; Command for checking function reordering
+; RUN: %p2i -i %s --filetype=obj --disassemble --args -O2 \
+; RUN:    -sz-seed=1 -randomize-pool-immediates=randomize \
+; RUN:    -randomize-pool-threshold=0x1 \
+; RUN:	  -reorder-global-variables \
+; RUN:    -reorder-basic-blocks \
+; RUN:    -reorder-functions \
+; RUN:    -randomize-regalloc \
+; RUN:    -nop-insertion \
+; RUN:    -reorder-pooled-constants \
+; RUN:    | FileCheck %s --check-prefix=FUNCREORDERING
+
+; Command for checking regalloc randomization
+; RUN: %p2i -i %s --filetype=obj --disassemble --args -O2 \
+; RUN:    -sz-seed=1 -randomize-pool-immediates=randomize \
+; RUN:    -randomize-pool-threshold=0x1 \
+; RUN:	  -reorder-global-variables \
+; RUN:    -reorder-basic-blocks \
+; RUN:    -reorder-functions \
+; RUN:    -randomize-regalloc \
+; RUN:    -nop-insertion \
+; RUN:    -reorder-pooled-constants \
+; RUN:    | FileCheck %s --check-prefix=REGALLOC
+
+; Command for checking nop insertion (Need to turn off randomize-regalloc)
+; RUN: %p2i -i %s --filetype=asm --args \
+; RUN:    -sz-seed=1 -randomize-pool-immediates=randomize \
+; RUN:	  -reorder-global-variables \
+; RUN:    -reorder-basic-blocks \
+; RUN:    -reorder-functions \
+; RUN:    -randomize-regalloc=false \
+; RUN:    -nop-insertion -nop-insertion-percentage=50\
+; RUN:    -reorder-pooled-constants \
+; RUN:    | FileCheck %s --check-prefix=NOPINSERTION
+
+; Command for checking pooled constants reordering
+; RUN: %p2i -i %s --filetype=obj --disassemble --dis-flags=-s \
+; RUN:    --args -O2 -sz-seed=1 \
+; RUN:    -randomize-pool-immediates=randomize \
+; RUN:    -randomize-pool-threshold=0x1 \
+; RUN:	  -reorder-global-variables \
+; RUN:    -reorder-basic-blocks \
+; RUN:    -reorder-functions \
+; RUN:    -randomize-regalloc \
+; RUN:    -nop-insertion \
+; RUN:    -reorder-pooled-constants \
+; RUN:    | FileCheck %s --check-prefix=POOLEDCONSTANTS
+
+
+; Global variables copied from reorder-global-variables.ll
+@PrimitiveInit = internal global [4 x i8] c"\1B\00\00\00", align 4
+@PrimitiveInitConst = internal constant [4 x i8] c"\0D\00\00\00", align 4
+@ArrayInit = internal global [20 x i8] c"\0A\00\00\00\14\00\00\00\1E\00\00\00(\00\00\002\00\00\00", align 4
+@ArrayInitPartial = internal global [40 x i8] c"<\00\00\00F\00\00\00P\00\00\00Z\00\00\00d\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", align 4
+@PrimitiveInitStatic = internal global [4 x i8] zeroinitializer, align 4
+@PrimitiveUninit = internal global [4 x i8] zeroinitializer, align 4
+@ArrayUninit = internal global [20 x i8] zeroinitializer, align 4
+@ArrayUninitConstDouble = internal constant [200 x i8] zeroinitializer, align 8
+@ArrayUninitConstInt = internal constant [20 x i8] zeroinitializer, align 4
+
+
+define <4 x i32> @func1(<4 x i32> %a, <4 x i32> %b) {
+entry:
+  %res = mul <4 x i32> %a, %b
+  ret <4 x i32> %res
+
+; NOPINSERTION-LABEL: func1
+; NOPINSERTION: nop # variant = 1
+; NOPINSERTION: subl $60, %esp
+; NOPINSERTION: nop # variant = 3
+; NOPINSERTION: movups %xmm0, 32(%esp)
+; NOPINSERTION: movups %xmm1, 16(%esp)
+; NOPINSERTION: movups 32(%esp), %xmm0
+; NOPINSERTION: nop # variant = 1
+; NOPINSERTION: pshufd $49, 32(%esp), %xmm1
+; NOPINSERTION: nop # variant = 4
+; NOPINSERTION: pshufd $49, 16(%esp), %xmm2
+; NOPINSERTION: nop # variant = 1
+; NOPINSERTION: pmuludq 16(%esp), %xmm0
+; NOPINSERTION: pmuludq %xmm2, %xmm1
+; NOPINSERTION: nop # variant = 0
+; NOPINSERTION: shufps $136, %xmm1, %xmm0
+; NOPINSERTION: nop # variant = 3
+; NOPINSERTION: pshufd $216, %xmm0, %xmm0
+; NOPINSERTION: nop # variant = 1
+; NOPINSERTION: movups %xmm0, (%esp)
+; NOPINSERTION: movups (%esp), %xmm0
+; NOPINSERTION: addl $60, %esp
+; NOPINSERTION: ret
+}
+
+
+
+define float @func2(float* %arg) {
+entry:
+  %arg.int = ptrtoint float* %arg to i32
+  %addr.int = add i32 %arg.int, 200000
+  %addr.ptr = inttoptr i32 %addr.int to float*
+  %addr.load = load float, float* %addr.ptr, align 4
+  ret float %addr.load
+
+; BLINDINGO2-LABEL: func2
+; BLINDINGO2: lea [[REG:e[a-z]*]],{{[[]}}{{e[a-z]*}}+0x340254{{[]]}}
+}
+
+define float @func3(i32 %arg, float %input) {
+entry:
+  switch i32 %arg, label %return [
+    i32 0, label %sw.bb
+    i32 1, label %sw.bb1
+    i32 2, label %sw.bb2
+    i32 3, label %sw.bb3
+    i32 4, label %sw.bb4
+  ]
+
+sw.bb:
+  %rbb = fadd float %input, 1.000000e+00
+  br label %return
+
+sw.bb1:
+  %rbb1 = fadd float %input, 2.000000e+00
+  br label %return
+
+sw.bb2:
+  %rbb2 = fadd float %input, 4.000000e+00
+  br label %return
+
+sw.bb3:
+  %rbb3 = fadd float %input, 5.000000e-01
+  br label %return
+
+sw.bb4:
+  %rbb4 = fadd float %input, 2.500000e-01
+  br label %return
+
+return:
+  %retval.0 = phi float [ %rbb, %sw.bb ], [ %rbb1, %sw.bb1 ], [ %rbb2, %sw.bb2 ], [ %rbb3, %sw.bb3 ], [ %rbb4, %sw.bb4], [ 0.000000e+00, %entry ]
+  ret float %retval.0
+}
+
+define <4 x i32> @func4(<4 x i32> %a, <4 x i32> %b) {
+entry:
+  %res = mul <4 x i32> %a, %b
+  ret <4 x i32> %res
+
+; REGALLOC-LABEL: func4
+; REGALLOC: movups  xmm3,xmm0
+; REGALLOC-NEXT: pshufd  xmm0,xmm0,0x31
+; REGALLOC-NEXT: pshufd  xmm5,xmm1,0x31
+; REGALLOC-NEXT: pmuludq xmm3,xmm1
+; REGALLOC-NEXT: pmuludq xmm0,xmm5
+; REGALLOC-NEXT: shufps  xmm3,xmm0,0x88
+; REGALLOC-NEXT: pshufd  xmm3,xmm3,0xd8
+; REGALLOC-NEXT: movups  xmm0,xmm3
+; REGALLOC-NEXT: ret
+}
+
+define void @func5(i32 %foo, i32 %bar) {
+entry:
+  %r1 = icmp eq i32 %foo, %bar
+  br i1 %r1, label %BB1, label %BB2
+BB1:
+  %r2 = icmp sgt i32 %foo, %bar
+  br i1 %r2, label %BB3, label %BB4
+BB2:
+  %r3 = icmp slt i32 %foo, %bar
+  br i1 %r3, label %BB3, label %BB4
+BB3:
+  ret void
+BB4:
+  ret void
+
+; BBREORDERING-LABEL: func5:
+; BBREORDERING: .Lfunc5$entry:
+; BBREORDERING: .Lfunc5$BB1:
+; BBREORDERING: .Lfunc5$BB2:
+; BBREORDERING: .Lfunc5$BB4:
+; BBREORDERING: .Lfunc5$BB3
+}
+
+define i32 @func6(i32 %arg) {
+entry:
+  %res = add i32 200000, %arg
+  ret i32 %res
+
+; BLINDINGO2-LABEL: func6
+; BLINDINGO2: mov [[REG:e[a-z]*]],0xc798f
+; BLINDINGO2-NEXT: lea [[REG]],{{[[]}}[[REG]]-0x96c4f{{[]]}}
+}
+
+; Check for function reordering
+; FUNCREORDERING-LABEL: func1
+; FUNCREORDERING-LABEL: func4
+; FUNCREORDERING-LABEL: func5
+; FUNCREORDERING-LABEL: func2
+; FUNCREORDERING-LABEL: func6
+; FUNCREORDERING-LABEL: func3
+
+; Check for global variable reordering
+; GLOBALVARS-LABEL: ArrayInit
+; GLOBALVARS-LABEL: PrimitiveInit
+; GLOBALVARS-LABEL: ArrayInitPartial
+; GLOBALVARS-LABEL: PrimitiveUninit
+; GLOBALVARS-LABEL: ArrayUninit
+; GLOBALVARS-LABEL: PrimitiveInitStatic
+; GLOBALVARS-LABEL: ArrayUninitConstDouble
+; GLOBALVARS-LABEL: ArrayUninitConstInt
+; GLOBALVARS-LABEL: PrimitiveInitConst
+
+; Check for pooled constant reordering
+; POOLEDCONSTANTS-LABEL: .rodata.cst4
+; POOLEDCONSTANTS: 0000803e 0000803f 00000000 0000003f
+; POOLEDCONSTANTS: 00008040 00000040