[XCore] Adapt Clang tests to opaque pointers.

[nikic]

LGTM

clang/test/CodeGen/xcore-abi.c

 // REQUIRES: xcore-registered-target
-// RUN: %clang_cc1 -no-opaque-pointers -triple xcore -verify %s
+// RUN: %clang_cc1 -triple xcore -verify %s
 _Static_assert(sizeof(long long) == 8, "sizeof long long is wrong");
 _Static_assert(_Alignof(long long) == 4, "alignof long long is wrong");
 
 _Static_assert(sizeof(double) == 8, "sizeof double is wrong");
 _Static_assert(_Alignof(double) == 4, "alignof double is wrong");
 
-// RUN: %clang_cc1 -no-opaque-pointers -triple xcore-unknown-unknown -fno-signed-char -fno-common -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple xcore-unknown-unknown -fno-signed-char -fno-common -emit-llvm -o - %s | FileCheck %s
 
 // CHECK: target triple = "xcore-unknown-unknown"
 
 // CHECK: @cgx = external constant i32, section ".cp.rodata"
 extern const int cgx;
 int fcgx() { return cgx;}
 // CHECK: @g1 ={{.*}} global i32 0, align 4
 int g1;
 // CHECK: @cg1 ={{.*}} constant i32 0, section ".cp.rodata", align 4
 const int cg1;
 
 #include <stdarg.h>
 struct x { int a[5]; };
 void f(void*);
 void testva (int n, ...) {
   // CHECK-LABEL: testva
   va_list ap;
   va_start(ap,n);
-  // CHECK: [[AP:%[a-z0-9]+]] = alloca i8*, align 4
-  // CHECK: [[AP1:%[a-z0-9]+]] = bitcast i8** [[AP]] to i8*
-  // CHECK: call void @llvm.va_start(i8* [[AP1]])
+  // CHECK: [[AP:%[a-z0-9]+]] = alloca ptr, align 4
+  // CHECK: [[V5:%[a-z0-9]+]] = alloca %struct.x, align 4
+  // CHECK: [[TMP:%[a-z0-9]+]] = alloca [4 x i32], align 4
+  // CHECK: call void @llvm.va_start(ptr [[AP]])
 
   char* v1 = va_arg (ap, char*);
   f(v1);
-  // CHECK: [[I:%[a-z0-9]+]] = load i8*, i8** [[AP]]
-  // CHECK: [[P:%[a-z0-9]+]] = bitcast i8* [[I]] to i8**
-  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, i8* [[I]], i32 4
-  // CHECK: store i8* [[IN]], i8** [[AP]]
-  // CHECK: [[V1:%[a-z0-9]+]] = load i8*, i8** [[P]]
-  // CHECK: store i8* [[V1]], i8** [[V:%[a-z0-9]+]], align 4
-  // CHECK: [[V2:%[a-z0-9]+]] = load i8*, i8** [[V]], align 4
-  // CHECK: call void @f(i8* noundef [[V2]])
+  // CHECK: [[I:%[a-z0-9]+]] = load ptr, ptr [[AP]]
+  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, ptr [[I]], i32 4
+  // CHECK: store ptr [[IN]], ptr [[AP]]
+  // CHECK: [[V1:%[a-z0-9]+]] = load ptr, ptr [[I]]
+  // CHECK: store ptr [[V1]], ptr [[V:%[a-z0-9]+]], align 4
+  // CHECK: [[V2:%[a-z0-9]+]] = load ptr, ptr [[V]], align 4
+  // CHECK: call void @f(ptr noundef [[V2]])
 
   char v2 = va_arg (ap, char); // expected-warning{{second argument to 'va_arg' is of promotable type 'char'}}
   f(&v2);
-  // CHECK: [[I:%[a-z0-9]+]] = load i8*, i8** [[AP]]
-  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, i8* [[I]], i32 4
-  // CHECK: store i8* [[IN]], i8** [[AP]]
-  // CHECK: [[V1:%[a-z0-9]+]] = load i8, i8* [[I]]
-  // CHECK: store i8 [[V1]], i8* [[V:%[a-z0-9]+]], align 1
-  // CHECK: call void @f(i8* noundef [[V]])
+  // CHECK: [[I:%[a-z0-9]+]] = load ptr, ptr [[AP]]
+  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, ptr [[I]], i32 4
+  // CHECK: store ptr [[IN]], ptr [[AP]]
+  // CHECK: [[V1:%[a-z0-9]+]] = load i8, ptr [[I]]
+  // CHECK: store i8 [[V1]], ptr [[V:%[a-z0-9]+]], align 1
+  // CHECK: call void @f(ptr noundef [[V]])
 
   int v3 = va_arg (ap, int);
   f(&v3);
-  // CHECK: [[I:%[a-z0-9]+]] = load i8*, i8** [[AP]]
-  // CHECK: [[P:%[a-z0-9]+]] = bitcast i8* [[I]] to i32*
-  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, i8* [[I]], i32 4
-  // CHECK: store i8* [[IN]], i8** [[AP]]
-  // CHECK: [[V1:%[a-z0-9]+]] = load i32, i32* [[P]]
-  // CHECK: store i32 [[V1]], i32* [[V:%[a-z0-9]+]], align 4
-  // CHECK: [[V2:%[a-z0-9]+]] = bitcast i32* [[V]] to i8*
-  // CHECK: call void @f(i8* noundef [[V2]])
+  // CHECK: [[I:%[a-z0-9]+]] = load ptr, ptr [[AP]]
+  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, ptr [[I]], i32 4
+  // CHECK: store ptr [[IN]], ptr [[AP]]
+  // CHECK: [[V1:%[a-z0-9]+]] = load i32, ptr [[I]]
+  // CHECK: store i32 [[V1]], ptr [[V:%[a-z0-9]+]], align 4
+  // CHECK: call void @f(ptr noundef [[V]])
 
   long long int v4 = va_arg (ap, long long int);
   f(&v4);
-  // CHECK: [[I:%[a-z0-9]+]] = load i8*, i8** [[AP]]
-  // CHECK: [[P:%[a-z0-9]+]] = bitcast i8* [[I]] to i64*
-  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, i8* [[I]], i32 8
-  // CHECK: store i8* [[IN]], i8** [[AP]]
-  // CHECK: [[V1:%[a-z0-9]+]] = load i64, i64* [[P]]
-  // CHECK: store i64 [[V1]], i64* [[V:%[a-z0-9]+]], align 4
-  // CHECK:[[V2:%[a-z0-9]+]] = bitcast i64* [[V]] to i8*
-  // CHECK: call void @f(i8* noundef [[V2]])
+  // CHECK: [[I:%[a-z0-9]+]] = load ptr, ptr [[AP]]
+  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, ptr [[I]], i32 8
+  // CHECK: store ptr [[IN]], ptr [[AP]]
+  // CHECK: [[V1:%[a-z0-9]+]] = load i64, ptr [[I]]
+  // CHECK: store i64 [[V1]], ptr [[V:%[a-z0-9]+]], align 4
+  // CHECK: call void @f(ptr noundef [[V]])
 
   struct x v5 = va_arg (ap, struct x);  // typical aggregate type
   f(&v5);
-  // CHECK: [[I:%[a-z0-9]+]] = load i8*, i8** [[AP]]
-  // CHECK: [[I2:%[a-z0-9]+]] = bitcast i8* [[I]] to %struct.x**
-  // CHECK: [[P:%[a-z0-9]+]] = load %struct.x*, %struct.x** [[I2]]
-  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, i8* [[I]], i32 4
-  // CHECK: store i8* [[IN]], i8** [[AP]]
-  // CHECK: [[V1:%[a-z0-9]+]] = bitcast %struct.x* [[V:%[a-z0-9]+]] to i8*
-  // CHECK: [[P1:%[a-z0-9]+]] = bitcast %struct.x* [[P]] to i8*
-  // CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 [[V1]], i8* align 4 [[P1]], i32 20, i1 false)
-  // CHECK: [[V2:%[a-z0-9]+]] = bitcast %struct.x* [[V]] to i8*
-  // CHECK: call void @f(i8* noundef [[V2]])
+  // CHECK: [[I:%[a-z0-9]+]] = load ptr, ptr [[AP]]
+  // CHECK: [[P:%[a-z0-9]+]] = load ptr, ptr [[I]]
+  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, ptr [[I]], i32 4
+  // CHECK: store ptr [[IN]], ptr [[AP]]
+  // CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[V5]], ptr align 4 [[P]], i32 20, i1 false)
+  // CHECK: call void @f(ptr noundef [[V5]])
 
   int* v6 = va_arg (ap, int[4]);  // an unusual aggregate type
   f(v6);
-  // CHECK: [[I:%[a-z0-9]+]] = load i8*, i8** [[AP]]
-  // CHECK: [[I2:%[a-z0-9]+]] = bitcast i8* [[I]] to [4 x i32]**
-  // CHECK: [[P:%[a-z0-9]+]] = load [4 x i32]*, [4 x i32]** [[I2]]
-  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, i8* [[I]], i32 4
-  // CHECK: store i8* [[IN]], i8** [[AP]]
-  // CHECK: [[V1:%[a-z0-9]+]] = bitcast [4 x i32]* [[V0:%[a-z0-9]+]] to i8*
-  // CHECK: [[P1:%[a-z0-9]+]] = bitcast [4 x i32]* [[P]] to i8*
-  // CHECK: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 [[V1]], i8* align 4 [[P1]], i32 16, i1 false)
-  // CHECK: [[V2:%[a-z0-9]+]] = getelementptr inbounds [4 x i32], [4 x i32]* [[V0]], i32 0, i32 0
-  // CHECK: store i32* [[V2]], i32** [[V:%[a-z0-9]+]], align 4
-  // CHECK: [[V3:%[a-z0-9]+]] = load i32*, i32** [[V]], align 4
-  // CHECK: [[V4:%[a-z0-9]+]] = bitcast i32* [[V3]] to i8*
-  // CHECK: call void @f(i8* noundef [[V4]])
+  // CHECK: [[I:%[a-z0-9]+]] = load ptr, ptr [[AP]]
+  // CHECK: [[P:%[a-z0-9]+]] = load ptr, ptr [[I]]
+  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, ptr [[I]], i32 4
+  // CHECK: store ptr [[IN]], ptr [[AP]]
+  // CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[TMP]], ptr align 4 [[P]], i32 16, i1 false)
+  // CHECK: [[V2:%[a-z0-9]+]] = getelementptr inbounds [4 x i32], ptr [[TMP]], i32 0, i32 0
+  // CHECK: store ptr [[V2]], ptr [[V:%[a-z0-9]+]], align 4
+  // CHECK: [[V3:%[a-z0-9]+]] = load ptr, ptr [[V]], align 4
+  // CHECK: call void @f(ptr noundef [[V3]])
 
   double v7 = va_arg (ap, double);
   f(&v7);
-  // CHECK: [[I:%[a-z0-9]+]] = load i8*, i8** [[AP]]
-  // CHECK: [[P:%[a-z0-9]+]] = bitcast i8* [[I]] to double*
-  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, i8* [[I]], i32 8
-  // CHECK: store i8* [[IN]], i8** [[AP]]
-  // CHECK: [[V1:%[a-z0-9]+]] = load double, double* [[P]]
-  // CHECK: store double [[V1]], double* [[V:%[a-z0-9]+]], align 4
-  // CHECK: [[V2:%[a-z0-9]+]] = bitcast double* [[V]] to i8*
-  // CHECK: call void @f(i8* noundef [[V2]])
+  // CHECK: [[I:%[a-z0-9]+]] = load ptr, ptr [[AP]]
+  // CHECK: [[IN:%[a-z0-9]+]] = getelementptr inbounds i8, ptr [[I]], i32 8
+  // CHECK: store ptr [[IN]], ptr [[AP]]
+  // CHECK: [[V1:%[a-z0-9]+]] = load double, ptr [[I]]
+  // CHECK: store double [[V1]], ptr [[V:%[a-z0-9]+]], align 4
+  // CHECK: call void @f(ptr noundef [[V]])
 }
 
 void testbuiltin (void) {
   // CHECK-LABEL: testbuiltin
   // CHECK: call i32 @llvm.xcore.getid()
   // CHECK: call i32 @llvm.xcore.getps(i32 {{%[a-z0-9]+}})
   // CHECK: call i32 @llvm.xcore.bitrev(i32 {{%[a-z0-9]+}})
   // CHECK: call void @llvm.xcore.setps(i32 {{%[a-z0-9]+}}, i32 {{%[a-z0-9]+}})
   volatile int i = __builtin_getid();
   volatile unsigned int ui = __builtin_getps(i);
   ui = __builtin_bitrev(ui);
   __builtin_setps(i,ui);
 
-  // CHECK: store volatile i32 0, i32* {{%[a-z0-9]+}}, align 4
-  // CHECK: store volatile i32 1, i32* {{%[a-z0-9]+}}, align 4
-  // CHECK: store volatile i32 -1, i32* {{%[a-z0-9]+}}, align 4
+  // CHECK: store volatile i32 0, ptr {{%[a-z0-9]+}}, align 4
+  // CHECK: store volatile i32 1, ptr {{%[a-z0-9]+}}, align 4
+  // CHECK: store volatile i32 -1, ptr {{%[a-z0-9]+}}, align 4
   volatile int res;
   res = __builtin_eh_return_data_regno(0);
   res = __builtin_eh_return_data_regno(1);
   res = __builtin_eh_return_data_regno(2);
 }
 
 // CHECK-LABEL: define{{.*}} zeroext i8 @testchar()
 // CHECK: ret i8 -1
 char testchar (void) {
   return (char)-1;
 }
 
 // CHECK-NOT: frame-pointer

