Remove the inttoptr dependency from load instructions.

Elides inttoptr casts used (exclusively) in load instructions when
PNaClVersion=2. This is an incremental start on removing the inttoptr
instruction from the PNaCl wire format (See issue 3544 for more information
on the strategy of removing ptrtoint).

Also modifies PNaCl bitcode reader/writer to accept PNaClVersion=1 as supported,
and PNaClVersion=2 as unsupported but readable (allowing pnacl-freeze and
pnacl-thaw to work on such files).

Also allows command-line option --pnacl-version for setting PNaClVersion in the
PNaCl bitcode writer.

Also fixes some problems on PNaCl bitcode headers, using common support to
determine when the read/written PNaCl bitcode file is valid.

BUG= https://code.google.com/p/nativeclient/issues/detail?id=3544
R=jvoung@chromium.org

Review URL: https://codereview.chromium.org/5812155903377408

1 files changed, 180 insertions, 0 deletions

diff --git a/test/NaCl/Bitcode/inttoptr-elide.ll b/test/NaCl/Bitcode/inttoptr-elide.ll
new file mode 100644
index 0000000000..2f35389fa5
--- /dev/null
+++ b/test/NaCl/Bitcode/inttoptr-elide.ll
@@ -0,0 +1,180 @@
+; Test how we handle eliding inttoptr instructions.
+; TODO(kschimpf) Expand these tests as further CL's are added for issue 3544.
+
+; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=1 | pnacl-bcanalyzer -dump \
+; RUN:              | FileCheck %s -check-prefix=PF1
+
+; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=1 | pnacl-thaw \
+; RUN:              | llvm-dis - | FileCheck %s -check-prefix=TD1
+
+; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=2 | pnacl-bcanalyzer -dump \
+; RUN:              | FileCheck %s -check-prefix=PF2
+
+; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=2 | pnacl-thaw \
+; RUN:              | llvm-dis - | FileCheck %s -check-prefix=TD2
+
+; ------------------------------------------------------
+
+; Test that we elide the simple case of inttoptr of a load.
+define void @SimpleLoad(i32 %i) {
+  %1 = inttoptr i32 %i to i32*
+  %2 = load i32* %1, align 4
+  ret void
+}
+
+; TD1:      define void @SimpleLoad(i32 %i) {
+; TD1-NEXT:   %1 = inttoptr i32 %i to i32*
+; TD1-NEXT:   %2 = load i32* %1, align 4
+; TD1-NEXT:   ret void
+; TD1-NEXT: }
+
+; PF1:       <FUNCTION_BLOCK NumWords=6 BlockCodeSize=4>
+; PF1-NEXT:    <DECLAREBLOCKS op0=1/>
+; PF1-NEXT:    <INST_CAST abbrevid=7 op0=1 op1=1 op2=10/>
+; PF1-NEXT:    <INST_LOAD abbrevid=4 op0=1 op1=3 op2=0/>
+; PF1-NEXT:    <INST_RET abbrevid=8/>
+; PF1:       </FUNCTION_BLOCK>
+
+; TD2:      define void @SimpleLoad(i32 %i) {
+; TD2-NEXT:   %1 = inttoptr i32 %i to i32*
+; TD2-NEXT:   %2 = load i32* %1, align 4
+; TD2-NEXT:   ret void
+; TD2-NEXT: }
+
+; PF2:       <FUNCTION_BLOCK NumWords=5 BlockCodeSize=4>
+; PF2-NEXT:    <DECLAREBLOCKS op0=1/>
+; PF2-NEXT:    <INST_LOAD abbrevid=4 op0=1 op1=3 op2=0 op3=0/>
+; PF2-NEXT:    <INST_RET abbrevid=8/>
+; PF2:       </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+
+; Test that we don't elide an inttoptr if one of its uses is not a load.
+define i32* @NonsimpleLoad(i32 %i) {
+  %1 = inttoptr i32 %i to i32*
+  %2 = load i32* %1, align 4
+  ret i32* %1
+}
+
+; TD1:      define i32* @NonsimpleLoad(i32 %i) {
+; TD1-NEXT:   %1 = inttoptr i32 %i to i32*
+; TD1-NEXT:   %2 = load i32* %1, align 4
+; TD1-NEXT:   ret i32* %1
+; TD1-NEXT: }
+
+; PF1:       <FUNCTION_BLOCK NumWords=6 BlockCodeSize=4>
+; PF1-NEXT:    <DECLAREBLOCKS op0=1/>
+; PF1-NEXT:    <INST_CAST abbrevid=7 op0=1 op1=1 op2=10/>
+; PF1-NEXT:    <INST_LOAD abbrevid=4 op0=1 op1=3 op2=0/>
+; PF1-NEXT:    <INST_RET abbrevid=9 op0=2/>
+; PF1:       </FUNCTION_BLOCK>
+
+; TD2:      define i32* @NonsimpleLoad(i32 %i) {
+; TD2-NEXT:   %1 = inttoptr i32 %i to i32*
+; TD2-NEXT:   %2 = load i32* %1, align 4
+; TD2-NEXT:   ret i32* %1
+; TD2-NEXT: }
+
+; PF2:       <FUNCTION_BLOCK NumWords=6 BlockCodeSize=4>
+; PF2-NEXT:    <DECLAREBLOCKS op0=1/>
+; PF2-NEXT:    <INST_CAST abbrevid=7 op0=1 op1=1 op2=10/>
+; PF2-NEXT:    <INST_LOAD abbrevid=4 op0=1 op1=3 op2=0 op3=0/>
+; PF2-NEXT:    <INST_RET abbrevid=9 op0=2/>
+; PF2:       </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+
+; Test that we can handle multiple inttoptr of loads.
+define i32 @TwoLoads(i32 %i) {
+  %1 = inttoptr i32 %i to i32*
+  %2 = load i32* %1, align 4
+  %3 = inttoptr i32 %i to i32*
+  %4 = load i32* %3, align 4
+  %5 = add i32 %2, %4
+  ret i32 %5
+}
+
+; TD1:      define i32 @TwoLoads(i32 %i) {
+; TD1-NEXT:   %1 = inttoptr i32 %i to i32*
+; TD1-NEXT:   %2 = load i32* %1, align 4
+; TD1-NEXT:   %3 = inttoptr i32 %i to i32*
+; TD1-NEXT:   %4 = load i32* %3, align 4
+; TD1-NEXT:   %5 = add i32 %2, %4
+; TD1-NEXT:   ret i32 %5
+; TD1-NEXT: }
+
+; PF1:       <FUNCTION_BLOCK NumWords=8 BlockCodeSize=4>
+; PF1-NEXT:    <DECLAREBLOCKS op0=1/>
+; PF1-NEXT:    <INST_CAST abbrevid=7 op0=1 op1=1 op2=10/>
+; PF1-NEXT:    <INST_LOAD abbrevid=4 op0=1 op1=3 op2=0/>
+; PF1-NEXT:    <INST_CAST abbrevid=7 op0=3 op1=1 op2=10/>
+; PF1-NEXT:    <INST_LOAD abbrevid=4 op0=1 op1=3 op2=0/>
+; PF1-NEXT:    <INST_BINOP abbrevid=5 op0=3 op1=1 op2=0/>
+; PF1-NEXT:    <INST_RET abbrevid=9 op0=1/>
+; PF1:       </FUNCTION_BLOCK>
+
+; TD2:      define i32 @TwoLoads(i32 %i) {
+; TD2-NEXT:   %1 = inttoptr i32 %i to i32*
+; TD2-NEXT:   %2 = load i32* %1, align 4
+; TD2-NEXT:   %3 = inttoptr i32 %i to i32*
+; TD2-NEXT:   %4 = load i32* %3, align 4
+; TD2-NEXT:   %5 = add i32 %2, %4
+; TD2-NEXT:   ret i32 %5
+; TD2-NEXT: }
+
+
+; PF2:       <FUNCTION_BLOCK NumWords=7 BlockCodeSize=4>
+; PF2-NEXT:    <DECLAREBLOCKS op0=1/>
+; PF2-NEXT:    <INST_LOAD abbrevid=4 op0=1 op1=3 op2=0 op3=0/>
+; PF2-NEXT:    <INST_LOAD abbrevid=4 op0=2 op1=3 op2=0 op3=0/>
+; PF2-NEXT:    <INST_BINOP abbrevid=5 op0=2 op1=1 op2=0/>
+; PF2-NEXT:    <INST_RET abbrevid=9 op0=1/>
+; PF2:      </FUNCTION_BLOCK>
+
+; ------------------------------------------------------
+
+; Test how we duplicate inttoptrs, even if optimized in the input file.
+define i32 @TwoLoadOpt(i32 %i) {
+  %1 = inttoptr i32 %i to i32*
+  %2 = load i32* %1, align 4
+  %3 = load i32* %1, align 4
+  %4 = add i32 %2, %3
+  ret i32 %4
+}
+
+; TD1:      define i32 @TwoLoadOpt(i32 %i) {
+; TD1-NEXT:   %1 = inttoptr i32 %i to i32*
+; TD1-NEXT:   %2 = load i32* %1, align 4
+; TD1-NEXT:   %3 = load i32* %1, align 4
+; TD1-NEXT:   %4 = add i32 %2, %3
+; TD1-NEXT:   ret i32 %4
+; TD1-NEXT: }
+
+; PF1:       <FUNCTION_BLOCK NumWords=7 BlockCodeSize=4>
+; PF1-NEXT:    <DECLAREBLOCKS op0=1/>
+; PF1-NEXT:    <INST_CAST abbrevid=7 op0=1 op1=1 op2=10/>
+; PF1-NEXT:    <INST_LOAD abbrevid=4 op0=1 op1=3 op2=0/>
+; PF1-NEXT:    <INST_LOAD abbrevid=4 op0=2 op1=3 op2=0/>
+; PF1-NEXT:    <INST_BINOP abbrevid=5 op0=2 op1=1 op2=0/>
+; PF1-NEXT:    <INST_RET abbrevid=9 op0=1/>
+; PF1:       </FUNCTION_BLOCK>
+
+; TD2:      define i32 @TwoLoadOpt(i32 %i) {
+; TD2-NEXT:   %1 = inttoptr i32 %i to i32*
+; TD2-NEXT:   %2 = load i32* %1, align 4
+; TD2-NEXT:   %3 = inttoptr i32 %i to i32*
+; TD2-NEXT:   %4 = load i32* %3, align 4
+; TD2-NEXT:   %5 = add i32 %2, %4
+; TD2-NEXT:   ret i32 %5
+; TD2-NEXT: }
+
+; PF2:       <FUNCTION_BLOCK NumWords=7 BlockCodeSize=4>
+; PF2-NEXT:    <DECLAREBLOCKS op0=1/>
+; PF2-NEXT:    <INST_LOAD abbrevid=4 op0=1 op1=3 op2=0 op3=0/>
+; PF2-NEXT:    <INST_LOAD abbrevid=4 op0=2 op1=3 op2=0 op3=0/>
+; PF2-NEXT:    <INST_BINOP abbrevid=5 op0=2 op1=1 op2=0/>
+; PF2-NEXT:    <INST_RET abbrevid=9 op0=1/>
+; PF2-NEXT:    <VALUE_SYMTAB NumWords=1 BlockCodeSize=3>
+; PF2-NEXT:      <ENTRY abbrevid=6 op0=4 op1=105/>
+; PF2-NEXT:    </VALUE_SYMTAB>
+; PF2:       </FUNCTION_BLOCK>