Changes from 3.7 merge to files not in upstream

test/Transforms/NaCl/flatten-globals.ll

 ; RUN: opt -flatten-globals %s -S | FileCheck %s
 ; RUN: opt -flatten-globals %s -S | FileCheck %s -check-prefix=CLEANED
 
 target datalayout = "p:32:32:32"
 
 
 ; Check simple cases
 
 @var_i32 = global i32 258
 ; CHECK: @var_i32 = global [4 x i8] c"\02\01\00\00"
@@ skipping 132 matching lines @@
 
 @block_addr = global i8* blockaddress(@func_with_block, %label)
 ; CHECK: @block_addr = global i32 ptrtoint (i8* blockaddress(@func_with_block, %label) to i32)
 
 @vector_reloc = global <2 x i32*> <i32* @var1, i32* @var1>
 ; CHECK: global <{ i32, i32 }> <{ i32 ptrtoint ([4 x i8]* @var1 to i32), i32 ptrtoint ([4 x i8]* @var1 to i32) }>
 
 
 ; Global references with addends
 
-@reloc_addend = global i32* getelementptr (%ptrs1* @ptrs1, i32 0, i32 2)
+@reloc_addend = global i32* getelementptr (%ptrs1, %ptrs1* @ptrs1, i32 0, i32 2)
 ; CHECK: @reloc_addend = global i32 add (i32 ptrtoint (<{ i32, [8 x i8] }>* @ptrs1 to i32), i32 8)
 
-@negative_addend = global %ptrs1* getelementptr (%ptrs1* @ptrs1, i32 -1)
+@negative_addend = global %ptrs1* getelementptr (%ptrs1, %ptrs1* @ptrs1, i32 -1)
 ; CHECK: @negative_addend = global i32 add (i32 ptrtoint (<{ i32, [8 x i8] }>* @ptrs1 to i32), i32 -12)
 
-@const_ptr = global i32* getelementptr (%ptrs1* null, i32 0, i32 2)
+@const_ptr = global i32* getelementptr (%ptrs1, %ptrs1* null, i32 0, i32 2)
 ; CHECK: @const_ptr = global [4 x i8] c"\08\00\00\00"
 
 @int_to_ptr = global i32* inttoptr (i16 260 to i32*)
 ; CHECK: @int_to_ptr = global [4 x i8] c"\04\01\00\00"
 
 ; Clang allows "(uintptr_t) &var" as a global initializer, so we
 ; handle this case.
 @ptr_to_int = global i32 ptrtoint (i8* @var2 to i32)
 ; CHECK: @ptr_to_int = global i32 ptrtoint ([1 x i8]* @var2 to i32)
 
 ; This is handled via Constant folding.  The getelementptr is
 ; converted to an undef when it is created, so the pass does not see a
 ; getelementptr here.
-@undef_gep = global i32* getelementptr (%ptrs1* undef, i32 0, i32 2)
+@undef_gep = global i32* getelementptr (%ptrs1, %ptrs1* undef, i32 0, i32 2)
 ; CHECK: @undef_gep = global [4 x i8] zeroinitializer
 
 ; Adding an offset to a function address isn't useful, but check that
 ; the pass handles it anyway.
 @func_addend = global i8* getelementptr (
+    i8, 
     i8* bitcast (void ()* @func_with_block to i8*), i32 123)
 ; CHECK: @func_addend = global i32 add (i32 ptrtoint (void ()* @func_with_block to i32), i32 123)
 
 ; Similarly, adding an offset to a label address isn't useful, but
 ; check it anyway.
 @block_addend = global i8* getelementptr (
+    i8, 
     i8* blockaddress(@func_with_block, %label), i32 100)
 ; CHECK: @block_addend = global i32 add (i32 ptrtoint (i8* blockaddress(@func_with_block, %label) to i32), i32 100)
 
 
 ; Special cases
 
 ; Leave vars with "appending" linkage alone.
 @appending = appending global [1 x i32*] [i32* @var1]
 ; CHECK: @appending = appending global [1 x i32*] [i32* bitcast ([4 x i8]* @var1 to i32*)]
 
 
 define i32* @get_address() {
   ret i32* @var_i32
 }
 ; CHECK: define i32* @get_address() {
 ; CHECK-NEXT: ret i32* bitcast ([4 x i8]* @var_i32 to i32*)
 
 
 define void @func_with_block() {
   br label %label
 label:
   ret void
 }