clang/test/CodeGen/xcore-stringtype.c

 // REQUIRES: xcore-registered-target
-// RUN: %clang_cc1 -no-opaque-pointers -triple xcore-unknown-unknown -fno-signed-char -fno-common -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple xcore-unknown-unknown -fno-signed-char -fno-common -emit-llvm -o - %s | FileCheck %s
 
 // CHECK: target triple = "xcore-unknown-unknown"
 
 // In the tests below, some types are not supported by the ABI (_Complex,
 // variable length arrays) and will thus emit no meta data.
 // The 38 tests that do emit typestrings are gathered into '!xcore.typestrings'
 // Please see 'Tools Development Guide' section 2.16.2 for format details:
 // <https://www.xmos.com/download/public/Tools-Development-Guide%28X9114A%29.pdf>
 
 // CHECK: !xcore.typestrings = !{
 // CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}},
 // CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}},
 // CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}},
 // CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}},
 // CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}},
 // CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}},
 // CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}},
 // CHECK: !{{[0-9]+}}, !{{[0-9]+}}, !{{[0-9]+}}
 // CHECK-NOT: , !{{[0-9]+}}
 // CHECK: }
 
 
 // test BuiltinType
-// CHECK: !{{[0-9]+}} = !{void (i1, i8, i8, i8, i16, i16, i16, i32, i32, i32,
-// CHECK:      i32, i32, i32, i64, i64, i64, float, double, double)*
+// CHECK: !{{[0-9]+}} = !{ptr
 // CHECK:      @builtinType, !"f{0}(b,uc,uc,sc,ss,us,ss,si,ui,si,sl,
 // CHECK:      ul,sl,sll,ull,sll,ft,d,ld)"}
 void builtinType(_Bool B, char C, unsigned char UC, signed char SC, short S,
                  unsigned short US, signed short SS, int I, unsigned int UI,
                  signed int SI, long L, unsigned long UL, signed long SL,
                  long long LL, unsigned long long ULL, signed long long SLL,
                  float F, double D, long double LD) {}
 double _Complex Complex; // not supported
 
 
 // test FunctionType & Qualifiers
