Changes from 3.7 merge to files not in upstream

test/Transforms/NaCl/replace-ptrs-with-ints.ll

 ; 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
@@ skipping 62 matching lines @@
 ; 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
+  %val = load %struct*, %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: %val = load i32, 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 ]
@@ skipping 81 matching lines @@
 ; 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
+  %val = load i16*, 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
+; CHECK-NEXT: %val = load i32, i32* %.asptr
 
 define i16* @constant_pointer_undef_load() {
-  %val = load i16** undef
+  %val = load i16*, 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
+; CHECK-NEXT: %val = load i32, i32* %.asptr
 
 
 define i8 @load(i8* %ptr) {
-  %x = load i8* %ptr
+  %x = load i8, 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
+; CHECK-NEXT: %x = load i8, 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
+  %x = load i8*, 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
+; CHECK-NEXT: %x = load i32, 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
+  %x = load atomic volatile i8, 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
+; CHECK-NEXT: %x = load atomic volatile i8, 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
 
 
@@ skipping 55 matching lines @@
 
 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
+  %val = load i32, i32* @var
   ret i32 %val
 }
 ; CHECK: define i32 @load_global() {
-; CHECK-NEXT: %val = load i32* @var
+; CHECK-NEXT: %val = load i32, i32* @var
 ; CHECK-NEXT: ret i32 %val
 
 define i16 @load_global_bitcast() {
   %ptr = bitcast i32* @var to i16*
-  %val = load i16* %ptr
+  %val = load i16, 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: %val = load i16, 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
@@ skipping 37 matching lines @@
   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)
+  call void @llvm.dbg.declare(metadata i32* %var, metadata !11, metadata !12), !dbg !13
+  call void @llvm.dbg.declare(metadata i32 %val, metadata !14, metadata !12), !dbg !13
   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)
+; CHECK-NEXT: call void @llvm.dbg.declare(metadata i32* %var, metadata !11, metadata !12), !dbg !13
 ; This case is currently not converted.
-; CHECK-NEXT: call void @llvm.dbg.declare(metadata !{null}, metadata !2, metadata !14)
+; CHECK-NEXT: call void @llvm.dbg.declare(metadata !2, metadata !14, metadata !12)
 ; 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)
+  tail call void @llvm.dbg.value(metadata i32 %val, i64 1, metadata !11, metadata !12), !dbg !18
+  tail call void @llvm.dbg.value(metadata i8* %ptr, i64 2, metadata !14, metadata !12), !dbg !18
 
 ; check that we don't crash when encountering odd things:
-  tail call void @llvm.dbg.value(metadata !{i8* null}, i64 3, metadata !1, metadata !14)
-  tail call void @llvm.dbg.value(metadata !{i8* undef}, i64 4, metadata !1, metadata !14)
-  tail call void @llvm.dbg.value(metadata !{}, i64 5, metadata !1, metadata !14)
+  tail call void @llvm.dbg.value(metadata i8* null, i64 3, metadata !11, metadata !12), !dbg !18
+  tail call void @llvm.dbg.value(metadata i8* undef, i64 4, metadata !11, metadata !12), !dbg !18
+  tail call void @llvm.dbg.value(metadata !{}, i64 5, metadata !11, metadata !12), !dbg !18
   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: call void @llvm.dbg.value(metadata !15, i64 3, metadata !1, metadata !14)
-; CHECK-NEXT: call void @llvm.dbg.value(metadata !16, i64 4, metadata !1, metadata !14)
-; CHECK-NEXT: call void @llvm.dbg.value(metadata !2, i64 5, metadata !1, metadata !14)
+; CHECK-NEXT: call void @llvm.dbg.value(metadata !2, i64 1, metadata !11, metadata !12)
+; CHECK-NEXT: call void @llvm.dbg.value(metadata !2, i64 2, metadata !14, metadata !12)
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i8* null, i64 3, metadata !11, metadata !12)
+; CHECK-NEXT: call void @llvm.dbg.value(metadata i8* undef, i64 4, metadata !11, metadata !12)
+; CHECK-NEXT: call void @llvm.dbg.value(metadata !2, i64 5, metadata !11, metadata !12)
 ; 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
@@ skipping 44 matching lines @@
 ; 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) {
+define void @readonly_readnone(i8* readonly dereferenceable_or_null(4)) {
   ret void
 }
 ; CHECK-LABEL: define void @readonly_readnone(i32)
 
 define nonnull i8* @nonnull_ptr(i8* nonnull) {
   ret i8* undef
 }
 ; CHECK-LABEL: define i32 @nonnull_ptr(i32)
 
 define dereferenceable(16) i8* @dereferenceable_ptr(i8* dereferenceable(8)) {
@@ skipping 30 matching lines @@
   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
+define i8* @getelementptr(i8, i8* %ptr) {
+  %gep = getelementptr i8, 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
 }
 
 
@@ skipping 51 matching lines @@
 ; 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
+  tail call void @llvm.dbg.value(metadata i8* %ptr, i64 0, metadata !11, metadata !12), !dbg !19
+  ret void, !dbg !19
 }
 ; 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}
+!llvm.module.flags = !{!8, !9}
+!llvm.ident = !{!10}
 
-!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]

[jvoung (off chromium), 2015/05/26 20:39:45]

If the test is now checking that "void (i32)* @debug_declare" shows up in the
metadata instead of nop (and instead of null, if that replaceFunction() call is
omitted), then you might be able to remove the @nop function test case, since it
isn't being checked in the subprograms anyway.

[Derek Schuff, 2015/05/26 22:01:33]

Done.

-!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 = !MDSubprogram(name: "debug_declare", scope: !1, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, function: void (i32)* @debug_declare, variables: !2)
 
-; CHECK: !4 = metadata !{{{.*}}nop{{.*}}, void (i32)* @nop, {{.*}}} ; [ DW_TAG_subprogram ] [line 1] [def] [nop]
+!0 = !MDCompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.7.0 (trunk 235150) (llvm/trunk 235152)", isOptimized: false, runtimeVersion: 0, emissionKind: 1, enums: !2, retainedTypes: !2, subprograms: !3, globals: !2, imports: !2)
+!1 = !MDFile(filename: "foo.c", directory: "/s/llvm/cmakebuild")
+!2 = !{}
+!3 = !{!4}
+!4 = !MDSubprogram(name: "debug_declare", scope: !1, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, function: void (i32)* @debug_declare, variables: !2)
+!5 = !MDSubroutineType(types: !6)
+!6 = !{null, !7}
+!7 = !MDBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{!"clang version 3.7.0 (trunk 235150) (llvm/trunk 235152)"}
+!11 = !MDLocalVariable(tag: DW_TAG_arg_variable, name: "val", arg: 1, scope: !4, file: !1, line: 1, type: !7)
+!12 = !MDExpression()
+!13 = !MDLocation(line: 1, column: 24, scope: !4)
+
+!14 = !MDLocalVariable(tag: DW_TAG_auto_variable, name: "var", scope: !4, file: !1, line: 2, type: !15)
+!15 = !MDCompositeType(tag: DW_TAG_array_type, baseType: !7, align: 32, elements: !16)
+!16 = !{!17}
+!17 = !MDSubrange(count: -1)
+!18 = !MDLocation(line: 2, column: 11, scope: !4)
+!19 = !MDLocation(line: 2, column: 3, scope: !4)