Changes from 3.7 merge to files not in upstream

test/NaCl/PNaClABI/instructions.ll

 ; RUN: not pnacl-abicheck < %s | FileCheck %s
 ; Test instruction opcodes allowed by PNaCl ABI
 
 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"
 target triple = "le32-unknown-nacl"
 
 define internal void @terminators() {
 ; CHECK: ERROR: Function terminators
 ; Terminator instructions
 terminators:
@@ skipping 127 matching lines @@
 ; CHECK-NEXT: disallowed: bad instruction opcode: {{.*}} insertvalue
 
   ret void
 }
 
 define internal void @memory() {
 ; CHECK: ERROR: Function memory
 ; Memory operations
   %a1 = alloca i8, i32 4
   %ptr = inttoptr i32 0 to i32*
-  %a2 = load i32* %ptr, align 1
+  %a2 = load i32, i32* %ptr, align 1
   store i32 undef, i32* %ptr, align 1
  ; CHECK-NOT: disallowed
-  %a4 = getelementptr { i32, i32}* undef ; CHECK-NEXT: disallowed: bad instruction opcode: {{.*}} getelementptr
+  %a4 = getelementptr { i32, i32}, { i32, i32}* undef ; CHECK-NEXT: disallowed: bad instruction opcode: {{.*}} getelementptr
   ret void
 }
 
 define internal void @vector_memory() {
 ; CHECK: ERROR: Function vector_memory
 ; Vector memory operations.
   %ptr16xi8 = inttoptr i32 0 to <16 x i8>*
   %ptr8xi16 = inttoptr i32 0 to <8 x i16>*
   %ptr4xi32 = inttoptr i32 0 to <4 x i32>*
   %ptr4xfloat = inttoptr i32 0 to <4 x float>*
 
-  %l16xi8 = load <16 x i8>* %ptr16xi8, align 1
-  %l8xi16 = load <8 x i16>* %ptr8xi16, align 2
-  %l4xi32 = load <4 x i32>* %ptr4xi32, align 4
-  %l4xfloat = load <4 x float>* %ptr4xfloat, align 4
+  %l16xi8 = load <16 x i8>, <16 x i8>* %ptr16xi8, align 1
+  %l8xi16 = load <8 x i16>, <8 x i16>* %ptr8xi16, align 2
+  %l4xi32 = load <4 x i32>, <4 x i32>* %ptr4xi32, align 4
+  %l4xfloat = load <4 x float>, <4 x float>* %ptr4xfloat, align 4
 
   store <16 x i8> undef, <16 x i8>* %ptr16xi8, align 1
   store <8 x i16> undef, <8 x i16>* %ptr8xi16, align 2
   store <4 x i32> undef, <4 x i32>* %ptr4xi32, align 4
   store <4 x float> undef, <4 x float>* %ptr4xfloat, align 4
 
  ; CHECK-NOT: disallowed
  ; The following vector types are disallowed.
   %ptr2xi1 = inttoptr i32 0 to <2 x i1>*         ; CHECK-NEXT: disallowed: bad result type: <2 x i1>*
   %ptr4xi1 = inttoptr i32 0 to <4 x i1>*         ; CHECK-NEXT: disallowed: bad result type: <4 x i1>*
@@ skipping 16 matching lines @@
   %ptr4xi64 = inttoptr i32 0 to <4 x i64>*       ; CHECK-NEXT: disallowed: bad result type: <4 x i64>*
   %ptr8xi64 = inttoptr i32 0 to <8 x i64>*       ; CHECK-NEXT: disallowed: bad result type: <8 x i64>*
   %ptr2xfloat = inttoptr i32 0 to <2 x float>*   ; CHECK-NEXT: disallowed: bad result type: <2 x float>*
   %ptr8xfloat = inttoptr i32 0 to <8 x float>*   ; CHECK-NEXT: disallowed: bad result type: <8 x float>*
   %ptr16xfloat = inttoptr i32 0 to <16 x float>* ; CHECK-NEXT: disallowed: bad result type: <16 x float>*
   %ptr2xdouble = inttoptr i32 0 to <2 x double>* ; CHECK-NEXT: disallowed: bad result type: <2 x double>*
   %ptr4xdouble = inttoptr i32 0 to <4 x double>* ; CHECK-NEXT: disallowed: bad result type: <4 x double>*
   %ptr8xdouble = inttoptr i32 0 to <8 x double>* ; CHECK-NEXT: disallowed: bad result type: <8 x double>*
 
   ; i1 vector pointers are simply disallowed, their alignment is inconsequential.
-  %l4xi1 = load <4 x i1>* %ptr4xi1, align 1    ; CHECK-NEXT: disallowed: bad pointer: %l4xi1 = load <4 x i1>* %ptr4xi1, align 1
-  %l8xi1 = load <8 x i1>* %ptr8xi1, align 1    ; CHECK-NEXT: disallowed: bad pointer: %l8xi1 = load <8 x i1>* %ptr8xi1, align 1
-  %l16xi1 = load <16 x i1>* %ptr16xi1, align 1 ; CHECK-NEXT: disallowed: bad pointer: %l16xi1 = load <16 x i1>* %ptr16xi1, align 1
+  %l4xi1 = load <4 x i1>, <4 x i1>* %ptr4xi1, align 1    ; CHECK-NEXT: disallowed: bad pointer: %l4xi1 = load <4 x i1>, <4 x i1>* %ptr4xi1, align 1
+  %l8xi1 = load <8 x i1>, <8 x i1>* %ptr8xi1, align 1    ; CHECK-NEXT: disallowed: bad pointer: %l8xi1 = load <8 x i1>, <8 x i1>* %ptr8xi1, align 1
+  %l16xi1 = load <16 x i1>, <16 x i1>* %ptr16xi1, align 1 ; CHECK-NEXT: disallowed: bad pointer: %l16xi1 = load <16 x i1>, <16 x i1>* %ptr16xi1, align 1
 
   store <4 x i1> undef, <4 x i1>* %ptr4xi1, align 1    ; CHECK-NEXT: disallowed: bad pointer: store <4 x i1> undef, <4 x i1>* %ptr4xi1, align 1
   store <8 x i1> undef, <8 x i1>* %ptr8xi1, align 1    ; CHECK-NEXT: disallowed: bad pointer: store <8 x i1> undef, <8 x i1>* %ptr8xi1, align 1
   store <16 x i1> undef, <16 x i1>* %ptr16xi1, align 1 ; CHECK-NEXT: disallowed: bad pointer: store <16 x i1> undef, <16 x i1>* %ptr16xi1, align 1
 
   ; Under- or over-aligned load/store are disallowed.
-  %a1_8xi16 = load <8 x i16>* %ptr8xi16, align 1       ; CHECK-NEXT: disallowed: bad alignment: %a1_8xi16 = load <8 x i16>* %ptr8xi16, align 1
-  %a1_4xi32 = load <4 x i32>* %ptr4xi32, align 1       ; CHECK-NEXT: disallowed: bad alignment: %a1_4xi32 = load <4 x i32>* %ptr4xi32, align 1
-  %a1_4xfloat = load <4 x float>* %ptr4xfloat, align 1 ; CHECK-NEXT: disallowed: bad alignment: %a1_4xfloat = load <4 x float>* %ptr4xfloat, align 1
+  %a1_8xi16 = load <8 x i16>, <8 x i16>* %ptr8xi16, align 1       ; CHECK-NEXT: disallowed: bad alignment: %a1_8xi16 = load <8 x i16>, <8 x i16>* %ptr8xi16, align 1
+  %a1_4xi32 = load <4 x i32>, <4 x i32>* %ptr4xi32, align 1       ; CHECK-NEXT: disallowed: bad alignment:      %a1_4xi32 = load <4 x i32>, <4 x i32>* %ptr4xi32, align 1
+  %a1_4xfloat = load <4 x float>, <4 x float>* %ptr4xfloat, align 1 ; CHECK-NEXT: disallowed: bad alignment:    %a1_4xfloat = load <4 x float>, <4 x float>* %ptr4xfloat, align 1
 
-  %a16_16xi8 = load <16 x i8>* %ptr16xi8, align 16       ; CHECK-NEXT: disallowed: bad alignment: %a16_16xi8 = load <16 x i8>* %ptr16xi8, align 16
-  %a16_8xi16 = load <8 x i16>* %ptr8xi16, align 16       ; CHECK-NEXT: disallowed: bad alignment: %a16_8xi16 = load <8 x i16>* %ptr8xi16, align 16
-  %a16_4xi32 = load <4 x i32>* %ptr4xi32, align 16       ; CHECK-NEXT: disallowed: bad alignment: %a16_4xi32 = load <4 x i32>* %ptr4xi32, align 16
-  %a16_4xfloat = load <4 x float>* %ptr4xfloat, align 16 ; CHECK-NEXT: disallowed: bad alignment: %a16_4xfloat = load <4 x float>* %ptr4xfloat, align 16
+  %a16_16xi8 = load <16 x i8>, <16 x i8>* %ptr16xi8, align 16       ; CHECK-NEXT: disallowed: bad alignment: %a16_16xi8 = load <16 x i8>, <16 x i8>* %ptr16xi8, align 16
+  %a16_8xi16 = load <8 x i16>, <8 x i16>* %ptr8xi16, align 16       ; CHECK-NEXT: disallowed: bad alignment: %a16_8xi16 = load <8 x i16>, <8 x i16>* %ptr8xi16, align 16
+  %a16_4xi32 = load <4 x i32>, <4 x i32>* %ptr4xi32, align 16       ; CHECK-NEXT: disallowed: bad alignment: %a16_4xi32 = load <4 x i32>, <4 x i32>* %ptr4xi32, align 16
+  %a16_4xfloat = load <4 x float>, <4 x float>* %ptr4xfloat, align 16 ; CHECK-NEXT: disallowed: bad alignment: %a16_4xfloat = load <4 x float>, <4 x float>* %ptr4xfloat, align 16
 
   store <8 x i16> undef, <8 x i16>* %ptr8xi16, align 1       ; CHECK-NEXT: disallowed: bad alignment: store <8 x i16> undef, <8 x i16>* %ptr8xi16, align 1
   store <4 x i32> undef, <4 x i32>* %ptr4xi32, align 1       ; CHECK-NEXT: disallowed: bad alignment: store <4 x i32> undef, <4 x i32>* %ptr4xi32, align 1
   store <4 x float> undef, <4 x float>* %ptr4xfloat, align 1 ; CHECK-NEXT: disallowed: bad alignment: store <4 x float> undef, <4 x float>* %ptr4xfloat, align 1
 
   store <16 x i8> undef, <16 x i8>* %ptr16xi8, align 16       ; CHECK-NEXT: disallowed: bad alignment: store <16 x i8> undef, <16 x i8>* %ptr16xi8, align 16
   store <8 x i16> undef, <8 x i16>* %ptr8xi16, align 16       ; CHECK-NEXT: disallowed: bad alignment: store <8 x i16> undef, <8 x i16>* %ptr8xi16, align 16
   store <4 x i32> undef, <4 x i32>* %ptr4xi32, align 16       ; CHECK-NEXT: disallowed: bad alignment: store <4 x i32> undef, <4 x i32>* %ptr4xi32, align 16
   store <4 x float> undef, <4 x float>* %ptr4xfloat, align 16 ; CHECK-NEXT: disallowed: bad alignment: store <4 x float> undef, <4 x float>* %ptr4xfloat, align 16
 
  ret void
 }
 
 define internal void @atomic() {
 ; CHECK: ERROR: Function atomic
   %ptr = inttoptr i32 0 to i32*
 
  ; CHECK-NOT: disallowed
-  %la = load atomic i32* %ptr seq_cst, align 4                      ; CHECK: disallowed: atomic load: {{.*}} load atomic
-  %lv = load volatile i32* %ptr, align 4                            ; CHECK: disallowed: volatile load: {{.*}} load volatile
+  %la = load atomic i32, i32* %ptr seq_cst, align 4                      ; CHECK: disallowed: atomic load: {{.*}} load atomic
+  %lv = load volatile i32, i32* %ptr, align 4                            ; CHECK: disallowed: volatile load: {{.*}} load volatile
   store atomic i32 undef, i32* %ptr seq_cst, align 4                ; CHECK: disallowed: atomic store: store atomic
   store volatile i32 undef, i32* %ptr, align 4                      ; CHECK: disallowed: volatile store: store volatile
   fence acq_rel                                                     ; CHECK: disallowed: bad instruction opcode: fence
   %cmpx = cmpxchg i32* %ptr, i32 undef, i32 undef acq_rel monotonic ; CHECK: disallowed: bad instruction opcode: {{.*}} cmpxchg
   %crm = atomicrmw add i32* %ptr, i32 1 acquire                     ; CHECK: disallowed: bad instruction opcode: {{.*}} atomicrmw
   ret void
 }
 
 define internal void @atomic_vector() {
 ; CHECK: ERROR: Function atomic_vector
   %ptr = inttoptr i32 0 to <4 x i32>*
 
  ; CHECK-NOT: disallowed
-  %la = load atomic <4 x i32>* %ptr seq_cst, align 1             ; CHECK: disallowed: atomic load: {{.*}} load atomic
-  %lv = load volatile <4 x i32>* %ptr, align 1                   ; CHECK: disallowed: volatile load: {{.*}} load volatile
+  %la = load atomic <4 x i32>, <4 x i32>* %ptr seq_cst, align 1             ; CHECK: disallowed: atomic load: {{.*}} load atomic
+  %lv = load volatile <4 x i32>, <4 x i32>* %ptr, align 1                   ; CHECK: disallowed: volatile load: {{.*}} load volatile
   store atomic <4 x i32> undef, <4 x i32>* %ptr seq_cst, align 1 ; CHECK: disallowed: atomic store: store atomic
   store volatile <4 x i32> undef, <4 x i32>* %ptr, align 1       ; CHECK: disallowed: volatile store: store volatile
   ret void
 }
 
 define internal void @conversion() {
 ; CHECK-NOT: Function conversion
 ; Conversion operations
   %t = trunc i32 undef to i8
   %z = zext i8 undef to i32
@@ skipping 141 matching lines @@
   %val = va_arg i8* %va_list, i32
   ret i32 %val
 }
 ; CHECK-NOT: disallowed
 ; CHECK: disallowed: bad instruction opcode: {{.*}} va_arg
 
 @global_var = internal global [4 x i8] zeroinitializer
 
 define internal void @constantexpr() {
 ; CHECK: ERROR: Function constantexpr
-  ptrtoint i8* getelementptr ([4 x i8]* @global_var, i32 1, i32 0) to i32
+  ptrtoint i8* getelementptr ([4 x i8], [4 x i8]* @global_var, i32 1, i32 0) to i32
   ret void
 }
 ; CHECK-NOT: disallowed
 ; CHECK: disallowed: operand not InherentPtr: %1 = ptrtoint i8* getelementptr
 
 define internal void @inline_asm() {
 ; CHECK: ERROR: Function inline_asm
   call void asm "foo", ""()
   ret void
 }
 ; CHECK-NOT: disallowed
 ; CHECK: disallowed: inline assembly: call void asm "foo", ""()
 
 ; CHECK-NOT: disallowed
 ; If another check is added, there should be a check-not in between each check