-// CHECK: !{{[0-9]+}} = !{void ()* @gI, !"f{0}()"}
-// CHECK: !{{[0-9]+}} = !{void (...)* @eI, !"f{0}()"}
-// CHECK: !{{[0-9]+}} = !{void ()* @gV, !"f{0}(0)"}
-// CHECK: !{{[0-9]+}} = !{void ()* @eV, !"f{0}(0)"}
-// CHECK: !{{[0-9]+}} = !{void (i32, ...)* @gVA, !"f{0}(si,va)"}
-// CHECK: !{{[0-9]+}} = !{void (i32, ...)* @eVA, !"f{0}(si,va)"}
-// CHECK: !{{[0-9]+}} = !{i32* (i32*)* @gQ, !"f{crv:p(cv:si)}(p(cv:si))"}
-// CHECK: !{{[0-9]+}} = !{i32* (i32*)* @eQ, !"f{crv:p(cv:si)}(p(cv:si))"}
+// CHECK: !{{[0-9]+}} = !{ptr @gI, !"f{0}()"}
+// CHECK: !{{[0-9]+}} = !{ptr @eI, !"f{0}()"}
+// CHECK: !{{[0-9]+}} = !{ptr @gV, !"f{0}(0)"}
+// CHECK: !{{[0-9]+}} = !{ptr @eV, !"f{0}(0)"}
+// CHECK: !{{[0-9]+}} = !{ptr @gVA, !"f{0}(si,va)"}
+// CHECK: !{{[0-9]+}} = !{ptr @eVA, !"f{0}(si,va)"}
+// CHECK: !{{[0-9]+}} = !{ptr @gQ, !"f{crv:p(cv:si)}(p(cv:si))"}
+// CHECK: !{{[0-9]+}} = !{ptr @eQ, !"f{crv:p(cv:si)}(p(cv:si))"}
 extern void eI();
 void gI() {eI();};
 extern void eV(void);
 void gV(void) {eV();}
 extern void eVA(int, ...);
 void gVA(int i, ...) {eVA(i);}
 extern const volatile int* volatile restrict const
     eQ(const volatile int * volatile restrict const);
 const volatile int* volatile restrict const
     gQ(const volatile int * volatile restrict const i) {return eQ(i);}
 
 
 // test PointerType
