Index: test/Transforms/NaCl/replace-ptrs-with-ints.ll |
diff --git a/test/Transforms/NaCl/replace-ptrs-with-ints.ll b/test/Transforms/NaCl/replace-ptrs-with-ints.ll |
new file mode 100644 |
index 0000000000000000000000000000000000000000..aaba9da0b7dd9deffa2edc90e1fa09b1856b24e5 |
--- /dev/null |
+++ b/test/Transforms/NaCl/replace-ptrs-with-ints.ll |
@@ -0,0 +1,634 @@ |
+; RUN: opt %s -replace-ptrs-with-ints -S | FileCheck %s |
+ |
+target datalayout = "p:32:32:32" |
+ |
+ |
+%struct = type { i32, i32 } |
+ |
+declare %struct* @addr_taken_func(%struct*) |
+ |
+@addr_of_func = global %struct* (%struct*)* @addr_taken_func |
+; CHECK: @addr_of_func = global %struct* (%struct*)* bitcast (i32 (i32)* @addr_taken_func to %struct* (%struct*)*) |
+ |
+@blockaddr = global i8* blockaddress(@indirectbr, %l1) |
+; CHECK: @blockaddr = global i8* blockaddress(@indirectbr, %l1) |
+ |
+ |
+define i8* @pointer_arg(i8* %ptr, i64 %non_ptr) { |
+ ret i8* %ptr |
+} |
+; CHECK: define i32 @pointer_arg(i32 %ptr, i64 %non_ptr) { |
+; CHECK-NEXT: ret i32 %ptr |
+; CHECK-NEXT: } |
+ |
+ |
+declare i8* @declared_func(i8*, i64) |
+; CHECK: declare i32 @declared_func(i32, i64) |
+ |
+ |
+define void @self_reference_phi(i8* %ptr) { |
+entry: |
+ br label %loop |
+loop: |
+ %x = phi i8* [ %x, %loop ], [ %ptr, %entry ] |
+ br label %loop |
+} |
+; CHECK: define void @self_reference_phi(i32 %ptr) { |
+; CHECK: %x = phi i32 [ %x, %loop ], [ %ptr, %entry ] |
+ |
+; Self-referencing bitcasts are possible in unreachable basic blocks. |
+; It is not very likely that we will encounter this, but we handle it |
+; for completeness. |
+define void @self_reference_bitcast(i8** %dest) { |
+ ret void |
+unreachable_loop: |
+ store i8* %self_ref, i8** %dest |
+ %self_ref = bitcast i8* %self_ref to i8* |
+ store i8* %self_ref, i8** %dest |
+ br label %unreachable_loop |
+} |
+; CHECK: define void @self_reference_bitcast(i32 %dest) { |
+; CHECK: store i32 undef, i32* %dest.asptr |
+; CHECK: store i32 undef, i32* %dest.asptr |
+ |
+define void @circular_reference_bitcasts(i8** %dest) { |
+ ret void |
+unreachable_loop: |
+ store i8* %cycle1, i8** %dest |
+ %cycle1 = bitcast i8* %cycle2 to i8* |
+ %cycle2 = bitcast i8* %cycle1 to i8* |
+ br label %unreachable_loop |
+} |
+; CHECK: define void @circular_reference_bitcasts(i32 %dest) { |
+; CHECK: store i32 undef, i32* %dest.asptr |
+ |
+define void @circular_reference_inttoptr(i8** %dest) { |
+ ret void |
+unreachable_loop: |
+ %ptr = inttoptr i32 %int to i8* |
+ %int = ptrtoint i8* %ptr to i32 |
+ store i8* %ptr, i8** %dest |
+ br label %unreachable_loop |
+} |
+; CHECK: define void @circular_reference_inttoptr(i32 %dest) { |
+; CHECK: store i32 undef, i32* %dest.asptr |
+ |
+define i8* @forwards_reference(%struct** %ptr) { |
+ br label %block1 |
+block2: |
+ ; Forwards reference to %val. |
+ %cast = bitcast %struct* %val to i8* |
+ br label %block3 |
+block1: |
+ %val = load %struct** %ptr |
+ br label %block2 |
+block3: |
+ ; Backwards reference to a forwards reference that has already been |
+ ; resolved. |
+ ret i8* %cast |
+} |
+; CHECK: define i32 @forwards_reference(i32 %ptr) { |
+; CHECK-NEXT: br label %block1 |
+; CHECK: block2: |
+; CHECK-NEXT: br label %block3 |
+; CHECK: block1: |
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32* |
+; CHECK-NEXT: %val = load i32* %ptr.asptr |
+; CHECK-NEXT: br label %block2 |
+; CHECK: block3: |
+; CHECK-NEXT: ret i32 %val |
+ |
+ |
+define i8* @phi_multiple_entry(i1 %arg, i8* %ptr) { |
+entry: |
+ br i1 %arg, label %done, label %done |
+done: |
+ %result = phi i8* [ %ptr, %entry ], [ %ptr, %entry ] |
+ ret i8* %result |
+} |
+; CHECK: define i32 @phi_multiple_entry(i1 %arg, i32 %ptr) { |
+; CHECK: %result = phi i32 [ %ptr, %entry ], [ %ptr, %entry ] |
+ |
+ |
+define i8* @select(i1 %cond, i8* %val1, i8* %val2) { |
+ %r = select i1 %cond, i8* %val1, i8* %val2 |
+ ret i8* %r |
+} |
+; CHECK: define i32 @select(i1 %cond, i32 %val1, i32 %val2) { |
+; CHECK-NEXT: %r = select i1 %cond, i32 %val1, i32 %val2 |
+ |
+ |
+define i32* @ptrtoint_same_size(i32* %ptr) { |
+ %a = ptrtoint i32* %ptr to i32 |
+ %b = add i32 %a, 4 |
+ %c = inttoptr i32 %b to i32* |
+ ret i32* %c |
+} |
+; CHECK: define i32 @ptrtoint_same_size(i32 %ptr) { |
+; CHECK-NEXT: %b = add i32 %ptr, 4 |
+; CHECK-NEXT: ret i32 %b |
+ |
+ |
+define i32* @ptrtoint_different_size(i32* %ptr) { |
+ %a = ptrtoint i32* %ptr to i64 |
+ %b = add i64 %a, 4 |
+ %c = inttoptr i64 %b to i32* |
+ ret i32* %c |
+} |
+; CHECK: define i32 @ptrtoint_different_size(i32 %ptr) { |
+; CHECK-NEXT: %a = zext i32 %ptr to i64 |
+; CHECK-NEXT: %b = add i64 %a, 4 |
+; CHECK-NEXT: %c = trunc i64 %b to i32 |
+; CHECK-NEXT: ret i32 %c |
+ |
+define i8 @ptrtoint_truncates_var(i32* %ptr) { |
+ %a = ptrtoint i32* %ptr to i8 |
+ ret i8 %a |
+} |
+; CHECK: define i8 @ptrtoint_truncates_var(i32 %ptr) { |
+; CHECK-NEXT: %a = trunc i32 %ptr to i8 |
+ |
+define i8 @ptrtoint_truncates_global() { |
+ %a = ptrtoint i32* @var to i8 |
+ ret i8 %a |
+} |
+; CHECK: define i8 @ptrtoint_truncates_global() { |
+; CHECK-NEXT: %expanded = ptrtoint i32* @var to i32 |
+; CHECK-NEXT: %a = trunc i32 %expanded to i8 |
+ |
+ |
+define i32* @pointer_bitcast(i64* %ptr) { |
+ %cast = bitcast i64* %ptr to i32* |
+ ret i32* %cast |
+} |
+; CHECK: define i32 @pointer_bitcast(i32 %ptr) { |
+; CHECK-NEXT: ret i32 %ptr |
+ |
+; Same-type non-pointer bitcasts happen to be left alone by this pass. |
+define i32 @no_op_bitcast(i32 %val) { |
+ %val2 = bitcast i32 %val to i32 |
+ ret i32 %val2 |
+} |
+; CHECK: define i32 @no_op_bitcast(i32 %val) { |
+; CHECK-NEXT: %val2 = bitcast i32 %val to i32 |
+ |
+define i64 @kept_bitcast(double %d) { |
+ %i = bitcast double %d to i64 |
+ ret i64 %i |
+} |
+; CHECK: define i64 @kept_bitcast(double %d) { |
+; CHECK-NEXT: %i = bitcast double %d to i64 |
+ |
+ |
+define i32 @constant_pointer_null() { |
+ %val = ptrtoint i32* null to i32 |
+ ret i32 %val |
+} |
+; CHECK: define i32 @constant_pointer_null() { |
+; CHECK-NEXT: ret i32 0 |
+ |
+define i32 @constant_pointer_undef() { |
+ %val = ptrtoint i32* undef to i32 |
+ ret i32 %val |
+} |
+; CHECK: define i32 @constant_pointer_undef() { |
+; CHECK-NEXT: ret i32 undef |
+ |
+define i16* @constant_pointer_null_load() { |
+ %val = load i16** null |
+ ret i16* %val |
+} |
+; CHECK: define i32 @constant_pointer_null_load() { |
+; CHECK-NEXT: %.asptr = inttoptr i32 0 to i32* |
+; CHECK-NEXT: %val = load i32* %.asptr |
+ |
+define i16* @constant_pointer_undef_load() { |
+ %val = load i16** undef |
+ ret i16* %val |
+} |
+; CHECK: define i32 @constant_pointer_undef_load() { |
+; CHECK-NEXT: %.asptr = inttoptr i32 undef to i32* |
+; CHECK-NEXT: %val = load i32* %.asptr |
+ |
+ |
+define i8 @load(i8* %ptr) { |
+ %x = load i8* %ptr |
+ ret i8 %x |
+} |
+; CHECK: define i8 @load(i32 %ptr) { |
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i8* |
+; CHECK-NEXT: %x = load i8* %ptr.asptr |
+ |
+define void @store(i8* %ptr, i8 %val) { |
+ store i8 %val, i8* %ptr |
+ ret void |
+} |
+; CHECK: define void @store(i32 %ptr, i8 %val) { |
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i8* |
+; CHECK-NEXT: store i8 %val, i8* %ptr.asptr |
+ |
+ |
+define i8* @load_ptr(i8** %ptr) { |
+ %x = load i8** %ptr |
+ ret i8* %x |
+} |
+; CHECK: define i32 @load_ptr(i32 %ptr) { |
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32* |
+; CHECK-NEXT: %x = load i32* %ptr.asptr |
+ |
+define void @store_ptr(i8** %ptr, i8* %val) { |
+ store i8* %val, i8** %ptr |
+ ret void |
+} |
+; CHECK: define void @store_ptr(i32 %ptr, i32 %val) { |
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32* |
+; CHECK-NEXT: store i32 %val, i32* %ptr.asptr |
+ |
+ |
+define i8 @load_attrs(i8* %ptr) { |
+ %x = load atomic volatile i8* %ptr seq_cst, align 128 |
+ ret i8 %x |
+} |
+; CHECK: define i8 @load_attrs(i32 %ptr) { |
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i8* |
+; CHECK-NEXT: %x = load atomic volatile i8* %ptr.asptr seq_cst, align 128 |
+ |
+define void @store_attrs(i8* %ptr, i8 %val) { |
+ store atomic volatile i8 %val, i8* %ptr singlethread release, align 256 |
+ ret void |
+} |
+; CHECK: define void @store_attrs(i32 %ptr, i8 %val) { |
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i8* |
+; CHECK-NEXT: store atomic volatile i8 %val, i8* %ptr.asptr singlethread release, align 256 |
+ |
+ |
+define i32 @cmpxchg(i32* %ptr, i32 %a, i32 %b) { |
+ %r = cmpxchg i32* %ptr, i32 %a, i32 %b seq_cst seq_cst |
+ %res = extractvalue { i32, i1 } %r, 0 |
+ ret i32 %res |
+} |
+; CHECK: define i32 @cmpxchg(i32 %ptr, i32 %a, i32 %b) { |
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32* |
+; CHECK-NEXT: %r = cmpxchg i32* %ptr.asptr, i32 %a, i32 %b seq_cst seq_cst |
+ |
+define i32 @atomicrmw(i32* %ptr, i32 %x) { |
+ %r = atomicrmw add i32* %ptr, i32 %x seq_cst |
+ ret i32 %r |
+} |
+; CHECK: define i32 @atomicrmw(i32 %ptr, i32 %x) { |
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i32* |
+; CHECK-NEXT: %r = atomicrmw add i32* %ptr.asptr, i32 %x seq_cst |
+ |
+ |
+define i8* @indirect_call(i8* (i8*)* %func, i8* %arg) { |
+ %result = call i8* %func(i8* %arg) |
+ ret i8* %result |
+} |
+; CHECK: define i32 @indirect_call(i32 %func, i32 %arg) { |
+; CHECK-NEXT: %func.asptr = inttoptr i32 %func to i32 (i32)* |
+; CHECK-NEXT: %result = call i32 %func.asptr(i32 %arg) |
+; CHECK-NEXT: ret i32 %result |
+ |
+ |
+; Test forwards reference |
+define i8* @direct_call1(i8* %arg) { |
+ %result = call i8* @direct_call2(i8* %arg) |
+ ret i8* %result |
+} |
+; CHECK: define i32 @direct_call1(i32 %arg) { |
+; CHECK-NEXT: %result = call i32 @direct_call2(i32 %arg) |
+; CHECK-NEXT: ret i32 %result |
+ |
+; Test backwards reference |
+define i8* @direct_call2(i8* %arg) { |
+ %result = call i8* @direct_call1(i8* %arg) |
+ ret i8* %result |
+} |
+; CHECK: define i32 @direct_call2(i32 %arg) { |
+; CHECK-NEXT: %result = call i32 @direct_call1(i32 %arg) |
+; CHECK-NEXT: ret i32 %result |
+ |
+ |
+@var = global i32 0 |
+ |
+define i32* @get_addr_of_global() { |
+ ret i32* @var |
+} |
+; CHECK: define i32 @get_addr_of_global() { |
+; CHECK-NEXT: %expanded = ptrtoint i32* @var to i32 |
+; CHECK-NEXT: ret i32 %expanded |
+ |
+define %struct* (%struct*)* @get_addr_of_func() { |
+ ret %struct* (%struct*)* @addr_taken_func |
+} |
+; CHECK: define i32 @get_addr_of_func() { |
+; CHECK-NEXT: %expanded = ptrtoint i32 (i32)* @addr_taken_func to i32 |
+; CEHCK-NEXT: ret i32 %expanded |
+ |
+ |
+define i32 @load_global() { |
+ %val = load i32* @var |
+ ret i32 %val |
+} |
+; CHECK: define i32 @load_global() { |
+; CHECK-NEXT: %val = load i32* @var |
+; CHECK-NEXT: ret i32 %val |
+ |
+define i16 @load_global_bitcast() { |
+ %ptr = bitcast i32* @var to i16* |
+ %val = load i16* %ptr |
+ ret i16 %val |
+} |
+; CHECK: define i16 @load_global_bitcast() { |
+; CHECK-NEXT: %var.bc = bitcast i32* @var to i16* |
+; CHECK-NEXT: %val = load i16* %var.bc |
+; CHECK-NEXT: ret i16 %val |
+ |
+ |
+; Check that unsimplified allocas are properly handled: |
+declare void @receive_alloca(%struct* %ptr) |
+ |
+define void @unsimplified_alloca() { |
+ %a = alloca %struct |
+ call void @receive_alloca(%struct* %a) |
+ unreachable |
+} |
+; CHECK-LABEL: define void @unsimplified_alloca() |
+; CHECK-NEXT: %a = alloca %struct |
+; CHECK-NEXT: %a.asint = ptrtoint %struct* %a to i32 |
+; CHECK-NEXT: call void @receive_alloca(i32 %a.asint) |
+; CHECK-NEXT: unreachable |
+ |
+ |
+define i1 @compare(i8* %ptr1, i8* %ptr2) { |
+ %cmp = icmp ult i8* %ptr1, %ptr2 |
+ ret i1 %cmp |
+} |
+; CHECK: define i1 @compare(i32 %ptr1, i32 %ptr2) { |
+; CHECK-NEXT: %cmp = icmp ult i32 %ptr1, %ptr2 |
+ |
+ |
+declare i8* @llvm.some.intrinsic(i8* %ptr) |
+ |
+define i8* @preserve_intrinsic_type(i8* %ptr) { |
+ %result = call i8* @llvm.some.intrinsic(i8* %ptr) |
+ ret i8* %result |
+} |
+; CHECK: define i32 @preserve_intrinsic_type(i32 %ptr) { |
+; CHECK-NEXT: %ptr.asptr = inttoptr i32 %ptr to i8* |
+; CHECK-NEXT: %result = call i8* @llvm.some.intrinsic(i8* %ptr.asptr) |
+; CHECK-NEXT: %result.asint = ptrtoint i8* %result to i32 |
+; CHECK-NEXT: ret i32 %result.asint |
+ |
+ |
+; Just check that the pass does not crash on inline asm. |
+define i16* @inline_asm1(i8* %ptr) { |
+ %val = call i16* asm "foo", "=r,r"(i8* %ptr) |
+ ret i16* %val |
+} |
+ |
+define i16** @inline_asm2(i8** %ptr) { |
+ %val = call i16** asm "foo", "=r,r"(i8** %ptr) |
+ ret i16** %val |
+} |
+ |
+ |
+declare void @llvm.dbg.declare(metadata, metadata, metadata) |
+declare void @llvm.dbg.value(metadata, i64, metadata, metadata) |
+ |
+define void @debug_declare(i32 %val) { |
+ ; We normally expect llvm.dbg.declare to be used on an alloca. |
+ %var = alloca i32 |
+ call void @llvm.dbg.declare(metadata !{i32* %var}, metadata !2, metadata !14) |
+ call void @llvm.dbg.declare(metadata !{i32 %val}, metadata !2, metadata !14) |
+ ret void |
+} |
+; CHECK: define void @debug_declare(i32 %val) { |
+; CHECK-NEXT: %var = alloca i32 |
+; CHECK-NEXT: call void @llvm.dbg.declare(metadata !{i32* %var}, metadata !2, metadata !14) |
+; This case is currently not converted. |
+; CHECK-NEXT: call void @llvm.dbg.declare(metadata !{null}, metadata !2, metadata !14) |
+; CHECK-NEXT: ret void |
+ |
+; For now, debugging info for values is lost. replaceAllUsesWith() |
+; does not work for metadata references -- it converts them to nulls. |
+; This makes dbg.value too tricky to handle for now. |
+define void @debug_value(i32 %val, i8* %ptr) { |
+ tail call void @llvm.dbg.value(metadata !{i32 %val}, i64 1, metadata !1, metadata !14) |
+ tail call void @llvm.dbg.value(metadata !{i8* %ptr}, i64 2, metadata !1, metadata !14) |
+ ret void |
+} |
+; CHECK: define void @debug_value(i32 %val, i32 %ptr) { |
+; CHECK-NEXT: call void @llvm.dbg.value(metadata !{null}, i64 1, metadata !1, metadata !14) |
+; CHECK-NEXT: call void @llvm.dbg.value(metadata !{null}, i64 2, metadata !1, metadata !14) |
+; CHECK-NEXT: ret void |
+ |
+ |
+declare void @llvm.lifetime.start(i64 %size, i8* %ptr) |
+declare {}* @llvm.invariant.start(i64 %size, i8* %ptr) |
+declare void @llvm.invariant.end({}* %start, i64 %size, i8* %ptr) |
+ |
+; GVN can introduce the following horrible corner case of a lifetime |
+; marker referencing a PHI node. But we convert the phi to i32 type, |
+; and lifetime.start doesn't work on an inttoptr converting an i32 phi |
+; to a pointer. Because of this, we just strip out all lifetime |
+; markers. |
+ |
+define void @alloca_lifetime_via_phi() { |
+entry: |
+ %buf = alloca i8 |
+ br label %block |
+block: |
+ %phi = phi i8* [ %buf, %entry ] |
+ call void @llvm.lifetime.start(i64 -1, i8* %phi) |
+ ret void |
+} |
+; CHECK: define void @alloca_lifetime_via_phi() { |
+; CHECK: %phi = phi i32 [ %buf.asint, %entry ] |
+; CHECK-NEXT: ret void |
+ |
+define void @alloca_lifetime() { |
+ %buf = alloca i8 |
+ call void @llvm.lifetime.start(i64 -1, i8* %buf) |
+ ret void |
+} |
+; CHECK: define void @alloca_lifetime() { |
+; CHECK-NEXT: %buf = alloca i8 |
+; CHECK-NEXT: ret void |
+ |
+define void @alloca_lifetime_via_bitcast() { |
+ %buf = alloca i32 |
+ %buf_cast = bitcast i32* %buf to i8* |
+ call void @llvm.lifetime.start(i64 -1, i8* %buf_cast) |
+ ret void |
+} |
+; CHECK: define void @alloca_lifetime_via_bitcast() { |
+; CHECK-NEXT: %buf = alloca i32 |
+; CHECK-NEXT: ret void |
+ |
+ |
+define void @strip_invariant_markers() { |
+ %buf = alloca i8 |
+ %start = call {}* @llvm.invariant.start(i64 1, i8* %buf) |
+ call void @llvm.invariant.end({}* %start, i64 1, i8* %buf) |
+ ret void |
+} |
+; CHECK: define void @strip_invariant_markers() { |
+; CHECK-NEXT: %buf = alloca i8 |
+; CHECK-NEXT: ret void |
+ |
+ |
+; "nocapture" and "noalias" only apply to pointers, so must be stripped. |
+define void @nocapture_attr(i8* nocapture noalias %ptr) { |
+ ret void |
+} |
+; CHECK: define void @nocapture_attr(i32 %ptr) { |
+ |
+ |
+define void @readonly_readnone(i8* readonly readnone) { |
+ ret void |
+} |
+; CHECK-LABEL: define void @readonly_readnone(i32) |
+ |
+; "nounwind" should be preserved. |
+define void @nounwind_func_attr() nounwind { |
+ ret void |
+} |
+; CHECK: define void @nounwind_func_attr() [[NOUNWIND:#[0-9]+]] { |
+ |
+define void @nounwind_call_attr() { |
+ call void @nounwind_func_attr() nounwind |
+ ret void |
+} |
+; CHECK: define void @nounwind_call_attr() { |
+; CHECK: call void @nounwind_func_attr() {{.*}}[[NOUNWIND]] |
+ |
+define fastcc void @fastcc_func() { |
+ ret void |
+} |
+; CHECK: define fastcc void @fastcc_func() { |
+ |
+define void @fastcc_call() { |
+ call fastcc void @fastcc_func() |
+ ret void |
+} |
+; CHECK: define void @fastcc_call() { |
+; CHECK-NEXT: call fastcc void @fastcc_func() |
+ |
+define void @tail_call() { |
+ tail call void @tail_call() |
+ ret void |
+} |
+; CHECK: define void @tail_call() |
+; CHECK-NEXT: tail call void @tail_call() |
+ |
+ |
+; Just check that the pass does not crash on getelementptr. (The pass |
+; should not depend unnecessarily on ExpandGetElementPtr having been |
+; run.) |
+define i8* @getelementptr(i8* %ptr) { |
+ %gep = getelementptr i8* %ptr, i32 10 |
+ ret i8* %gep |
+} |
+ |
+; Just check that the pass does not crash on va_arg. |
+define i32* @va_arg(i8* %valist) { |
+ %r = va_arg i8* %valist, i32* |
+ ret i32* %r |
+} |
+ |
+ |
+define void @indirectbr(i8* %addr) { |
+ indirectbr i8* %addr, [ label %l1, label %l2 ] |
+l1: |
+ ret void |
+l2: |
+ ret void |
+} |
+; CHECK: define void @indirectbr(i32 %addr) { |
+; CHECK-NEXT: %addr.asptr = inttoptr i32 %addr to i8* |
+; CHECK-NEXT: indirectbr i8* %addr.asptr, [label %l1, label %l2] |
+ |
+ |
+define i8* @invoke(i8* %val) { |
+ %result = invoke i8* @direct_call1(i8* %val) |
+ to label %cont unwind label %lpad |
+cont: |
+ ret i8* %result |
+lpad: |
+ %lp = landingpad { i8*, i32 } personality void (i8*)* @personality_func cleanup |
+ %p = extractvalue { i8*, i32 } %lp, 0 |
+ %s = insertvalue { i8*, i32 } %lp, i8* %val, 0 |
+ ret i8* %p |
+} |
+; CHECK: define i32 @invoke(i32 %val) { |
+; CHECK-NEXT: %result = invoke i32 @direct_call1(i32 %val) |
+; CHECK-NEXT: to label %cont unwind label %lpad |
+; CHECK: %lp = landingpad { i8*, i32 } personality void (i8*)* bitcast (void (i32)* @personality_func to void (i8*)*) |
+; CHECK: %p = extractvalue { i8*, i32 } %lp, 0 |
+; CHECK-NEXT: %p.asint = ptrtoint i8* %p to i32 |
+; CHECK-NEXT: %val.asptr = inttoptr i32 %val to i8* |
+; CHECK-NEXT: %s = insertvalue { i8*, i32 } %lp, i8* %val.asptr, 0 |
+; CHECK-NEXT: ret i32 %p.asint |
+ |
+define void @personality_func(i8* %arg) { |
+ ret void |
+} |
+ |
+ |
+declare i32 @llvm.eh.typeid.for(i8*) |
+ |
+@typeid = global i32 0 |
+ |
+; The argument here must be left as a bitcast, otherwise the backend |
+; rejects it. |
+define void @typeid_for() { |
+ %bc = bitcast i32* @typeid to i8* |
+ call i32 @llvm.eh.typeid.for(i8* %bc) |
+ ret void |
+} |
+; CHECK: define void @typeid_for() { |
+; CHECK-NEXT: %typeid.bc = bitcast i32* @typeid to i8* |
+; CHECK-NEXT: call i32 @llvm.eh.typeid.for(i8* %typeid.bc) |
+ |
+ |
+; Subprogram debug metadata may refer to a function. |
+; Make sure those are updated too. |
+; Regenerate the debug info from the following C program: |
+; void nop(void *ptr) { |
+; } |
+ |
+define void @nop(i8* %ptr) { |
+ tail call void @llvm.dbg.value(metadata !{i8* %ptr}, i64 0, metadata !10, metadata !14), !dbg !15 |
+ ret void, !dbg !16 |
+} |
+; CHECK: define void @nop(i32 %ptr) { |
+; CHECK-NEXT: call void @llvm.dbg.value{{.*}} |
+; CHECK-NEXT: ret void |
+ |
+ |
+; CHECK: attributes {{.*}}[[NOUNWIND]] = { nounwind } |
+ |
+!llvm.dbg.cu = !{!0} |
+!llvm.module.flags = !{!11, !12} |
+!llvm.ident = !{!13} |
+ |
+!0 = metadata !{metadata !"0x11\0012\00clang version 3.6.0", metadata !1, metadata !2, metadata !2, metadata !3, metadata !2, metadata !2} ; [ DW_TAG_compile_unit ] [/home/foo/test_debug.c] [DW_LANG_C99] |
+!1 = metadata !{metadata !"test_debug.c", metadata !"/home/foo"} |
+!2 = metadata !{} |
+!3 = metadata !{metadata !4} |
+!4 = metadata !{metadata !"0x2e\00nop\00nop\00\001\000\001\000\000\00256\001\001", metadata !1, metadata !5, metadata !6, null, void (i8*)* @nop, null, null, metadata !9} ; [ DW_TAG_subprogram ] [line 1] [def] [nop] |
+!5 = metadata !{metadata !"0x29", metadata !1} ; [ DW_TAG_file_type ] [/home/foo/test_debug.c] |
+!6 = metadata !{metadata !"0x15\00\000\000\000\000\000\000", null, null, null, metadata !7, null, null, null} ; [ DW_TAG_subroutine_type ] [line 0, size 0, align 0, offset 0] [from ] |
+!7 = metadata !{null, metadata !8} |
+!8 = metadata !{metadata !"0xf\00\000\0032\0032\000\000", null, null, null} ; [ DW_TAG_pointer_type ] [line 0, size 32, align 32, offset 0] [from ] |
+!9 = metadata !{metadata !10} |
+!10 = metadata !{metadata !"0x101\00ptr\0016777217\000", metadata !4, metadata !5, metadata !8} ; [ DW_TAG_arg_variable ] [ptr] [line 1] |
+!11 = metadata !{i32 2, metadata !"Dwarf Version", i32 4} |
+!12 = metadata !{i32 2, metadata !"Debug Info Version", i32 2} |
+!13 = metadata !{metadata !"clang version 3.6.0"} |
+!14 = metadata !{metadata !"0x102"} ; [ DW_TAG_expression ] |
+!15 = metadata !{i32 1, i32 16, metadata !4, null} |
+!16 = metadata !{i32 2, i32 1, metadata !4, null} |
+ |
+; CHECK: !4 = metadata !{{{.*}}nop{{.*}}, void (i32)* @nop, {{.*}}} ; [ DW_TAG_subprogram ] [line 1] [def] [nop] |