Changes from 3.7 merge to files not in upstream

test/Transforms/NaCl/promote-integers.ll

 ; RUN: opt < %s -nacl-promote-ints -S | FileCheck %s
 
 target datalayout = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-p:32:32:32-v128:32:32"
 
 declare void @consume_i16(i16 %a)
 
 ; CHECK-LABEL: @sext_to_illegal(
 ; CHECK-NEXT: %a40 = sext i32 %a to i64
 ; (0xFFFFFFFFFF)
 define void @sext_to_illegal(i32 %a) {
@@ skipping 321 matching lines @@
   %s40 = select i1 true, i40 %a40, i40 -1
   ret void
 }
 
 ; Allocas are left unchanged.
 ; CHECK-LABEL: @alloca40(
 ; CHECK: %a = alloca i40, align 8
 define void @alloca40() {
   %a = alloca i40, align 8
   %b = bitcast i40* %a to i8*
-  %c = load i8* %b
+  %c = load i8, i8* %b
   ret void
 }
 
 ; CHECK-LABEL: @load24(
 ; CHECK:      %bc.loty = bitcast i8* %a to i16*
-; CHECK-NEXT: %load.lo = load i16* %bc.loty, align 8
+; CHECK-NEXT: %load.lo = load i16, i16* %bc.loty, align 8
 ; CHECK-NEXT: %load.lo.ext = zext i16 %load.lo to i32
-; CHECK-NEXT: %bc.hi = getelementptr i16* %bc.loty, i32 1
+; CHECK-NEXT: %bc.hi = getelementptr i16, i16* %bc.loty, i32 1
 ; CHECK-NEXT: %bc.hity = bitcast i16* %bc.hi to i8*
-; CHECK-NEXT: %load.hi = load i8* %bc.hity, align 2
+; CHECK-NEXT: %load.hi = load i8, i8* %bc.hity, align 2
 ; CHECK-NEXT: %load.hi.ext = zext i8 %load.hi to i32
 ; CHECK-NEXT: %load.hi.ext.sh = shl i32 %load.hi.ext, 16
 ; CHECK-NEXT: %load = or i32 %load.lo.ext, %load.hi.ext.sh
 define void @load24(i8* %a) {
   %bc = bitcast i8* %a to i24*
-  %load = load i24* %bc, align 8
+  %load = load i24, i24* %bc, align 8
   ret void
 }
 
 ; CHECK-LABEL: @load24_overaligned(
-; CHECK: %load.lo = load i16* %bc.loty, align 32
-; CHECK: %load.hi = load i8* %bc.hity, align 2
+; CHECK: %load.lo = load i16, i16* %bc.loty, align 32
+; CHECK: %load.hi = load i8, i8* %bc.hity, align 2
 define void @load24_overaligned(i8* %a) {
   %bc = bitcast i8* %a to i24*
-  %load = load i24* %bc, align 32
+  %load = load i24, i24* %bc, align 32
   ret void
 }
 
 ; CHECK-LABEL: @load48(
-; CHECK:      %load.lo = load i32* %a, align 8
+; CHECK:      %load.lo = load i32, i32* %a, align 8
 ; CHECK-NEXT: %load.lo.ext = zext i32 %load.lo to i64
-; CHECK-NEXT: %bc.hi = getelementptr i32* %a, i32 1
+; CHECK-NEXT: %bc.hi = getelementptr i32, i32* %a, i32 1
 ; CHECK-NEXT: %bc.hity = bitcast i32* %bc.hi to i16*
-; CHECK-NEXT: %load.hi = load i16* %bc.hity, align 4
+; CHECK-NEXT: %load.hi = load i16, i16* %bc.hity, align 4
 ; CHECK-NEXT: %load.hi.ext = zext i16 %load.hi to i64
 ; CHECK-NEXT: %load.hi.ext.sh = shl i64 %load.hi.ext, 32
 ; CHECK-NEXT: %load = or i64 %load.lo.ext, %load.hi.ext.sh
 define void @load48(i32* %a) {
   %bc = bitcast i32* %a to i48*
-  %load = load i48* %bc, align 8
+  %load = load i48, i48* %bc, align 8
   ret void
 }
 
 ; CHECK-LABEL: @load56(
 ; CHECK:       %bc = bitcast i32* %a to i56*
-; CHECK-NEXT:  %load.lo = load i32* %a, align 8
+; CHECK-NEXT:  %load.lo = load i32, i32* %a, align 8
 ; CHECK-NEXT:  %load.lo.ext = zext i32 %load.lo to i64
-; CHECK-NEXT:  %bc.hi = getelementptr i32* %a, i32 1
+; CHECK-NEXT:  %bc.hi = getelementptr i32, i32* %a, i32 1
 ; CHECK-NEXT:  %bc.hity = bitcast i32* %bc.hi to i24*
 ; CHECK-NEXT:  %bc.hity.loty = bitcast i32* %bc.hi to i16*
-; CHECK-NEXT:  %load.hi.lo = load i16* %bc.hity.loty, align 4
+; CHECK-NEXT:  %load.hi.lo = load i16, i16* %bc.hity.loty, align 4
 ; CHECK-NEXT:  %load.hi.lo.ext = zext i16 %load.hi.lo to i32
-; CHECK-NEXT:  %bc.hity.hi = getelementptr i16* %bc.hity.loty, i32 1
+; CHECK-NEXT:  %bc.hity.hi = getelementptr i16, i16* %bc.hity.loty, i32 1
 ; CHECK-NEXT:  %bc.hity.hity = bitcast i16* %bc.hity.hi to i8*
-; CHECK-NEXT:  %load.hi.hi = load i8* %bc.hity.hity, align 2
+; CHECK-NEXT:  %load.hi.hi = load i8, i8* %bc.hity.hity, align 2
 ; CHECK-NEXT:  %load.hi.hi.ext = zext i8 %load.hi.hi to i32
 ; CHECK-NEXT:  %load.hi.hi.ext.sh = shl i32 %load.hi.hi.ext, 16
 ; CHECK-NEXT:  %load.hi = or i32 %load.hi.lo.ext, %load.hi.hi.ext.sh
 ; CHECK-NEXT:  %load.hi.ext = zext i32 %load.hi to i64
 ; CHECK-NEXT:  %load.hi.ext.sh = shl i64 %load.hi.ext, 32
 ; CHECK-NEXT:  %load = or i64 %load.lo.ext, %load.hi.ext.sh
 define void @load56(i32* %a) {
   %bc = bitcast i32* %a to i56*
-  %load = load i56* %bc
+  %load = load i56, i56* %bc
   ret void
 }
 
 ; Ensure that types just above and just below large powers of 2 can be compiled.
 ; CHECK-LABEL: @load_large(
 define void @load_large(i32* %a) {
   %bc1 = bitcast i32* %a to i2056*
-  %load1 = load i2056* %bc1
+  %load1 = load i2056, i2056* %bc1
   %bc2 = bitcast i32* %a to i4088*
-  %load2 = load i4088* %bc2
+  %load2 = load i4088, i4088* %bc2
   ret void
 }
 
 ; CHECK-LABEL: @store24(
 ; CHECK:      %b24 = zext i8 %b to i32
 ; CHECK-NEXT: %bc.loty = bitcast i8* %a to i16*
 ; CHECK-NEXT: %b24.lo = trunc i32 %b24 to i16
 ; CHECK-NEXT: store i16 %b24.lo, i16* %bc.loty, align 4
 ; CHECK-NEXT: %b24.hi.sh = lshr i32 %b24, 16
-; CHECK-NEXT: %bc.hi = getelementptr i16* %bc.loty, i32 1
+; CHECK-NEXT: %bc.hi = getelementptr i16, i16* %bc.loty, i32 1
 ; CHECK-NEXT: %b24.hi = trunc i32 %b24.hi.sh to i8
 ; CHECK-NEXT: %bc.hity = bitcast i16* %bc.hi to i8*
 ; CHECK-NEXT: store i8 %b24.hi, i8* %bc.hity, align 2
 define void @store24(i8* %a, i8 %b) {
   %bc = bitcast i8* %a to i24*
   %b24 = zext i8 %b to i24
   store i24 %b24, i24* %bc
   ret void
 }
 
 ; CHECK-LABEL: @store24_overaligned(
 ; CHECK: store i16 %b24.lo, i16* %bc.loty, align 32
 ; CHECK: store i8 %b24.hi, i8* %bc.hity, align 2
 define void @store24_overaligned(i8* %a, i8 %b) {
   %bc = bitcast i8* %a to i24*
   %b24 = zext i8 %b to i24
   store i24 %b24, i24* %bc, align 32
   ret void
 }
 
 ; CHECK-LABEL: @store56(
 ; CHECK:      %b56 = zext i8 %b to i64
 ; CHECK-NEXT: %bc.loty = bitcast i8* %a to i32*
 ; CHECK-NEXT: %b56.lo = trunc i64 %b56 to i32
 ; CHECK-NEXT: store i32 %b56.lo, i32* %bc.loty, align 8
 ; CHECK-NEXT: %b56.hi.sh = lshr i64 %b56, 32
-; CHECK-NEXT: %bc.hi = getelementptr i32* %bc.loty, i32 1
+; CHECK-NEXT: %bc.hi = getelementptr i32, i32* %bc.loty, i32 1
 ; CHECK-NEXT: %bc.hity = bitcast i32* %bc.hi to i24*
 ; CHECK-NEXT: %bc.hity.loty = bitcast i32* %bc.hi to i16*
 ; CHECK-NEXT: %b56.hi.sh.lo = trunc i64 %b56.hi.sh to i16
 ; CHECK-NEXT: store i16 %b56.hi.sh.lo, i16* %bc.hity.loty, align 4
 ; CHECK-NEXT: %b56.hi.sh.hi.sh = lshr i64 %b56.hi.sh, 16
-; CHECK-NEXT: %bc.hity.hi = getelementptr i16* %bc.hity.loty, i32 1
+; CHECK-NEXT: %bc.hity.hi = getelementptr i16, i16* %bc.hity.loty, i32 1
 ; CHECK-NEXT: %b56.hi.sh.hi = trunc i64 %b56.hi.sh.hi.sh to i8
 ; CHECK-NEXT: %bc.hity.hity = bitcast i16* %bc.hity.hi to i8*
 ; CHECK-NEXT: store i8 %b56.hi.sh.hi, i8* %bc.hity.hity, align 2
 define void @store56(i8* %a, i8 %b) {
   %bc = bitcast i8* %a to i56*
   %b56 = zext i8 %b to i56
   store i56 %b56, i56* %bc
   ret void
 }
 
@@ skipping 44 matching lines @@
   ret void
 if2:
   ret void
 end:
   ret void
 }
 
 
 ; The getelementptr here should be handled unchanged.
 ; CHECK-LABEL: @pointer_to_array(
-; CHECK: %element_ptr = getelementptr [2 x i40]* %ptr, i32 0, i32 0
+; CHECK: %element_ptr = getelementptr [2 x i40], [2 x i40]* %ptr, i32 0, i32 0
 define void @pointer_to_array([2 x i40]* %ptr) {
-  %element_ptr = getelementptr [2 x i40]* %ptr, i32 0, i32 0
-  load i40* %element_ptr
+  %element_ptr = getelementptr [2 x i40], [2 x i40]* %ptr, i32 0, i32 0
+  load i40, i40* %element_ptr
   ret void
 }
 
 ; Store 0x1222277777777 and make sure it's split up into 3 stores of each part.
 ; CHECK-LABEL: @constants(
 ; CHECK: store i32 2004318071, i32* %{{.*}}, align 4
 ; CHECK: store i16 8738, i16* %{{.*}}
 ; CHECK: store i8 1, i8* %{{.*}}
 define void @constants(i56* %ptr) {
   store i56 319006405261175, i56* %ptr, align 4
   ret void
 }
 
 @from = external global [300 x i8], align 4
 @to = external global [300 x i8], align 4
 
 ; CHECK-LABEL: @load_bc_to_i80(
 ; CHECK-NEXT:  %expanded = bitcast [300 x i8]* @from to i64*
-; CHECK-NEXT:  %loaded.short.lo = load i64* %expanded, align 4
+; CHECK-NEXT:  %loaded.short.lo = load i64, i64* %expanded, align 4
 ; CHECK-NEXT:  %loaded.short.lo.ext = zext i64 %loaded.short.lo to i128
 ; CHECK-NEXT:  %expanded5 = bitcast [300 x i8]* @from to i64*
-; CHECK-NEXT:  %expanded4 = getelementptr i64* %expanded5, i32 1
+; CHECK-NEXT:  %expanded4 = getelementptr i64, i64* %expanded5, i32 1
 ; CHECK-NEXT:  %expanded3 = bitcast i64* %expanded4 to i16*
-; CHECK-NEXT:  %loaded.short.hi = load i16* %expanded3, align 4
+; CHECK-NEXT:  %loaded.short.hi = load i16, i16* %expanded3, align 4
 ; CHECK-NEXT:  %loaded.short.hi.ext = zext i16 %loaded.short.hi to i128
 ; CHECK-NEXT:  %loaded.short.hi.ext.sh = shl i128 %loaded.short.hi.ext, 64
 ; CHECK-NEXT:  %loaded.short = or i128 %loaded.short.lo.ext, %loaded.short.hi.ext.sh
 ; CHECK-NEXT:  %loaded.short.lo1 = trunc i128 %loaded.short to i64
 ; CHECK-NEXT:  %expanded6 = bitcast [300 x i8]* @to to i64*
 ; CHECK-NEXT:  store i64 %loaded.short.lo1, i64* %expanded6, align 4
 ; CHECK-NEXT:  %loaded.short.hi.sh = lshr i128 %loaded.short, 64
 ; CHECK-NEXT:  %loaded.short.hi2 = trunc i128 %loaded.short.hi.sh to i16
 ; CHECK-NEXT:  %expanded9 = bitcast [300 x i8]* @to to i64*
-; CHECK-NEXT:  %expanded8 = getelementptr i64* %expanded9, i32 1
+; CHECK-NEXT:  %expanded8 = getelementptr i64, i64* %expanded9, i32 1
 ; CHECK-NEXT:  %expanded7 = bitcast i64* %expanded8 to i16*
 ; CHECK-NEXT:  store i16 %loaded.short.hi2, i16* %expanded7, align 4
 define void @load_bc_to_i80() {
-  %loaded.short = load i80* bitcast ([300 x i8]* @from to i80*), align 4
+  %loaded.short = load i80, i80* bitcast ([300 x i8]* @from to i80*), align 4
   store i80 %loaded.short, i80* bitcast ([300 x i8]* @to to i80*), align 4
   ret void
 }