-// CHECK: !{{[0-9]+}} = !{i32* (i32*, i32* (i32*)*)*
+// CHECK: !{{[0-9]+}} = !{ptr
 // CHECK:       @pointerType, !"f{p(si)}(p(si),p(f{p(si)}(p(si))))"}
-// CHECK: !{{[0-9]+}} = !{i32** @EP, !"p(si)"}
-// CHECK: !{{[0-9]+}} = !{i32** @GP, !"p(si)"}
+// CHECK: !{{[0-9]+}} = !{ptr @EP, !"p(si)"}
+// CHECK: !{{[0-9]+}} = !{ptr @GP, !"p(si)"}
 extern int* EP;
 int* GP;
 int* pointerType(int *I, int * (*FP)(int *)) {
   return I? EP : GP;
 }
 
 // test ArrayType
-// CHECK: !{{[0-9]+}} = !{[2 x i32]* (i32*, i32*, [2 x i32]*, [2 x i32]*, i32*)*
+// CHECK: !{{[0-9]+}} = !{ptr
 // CHECK:       @arrayType, !"f{p(a(2:si))}(p(si),p(cv:si),p(a(2:si)),
 // CHECK:       p(a(2:si)),p(si))"}
-// CHECK: !{{[0-9]+}} = !{[0 x i32]* @EA1, !"a(*:cv:si)"}
-// CHECK: !{{[0-9]+}} = !{[2 x i32]* @EA2, !"a(2:si)"}
-// CHECK: !{{[0-9]+}} = !{[0 x [2 x i32]]* @EA3, !"a(*:a(2:si))"}
-// CHECK: !{{[0-9]+}} = !{[3 x [2 x i32]]* @EA4, !"a(3:a(2:si))"}
-// CHECK: !{{[0-9]+}} = !{[2 x i32]* @GA1, !"a(2:cv:si)"}
-// CHECK: !{{[0-9]+}} = !{void ([2 x i32]*)* @arrayTypeVariable1,
+// CHECK: !{{[0-9]+}} = !{ptr @EA1, !"a(*:cv:si)"}
+// CHECK: !{{[0-9]+}} = !{ptr @EA2, !"a(2:si)"}
+// CHECK: !{{[0-9]+}} = !{ptr @EA3, !"a(*:a(2:si))"}
+// CHECK: !{{[0-9]+}} = !{ptr @EA4, !"a(3:a(2:si))"}
+// CHECK: !{{[0-9]+}} = !{ptr @GA1, !"a(2:cv:si)"}
+// CHECK: !{{[0-9]+}} = !{ptr @arrayTypeVariable1,
 // CHECK:       !"f{0}(p(a(2:si)))"}
