path: root/test/NaCl/Bitcode/ptrtoint-elide.ll

; Test how we handle eliding ptrtoint instructions.

; RUN: llvm-as < %s | pnacl-freeze --pnacl-version=1 \
; RUN:              | pnacl-bcanalyzer -dump-records \
; 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 \
; RUN:              | pnacl-bcanalyzer -dump-records \
; 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

; ------------------------------------------------------

declare i32 @bar(i32)

@bytes = internal global [4 x i8] c"abcd"

; ------------------------------------------------------

; Show simple case where we use ptrtoint
define void @AllocCastSimple() {
  %1 = alloca i8, i32 4, align 8
  %2 = ptrtoint i8* %1 to i32
  %3 = bitcast [4 x i8]* @bytes to i32*
  store i32 %2, i32* %3, align 1
  ret void
}

; TD1:      define void @AllocCastSimple() {
; TD1-NEXT:   %1 = alloca i8, i32 4, align 8
; TD1-NEXT:   %2 = ptrtoint i8* %1 to i32
; TD1-NEXT:   %3 = bitcast [4 x i8]* @bytes to i32*
; TD1-NEXT:   store i32 %2, i32* %3, align 1
; TD1-NEXT:   ret void
; TD1-NEXT: }

; PF1:        <FUNCTION_BLOCK>
; PF1:          </CONSTANTS_BLOCK>
; PF1-NEXT:     <INST_ALLOCA op0=1 op1=4/>
; PF1-NEXT:     <INST_CAST op0=1 op1={{.*}} op2=9/>
; PF1-NEXT:     <INST_CAST op0=4 op1={{.*}} op2=11/>
; PF1-NEXT:     <INST_STORE op0=1 op1=2 op2=1 op3=0/>
; PF1-NEXT:     <INST_RET/>
; PF1-NEXT:   </FUNCTION_BLOCK>

; TD2:      define void @AllocCastSimple() {
; TD2-NEXT:   %1 = alloca i8, i32 4, align 8
; TD2-NEXT:   %2 = ptrtoint i8* %1 to i32
; TD2-NEXT:   %3 = bitcast [4 x i8]* @bytes to i32*
; TD2-NEXT:   store i32 %2, i32* %3, align 1
; TD2-NEXT:   ret void
; TD2-NEXT: }

; PF2:        <FUNCTION_BLOCK>
; PF2:          </CONSTANTS_BLOCK>
; PF2-NEXT:     <INST_ALLOCA op0=1 op1=4/>
; PF2-NEXT:     <INST_STORE op0=3 op1=1 op2=1/>
; PF2-NEXT:     <INST_RET/>
; PF2-NEXT:   </FUNCTION_BLOCK>

; ------------------------------------------------------

; Same as above, but with the cast order changed. Shows
; that we always inject casts back in a fixed order. Hence,
; in PNaCl version 2, the casts will be reversed.
define void @AllocCastSimpleReversed() {
  %1 = alloca i8, i32 4, align 8
  %2 = bitcast [4 x i8]* @bytes to i32*
  %3 = ptrtoint i8* %1 to i32
  store i32 %3, i32* %2, align 1
  ret void
}

; TD1:      define void @AllocCastSimpleReversed() {
; TD1-NEXT:   %1 = alloca i8, i32 4, align 8
; TD1-NEXT:   %2 = bitcast [4 x i8]* @bytes to i32*
; TD1-NEXT:   %3 = ptrtoint i8* %1 to i32
; TD1-NEXT:   store i32 %3, i32* %2, align 1
; TD1-NEXT:   ret void
; TD1-NEXT: }

; PF1:        <FUNCTION_BLOCK>
; PF1:          </CONSTANTS_BLOCK>
; PF1-NEXT:     <INST_ALLOCA op0=1 op1=4/>
; PF1-NEXT:     <INST_CAST op0=3 op1={{.*}} op2=11/>
; PF1-NEXT:     <INST_CAST op0=2 op1={{.*}} op2=9/>
; PF1-NEXT:     <INST_STORE op0=2 op1=1 op2=1 op3=0/>
; PF1-NEXT:     <INST_RET/>
; PF1-NEXT:   </FUNCTION_BLOCK>

; TD2:      define void @AllocCastSimpleReversed() {
; TD2-NEXT:   %1 = alloca i8, i32 4, align 8
; TD2-NEXT:   %2 = ptrtoint i8* %1 to i32
; TD2-NEXT:   %3 = bitcast [4 x i8]* @bytes to i32*
; TD2-NEXT:   store i32 %2, i32* %3, align 1
; TD2-NEXT:   ret void
; TD2-NEXT: }

; PF2:        <FUNCTION_BLOCK>
; PF2:          </CONSTANTS_BLOCK>
; PF2-NEXT:     <INST_ALLOCA op0=1 op1=4/>
; PF2-NEXT:     <INST_STORE op0=3 op1=1 op2=1/>
; PF2-NEXT:     <INST_RET/>
; PF2-NEXT:   </FUNCTION_BLOCK>

; ------------------------------------------------------

; Show case where we delete ptrtoint because they aren't used.
define void @AllocCastDelete() {
  %1 = alloca i8, i32 4, align 8
  %2 = ptrtoint i8* %1 to i32
  %3 = alloca i8, i32 4, align 8
  %4 =