-// CHECK: !{{[0-9]+}} = !{void (void ([2 x i32]*)*)* @arrayTypeVariable2,
+// CHECK: !{{[0-9]+}} = !{ptr @arrayTypeVariable2,
 // CHECK:       !"f{0}(p(f{0}(p(a(2:si)))))"}
-// CHECK: !{{[0-9]+}} = !{[3 x [2 x i32]]* @GA2, !"a(3:a(2:si))"}
+// CHECK: !{{[0-9]+}} = !{ptr @GA2, !"a(3:a(2:si))"}
 extern int GA2[3][2];
 extern const volatile int EA1[];
 extern int EA2[2];
 extern int EA3[][2];
 extern int EA4[3][2];
 const volatile int GA1[2];
 extern void arrayTypeVariable1(int[*][2]);
 extern void arrayTypeVariable2( void(*fp)(int[*][2]) );
RetType* arrayType(int A1[], int const volatile A2[2], int A3[][2],
   arrayTypeVariable2(arrayTypeVariable1);
   arrayTypeVariable3(EA4);
   arrayTypeVariable4(arrayTypeVariable3);
   return GA2;
 }
 
 
 // test StructureType
-// CHECK: !{{[0-9]+}} = !{void (%struct.S1*)* @structureType1,
+// CHECK: !{{[0-9]+}} = !{ptr @structureType1,
 // CHECK:       !"f{0}(s(S1){m(ps2){p(s(S2){m(ps3){p(s(S3){m(s1){s(S1){}}})}})}})"}
-// CHECK: !{{[0-9]+}} = !{void (%struct.S2*)* @structureType2,
+// CHECK: !{{[0-9]+}} = !{ptr @structureType2,
 // CHECK:       !"f{0}(s(S2){m(ps3){p(s(S3){m(s1){s(S1){m(ps2){p(s(S2){})}}}})}})"}
-// CHECK: !{{[0-9]+}} = !{void (%struct.S3*)* @structureType3,
+// CHECK: !{{[0-9]+}} = !{ptr @structureType3,
 // CHECK:       !"f{0}(s(S3){m(s1){s(S1){m(ps2){p(s(S2){m(ps3){p(s(S3){})}})}}}})"}
-// CHECK: !{{[0-9]+}} = !{void (%struct.S4*)* @structureType4,
+// CHECK: !{{[0-9]+}} = !{ptr @structureType4,
 // CHECK:       !"f{0}(s(S4){m(s1){s(S1){m(ps2){p(s(S2){m(ps3){p(s(S3){m(s1){s(S1){}}})}})}}}})"}
-// CHECK: !{{[0-9]+}} = !{%struct.anon* @StructAnon, !"s(){m(A){si}}"}
-// CHECK: !{{[0-9]+}} = !{i32 (%struct.SB*)* @structureTypeB,
+// CHECK: !{{[0-9]+}} = !{ptr @StructAnon, !"s(){m(A){si}}"}
+// CHECK: !{{[0-9]+}} = !{ptr @structureTypeB,
 // CHECK:       !"f{si}(s(SB){m(){b(4:si)},m(){b(2:si)},m(N4){b(4:si)},
 // CHECK:       m(N2){b(2:si)},m(){b(4:ui)},m(){b(4:si)},m(){b(4:c:si)},
 // CHECK:       m(){b(4:c:si)},m(){b(4:cv:si)}})"}
 struct S2;
 struct S1{struct S2 *ps2;};
 struct S3;
 struct S2{struct S3 *ps3;};
 struct S3{struct S1 s1;};
 struct S4{struct S1 s1;};
 void structureType1(struct S1 s1){}
 void structureType2(struct S2 s2){}
 void structureType3(struct S3 s3){}
 void structureType4(struct S4 s4){}
 struct {int A;} StructAnon = {1};
 struct SB{int:4; int:2; int N4:4; int N2:2; unsigned int:4; signed int:4;
           const int:4; int const :4; volatile const int:4;};
 int structureTypeB(struct SB sb){return StructAnon.A;}
 
 
 // test UnionType
-// CHECK: !{{[0-9]+}} = !{void (%union.U1*)* @unionType1,
+// CHECK: !{{[0-9]+}} = !{ptr @unionType1,
 // CHECK:       !"f{0}(u(U1){m(pu2){p(u(U2){m(pu3){p(u(U3){m(u1){u(U1){}}})}})}})"}
-// CHECK: !{{[0-9]+}} = !{void (%union.U2*)* @unionType2,
+// CHECK: !{{[0-9]+}} = !{ptr @unionType2,
 // CHECK:       !"f{0}(u(U2){m(pu3){p(u(U3){m(u1){u(U1){m(pu2){p(u(U2){})}}}})}})"}
-// CHECK: !{{[0-9]+}} = !{void (%union.U3*)* @unionType3,
+// CHECK: !{{[0-9]+}} = !{ptr @unionType3,
 // CHECK:       !"f{0}(u(U3){m(u1){u(U1){m(pu2){p(u(U2){m(pu3){p(u(U3){})}})}}}})"}
-// CHECK: !{{[0-9]+}} = !{void (%union.U4*)* @unionType4,
+// CHECK: !{{[0-9]+}} = !{ptr @unionType4,
 // CHECK:       !"f{0}(u(U4){m(u1){u(U1){m(pu2){p(u(U2){m(pu3){p(u(U3){m(u1){u(U1){}}})}})}}}})"}
-// CHECK: !{{[0-9]+}} = !{%union.anon* @UnionAnon, !"u(){m(A){si}}"}
-// CHECK: !{{[0-9]+}} = !{i32 (%union.UB*)* @unionTypeB,
+// CHECK: !{{[0-9]+}} = !{ptr @UnionAnon, !"u(){m(A){si}}"}
+// CHECK: !{{[0-9]+}} = !{ptr @unionTypeB,
 // CHECK:       !"f{si}(u(UB){m(N2){b(2:si)},m(N4){b(4:si)},m(){b(2:si)},
 // CHECK:       m(){b(4:c:si)},m(){b(4:c:si)},m(){b(4:cv:si)},m(){b(4:si)},
 // CHECK:       m(){b(4:si)},m(){b(4:ui)}})"}
 union U2;
 union U1{union U2 *pu2;};
 union U3;
 union U2{union U3 *pu3;};
 union U3{union U1 u1;};
 union U4{union U1 u1;};
 void unionType1(union U1 u1) {}
 void unionType2(union U2 u2) {}
 void unionType3(union U3 u3) {}
 void unionType4(union U4 u4) {}
 union UB{int:4; int:2; int N4:4; int N2:2; unsigned int:4; signed int:4;
          const int:4; int const :4; volatile const int:4;};
 union {int A;} UnionAnon = {1};
 int unionTypeB(union UB ub) {return UnionAnon.A;}
 
 
 // test EnumType
-// CHECK: !{{[0-9]+}} = !{i32* @EnumAnon, !"e(){m(EA){3}}"}
-// CHECK: !{{[0-9]+}} = !{i32 (i32)* @enumType,
+// CHECK: !{{[0-9]+}} = !{ptr @EnumAnon, !"e(){m(EA){3}}"}
+// CHECK: !{{[0-9]+}} = !{ptr @enumType,
 // CHECK:       !"f{si}(e(E){m(A){7},m(B){6},m(C){5},m(D){0}})"}
 enum E {D, C=5, B, A};
 enum {EA=3} EnumAnon = EA;
 int enumType(enum E e) {return EnumAnon;}
 
 
-// CHECK: !{{[0-9]+}} = !{i32 ()* @testReDecl, !"f{si}()"}
-// CHECK: !{{[0-9]+}} = !{[10 x i32]* @After, !"a(10:si)"}
-// CHECK: !{{[0-9]+}} = !{[10 x i32]* @Before, !"a(10:si)"}
+// CHECK: !{{[0-9]+}} = !{ptr @testReDecl, !"f{si}()"}
+// CHECK: !{{[0-9]+}} = !{ptr @After, !"a(10:si)"}
+// CHECK: !{{[0-9]+}} = !{ptr @Before, !"a(10:si)"}
 extern int After[];
 extern int Before[10];
 int testReDecl() {return After[0] + Before[0];}
 int After[10];
 int Before[];