; RUN: echo | llvm-as > %t.tmp.bc
; RUN: llvm-link %t.tmp.bc %t.bc
-@X = constant i32 5 ; <i32*> [#uses=2]
-@Y = internal global [2 x i32*] [ i32* @X, i32* @X ] ; <[2 x i32*]*> [#uses=0]
+@X = constant i32 5 ; <ptr> [#uses=2]
+@Y = internal global [2 x ptr] [ ptr @X, ptr @X ] ; <ptr> [#uses=0]
; RUN: llvm-as < %s > %t2.bc
; RUN: llvm-link %t1.bc %t2.bc
-@work = global i32 (i32, i32)* @zip ; <i32 (i32, i32)**> [#uses=0]
+@work = global ptr @zip ; <ptr> [#uses=0]
declare i32 @zip(i32, i32)
; RUN: llvm-as < %s > %t.bc
; RUN: llvm-link %t.LinkTest.bc %t.bc
-@work = global i32 4 ; <i32*> [#uses=1]
-@test = global i32* getelementptr (i32, i32* @work, i64 1) ; <i32**> [#uses=0]
+@work = global i32 4 ; <ptr> [#uses=1]
+@test = global ptr getelementptr (i32, ptr @work, i64 1) ; <ptr> [#uses=0]
%T = type opaque
-declare %T* @create()
+declare ptr @create()
define void @test() {
- %X = call %T* @create( ) ; <%T*> [#uses=1]
- %v = icmp eq %T* %X, null ; <i1> [#uses=0]
+ %X = call ptr @create( ) ; <ptr> [#uses=1]
+ %v = icmp eq ptr %X, null ; <i1> [#uses=0]
ret void
}
; This one fails because the LLVM runtime is allowing two null pointers of
; the same type to be created!
-; RUN: echo "%M = type { %N*} %N = type opaque" | llvm-as > %t.2.bc
+; RUN: echo "%M = type { ptr} %N = type opaque" | llvm-as > %t.2.bc
; RUN: llvm-as < %s > %t.1.bc
; RUN: llvm-link %t.1.bc %t.2.bc
-%M = type { i32* }
+%M = type { ptr }
%N = type i32
; RUN: llvm-link %S/Inputs/2003-05-31-LinkerRename.ll %s -S | FileCheck %s
-; CHECK: @bar = global i32 ()* @foo.2
+; CHECK: @bar = global ptr @foo.2
; CHECK: define internal i32 @foo.2() {
; CHECK-NEXT: ret i32 7
; RUN: llvm-link %t.1.bc %t.2.bc
%T = type opaque
-@a = constant { %T* } zeroinitializer ; <{ %T* }*> [#uses=0]
+@a = constant { ptr } zeroinitializer ; <ptr> [#uses=0]
; RUN: llvm-link %t.1.bc %t.2.bc
%T = type opaque
-@X = constant { %T* } zeroinitializer ; <{ %T* }*> [#uses=0]
+@X = constant { ptr } zeroinitializer ; <ptr> [#uses=0]
; RUN: llvm-as < %s > %t.out1.bc
-; RUN: echo "%M = type { i32, i32* } " | llvm-as > %t.out2.bc
+; RUN: echo "%M = type { i32, ptr } " | llvm-as > %t.out2.bc
; RUN: llvm-link %t.out1.bc %t.out2.bc
-%M = type { i32, %N* }
+%M = type { i32, ptr }
%N = type opaque
-;%X = global { int, %N* } { int 5, %N* null }
+;%X = global { int, ptr } { int 5, ptr null }
; net.
; RUN: llvm-as < %s > %t.out1.bc
-; RUN: echo "%M = type { %M*, i32* }" | llvm-as > %t.out2.bc
+; RUN: echo "%M = type { ptr, ptr }" | llvm-as > %t.out2.bc
; RUN: llvm-link %t.out1.bc %t.out2.bc
%T1 = type opaque
-%M = type { %M*, %T1* }
+%M = type { ptr, ptr }
%M = type opaque
-define void @foo(i32* %V) {
+define void @foo(ptr %V) {
ret void
}
-declare void @foo.upgrd.1(%M*)
+declare void @foo.upgrd.1(ptr)
%M = type opaque
-define void @foo(i32* %V) {
+define void @foo(ptr %V) {
ret void
}
-declare void @foo.upgrd.1(%M*)
+declare void @foo.upgrd.1(ptr)
define void @other() {
- call void @foo.upgrd.1( %M* null )
- call void @foo( i32* null )
+ call void @foo.upgrd.1( ptr null )
+ call void @foo( ptr null )
ret void
}
%M = type opaque
; GLobal using the resolved function prototype
-@0 = global void (%M*)* @foo ; <void (%M*)**>:0 [#uses=0]
+@0 = global ptr @foo ; <ptr>:0 [#uses=0]
-define void @foo.upgrd.1(i32* %V) {
+define void @foo.upgrd.1(ptr %V) {
ret void
}
-declare void @foo(%M*)
+declare void @foo(ptr)
; RUN: llvm-as < %s > %t.out2.bc
-; RUN: echo "@me = global i32* null" | llvm-as > %t.out1.bc
+; RUN: echo "@me = global ptr null" | llvm-as > %t.out1.bc
; RUN: llvm-link %t.out1.bc %t.out2.bc -o /dev/null
-@me = weak global i32* null ; <i32**> [#uses=0]
+@me = weak global ptr null ; <ptr> [#uses=0]
target datalayout = "e-p:32:32"
%myint = type opaque
- %struct1 = type { i32, void (%struct2*)*, %myint*, i32 (i32*)* }
+ %struct1 = type { i32, ptr, ptr, ptr }
%struct2 = type { %struct1 }
-@driver1 = global %struct1 zeroinitializer ; <%struct1*> [#uses=1]
-@m1 = external global [1 x i8]* ; <[1 x i8]**> [#uses=0]
-@str1 = constant [1 x i8] zeroinitializer ; <[1 x i8]*> [#uses=0]
-@str2 = constant [2 x i8] zeroinitializer ; <[2 x i8]*> [#uses=0]
-@str3 = constant [3 x i8] zeroinitializer ; <[3 x i8]*> [#uses=0]
-@str4 = constant [4 x i8] zeroinitializer ; <[4 x i8]*> [#uses=0]
-@str5 = constant [5 x i8] zeroinitializer ; <[5 x i8]*> [#uses=0]
-@str6 = constant [6 x i8] zeroinitializer ; <[6 x i8]*> [#uses=0]
-@str7 = constant [7 x i8] zeroinitializer ; <[7 x i8]*> [#uses=0]
-@str8 = constant [8 x i8] zeroinitializer ; <[8 x i8]*> [#uses=0]
-@str9 = constant [9 x i8] zeroinitializer ; <[9 x i8]*> [#uses=0]
-@stra = constant [10 x i8] zeroinitializer ; <[10 x i8]*> [#uses=0]
-@strb = constant [11 x i8] zeroinitializer ; <[11 x i8]*> [#uses=0]
-@strc = constant [12 x i8] zeroinitializer ; <[12 x i8]*> [#uses=0]
-@strd = constant [13 x i8] zeroinitializer ; <[13 x i8]*> [#uses=0]
-@stre = constant [14 x i8] zeroinitializer ; <[14 x i8]*> [#uses=0]
-@strf = constant [15 x i8] zeroinitializer ; <[15 x i8]*> [#uses=0]
-@strg = constant [16 x i8] zeroinitializer ; <[16 x i8]*> [#uses=0]
-@strh = constant [17 x i8] zeroinitializer ; <[17 x i8]*> [#uses=0]
+@driver1 = global %struct1 zeroinitializer ; <ptr> [#uses=1]
+@m1 = external global ptr ; <ptr> [#uses=0]
+@str1 = constant [1 x i8] zeroinitializer ; <ptr> [#uses=0]
+@str2 = constant [2 x i8] zeroinitializer ; <ptr> [#uses=0]
+@str3 = constant [3 x i8] zeroinitializer ; <ptr> [#uses=0]
+@str4 = constant [4 x i8] zeroinitializer ; <ptr> [#uses=0]
+@str5 = constant [5 x i8] zeroinitializer ; <ptr> [#uses=0]
+@str6 = constant [6 x i8] zeroinitializer ; <ptr> [#uses=0]
+@str7 = constant [7 x i8] zeroinitializer ; <ptr> [#uses=0]
+@str8 = constant [8 x i8] zeroinitializer ; <ptr> [#uses=0]
+@str9 = constant [9 x i8] zeroinitializer ; <ptr> [#uses=0]
+@stra = constant [10 x i8] zeroinitializer ; <ptr> [#uses=0]
+@strb = constant [11 x i8] zeroinitializer ; <ptr> [#uses=0]
+@strc = constant [12 x i8] zeroinitializer ; <ptr> [#uses=0]
+@strd = constant [13 x i8] zeroinitializer ; <ptr> [#uses=0]
+@stre = constant [14 x i8] zeroinitializer ; <ptr> [#uses=0]
+@strf = constant [15 x i8] zeroinitializer ; <ptr> [#uses=0]
+@strg = constant [16 x i8] zeroinitializer ; <ptr> [#uses=0]
+@strh = constant [17 x i8] zeroinitializer ; <ptr> [#uses=0]
-declare void @func(%struct2*)
+declare void @func(ptr)
define void @tty_init() {
entry:
- store volatile void (%struct2*)* @func, void (%struct2*)** getelementptr (%struct1, %struct1* @driver1, i64 0, i32 1)
+ store volatile ptr @func, ptr getelementptr (%struct1, ptr @driver1, i64 0, i32 1)
ret void
}
; RUN: echo
target datalayout = "e-p:32:32"
%myint = type i16
- %struct1 = type { i32, void (%struct2*)*, i16*, i32 (i32*)* }
+ %struct1 = type { i32, ptr, ptr, ptr }
%struct2 = type { %struct1 }
-define internal void @f1(%struct1* %tty) {
+define internal void @f1(ptr %tty) {
loopentry.preheader:
- %tmp.2.i.i = getelementptr %struct1, %struct1* %tty, i64 0, i32 1 ; <void (%struct2*)**> [#uses=1]
- %tmp.3.i.i = load volatile void (%struct2*)*, void (%struct2*)** %tmp.2.i.i ; <void (%struct2*)*> [#uses=0]
+ %tmp.2.i.i = getelementptr %struct1, ptr %tty, i64 0, i32 1 ; <ptr> [#uses=1]
+ %tmp.3.i.i = load volatile ptr, ptr %tmp.2.i.i ; <ptr> [#uses=0]
ret void
}
; RUN: llvm-link %t.1.bc %t.2.bc -S | FileCheck %s
; CHECK: global i32 7
-@X = external constant i32 ; <i32*> [#uses=0]
+@X = external constant i32 ; <ptr> [#uses=0]
; When linked, the globals should be merged, and the result should still
; be named '@G'.
-@G = appending global [1 x i32] zeroinitializer ; <[1 x i32]*> [#uses=0]
+@G = appending global [1 x i32] zeroinitializer ; <ptr> [#uses=0]
target datalayout = "E-p:32:32"
target triple = "powerpc-apple-darwin7.7.0"
-@source = global <4 x i32> < i32 0, i32 1, i32 2, i32 3 > ; <<4 x i32>*> [#uses=0]
+@source = global <4 x i32> < i32 0, i32 1, i32 2, i32 3 > ; <ptr> [#uses=0]
define i32 @main() {
ret i32 0
; ModuleID = 'bug.o'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu"
-@foo = weak global i32 0 ; <i32*> [#uses=1]
+@foo = weak global i32 0 ; <ptr> [#uses=1]
-@bar = weak alias i32, i32* @foo ; <i32*> [#uses=1]
+@bar = weak alias i32, ptr @foo ; <ptr> [#uses=1]
define i32 @baz() nounwind {
entry:
- %tmp1 = load i32, i32* @bar, align 4 ; <i32> [#uses=1]
+ %tmp1 = load i32, ptr @bar, align 4 ; <i32> [#uses=1]
ret i32 %tmp1
}
define i32 @main(...) nounwind {
entry:
- %retval = alloca i32 ; <i32*> [#uses=2]
+ %retval = alloca i32 ; <ptr> [#uses=2]
call void @llvm.dbg.func.start(metadata !0)
- store i32 0, i32* %retval
+ store i32 0, ptr %retval
call void @llvm.dbg.stoppoint(i32 4, i32 5, metadata !1)
call void @f()
br label %return
return: ; preds = %entry
- %0 = load i32, i32* %retval ; <i32> [#uses=1]
+ %0 = load i32, ptr %retval ; <i32> [#uses=1]
call void @llvm.dbg.stoppoint(i32 5, i32 1, metadata !1)
call void @llvm.dbg.region.end(metadata !0)
ret i32 %0
define i32 @f(...) nounwind {
entry:
- %retval = alloca i32 ; <i32*> [#uses=1]
+ %retval = alloca i32 ; <ptr> [#uses=1]
call void @llvm.dbg.func.start(metadata !0)
br label %return
return: ; preds = %entry
- %0 = load i32, i32* %retval ; <i32> [#uses=1]
+ %0 = load i32, ptr %retval ; <i32> [#uses=1]
call void @llvm.dbg.stoppoint(i32 3, i32 1, metadata !1)
call void @llvm.dbg.region.end(metadata !0)
ret i32 %0
; Function Attrs: nounwind ssp uwtable
define void @foo() #0 !dbg !8 {
entry:
- store i32 1, i32* @x, align 4, !dbg !11
+ store i32 1, ptr @x, align 4, !dbg !11
ret void, !dbg !11
}
; Function Attrs: nounwind ssp uwtable
define void @bar() #0 !dbg !8 {
entry:
- store i32 1, i32* @x, align 4, !dbg !11
+ store i32 1, ptr @x, align 4, !dbg !11
ret void, !dbg !11
}
define void @_Z3fooN2N11AE() nounwind uwtable ssp !dbg !5 {
entry:
%mya = alloca %"class.N1::A", align 1
- call void @llvm.dbg.declare(metadata %"class.N1::A"* %mya, metadata !9, metadata !DIExpression()), !dbg !13
+ call void @llvm.dbg.declare(metadata ptr %mya, metadata !9, metadata !DIExpression()), !dbg !13
ret void, !dbg !14
}
define void @_Z3barN2N11AE() nounwind uwtable ssp !dbg !5 {
entry:
%youra = alloca %"class.N1::A", align 1
- call void @llvm.dbg.declare(metadata %"class.N1::A"* %youra, metadata !9, metadata !DIExpression()), !dbg !13
+ call void @llvm.dbg.declare(metadata ptr %youra, metadata !9, metadata !DIExpression()), !dbg !13
ret void, !dbg !14
}
; RUN: llvm-link %t.1.bc %t.2.bc -S | FileCheck %s
; CHECK: [i32 7, i32 8]
-@X = appending global [1 x i32] [ i32 7 ] ; <[1 x i32]*> [#uses=0]
+@X = appending global [1 x i32] [ i32 7 ] ; <ptr> [#uses=0]
; CHECK-DAG: @Y = external global [1 x i32]
@Y = external global [1 x i32]
-define [1 x i32]* @use-Y() {
- ret [1 x i32] *@Y
+define ptr @use-Y() {
+ ret ptr @Y
}
; Test if metadata in dbg.declare is mapped properly or not.
; rdar://13089880
-; CHECK: define i32 @main(i32 %argc, i8** %argv)
-; CHECK: call void @llvm.dbg.declare(metadata i32* %argc.addr, metadata !{{[0-9]+}}, metadata {{.*}})
-; CHECK: call void @llvm.dbg.declare(metadata i8*** %argv.addr, metadata !{{[0-9]+}}, metadata {{.*}})
-; CHECK: define void @test(i32 %argc, i8** %argv)
-; CHECK: call void @llvm.dbg.declare(metadata i32* %argc.addr, metadata !{{[0-9]+}}, metadata {{.*}})
-; CHECK: call void @llvm.dbg.declare(metadata i8*** %argv.addr, metadata !{{[0-9]+}}, metadata {{.*}})
-; CHECK: call void @llvm.dbg.declare(metadata i32* %i, metadata !{{[0-9]+}}, metadata {{.*}})
+; CHECK: define i32 @main(i32 %argc, ptr %argv)
+; CHECK: call void @llvm.dbg.declare(metadata ptr %argc.addr, metadata !{{[0-9]+}}, metadata {{.*}})
+; CHECK: call void @llvm.dbg.declare(metadata ptr %argv.addr, metadata !{{[0-9]+}}, metadata {{.*}})
+; CHECK: define void @test(i32 %argc, ptr %argv)
+; CHECK: call void @llvm.dbg.declare(metadata ptr %argc.addr, metadata !{{[0-9]+}}, metadata {{.*}})
+; CHECK: call void @llvm.dbg.declare(metadata ptr %argv.addr, metadata !{{[0-9]+}}, metadata {{.*}})
+; CHECK: call void @llvm.dbg.declare(metadata ptr %i, metadata !{{[0-9]+}}, metadata {{.*}})
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0"
-define i32 @main(i32 %argc, i8** %argv) uwtable ssp !dbg !5 {
+define i32 @main(i32 %argc, ptr %argv) uwtable ssp !dbg !5 {
entry:
%retval = alloca i32, align 4
%argc.addr = alloca i32, align 4
- %argv.addr = alloca i8**, align 8
- store i32 0, i32* %retval
- store i32 %argc, i32* %argc.addr, align 4
- call void @llvm.dbg.declare(metadata i32* %argc.addr, metadata !14, metadata !DIExpression()), !dbg !15
- store i8** %argv, i8*** %argv.addr, align 8
- call void @llvm.dbg.declare(metadata i8*** %argv.addr, metadata !16, metadata !DIExpression()), !dbg !15
- %0 = load i32, i32* %argc.addr, align 4, !dbg !17
- %1 = load i8**, i8*** %argv.addr, align 8, !dbg !17
- call void @test(i32 %0, i8** %1), !dbg !17
+ %argv.addr = alloca ptr, align 8
+ store i32 0, ptr %retval
+ store i32 %argc, ptr %argc.addr, align 4
+ call void @llvm.dbg.declare(metadata ptr %argc.addr, metadata !14, metadata !DIExpression()), !dbg !15
+ store ptr %argv, ptr %argv.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %argv.addr, metadata !16, metadata !DIExpression()), !dbg !15
+ %0 = load i32, ptr %argc.addr, align 4, !dbg !17
+ %1 = load ptr, ptr %argv.addr, align 8, !dbg !17
+ call void @test(i32 %0, ptr %1), !dbg !17
ret i32 0, !dbg !19
}
declare void @llvm.dbg.declare(metadata, metadata, metadata) nounwind readnone
-declare void @test(i32, i8**)
+declare void @test(i32, ptr)
!llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!21}
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9.0"
-define void @test(i32 %argc, i8** %argv) uwtable ssp !dbg !5 {
+define void @test(i32 %argc, ptr %argv) uwtable ssp !dbg !5 {
entry:
%argc.addr = alloca i32, align 4
- %argv.addr = alloca i8**, align 8
+ %argv.addr = alloca ptr, align 8
%i = alloca i32, align 4
- store i32 %argc, i32* %argc.addr, align 4
- call void @llvm.dbg.declare(metadata i32* %argc.addr, metadata !14, metadata !DIExpression()), !dbg !15
- store i8** %argv, i8*** %argv.addr, align 8
- call void @llvm.dbg.declare(metadata i8*** %argv.addr, metadata !16, metadata !DIExpression()), !dbg !15
- call void @llvm.dbg.declare(metadata i32* %i, metadata !17, metadata !DIExpression()), !dbg !20
- store i32 0, i32* %i, align 4, !dbg !20
+ store i32 %argc, ptr %argc.addr, align 4
+ call void @llvm.dbg.declare(metadata ptr %argc.addr, metadata !14, metadata !DIExpression()), !dbg !15
+ store ptr %argv, ptr %argv.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %argv.addr, metadata !16, metadata !DIExpression()), !dbg !15
+ call void @llvm.dbg.declare(metadata ptr %i, metadata !17, metadata !DIExpression()), !dbg !20
+ store i32 0, ptr %i, align 4, !dbg !20
br label %for.cond, !dbg !20
for.cond: ; preds = %for.inc, %entry
- %0 = load i32, i32* %i, align 4, !dbg !20
- %1 = load i32, i32* %argc.addr, align 4, !dbg !20
+ %0 = load i32, ptr %i, align 4, !dbg !20
+ %1 = load i32, ptr %argc.addr, align 4, !dbg !20
%cmp = icmp slt i32 %0, %1, !dbg !20
br i1 %cmp, label %for.body, label %for.end, !dbg !20
for.body: ; preds = %for.cond
- %2 = load i32, i32* %i, align 4, !dbg !21
+ %2 = load i32, ptr %i, align 4, !dbg !21
%idxprom = sext i32 %2 to i64, !dbg !21
- %3 = load i8**, i8*** %argv.addr, align 8, !dbg !21
- %arrayidx = getelementptr inbounds i8*, i8** %3, i64 %idxprom, !dbg !21
- %4 = load i8*, i8** %arrayidx, align 8, !dbg !21
- %call = call i32 @puts(i8* %4), !dbg !21
+ %3 = load ptr, ptr %argv.addr, align 8, !dbg !21
+ %arrayidx = getelementptr inbounds ptr, ptr %3, i64 %idxprom, !dbg !21
+ %4 = load ptr, ptr %arrayidx, align 8, !dbg !21
+ %call = call i32 @puts(ptr %4), !dbg !21
br label %for.inc, !dbg !23
for.inc: ; preds = %for.body
- %5 = load i32, i32* %i, align 4, !dbg !20
+ %5 = load i32, ptr %i, align 4, !dbg !20
%inc = add nsw i32 %5, 1, !dbg !20
- store i32 %inc, i32* %i, align 4, !dbg !20
+ store i32 %inc, ptr %i, align 4, !dbg !20
br label %for.cond, !dbg !20
for.end: ; preds = %for.cond
declare void @llvm.dbg.declare(metadata, metadata, metadata) nounwind readnone
-declare i32 @puts(i8*)
+declare i32 @puts(ptr)
!llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!27}
-@bar = global i32()* @foo
+@bar = global ptr @foo
define internal i32 @foo() {
ret i32 7
%bug_type = type opaque
-declare i32 @bug_a(%bug_type*)
-declare i32 @bug_b(%bug_type*)
+declare i32 @bug_a(ptr)
+declare i32 @bug_b(ptr)
-%bug_type = type { %bug_type* }
+%bug_type = type { ptr }
%bar = type { i32 }
-define i32 @bug_a(%bug_type* %fp) nounwind uwtable {
+define i32 @bug_a(ptr %fp) nounwind uwtable {
entry:
- %d_stream = getelementptr inbounds %bug_type, %bug_type* %fp, i64 0, i32 0
ret i32 0
}
-define i32 @bug_b(%bar* %a) nounwind uwtable {
+define i32 @bug_b(ptr %a) nounwind uwtable {
entry:
ret i32 0
}
%foo2 = type { [8 x i8] }
-declare void @zed(%foo2*)
+declare void @zed(%foo2)
%foo = type { [8 x i8] }
%bar = type { [9 x i8] }
-@zed = alias void (%foo*), bitcast (void (%bar*)* @xyz to void (%foo*)*)
+@zed = alias void (%bar), ptr @xyz
-define void @xyz(%bar* %this) {
+define void @xyz(%foo %this) {
entry:
ret void
}
@tlsvar1 = thread_local global i32 0, align 4
-@tlsvar2 = hidden thread_local alias i32, i32* @tlsvar1
+@tlsvar2 = hidden thread_local alias i32, ptr @tlsvar1
@zed = global i32 42
-@foo = alias i32, i32* @zed
-@foo2 = alias i16, bitcast (i32* @zed to i16*)
+@foo = alias i32, ptr @zed
+@foo2 = alias i16, ptr @zed
-@var = appending global [1 x i8* ] undef
+@var = appending global [1 x ptr] undef
-@h = global void ()* @f
-@h2 = global void ()* @g
+@h = global ptr @f
+@h2 = global ptr @g
define available_externally void @f() {
ret void
-define i32* @foo(i32 %x) { ret i32* @baz }
+define ptr @foo(i32 %x) { ret ptr @baz }
@baz = external global i32
-declare i32* @foo(...)
-define i32* @bar() {
- %ret = call i32* (...) @foo( i32 123 )
- ret i32* %ret
+declare ptr @foo(...)
+define ptr @bar() {
+ %ret = call ptr (...) @foo( i32 123 )
+ ret ptr %ret
}
@baz = global i32 0
%a = type { i64 }
%struct = type { i32, i8 }
-define void @g(%a* byref(%a)) {
+define void @g(ptr byref(%a)) {
ret void
}
-declare void @baz(%struct* byref(%struct))
+declare void @baz(ptr byref(%struct))
-define void @foo(%struct* byref(%struct) %a) {
- call void @baz(%struct* byref(%struct) %a)
+define void @foo(ptr byref(%struct) %a) {
+ call void @baz(ptr byref(%struct) %a)
ret void
}
%struct = type {i32, i8}
-declare void @baz(%struct* byval(%struct))
+declare void @baz(ptr byval(%struct))
-define void @foo(%struct* byval(%struct) %a) {
- call void @baz(%struct* byval(%struct) %a)
+define void @foo(ptr byval(%struct) %a) {
+ call void @baz(ptr byval(%struct) %a)
ret void
}
@v = weak global i8 1
-@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @f, i8* @v}]
+@llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @f, ptr @v}]
define weak void @f() {
ret void
$foo = comdat any
@foo = global i8 1, comdat
-@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @bar, i8* @foo }]
+@llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @bar, ptr @foo }]
define void @bar() comdat($foo) {
ret void
}
$foo = comdat any
%t = type { i8 }
@foo = global %t zeroinitializer, comdat
-@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @bar, i8* getelementptr (%t, %t* @foo, i32 0, i32 0) }]
+@llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @bar, ptr @foo }]
define internal void @bar() comdat($foo) {
ret void
}
!0 = !{}
!1 = !{!0}
-!2 = !{i32* @global}
+!2 = !{ptr @global}
!3 = distinct !{}
!4 = distinct !{!0}
-!5 = distinct !{i32* @global}
+!5 = distinct !{ptr @global}
!6 = !{!3}
!7 = !{!4}
!8 = !{!5}
%struct = type {i32, i8}
define void @struct_elementtype_2() {
- call %struct* @llvm.preserve.array.access.index.p0s_structs.p0s_structs(%struct* elementtype(%struct) null, i32 0, i32 0)
+ call ptr @llvm.preserve.array.access.index.p0.p0(ptr elementtype(%struct) null, i32 0, i32 0)
ret void
}
-declare %struct* @llvm.preserve.array.access.index.p0s_structs.p0s_structs(%struct*, i32, i32)
+declare ptr @llvm.preserve.array.access.index.p0.p0(ptr, i32, i32)
%t = type {i32, float}
-define void @foo(<4 x %t*> %x) {
+define void @foo(<4 x ptr> %x) {
ret void
}
@v = weak global i8 1
-@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @foo, i8* @v}]
+@llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @foo, ptr @v}]
define void @foo() {
ret void
@var5 = internal global i32 0, align 4
@var6 = internal global i32 0, align 4
-@var7 = global i32* @var5, align 4
-@var8 = global i32* @var6, align 4
+@var7 = global ptr @var5, align 4
+@var8 = global ptr @var6, align 4
define i32 @foo2() {
entry:
- %0 = load i32*, i32** @var7, align 4
- %1 = load i32, i32* %0, align 4
- %2 = load i32*, i32** @var8, align 4
- %3 = load i32, i32* %2, align 4
+ %0 = load ptr, ptr @var7, align 4
+ %1 = load i32, ptr %0, align 4
+ %2 = load ptr, ptr @var8, align 4
+ %3 = load i32, ptr %2, align 4
%add = add nsw i32 %3, %1
ret i32 %add
}
%a = type { i64 }
%struct = type { i32, i8 }
-define void @g(%a* inalloca(%a)) {
+define void @g(ptr inalloca(%a)) {
ret void
}
-declare void @baz(%struct* inalloca(%struct))
+declare void @baz(ptr inalloca(%struct))
-define void @foo(%struct* inalloca(%struct) %a) {
- call void @baz(%struct* inalloca(%struct) %a)
+define void @foo(ptr inalloca(%struct) %a) {
+ call void @baz(ptr inalloca(%struct) %a)
ret void
}
declare i32 @foo()
define void @bar() {
- load i32, i32* @X
+ load i32, ptr @X
call i32 @foo()
ret void
}
define i64 @foo() { ret i64 7 }
-@llvm.used = appending global [2 x i8*] [i8* @Y, i8* bitcast (i64 ()* @foo to i8*)], section "llvm.metadata"
+@llvm.used = appending global [2 x ptr] [ptr @Y, ptr @foo], section "llvm.metadata"
define void @f2() !attach !0 {
call void @f1()
- store i32 0, i32* @g1
+ store i32 0, ptr @g1
ret void
}
%class.anon = type { i8 }
; Function Attrs: noinline norecurse nounwind optnone ssp uwtable
-define i32 @main(i32 %argc, i8** %argv) #0 !dbg !8 {
+define i32 @main(i32 %argc, ptr %argv) #0 !dbg !8 {
entry:
%argc.addr = alloca i32, align 4
- %argv.addr = alloca i8**, align 8
+ %argv.addr = alloca ptr, align 8
%agg.tmp = alloca %class.Error, align 1
- store i32 %argc, i32* %argc.addr, align 4
- call void @llvm.dbg.declare(metadata i32* %argc.addr, metadata !15, metadata !DIExpression()), !dbg !16
- store i8** %argv, i8*** %argv.addr, align 8
- call void @llvm.dbg.declare(metadata i8*** %argv.addr, metadata !17, metadata !DIExpression()), !dbg !18
+ store i32 %argc, ptr %argc.addr, align 4
+ call void @llvm.dbg.declare(metadata ptr %argc.addr, metadata !15, metadata !DIExpression()), !dbg !16
+ store ptr %argv, ptr %argv.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %argv.addr, metadata !17, metadata !DIExpression()), !dbg !18
call void @_Z12consumeError5Error(), !dbg !19
ret i32 0, !dbg !20
}
entry:
%Err = alloca %class.Error, align 1
%agg.tmp = alloca %class.anon, align 1
- call void @llvm.dbg.declare(metadata %class.Error* %Err, metadata !25, metadata !DIExpression()), !dbg !26
+ call void @llvm.dbg.declare(metadata ptr %Err, metadata !25, metadata !DIExpression()), !dbg !26
call void @_Z15handleAllErrorsIZ12consumeError5ErrorEUlvE_EvT_(), !dbg !27
ret void, !dbg !28
}
define linkonce_odr void @_Z15handleAllErrorsIZ12consumeError5ErrorEUlvE_EvT_() #2 !dbg !29 {
entry:
%Handlers = alloca %class.anon, align 1
- call void @llvm.dbg.declare(metadata %class.anon* %Handlers, metadata !35, metadata !DIExpression()), !dbg !36
+ call void @llvm.dbg.declare(metadata ptr %Handlers, metadata !35, metadata !DIExpression()), !dbg !36
ret void, !dbg !37
}
@used1 = global i8 4
@used2 = global i32 123
-@llvm.compiler.used = appending global [2 x i8*] [
- i8* @used1,
- i8* bitcast (i32* @used2 to i8*)
+@llvm.compiler.used = appending global [2 x ptr] [
+ ptr @used1,
+ ptr @used2
], section "llvm.metadata"
ret void
}
-@llvm.global_ctors = appending global[2 x{i32, void() *, i8 * }] [
- {i32, void() *, i8 * } { i32 2, void() *@ctor1, i8 *null},
- {i32, void() *, i8 * } { i32 7, void() *@ctor2, i8 *null}]
+@llvm.global_ctors = appending global[2 x{i32, ptr, ptr }] [
+ {i32, ptr, ptr } { i32 2, ptr @ctor1, ptr null},
+ {i32, ptr, ptr } { i32 7, ptr @ctor2, ptr null}]
ret void
}
-@llvm.global_dtors = appending global[2 x{i32, void() *, i8 * }] [
- {i32, void() *, i8 * } { i32 2, void() *@dtor1, i8 *null},
- {i32, void() *, i8 * } { i32 7, void() *@dtor2, i8 *null}]
+@llvm.global_dtors = appending global[2 x{i32, ptr, ptr }] [
+ {i32, ptr, ptr } { i32 2, ptr @dtor1, ptr null},
+ {i32, ptr, ptr } { i32 7, ptr @dtor2, ptr null}]
declare i32 @foo()
define void @bar() {
- load i32, i32* @X
+ load i32, ptr @X
call i32 @foo()
ret void
}
@used1 = global i8 4
@used2 = global i32 123
-@llvm.used = appending global [2 x i8*] [
- i8* @used1,
- i8* bitcast (i32* @used2 to i8*)
+@llvm.used = appending global [2 x ptr] [
+ ptr @used1,
+ ptr @used2
], section "llvm.metadata"
%A = type { }
-%B = type { %D, %E, %B* }
+%B = type { %D, %E, ptr }
%D = type { %E }
%E = type opaque
@g3 = external global %B
define void @f1() {
- getelementptr %A, %A* null, i32 0
+ getelementptr %A, ptr null, i32 0
ret void
}
-define %A* @use_g2() {
- ret %A* @g2
+define ptr @use_g2() {
+ ret ptr @g2
}
-define %B* @use_g3() {
- ret %B* @g3
+define ptr @use_g3() {
+ ret ptr @g3
}
%struct.Class = type { i8 }
-define weak_odr i32 @_ZN5ClassIiE3fooEv(%struct.Class* %this) align 2 !dbg !4 {
+define weak_odr i32 @_ZN5ClassIiE3fooEv(ptr %this) align 2 !dbg !4 {
entry:
- %this.addr = alloca %struct.Class*, align 8
- store %struct.Class* %this, %struct.Class** %this.addr, align 8
- %this1 = load %struct.Class*, %struct.Class** %this.addr
+ %this.addr = alloca ptr, align 8
+ store ptr %this, ptr %this.addr, align 8
+ %this1 = load ptr, ptr %this.addr
ret i32 0, !dbg !12
}
%a = type { i64 }
%struct = type { i32, i8 }
-define void @g(%a* sret(%a)) {
+define void @g(ptr sret(%a)) {
ret void
}
-declare void @baz(%struct* sret(%struct))
+declare void @baz(ptr sret(%struct))
-define void @foo(%struct* sret(%struct) %a) {
- call void @baz(%struct* sret(%struct) %a)
+define void @foo(ptr sret(%struct) %a) {
+ call void @baz(ptr sret(%struct) %a)
ret void
}
%u = type { i8 }
@g2 = global %u zeroinitializer
-@a = weak alias %u, %u* @g2
+@a = weak alias %u, ptr @g2
%B = type { i8 }
@g1 = external global %A.11
-define %A.11* @use_g1() {
- ret %A.11* @g1
+define ptr @use_g1() {
+ ret ptr @g1
}
%A.11 = type opaque
@g2 = external global %A.11
-define %A.11* @use_g2() {
- ret %A.11* @g2
+define ptr @use_g2() {
+ ret ptr @g2
}
entry:
%a.addr = alloca i32, align 4
%t = alloca %class.A, align 4
- store i32 %a, i32* %a.addr, align 4
- call void @llvm.dbg.declare(metadata i32* %a.addr, metadata !20, metadata !DIExpression()), !dbg !21
- call void @llvm.dbg.declare(metadata %class.A* %t, metadata !22, metadata !DIExpression()), !dbg !23
+ store i32 %a, ptr %a.addr, align 4
+ call void @llvm.dbg.declare(metadata ptr %a.addr, metadata !20, metadata !DIExpression()), !dbg !21
+ call void @llvm.dbg.declare(metadata ptr %t, metadata !22, metadata !DIExpression()), !dbg !23
ret void, !dbg !24
}
; ModuleID = 'bar.cpp'
-%class.B = type { i32, %class.A* }
+%class.B = type { i32, ptr }
%class.A = type { %class.Base, i32 }
%class.Base = type { i32 }
entry:
%a.addr = alloca i32, align 4
%t = alloca %class.B, align 8
- store i32 %a, i32* %a.addr, align 4
- call void @llvm.dbg.declare(metadata i32* %a.addr, metadata !28, metadata !DIExpression()), !dbg !29
- call void @llvm.dbg.declare(metadata %class.B* %t, metadata !30, metadata !DIExpression()), !dbg !31
+ store i32 %a, ptr %a.addr, align 4
+ call void @llvm.dbg.declare(metadata ptr %a.addr, metadata !28, metadata !DIExpression()), !dbg !29
+ call void @llvm.dbg.declare(metadata ptr %t, metadata !30, metadata !DIExpression()), !dbg !31
ret void, !dbg !32
}
entry:
%retval = alloca i32, align 4
%a = alloca %class.A, align 4
- store i32 0, i32* %retval
- call void @llvm.dbg.declare(metadata %class.A* %a, metadata !33, metadata !DIExpression()), !dbg !34
+ store i32 0, ptr %retval
+ call void @llvm.dbg.declare(metadata ptr %a, metadata !33, metadata !DIExpression()), !dbg !34
call void @_Z1fi(i32 0), !dbg !35
call void @_Z1gi(i32 1), !dbg !36
ret i32 0, !dbg !37
; }
; ModuleID = 'foo.cpp'
-%struct.Base = type { i32, %struct.Base* }
+%struct.Base = type { i32, ptr }
; Function Attrs: nounwind ssp uwtable
define void @_Z1fi(i32 %a) #0 !dbg !12 {
entry:
%a.addr = alloca i32, align 4
%t = alloca %struct.Base, align 8
- store i32 %a, i32* %a.addr, align 4
- call void @llvm.dbg.declare(metadata i32* %a.addr, metadata !17, metadata !DIExpression()), !dbg !18
- call void @llvm.dbg.declare(metadata %struct.Base* %t, metadata !19, metadata !DIExpression()), !dbg !20
+ store i32 %a, ptr %a.addr, align 4
+ call void @llvm.dbg.declare(metadata ptr %a.addr, metadata !17, metadata !DIExpression()), !dbg !18
+ call void @llvm.dbg.declare(metadata ptr %t, metadata !19, metadata !DIExpression()), !dbg !20
ret void, !dbg !21
}
; ModuleID = 'bar.cpp'
-%struct.Base = type { i32, %struct.Base* }
+%struct.Base = type { i32, ptr }
; Function Attrs: nounwind ssp uwtable
define void @_Z1gi(i32 %a) #0 !dbg !12 {
entry:
%a.addr = alloca i32, align 4
%t = alloca %struct.Base, align 8
- store i32 %a, i32* %a.addr, align 4
- call void @llvm.dbg.declare(metadata i32* %a.addr, metadata !20, metadata !DIExpression()), !dbg !21
- call void @llvm.dbg.declare(metadata %struct.Base* %t, metadata !22, metadata !DIExpression()), !dbg !23
+ store i32 %a, ptr %a.addr, align 4
+ call void @llvm.dbg.declare(metadata ptr %a.addr, metadata !20, metadata !DIExpression()), !dbg !21
+ call void @llvm.dbg.declare(metadata ptr %t, metadata !22, metadata !DIExpression()), !dbg !23
ret void, !dbg !24
}
define i32 @main() #2 !dbg !16 {
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval
+ store i32 0, ptr %retval
call void @_Z1fi(i32 0), !dbg !25
call void @_Z1gi(i32 1), !dbg !26
ret i32 0, !dbg !27
-%t = type { i8* }
+%t = type { ptr }
declare %t @g()
define %t @g2() {
-%t = type { i8* }
+%t = type { ptr }
declare %t @f()
define %t @g() {
@v4 = hidden global i32 1, comdat($c1)
; Aliases
-@a1 = weak hidden alias i32, i32* @v1
-@a2 = weak protected alias i32, i32* @v2
-@a3 = weak hidden alias i32, i32* @v3
+@a1 = weak hidden alias i32, ptr @v1
+@a2 = weak protected alias i32, ptr @v2
+@a3 = weak hidden alias i32, ptr @v3
; Functions
define weak hidden void @f1() {
; RUN: llvm-as < %s > %t.1.bc
; RUN: llvm-link %t.1.bc %t.2.bc -S
-@X = linkonce global i32 7 ; <i32*> [#uses=0]
+@X = linkonce global i32 7 ; <ptr> [#uses=0]
@G = addrspace(2) global i32 256
; CHECK: @G = addrspace(2) global i32
-@GA = alias i32, i32 addrspace(2)* @G
-; CHECK: @GA = alias i32, i32 addrspace(2)* @G
+@GA = alias i32, ptr addrspace(2) @G
+; CHECK: @GA = alias i32, ptr addrspace(2) @G
define void @foo() addrspace(3) {
; CHECK: define void @foo() addrspace(3)
target triple = "x86_64-apple-macosx10.9"
; CHECK-DAG: @A = internal constant i8 1
-; CHECK-DAG: @B = alias i8, i8* @A
-; CHECK-DAG: @C = global [2 x i8*] [i8* @A, i8* @B]
+; CHECK-DAG: @B = alias i8, ptr @A
+; CHECK-DAG: @C = global [2 x ptr] [ptr @A, ptr @B]
@A = internal constant i8 1
-@B = alias i8, i8* @A
-@C = global [2 x i8*] [i8* @A, i8* @B]
+@B = alias i8, ptr @A
+@C = global [2 x ptr] [ptr @A, ptr @B]
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.9"
-; CHECK-DAG: @gv0 = constant i64* @alias
-; CHECK-DAG: @gv1 = constant i64 ptrtoint (i64* @gv1 to i64)
-; CHECK-DAG: @alias = alias i64, i64* @gv1
+; CHECK-DAG: @gv0 = constant ptr @alias
+; CHECK-DAG: @gv1 = constant i64 ptrtoint (ptr @gv1 to i64)
+; CHECK-DAG: @alias = alias i64, ptr @gv1
-@gv0 = constant i64* @alias
-@gv1 = constant i64 ptrtoint (i64* @gv1 to i64)
+@gv0 = constant ptr @alias
+@gv1 = constant i64 ptrtoint (ptr @gv1 to i64)
-@alias = alias i64, i64* @gv1
+@alias = alias i64, ptr @gv1
; before using the IRMover.
@foo = weak global i32 0
-; C1-DAG: @foo = alias i32, i32* @zed
-; C2-DAG: @foo = alias i32, i32* @zed
+; C1-DAG: @foo = alias i32, ptr @zed
+; C2-DAG: @foo = alias i32, ptr @zed
-@bar = alias i32, i32* @foo
-; C1-DAG: @bar = alias i32, i32* @foo
+@bar = alias i32, ptr @foo
+; C1-DAG: @bar = alias i32, ptr @foo
; C2-DAG: @foo.1 = internal global i32 0
-; C2-DAG: @bar = alias i32, i32* @foo.1
+; C2-DAG: @bar = alias i32, ptr @foo.1
@foo2 = weak global i32 0
-; C1-DAG: @foo2 = alias i16, bitcast (i32* @zed to i16*)
-; C2-DAG: @foo2 = alias i16, bitcast (i32* @zed to i16*)
+; C1-DAG: @foo2 = alias i16, ptr @zed
+; C2-DAG: @foo2 = alias i16, ptr @zed
-@bar2 = alias i32, i32* @foo2
-; C1-DAG: @bar2 = alias i32, bitcast (i16* @foo2 to i32*)
+@bar2 = alias i32, ptr @foo2
+; C1-DAG: @bar2 = alias i32, ptr @foo2
; C2-DAG: @foo2.2 = internal global i32 0
-; C2-DAG: @bar2 = alias i32, i32* @foo2.2
+; C2-DAG: @bar2 = alias i32, ptr @foo2.2
; C1-DAG: @zed = global i32 42
; C2-DAG: @zed = global i32 42
; Check that llvm-link does not crash when materializing appending global with
; initializer depending on another appending global.
-; CHECK-DAG: @use = appending global [1 x i8*] [i8* bitcast ([1 x i8*]* @var to i8*)]
-; CHECK-DAG: @var = appending global [1 x i8*] undef
+; CHECK-DAG: @use = appending global [1 x ptr] [ptr @var]
+; CHECK-DAG: @var = appending global [1 x ptr] undef
-@use = appending global [1 x i8*] [i8* bitcast ([1 x i8*]* @var to i8*)]
-@var = appending global [1 x i8*] undef
+@use = appending global [1 x ptr] [ptr @var]
+@var = appending global [1 x ptr] undef
; CHECK: can only link appending global with another appending global
-@var = global i8* undef
+@var = global ptr undef
; CHECK: Appending variables linked with different const'ness
-@var = appending constant [1 x i8* ] undef
+@var = appending constant [1 x ptr ] undef
; CHECK: Appending variables with different element types
-@var = appending global [1 x i32* ] undef
+@var = appending global [1 x i32] undef
; CHECK: Appending variables with different visibility need to be linked
-@var = appending hidden global [1 x i32* ] undef
+@var = appending hidden global [1 x ptr ] undef
; CHECK: Appending variables with different section name need to be linked
-@var = appending global [1 x i32* ] undef, section "dummy"
+@var = appending global [1 x ptr ] undef, section "dummy"
; Checks that we can link global variable with appending linkage with the
; existing external declaration.
-; CHECK-DAG: @var = appending global [1 x i8*] undef
-; CHECK-DAG: @use = global [1 x i8*] [i8* bitcast ([1 x i8*]* @var to i8*)]
+; CHECK-DAG: @var = appending global [1 x ptr] undef
+; CHECK-DAG: @use = global [1 x ptr] [ptr @var]
-@var = external global i8*
-@use = global [1 x i8*] [i8* bitcast (i8** @var to i8*)]
+@var = external global ptr
+@use = global [1 x ptr] [ptr @var]
ret void
}
-define void ()* @main() {
+define ptr @main() {
call void @g()
- ret void ()* @f
+ ret ptr @f
}
; CHECK-DAG: define available_externally void @g() {
; RUN: llvm-as %s -o %t.bc
; RUN: llvm-link %t.bc -S | FileCheck %s
-declare void @f(i8*)
+declare void @f(ptr)
; Test that a blockaddress in @y referring to %label in @x can be moved when @y
; appears after @x.
define void @y() {
; CHECK: define void @y() {
-; CHECK-NEXT: call void @f(i8* blockaddress(@x, %label))
- call void @f(i8* blockaddress(@x, %label))
+; CHECK-NEXT: call void @f(ptr blockaddress(@x, %label))
+ call void @f(ptr blockaddress(@x, %label))
ret void
}
; appears before @b.
define void @a() {
; CHECK: define void @a() {
-; CHECK-NEXT: call void @f(i8* blockaddress(@b, %label))
- call void @f(i8* blockaddress(@b, %label))
+; CHECK-NEXT: call void @f(ptr blockaddress(@b, %label))
+ call void @f(ptr blockaddress(@b, %label))
ret void
}
; CHECK-NEXT: br label %label
; CHECK-EMPTY:
; CHECK-NEXT: label:
-; CHECK-NEXT: call void @f(i8* blockaddress(@d, %label))
+; CHECK-NEXT: call void @f(ptr blockaddress(@d, %label))
br label %label
label:
- call void @f(i8* blockaddress(@d, %label))
+ call void @f(ptr blockaddress(@d, %label))
ret void
}
; CHECK-NEXT: br label %label
; CHECK-EMPTY:
; CHECK-NEXT: label:
-; CHECK-NEXT: call void @f(i8* blockaddress(@c, %label))
+; CHECK-NEXT: call void @f(ptr blockaddress(@c, %label))
br label %label
label:
- call void @f(i8* blockaddress(@c, %label))
+ call void @f(ptr blockaddress(@c, %label))
ret void
}
; CHECK-NEXT: br label %label
; CHECK-EMPTY:
; CHECK-NEXT: label:
-; CHECK-NEXT: call void @f(i8* blockaddress(@parsed, %label))
+; CHECK-NEXT: call void @f(ptr blockaddress(@parsed, %label))
br label %label
label:
- call void @f(i8* blockaddress(@parsed, %label))
+ call void @f(ptr blockaddress(@parsed, %label))
ret void
}
; CHECK-NEXT: br label %label
; CHECK-EMPTY:
; CHECK-NEXT: label:
-; CHECK-NEXT: call void @f(i8* blockaddress(@parsed3, %label))
+; CHECK-NEXT: call void @f(ptr blockaddress(@parsed3, %label))
br label %label
label:
- call void @f(i8* blockaddress(@parsed3, %label))
+ call void @f(ptr blockaddress(@parsed3, %label))
ret void
}
%a = type { i64 }
%struct = type { i32, i8 }
-; CHECK-LABEL: define void @f(%a* byref(%a) %0)
-define void @f(%a* byref(%a)) {
+; CHECK-LABEL: define void @f(ptr byref(%a) %0)
+define void @f(ptr byref(%a)) {
ret void
}
; CHECK-LABEL: define void @bar(
-; CHECK: call void @foo(%struct* byref(%struct) %ptr)
+; CHECK: call void @foo(ptr byref(%struct) %ptr)
define void @bar() {
%ptr = alloca %struct
- call void @foo(%struct* byref(%struct) %ptr)
+ call void @foo(ptr byref(%struct) %ptr)
ret void
}
-; CHECK-LABEL: define void @g(%a* byref(%a) %0)
+; CHECK-LABEL: define void @g(ptr byref(%a) %0)
-; CHECK-LABEL: define void @foo(%struct* byref(%struct) %a)
-; CHECK-NEXT: call void @baz(%struct* byref(%struct) %a)
-declare void @foo(%struct* byref(%struct) %a)
+; CHECK-LABEL: define void @foo(ptr byref(%struct) %a)
+; CHECK-NEXT: call void @baz(ptr byref(%struct) %a)
+declare void @foo(ptr byref(%struct) %a)
-; CHECK: declare void @baz(%struct* byref(%struct))
+; CHECK: declare void @baz(ptr byref(%struct))
%struct = type {i32, i8}
-declare void @foo(%struct* byval(%struct) %a)
+declare void @foo(ptr byval(%struct) %a)
define void @bar() {
%ptr = alloca %struct
-; CHECK: call void @foo(%struct* byval(%struct) %ptr)
- call void @foo(%struct* byval(%struct) %ptr)
+; CHECK: call void @foo(ptr byval(%struct) %ptr)
+ call void @foo(ptr byval(%struct) %ptr)
ret void
}
-; CHECK: define void @foo(%struct* byval(%struct) %a)
-; CHECK-NEXT: call void @baz(%struct* byval(%struct) %a)
+; CHECK: define void @foo(ptr byval(%struct) %a)
+; CHECK-NEXT: call void @baz(ptr byval(%struct) %a)
-; CHECK: declare void @baz(%struct* byval(%struct))
+; CHECK: declare void @baz(ptr byval(%struct))
;--- 1.ll
$c = comdat any
-@a = alias void (), void ()* @f
+@a = alias void (), ptr @f
define internal void @f() comdat($c) {
ret void
}
; CHECK1-DAG: $c = comdat any
-; CHECK1-DAG: @a = alias void (), void ()* @f
+; CHECK1-DAG: @a = alias void (), ptr @f
; CHECK1-DAG: define internal void @f() comdat($c)
$f2 = comdat largest
target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
$foo = comdat largest
-@foo = linkonce_odr unnamed_addr constant [1 x i8*] [i8* bitcast (void ()* @bar to i8*)], comdat($foo)
+@foo = linkonce_odr unnamed_addr constant [1 x ptr] [ptr @bar], comdat($foo)
-; CHECK: @foo = alias i8*, getelementptr inbounds ([2 x i8*], [2 x i8*]* @some_name, i32 0, i32 1)
+; CHECK: @foo = alias ptr, getelementptr inbounds ([2 x ptr], ptr @some_name, i32 0, i32 1)
declare void @bar() unnamed_addr
$foo = comdat largest
@zed = external constant i8
-@some_name = private unnamed_addr constant [2 x i8*] [i8* @zed, i8* bitcast (void ()* @bar to i8*)], comdat($foo)
-@foo = alias i8*, getelementptr([2 x i8*], [2 x i8*]* @some_name, i32 0, i32 1)
+@some_name = private unnamed_addr constant [2 x ptr] [ptr @zed, ptr @bar], comdat($foo)
+@foo = alias ptr, getelementptr([2 x ptr], ptr @some_name, i32 0, i32 1)
declare void @bar() unnamed_addr
$c = comdat any
@v2 = weak dllexport global i32 0, comdat ($c)
-define i32* @f2() {
- ret i32* @v2
+define ptr @f2() {
+ ret ptr @v2
}
-@v3 = weak alias i32, i32* @v2
-define i32* @f3() {
- ret i32* @v3
+@v3 = weak alias i32, ptr @v2
+define ptr @f3() {
+ ret ptr @v3
}
$foo = comdat any
@foo = internal global i8 0, comdat
-define i8* @bar() {
- ret i8* @foo
+define ptr @bar() {
+ ret ptr @foo
}
; CHECK: $foo = comdat any
; CHECK: @foo = internal global i8 0, comdat
; CHECK: @foo.1 = internal global i8 1, comdat($foo)
-; CHECK: define i8* @bar() {
-; CHECK-NEXT: ret i8* @foo
+; CHECK: define ptr @bar() {
+; CHECK-NEXT: ret ptr @foo
; CHECK-NEXT: }
-; CHECK: define i8* @zed() {
+; CHECK: define ptr @zed() {
; CHECK-NEXT: call void @bax()
-; CHECK-NEXT: ret i8* @foo.1
+; CHECK-NEXT: ret ptr @foo.1
; CHECK-NEXT: }
; CHECK: define internal void @bax() comdat($foo) {
;--- 1-aux.ll
$foo = comdat any
@foo = internal global i8 1, comdat
-define i8* @zed() {
+define ptr @zed() {
call void @bax()
- ret i8* @foo
+ ret ptr @foo
}
define internal void @bax() comdat($foo) {
ret void
; CHECK-DAG: @foo = global i64 43, comdat
; RM-NOT: @alias =
-@alias = alias i32, i32* @foo
+@alias = alias i32, ptr @foo
; We should arguably reject an out of comdat reference to int_alias. Given that
; the verifier accepts it, test that we at least produce an output that passes
; the verifier.
; CHECK-DAG: @int_alias = external global i32
-@int_alias = internal alias i32, i32* @foo
-@bar = global i32* @int_alias
+@int_alias = internal alias i32, ptr @foo
+@bar = global ptr @int_alias
-@func_alias = alias void (), void ()* @func
-@zed = global void()* @func_alias
-; CHECK-DAG: @zed = global void ()* @func_alias
+@func_alias = alias void (), ptr @func
+@zed = global ptr @func_alias
+; CHECK-DAG: @zed = global ptr @func_alias
; CHECK-DAG: declare void @func_alias()
; RM-NOT: @func()
$c1 = comdat largest
@some_name = unnamed_addr constant i32 42, comdat($c1)
-@c1 = alias i8, inttoptr (i32 1 to i8*)
+@c1 = alias i8, inttoptr (i32 1 to ptr)
;--- no-base-object-aux.ll
$c1 = comdat largest
@some_name = private unnamed_addr constant i32 42, comdat($c1)
-@c1 = alias i32, i32* @some_name
+@c1 = alias i32, ptr @some_name
}
; Reference one member of comdat so that comdat is generated.
define void @ref_linkoncecomdat() {
- load i32, i32* @linkoncecomdat, align 4
+ load i32, ptr @linkoncecomdat, align 4
ret void
}
; CHECK: $_ZN3fooIiEC5Ev = comdat any
; NOCOMDAT-NOT: comdat
-@_ZN3fooIiEC1Ev = weak_odr alias void (), void ()* @_ZN3fooIiEC2Ev
-; CHECK: @_ZN3fooIiEC1Ev = weak_odr alias void (), void ()* @_ZN3fooIiEC2Ev
+@_ZN3fooIiEC1Ev = weak_odr alias void (), ptr @_ZN3fooIiEC2Ev
+; CHECK: @_ZN3fooIiEC1Ev = weak_odr alias void (), ptr @_ZN3fooIiEC2Ev
; NOCOMDAT-DAG: define weak_odr void @_ZN3fooIiEC1Ev() {
; CHECK: define weak_odr void @_ZN3fooIiEC2Ev() comdat($_ZN3fooIiEC5Ev) {
; Test the bitcode writer too. It used to crash.
; RUN: llvm-link %s %p/Inputs/ctors.ll -o %t.bc
-; ALL: @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @f, i8* @v }]
+; ALL: @llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @f, ptr @v }]
@v = weak global i8 0
; CHECK1: @v = weak global i8 0
; CHECK2: @v = weak global i8 1
-@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @f, i8* @v }]
+@llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @f, ptr @v }]
define weak void @f() {
ret void
; entry.
@v = linkonce global i8 42
-@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @f, i8* @v }]
+@llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @f, ptr @v }]
-; CHECK: @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @f, i8* @v }]
+; CHECK: @llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @f, ptr @v }]
; CHECK: @global = linkonce global i32 0
@global = linkonce global i32 0
; Add an external reference to @global so that it gets linked in.
-@alias = alias i32, i32* @global
+@alias = alias i32, ptr @global
; CHECK: !named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !0, !1, !2, !9, !10, !11, !12, !13, !14}
!named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8}
; CHECK: !0 = !{}
; CHECK-NEXT: !1 = !{!0}
-; CHECK-NEXT: !2 = !{i32* @global}
+; CHECK-NEXT: !2 = !{ptr @global}
; CHECK-NEXT: !3 = distinct !{}
; CHECK-NEXT: !4 = distinct !{!0}
-; CHECK-NEXT: !5 = distinct !{i32* @global}
+; CHECK-NEXT: !5 = distinct !{ptr @global}
; CHECK-NEXT: !6 = !{!3}
; CHECK-NEXT: !7 = !{!4}
; CHECK-NEXT: !8 = !{!5}
; CHECK-NEXT: !9 = distinct !{}
; CHECK-NEXT: !10 = distinct !{!0}
-; CHECK-NEXT: !11 = distinct !{i32* @global}
+; CHECK-NEXT: !11 = distinct !{ptr @global}
; CHECK-NEXT: !12 = !{!9}
; CHECK-NEXT: !13 = !{!10}
; CHECK-NEXT: !14 = !{!11}
; CHECK-NOT: !
!0 = !{}
!1 = !{!0}
-!2 = !{i32* @global}
+!2 = !{ptr @global}
!3 = distinct !{}
!4 = distinct !{!0}
-!5 = distinct !{i32* @global}
+!5 = distinct !{ptr @global}
!6 = !{!3}
!7 = !{!4}
!8 = !{!5}
; Check that the attribute for elementtype matches when linking.
; CHECK: define void @struct_elementtype_2
-; CHECK: call %struct* @llvm.preserve.array.access.index.p0s_structs.p0s_structs(%struct* elementtype(%struct) null, i32 0, i32 0)
+; CHECK: call ptr @llvm.preserve.array.access.index.p0.p0(ptr elementtype(%struct) null, i32 0, i32 0)
; CHECK: define void @struct_elementtype
-; CHECK: call %struct* @llvm.preserve.array.access.index.p0s_structs.p0s_structs(%struct* elementtype(%struct) null, i32 0, i32 0)
+; CHECK: call ptr @llvm.preserve.array.access.index.p0.p0(ptr elementtype(%struct) null, i32 0, i32 0)
%struct = type {i32, i8}
define void @struct_elementtype() {
- call %struct* @llvm.preserve.array.access.index.p0s_structs.p0s_structs(%struct* elementtype(%struct) null, i32 0, i32 0)
+ call ptr @llvm.preserve.array.access.index.p0.p0(ptr elementtype(%struct) null, i32 0, i32 0)
ret void
}
-declare %struct* @llvm.preserve.array.access.index.p0s_structs.p0s_structs(%struct*, i32, i32)
+declare ptr @llvm.preserve.array.access.index.p0.p0(ptr, i32, i32)
target triple = "x86_64-apple-macosx10.15.0"
@__swift_reflection_version = linkonce_odr hidden constant i16 3
-@llvm.used = appending global [1 x i8*] [i8* bitcast (i16* @__swift_reflection_version to i8*)], section "llvm.metadata", align 8
+@llvm.used = appending global [1 x ptr] [ptr @__swift_reflection_version], section "llvm.metadata", align 8
-define i32 @main(i32 %0, i8** %1) #0 {
- %3 = bitcast i8** %1 to i8*
+define i32 @main(i32 %0, ptr %1) #0 {
ret i32 0
}
!10 = !{!"-lswiftSwiftOnoneSupport"}
!11 = !{!"-lswiftCore"}
!12 = !{!"-lobjc"}
-!13 = !{[1 x i8*]* @llvm.used, null, null, i1 false, i1 true}
+!13 = !{ptr @llvm.used, null, null, i1 false, i1 true}
; CHECK: !{{[0-9]+}} = !{i32 1, !"Objective-C Garbage Collection", i8 0}
; CHECK: !{{[0-9]+}} = !{i32 1, !"Swift ABI Version", i32 7}
; RUN: llvm-link %s %p/func-attrs-b.ll -S -o - | FileCheck %s
; PR2382
-; CHECK: call void @check0(%struct.S0* sret(%struct.S0) null, %struct.S0* byval(%struct.S0) align 4 null, %struct.S0* align 4 null, %struct.S0* byval(%struct.S0) align 4 null)
-; CHECK: define void @check0(%struct.S0* sret(%struct.S0) %agg.result, %struct.S0* byval(%struct.S0) %arg0, %struct.S0* %arg1, %struct.S0* byval(%struct.S0) %arg2)
+; CHECK: call void @check0(ptr sret(%struct.S0) null, ptr byval(%struct.S0) align 4 null, ptr align 4 null, ptr byval(%struct.S0) align 4 null)
+; CHECK: define void @check0(ptr sret(%struct.S0) %agg.result, ptr byval(%struct.S0) %arg0, ptr %arg1, ptr byval(%struct.S0) %arg2)
%struct.S0 = type <{ i8, i8, i8, i8 }>
define void @a() {
- call void @check0(%struct.S0* sret(%struct.S0) null, %struct.S0* byval(%struct.S0) align 4 null, %struct.S0* align 4 null, %struct.S0* byval(%struct.S0) align 4 null)
+ call void @check0(ptr sret(%struct.S0) null, ptr byval(%struct.S0) align 4 null, ptr align 4 null, ptr byval(%struct.S0) align 4 null)
ret void
}
-declare void @check0(%struct.S0*, %struct.S0*, %struct.S0*, %struct.S0*)
+declare void @check0(ptr, ptr, ptr, ptr)
%struct.S0 = type <{ i8, i8, i8, i8 }>
-define void @check0(%struct.S0* sret(%struct.S0) %agg.result, %struct.S0* byval(%struct.S0) %arg0, %struct.S0* %arg1, %struct.S0* byval(%struct.S0) %arg2) {
+define void @check0(ptr sret(%struct.S0) %agg.result, ptr byval(%struct.S0) %arg0, ptr %arg1, ptr byval(%struct.S0) %arg2) {
ret void
}
; CHECK-NOT: @llvm.global_ctors = {{.*}}@foo
declare void @f()
-@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @f, i8* null}]
+@llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @f, ptr null}]
define i32 @main() {
entry:
}
$comdat2 = comdat any
-@comdat2_alias = alias void (), void ()* @comdat2_func1
+@comdat2_alias = alias void (), ptr @comdat2_func1
define internal void @comdat2_func1() comdat($comdat2) {
ret void
}
@var1 = internal global i32 0, align 4
@var2 = internal global i32 0, align 4
-@var3 = global i32* @var1, align 4
-@var4 = global i32* @var2, align 4
+@var3 = global ptr @var1, align 4
+@var4 = global ptr @var2, align 4
define i32 @foo() {
entry:
- %0 = load i32*, i32** @var3, align 4
- %1 = load i32, i32* %0, align 4
- %2 = load i32*, i32** @var4, align 4
- %3 = load i32, i32* %2, align 4
+ %0 = load ptr, ptr @var3, align 4
+ %1 = load i32, ptr %0, align 4
+ %2 = load ptr, ptr @var4, align 4
+ %3 = load i32, ptr %2, align 4
%add = add nsw i32 %3, %1
ret i32 %add
}
%a = type { i64 }
%struct = type { i32, i8 }
-; CHECK-LABEL: define void @f(%a* inalloca(%a) %0)
-define void @f(%a* inalloca(%a)) {
+; CHECK-LABEL: define void @f(ptr inalloca(%a) %0)
+define void @f(ptr inalloca(%a)) {
ret void
}
; CHECK-LABEL: define void @bar(
-; CHECK: call void @foo(%struct* inalloca(%struct) %ptr)
+; CHECK: call void @foo(ptr inalloca(%struct) %ptr)
define void @bar() {
%ptr = alloca inalloca %struct
- call void @foo(%struct* inalloca(%struct) %ptr)
+ call void @foo(ptr inalloca(%struct) %ptr)
ret void
}
-; CHECK-LABEL: define void @g(%a* inalloca(%a) %0)
+; CHECK-LABEL: define void @g(ptr inalloca(%a) %0)
-; CHECK-LABEL: define void @foo(%struct* inalloca(%struct) %a)
-; CHECK-NEXT: call void @baz(%struct* inalloca(%struct) %a)
-declare void @foo(%struct* inalloca(%struct) %a)
+; CHECK-LABEL: define void @foo(ptr inalloca(%struct) %a)
+; CHECK-NEXT: call void @baz(ptr inalloca(%struct) %a)
+declare void @foo(ptr inalloca(%struct) %a)
-; CHECK: declare void @baz(%struct* inalloca(%struct))
+; CHECK: declare void @baz(ptr inalloca(%struct))
; rdar://9776316 - type remapping needed for inline asm blobs.
-%T = type { [18 x i32], [4 x i8*] }
+%T = type { [18 x i32], [4 x ptr] }
-define void @f(%T* %x) nounwind ssp {
+define void @f(ptr %x) nounwind ssp {
entry:
-call void asm sideeffect "", "=*m"(%T* elementtype(%T) %x) nounwind
+call void asm sideeffect "", "=*m"(ptr elementtype(%T) %x) nounwind
unreachable
}
CU-LABEL:@U = global i32 6
CI-LABEL:@U = internal global i32 6
CN-NOT:@U
-DI-LABEL: @llvm.used = appending global [2 x i8*] [i8* @Y, i8* bitcast (i64 ()* @foo to i8*)], section "llvm.metadata"
+DI-LABEL: @llvm.used = appending global [2 x ptr] [ptr @Y, ptr @foo], section "llvm.metadata"
DI-LABEL: @Y = global i8 42
B-LABEL: define void @bar() {
; RUN: llvm-as %s -o %t1.bc
-; RUN: echo "declare void @__eprintf(i8*, i8*, i32, i8*) noreturn define void @foo() { tail call void @__eprintf( i8* undef, i8* undef, i32 4, i8* null ) noreturn nounwind unreachable }" | llvm-as -o %t2.bc
+; RUN: echo "declare void @__eprintf(ptr, ptr, i32, ptr) noreturn define void @foo() { tail call void @__eprintf( ptr undef, ptr undef, i32 4, ptr null ) noreturn nounwind unreachable }" | llvm-as -o %t2.bc
; RUN: llvm-link %t2.bc %t1.bc -S | FileCheck %s
; RUN: llvm-link %t1.bc %t2.bc -S | FileCheck %s
; CHECK: __eprintf
; rdar://6072702
-@__eprintf = external global i8* ; <i8**> [#uses=1]
+@__eprintf = external global ptr ; <ptr> [#uses=1]
-define i8* @test() {
- %A = load i8*, i8** @__eprintf ; <i8*> [#uses=1]
- ret i8* %A
+define ptr @test() {
+ %A = load ptr, ptr @__eprintf ; <ptr> [#uses=1]
+ ret ptr %A
}
; RUN: llvm-link -S %s -o - | FileCheck %s
-; CHECK-DAG: @foo = private externally_initialized global i8* null
-@foo = private externally_initialized global i8* null
+; CHECK-DAG: @foo = private externally_initialized global ptr null
+@foo = private externally_initialized global ptr null
-@useFoo = global i8** @foo
+@useFoo = global ptr @foo
; CHECK-DAG: @array = appending global [7 x i8] c"abcdefg", align 1
@array = appending global [7 x i8] c"abcdefg", align 1
; CHECK: ret void, !attach !0
; CHECK: define void @goo(i32 %b)
; CHECK: ret void, !attach !1
-; CHECK: !0 = !{i32 524334, void (i32)* @foo}
-; CHECK: !1 = !{i32 524334, void (i32)* @goo}
+; CHECK: !0 = !{i32 524334, ptr @foo}
+; CHECK: !1 = !{i32 524334, ptr @goo}
define void @foo(i32 %a) nounwind {
entry:
ret void, !attach !0
}
-!0 = !{i32 524334, void (i32)* @foo}
+!0 = !{i32 524334, ptr @foo}
; CHECK-LINKED1: define void @f1() !attach !0 {
define void @f1() !attach !0 {
call void @f2()
- store i32 0, i32* @g2
+ store i32 0, ptr @g2
ret void
}
ret void, !attach !0
}
-!0 = !{i32 524334, void (i32)* @goo}
+!0 = !{i32 524334, ptr @goo}
; CHECK-DAG: @a = global i32 0
; CHECK-DAG: @b = global i32 0, !associated !0
-; CHECK-DAG: !0 = !{i32* @b}
+; CHECK-DAG: !0 = !{ptr @b}
@a = global i32 0
@b = global i32 0, !associated !0
-!0 = !{i32* @b}
+!0 = !{ptr @b}
; RUN: llvm-link -S -o - %s %S/Inputs/metadata-with-global-value-operand.ll | FileCheck %s
; This test confirms that the !{null} from the second module doesn't get mapped
-; onto the abandoned !{i1* @var} node from this module.
+; onto the abandoned !{ptr @var} node from this module.
; CHECK: @var = global
@var = global i1 false
; CHECK: !named.null = !{!1}
!named.vars = !{!0}
-; CHECK: !0 = !{i1* @var}
+; CHECK: !0 = !{ptr @var}
; CHECK: !1 = !{null}
-!0 = !{i1* @var}
+!0 = !{ptr @var}
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.12.0"
-@foo = external unnamed_addr constant { [4 x i8*], [32 x i8] }, align 32
+@foo = external unnamed_addr constant { [4 x ptr], [32 x i8] }, align 32
!llvm.bitsets = !{!0}
-!0 = !{!"foo", [4 x i8*]* getelementptr inbounds ({ [4 x i8*], [32 x i8] }, { [4 x i8*], [32 x i8] }* @foo, i32 0, i32 0), i64 16}
+!0 = !{!"foo", ptr getelementptr inbounds ({ [4 x ptr], [32 x i8] }, ptr @foo, i32 0, i32 0), i64 16}
entry:
%Err = alloca %class.Error, align 1
%agg.tmp = alloca %class.anon, align 1
- call void @llvm.dbg.declare(metadata %class.Error* %Err, metadata !17, metadata !DIExpression()), !dbg !18
+ call void @llvm.dbg.declare(metadata ptr %Err, metadata !17, metadata !DIExpression()), !dbg !18
call void @_Z15handleAllErrorsIZ12consumeError5ErrorEUlvE_EvT_(), !dbg !19
ret void, !dbg !20
}
define linkonce_odr void @_Z15handleAllErrorsIZ12consumeError5ErrorEUlvE_EvT_() #0 !dbg !21 {
entry:
%Handlers = alloca %class.anon, align 1
- call void @llvm.dbg.declare(metadata %class.anon* %Handlers, metadata !27, metadata !DIExpression()), !dbg !28
+ call void @llvm.dbg.declare(metadata ptr %Handlers, metadata !27, metadata !DIExpression()), !dbg !28
ret void, !dbg !29
}
; Empty destination module!
-; CHECK-DAG: @llvm.compiler.used = appending global [2 x i8*] [i8* @used1, i8* bitcast (i32* @used2 to i8*)], section "llvm.metadata"
+; CHECK-DAG: @llvm.compiler.used = appending global [2 x ptr] [ptr @used1, ptr @used2], section "llvm.metadata"
; NO-INTERNALIZE-DAG: @used1 = global i8 4
; INTERNALIZE-DAG: @used1 = internal global i8 4
; NO-INTERNALIZE-DAG: @used2 = global i32 123
; Empty destination module!
-; CHECK: @llvm.global_ctors = appending global [2 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 2, void ()* @ctor1, i8* null }, { i32, void ()*, i8* } { i32 7, void ()* @ctor2, i8* null }]
+; CHECK: @llvm.global_ctors = appending global [2 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 2, ptr @ctor1, ptr null }, { i32, ptr, ptr } { i32 7, ptr @ctor2, ptr null }]
; CHECK: define internal void @ctor1()
; CHECK: define internal void @ctor2()
; NO-INTERNALIZE: define void @func1()
ret void
}
-@llvm.global_ctors = appending global[1 x{i32, void() *, i8 * }] [
- {i32, void() *, i8 * } { i32 4, void() *@ctor1, i8 *null}]
+@llvm.global_ctors = appending global[1 x{i32, ptr, ptr }] [
+ {i32, ptr, ptr } { i32 4, ptr @ctor1, ptr null}]
-; CHECK: @llvm.global_ctors = appending global [3 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 4, void ()* @ctor1, i8* null }, { i32, void ()*, i8* } { i32 2, void ()* @ctor1.2, i8* null }, { i32, void ()*, i8* } { i32 7, void ()* @ctor2, i8* null }]
+; CHECK: @llvm.global_ctors = appending global [3 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 4, ptr @ctor1, ptr null }, { i32, ptr, ptr } { i32 2, ptr @ctor1.2, ptr null }, { i32, ptr, ptr } { i32 7, ptr @ctor2, ptr null }]
; CHECK: define internal void @ctor1()
; CHECK: define void @foo()
; CHECK: define internal void @ctor1.{{[0-9]+}}()
; Empty destination module!
-; CHECK: @llvm.global_dtors = appending global [2 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 2, void ()* @dtor1, i8* null }, { i32, void ()*, i8* } { i32 7, void ()* @dtor2, i8* null }]
+; CHECK: @llvm.global_dtors = appending global [2 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 2, ptr @dtor1, ptr null }, { i32, ptr, ptr } { i32 7, ptr @dtor2, ptr null }]
; CHECK: define internal void @dtor1()
; CHECK: define internal void @dtor2()
; NO-INTERNALIZE: define void @func1()
ret void
}
-@llvm.global_dtors = appending global[1 x{i32, void() *, i8 * }] [
- {i32, void() *, i8 * } { i32 4, void() *@dtor1, i8 *null}]
+@llvm.global_dtors = appending global[1 x{i32, ptr, ptr }] [
+ {i32, ptr, ptr } { i32 4, ptr @dtor1, ptr null}]
-; CHECK: @llvm.global_dtors = appending global [3 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 4, void ()* @dtor1, i8* null }, { i32, void ()*, i8* } { i32 2, void ()* @dtor1.2, i8* null }, { i32, void ()*, i8* } { i32 7, void ()* @dtor2, i8* null }]
+; CHECK: @llvm.global_dtors = appending global [3 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 4, ptr @dtor1, ptr null }, { i32, ptr, ptr } { i32 2, ptr @dtor1.2, ptr null }, { i32, ptr, ptr } { i32 7, ptr @dtor2, ptr null }]
; CHECK: define internal void @dtor1()
; CHECK: define void @foo()
; CHECK: define internal void @dtor1.{{[0-9]+}}()
define i32 @foo() { ret i32 7 }
define i32 @unused() { ret i32 8 }
define linkonce_odr hidden i32 @unused_linkonce() { ret i32 8 }
-@linkoncealias = alias void (...), bitcast (void ()* @linkoncefunc2 to void (...)*)
+@linkoncealias = alias void (...), ptr @linkoncefunc2
-@weakalias = weak alias void (...), bitcast (void ()* @globalfunc1 to void (...)*)
-@analias = alias void (...), bitcast (void ()* @globalfunc2 to void (...)*)
+@weakalias = weak alias void (...), ptr @globalfunc1
+@analias = alias void (...), ptr @globalfunc2
define void @globalfunc1() #0 {
entry:
}
!llvm.named = !{!0, !1, !2, !3, !4, !5, !6}
-!0 = !{i32 ()* @unused}
-!1 = !{i32* @U}
-!2 = !{i32 ()* @unused_linkonce}
-!3 = !{i32* @U_linkonce}
-!4 = !{void (...)* @weakalias}
-!5 = !{void (...)* @analias}
-!6 = !{void (...)* @linkoncealias}
+!0 = !{ptr @unused}
+!1 = !{ptr @U}
+!2 = !{ptr @unused_linkonce}
+!3 = !{ptr @U_linkonce}
+!4 = !{ptr @weakalias}
+!5 = !{ptr @analias}
+!6 = !{ptr @linkoncealias}
; Empty destination module!
-; CHECK-DAG: @llvm.used = appending global [2 x i8*] [i8* @used1, i8* bitcast (i32* @used2 to i8*)], section "llvm.metadata"
+; CHECK-DAG: @llvm.used = appending global [2 x ptr] [ptr @used1, ptr @used2], section "llvm.metadata"
; CHECK-DAG: @used1 = global i8 4
; CHECK-DAG: @used2 = global i32 123
; RUN: llvm-link %p/opaque.ll %p/Inputs/opaque.ll -S -o - | FileCheck %s
; CHECK-DAG: %A = type {}
-; CHECK-DAG: %B = type { %C, %C, %B* }
-; CHECK-DAG: %B.1 = type { %D, %E, %B.1* }
+; CHECK-DAG: %B = type { %C, %C, ptr }
+; CHECK-DAG: %B.1 = type { %D, %E, ptr }
; CHECK-DAG: %C = type { %A }
; CHECK-DAG: %D = type { %E }
; CHECK-DAG: %E = type opaque
; CHECK-DAG: @g2 = external global %A
; CHECK-DAG: @g3 = external global %B.1
-; CHECK-DAG: getelementptr %A, %A* null, i32 0
+; CHECK-DAG: getelementptr %A, ptr null, i32 0
%A = type opaque
-%B = type { %C, %C, %B* }
+%B = type { %C, %C, ptr }
%C = type { %A }
@g1 = external global %B
-define %B* @use_g1() {
- ret %B* @g1
+define ptr @use_g1() {
+ ret ptr @g1
}
}
; Function Attrs: nounwind ssp uwtable
-define i32 @main(i32 %argc, i8** %argv) {
+define i32 @main(i32 %argc, ptr %argv) {
entry:
%a = call i32 @foo(i32 2)
ret i32 %a
; CHECK-NEXT: ret i32 4
; Function Attrs: nounwind ssp uwtable
-define i32 @main(i32 %argc, i8** %argv) {
+define i32 @main(i32 %argc, ptr %argv) {
entry:
%a = call i32 @foo(i32 2)
ret i32 %a
; CHECK-LABEL: define i32 @main(
; CHECK-NEXT: entry:
; CHECK-NEXT: call i32 @foo.2(
-define i32 @main(i32 %argc, i8** %argv) {
+define i32 @main(i32 %argc, ptr %argv) {
entry:
%a = call i32 @foo(i32 2)
ret i32 %a
}
; Function Attrs: nounwind ssp uwtable
-define i32 @main(i32 %argc, i8** %argv) {
+define i32 @main(i32 %argc, ptr %argv) {
entry:
%a = call i32 @foo(i32 2)
ret i32 %a
; This file is used by first.ll, so it doesn't actually do anything itself
; RUN: true
-%AnalysisResolver = type { i8, %PMDataManager* }
-%"DenseMap<P*,AU*>" = type { i64, %"pair<P*,AU*>"*, i64, i64 }
-%PMDataManager = type { i8, %PMTopLevelManager*, i8, i8, i8, i8, i8, i64, i8 }
+%AnalysisResolver = type { i8, ptr }
+%"DenseMap<P*,AU*>" = type { i64, ptr, i64, i64 }
+%PMDataManager = type { i8, ptr, i8, i8, i8, i8, i8, i64, i8 }
%PMTopLevelManager = type { i8, i8, i8, i8, i8, i8, i8, i8, %"DenseMap<P*,AU*>" }
-%P = type { i8, %AnalysisResolver*, i64 }
-%PI = type { i8, i8, i8, i8, i8, i8, %"vector<const PI*>", %P* }
-%"SmallVImpl<const PI*>" = type { i8, %PI* }
+%P = type { i8, ptr, i64 }
+%PI = type { i8, i8, i8, i8, i8, i8, %"vector<const PI*>", ptr }
+%"SmallVImpl<const PI*>" = type { i8, ptr }
%"_V_base<const PI*>" = type { %"_V_base<const PI*>::_V_impl" }
-%"_V_base<const PI*>::_V_impl" = type { %PI*, i8, i8 }
+%"_V_base<const PI*>::_V_impl" = type { ptr, i8, i8 }
%"pair<P*,AU*>" = type opaque
%"vector<const PI*>" = type { %"_V_base<const PI*>" }
-define void @f(%"SmallVImpl<const PI*>"* %this) {
+define void @f(ptr %this) {
entry:
- %x = getelementptr inbounds %"SmallVImpl<const PI*>", %"SmallVImpl<const PI*>"* %this, i64 0, i32 1
+ %x = getelementptr inbounds %"SmallVImpl<const PI*>", ptr %this, i64 0, i32 1
ret void
}
; RUN: llvm-link %s %p/partial-type-refinement-link.ll -S | FileCheck %s
; PR4954
-; CHECK: load %PI*, %PI** getelementptr inbounds (%"RegisterP<LowerArrayLength>", %"RegisterP<LowerArrayLength>"* @_ZN3mvmL1XE, i64 0, i32 0, i32 6, i32 0, i32 0, i32 0), align 16
+; CHECK: load ptr, ptr getelementptr inbounds (%"RegisterP<LowerArrayLength>", ptr @_ZN3mvmL1XE, i64 0, i32 0, i32 6, i32 0, i32 0, i32 0), align 16
-%AnalysisResolver = type { i8, %PMDataManager* }
-%"DenseMap<P*,AU*>" = type { i64, %"pair<P*,AU*>"*, i64, i64 }
-%PMDataManager = type { i8, %PMTopLevelManager*, i8, i8, i8, i8, i8, i64, i8 }
+%AnalysisResolver = type { i8, ptr }
+%"DenseMap<P*,AU*>" = type { i64, ptr, i64, i64 }
+%PMDataManager = type { i8, ptr, i8, i8, i8, i8, i8, i64, i8 }
%PMTopLevelManager = type { i8, i8, i8, i8, i8, i8, i8, i8, %"DenseMap<P*,AU*>" }
-%P = type { i8, %AnalysisResolver*, i64 }
-%PI = type { i8, i8, i8, i8, i8, i8, %"vector<const PI*>", %P* }
+%P = type { i8, ptr, i64 }
+%PI = type { i8, i8, i8, i8, i8, i8, %"vector<const PI*>", ptr }
%"RegisterP<LowerArrayLength>" = type { %PI }
%"_V_base<const PI*>" = type { %"_V_base<const PI*>::_V_impl" }
-%"_V_base<const PI*>::_V_impl" = type { %PI*, i8, i8 }
+%"_V_base<const PI*>::_V_impl" = type { ptr, i8, i8 }
%"pair<P*,AU*>" = type opaque
%"vector<const PI*>" = type { %"_V_base<const PI*>" }
define void @__tcf_0() nounwind {
entry:
- %0 = load %PI*, %PI** getelementptr inbounds (%"RegisterP<LowerArrayLength>", %"RegisterP<LowerArrayLength>"* @_ZN3mvmL1XE, i64 0, i32 0, i32 6, i32 0, i32 0, i32 0), align 16
+ %0 = load ptr, ptr getelementptr inbounds (%"RegisterP<LowerArrayLength>", ptr @_ZN3mvmL1XE, i64 0, i32 0, i32 6, i32 0, i32 0, i32 0), align 16
ret void
}
@g2 = linkonce_odr global i8 0
; CHECK-NOT: @g2
-@a1 = private alias i8, i8* @g1
+@a1 = private alias i8, ptr @g1
; CHECK-NOT: @a1
-@a2 = linkonce_odr alias i8, i8* @g2
+@a2 = linkonce_odr alias i8, ptr @g2
; CHECK-NOT: @a2
define private void @f1() {
; RUN: llvm-link %s -S -o - | FileCheck %s
-@g1 = global void()* @f2
-; CHECK-DAG: @g1 = global void ()* @f2
+@g1 = global ptr @f2
+; CHECK-DAG: @g1 = global ptr @f2
@p1 = global i8 42
; CHECK-DAG: @p1 = global i8 42
@p2 = internal global i8 43
; CHECK-DAG: @p2 = internal global i8 43
-define void @f1() prologue i8* @p1 {
+define void @f1() prologue ptr @p1 {
ret void
}
-; CHECK-DAG: define void @f1() prologue i8* @p1 {
+; CHECK-DAG: define void @f1() prologue ptr @p1 {
-define internal void @f2() prologue i8* @p2 {
+define internal void @f2() prologue ptr @p2 {
ret void
}
-; CHECK-DAG: define internal void @f2() prologue i8* @p2 {
+; CHECK-DAG: define internal void @f2() prologue ptr @p2 {
define i32 @_Z3foov() !dbg !4 {
entry:
%tmp = alloca %struct.Class, align 1
- %call = call i32 @_ZN5ClassIiE3fooEv(%struct.Class* %tmp), !dbg !14
+ %call = call i32 @_ZN5ClassIiE3fooEv(ptr %tmp), !dbg !14
ret i32 %call, !dbg !14
}
-; CHECK: define weak_odr i32 @_ZN5ClassIiE3fooEv(%struct.Class* %this){{.*}} !dbg ![[SP2:[0-9]+]] {
+; CHECK: define weak_odr i32 @_ZN5ClassIiE3fooEv(ptr %this){{.*}} !dbg ![[SP2:[0-9]+]] {
; CHECK-NOT: }
; CHECK: !dbg ![[LOC:[0-9]+]]
-define linkonce_odr i32 @_ZN5ClassIiE3fooEv(%struct.Class* %this) align 2 !dbg !7 {
+define linkonce_odr i32 @_ZN5ClassIiE3fooEv(ptr %this) align 2 !dbg !7 {
entry:
- %this.addr = alloca %struct.Class*, align 8
- store %struct.Class* %this, %struct.Class** %this.addr, align 8
- %this1 = load %struct.Class*, %struct.Class** %this.addr
+ %this.addr = alloca ptr, align 8
+ store ptr %this, ptr %this.addr, align 8
+ %this1 = load ptr, ptr %this.addr
ret i32 0, !dbg !15
}
%t = type {i32, float}
; CHECK: define void @foo(<4 x
; CHECK: define void @bar(<vscale x 4 x
-define void @bar(<vscale x 4 x %t*> %x) {
+define void @bar(<vscale x 4 x ptr> %x) {
ret void
}
%a = type { i64 }
%struct = type { i32, i8 }
-; CHECK-LABEL: define void @f(%a* sret(%a) %0)
-define void @f(%a* sret(%a)) {
+; CHECK-LABEL: define void @f(ptr sret(%a) %0)
+define void @f(ptr sret(%a)) {
ret void
}
; CHECK-LABEL: define void @bar(
-; CHECK: call void @foo(%struct* sret(%struct) %ptr)
+; CHECK: call void @foo(ptr sret(%struct) %ptr)
define void @bar() {
%ptr = alloca %struct
- call void @foo(%struct* sret(%struct) %ptr)
+ call void @foo(ptr sret(%struct) %ptr)
ret void
}
-; CHECK-LABEL: define void @g(%a* sret(%a) %0)
+; CHECK-LABEL: define void @g(ptr sret(%a) %0)
-; CHECK-LABEL: define void @foo(%struct* sret(%struct) %a)
-; CHECK-NEXT: call void @baz(%struct* sret(%struct) %a)
-declare void @foo(%struct* sret(%struct) %a)
+; CHECK-LABEL: define void @foo(ptr sret(%struct) %a)
+; CHECK-NEXT: call void @baz(ptr sret(%struct) %a)
+declare void @foo(ptr sret(%struct) %a)
-; CHECK: declare void @baz(%struct* sret(%struct))
+; CHECK: declare void @baz(ptr sret(%struct))
%t = type { i8 }
@g = global %t zeroinitializer
-@a = weak alias %t, %t* @g
+@a = weak alias %t, ptr @g
; CHECK: @g = global %t zeroinitializer
; CHECK: @g2 = global %t zeroinitializer
-; CHECK: @a = weak alias %t, %t* @g
+; CHECK: @a = weak alias %t, ptr @g
%B = type { i8 }
@g3 = external global %A
-define %A* @use_g3() {
- ret %A* @g3
+define ptr @use_g3() {
+ ret ptr @g3
}
define internal void @_ZL3barv() #0 !dbg !19 {
entry:
%a = alloca %class.A, align 4
- call void @llvm.dbg.declare(metadata %class.A* %a, metadata !24, metadata !DIExpression()), !dbg !25
+ call void @llvm.dbg.declare(metadata ptr %a, metadata !24, metadata !DIExpression()), !dbg !25
ret void, !dbg !26
}
%class.A = type { i32 }
; Function Attrs: nounwind
-define void @_ZN1A6getFooEv(%class.A* %this) #0 align 2 !dbg !15 {
+define void @_ZN1A6getFooEv(ptr %this) #0 align 2 !dbg !15 {
entry:
- %this.addr = alloca %class.A*, align 8
- store %class.A* %this, %class.A** %this.addr, align 8
- call void @llvm.dbg.declare(metadata %class.A** %this.addr, metadata !24, metadata !DIExpression()), !dbg !26
- %this1 = load %class.A*, %class.A** %this.addr
+ %this.addr = alloca ptr, align 8
+ store ptr %this, ptr %this.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %this.addr, metadata !24, metadata !DIExpression()), !dbg !26
+ %this1 = load ptr, ptr %this.addr
ret void, !dbg !27
}
entry:
%a.addr = alloca i32, align 4
%t = alloca %struct.Base, align 4
- store i32 %a, i32* %a.addr, align 4
- call void @llvm.dbg.declare(metadata i32* %a.addr, metadata !15, metadata !DIExpression()), !dbg !16
- call void @llvm.dbg.declare(metadata %struct.Base* %t, metadata !17, metadata !DIExpression()), !dbg !18
+ store i32 %a, ptr %a.addr, align 4
+ call void @llvm.dbg.declare(metadata ptr %a.addr, metadata !15, metadata !DIExpression()), !dbg !16
+ call void @llvm.dbg.declare(metadata ptr %t, metadata !17, metadata !DIExpression()), !dbg !18
ret void, !dbg !19
}
entry:
%a.addr = alloca i32, align 4
%t = alloca %struct.Base, align 4
- store i32 %a, i32* %a.addr, align 4
- call void @llvm.dbg.declare(metadata i32* %a.addr, metadata !18, metadata !DIExpression()), !dbg !19
- call void @llvm.dbg.declare(metadata %struct.Base* %t, metadata !20, metadata !DIExpression()), !dbg !21
+ store i32 %a, ptr %a.addr, align 4
+ call void @llvm.dbg.declare(metadata ptr %a.addr, metadata !18, metadata !DIExpression()), !dbg !19
+ call void @llvm.dbg.declare(metadata ptr %t, metadata !20, metadata !DIExpression()), !dbg !21
ret void, !dbg !22
}
define i32 @main() #2 !dbg !14 {
entry:
%retval = alloca i32, align 4
- store i32 0, i32* %retval
+ store i32 0, ptr %retval
call void @_Z1fi(i32 0), !dbg !23
call void @_Z1gi(i32 1), !dbg !24
ret i32 0, !dbg !25
; ModuleID = 'a.cpp'
-%class.A = type { i32 (...)** }
+%class.A = type { ptr }
-@_ZTV1A = external unnamed_addr constant [4 x i8*]
+@_ZTV1A = external unnamed_addr constant [4 x ptr]
; Function Attrs: nounwind
define i32 @_Z3barv() #0 !dbg !27 {
entry:
%tmp = alloca %class.A, align 8
- %0 = bitcast %class.A* %tmp to i8*, !dbg !38
- call void @llvm.memset.p0i8.i64(i8* align 8 %0, i8 0, i64 8, i1 false), !dbg !38
- call void @_ZN1AC1Ev(%class.A* %tmp) #1, !dbg !38
- %call = call i32 @_ZN1A6getFooEv(%class.A* %tmp), !dbg !38
+ call void @llvm.memset.p0.i64(ptr align 8 %tmp, i8 0, i64 8, i1 false), !dbg !38
+ call void @_ZN1AC1Ev(ptr %tmp) #1, !dbg !38
+ %call = call i32 @_ZN1A6getFooEv(ptr %tmp), !dbg !38
ret i32 %call, !dbg !38
}
; Function Attrs: nounwind
-declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) #1
+declare void @llvm.memset.p0.i64(ptr nocapture, i8, i64, i1) #1
; Function Attrs: inlinehint nounwind
-define linkonce_odr void @_ZN1AC1Ev(%class.A* %this) unnamed_addr #2 align 2 !dbg !31 {
+define linkonce_odr void @_ZN1AC1Ev(ptr %this) unnamed_addr #2 align 2 !dbg !31 {
entry:
- %this.addr = alloca %class.A*, align 8
- store %class.A* %this, %class.A** %this.addr, align 8
- call void @llvm.dbg.declare(metadata %class.A** %this.addr, metadata !39, metadata !DIExpression()), !dbg !41
- %this1 = load %class.A*, %class.A** %this.addr
- call void @_ZN1AC2Ev(%class.A* %this1) #1, !dbg !42
+ %this.addr = alloca ptr, align 8
+ store ptr %this, ptr %this.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %this.addr, metadata !39, metadata !DIExpression()), !dbg !41
+ %this1 = load ptr, ptr %this.addr
+ call void @_ZN1AC2Ev(ptr %this1) #1, !dbg !42
ret void, !dbg !42
}
-declare i32 @_ZN1A6getFooEv(%class.A*)
+declare i32 @_ZN1A6getFooEv(ptr)
; Function Attrs: nounwind readnone
declare void @llvm.dbg.declare(metadata, metadata, metadata) #4
; Function Attrs: inlinehint nounwind
-define linkonce_odr void @_ZN1AC2Ev(%class.A* %this) unnamed_addr #2 align 2 !dbg !34 {
+define linkonce_odr void @_ZN1AC2Ev(ptr %this) unnamed_addr #2 align 2 !dbg !34 {
entry:
- %this.addr = alloca %class.A*, align 8
- store %class.A* %this, %class.A** %this.addr, align 8
- call void @llvm.dbg.declare(metadata %class.A** %this.addr, metadata !44, metadata !DIExpression()), !dbg !45
- %this1 = load %class.A*, %class.A** %this.addr
- %0 = bitcast %class.A* %this1 to i8***, !dbg !46
- store i8** getelementptr inbounds ([4 x i8*], [4 x i8*]* @_ZTV1A, i64 0, i64 2), i8*** %0, !dbg !46
+ %this.addr = alloca ptr, align 8
+ store ptr %this, ptr %this.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %this.addr, metadata !44, metadata !DIExpression()), !dbg !45
+ %this1 = load ptr, ptr %this.addr
+ store ptr getelementptr inbounds ([4 x ptr], ptr @_ZTV1A, i64 0, i64 2), ptr %this1, !dbg !46
ret void, !dbg !46
}
; target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
; target triple = "x86_64-apple-macosx10.9.0"
-%class.A = type { i32 (...)** }
+%class.A = type { ptr }
-@_ZTV1A = unnamed_addr constant [4 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*), i8* bitcast (void (%class.A*)* @_ZN1A6setFooEv to i8*), i8* bitcast (i32 (%class.A*)* @_ZN1A6getFooEv to i8*)]
-@_ZTVN10__cxxabiv117__class_type_infoE = external global i8*
+@_ZTV1A = unnamed_addr constant [4 x ptr] [ptr null, ptr @_ZTI1A, ptr @_ZN1A6setFooEv, ptr @_ZN1A6getFooEv]
+@_ZTVN10__cxxabiv117__class_type_infoE = external global ptr
@_ZTS1A = constant [3 x i8] c"1A\00"
-@_ZTI1A = unnamed_addr constant { i8*, i8* } { i8* bitcast (i8** getelementptr inbounds (i8*, i8** @_ZTVN10__cxxabiv117__class_type_infoE, i64 2) to i8*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1A, i32 0, i32 0) }
+@_ZTI1A = unnamed_addr constant { ptr, ptr } { ptr getelementptr inbounds (ptr, ptr @_ZTVN10__cxxabiv117__class_type_infoE, i64 2), ptr @_ZTS1A }
; Function Attrs: nounwind
-define void @_ZN1A6setFooEv(%class.A* %this) unnamed_addr #0 align 2 !dbg !26 {
+define void @_ZN1A6setFooEv(ptr %this) unnamed_addr #0 align 2 !dbg !26 {
entry:
- %this.addr = alloca %class.A*, align 8
- store %class.A* %this, %class.A** %this.addr, align 8
- call void @llvm.dbg.declare(metadata %class.A** %this.addr, metadata !32, metadata !DIExpression()), !dbg !34
- %this1 = load %class.A*, %class.A** %this.addr
+ %this.addr = alloca ptr, align 8
+ store ptr %this, ptr %this.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %this.addr, metadata !32, metadata !DIExpression()), !dbg !34
+ %this1 = load ptr, ptr %this.addr
ret void, !dbg !35
}
declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
; Function Attrs: nounwind
-define i32 @_ZN1A6getFooEv(%class.A* %this) unnamed_addr #0 align 2 !dbg !28 {
+define i32 @_ZN1A6getFooEv(ptr %this) unnamed_addr #0 align 2 !dbg !28 {
entry:
- %this.addr = alloca %class.A*, align 8
- store %class.A* %this, %class.A** %this.addr, align 8
- call void @llvm.dbg.declare(metadata %class.A** %this.addr, metadata !36, metadata !DIExpression()), !dbg !37
- %this1 = load %class.A*, %class.A** %this.addr
+ %this.addr = alloca ptr, align 8
+ store ptr %this, ptr %this.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %this.addr, metadata !36, metadata !DIExpression()), !dbg !37
+ %this1 = load ptr, ptr %this.addr
ret i32 1, !dbg !38
}
; CHECK-NEXT: %A = type { i8 }
; CHECK: @g1 = global %C.0 zeroinitializer
-; CHECK: getelementptr %C.0, %C.0* null, i64 0, i32 0, i32 0
+; CHECK: getelementptr %C.0, ptr null, i64 0, i32 0, i32 0
%A = type { i8 }
%B = type { %A }
%C = type { %B }
%C.0 = type { %B }
define void @f1() {
- getelementptr %C, %C* null, i64 0, i32 0, i32 0
+ getelementptr %C, ptr null, i64 0, i32 0, i32 0
ret void
}
@g1 = global %C.0 zeroinitializer
%struct.SA = type { i32 }
; Function Attrs: ssp uwtable
-define void @_Z4topAP1A2SA(%class.A* %a, i32 %sa.coerce) #0 !dbg !15 {
+define void @_Z4topAP1A2SA(ptr %a, i32 %sa.coerce) #0 !dbg !15 {
entry:
%sa = alloca %struct.SA, align 4
- %a.addr = alloca %class.A*, align 8
+ %a.addr = alloca ptr, align 8
%agg.tmp = alloca %struct.SA, align 4
- %coerce.dive = getelementptr %struct.SA, %struct.SA* %sa, i32 0, i32 0
- store i32 %sa.coerce, i32* %coerce.dive
- store %class.A* %a, %class.A** %a.addr, align 8
- call void @llvm.dbg.declare(metadata %class.A** %a.addr, metadata !24, metadata !DIExpression()), !dbg !25
- call void @llvm.dbg.declare(metadata %struct.SA* %sa, metadata !26, metadata !DIExpression()), !dbg !27
- %0 = load %class.A*, %class.A** %a.addr, align 8, !dbg !28
- %1 = bitcast %struct.SA* %agg.tmp to i8*, !dbg !28
- %2 = bitcast %struct.SA* %sa to i8*, !dbg !28
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %1, i8* align 4 %2, i64 4, i1 false), !dbg !28
- %coerce.dive1 = getelementptr %struct.SA, %struct.SA* %agg.tmp, i32 0, i32 0, !dbg !28
- %3 = load i32, i32* %coerce.dive1, !dbg !28
- call void @_ZN1A5testAE2SA(%class.A* %0, i32 %3), !dbg !28
+ store i32 %sa.coerce, ptr %sa
+ store ptr %a, ptr %a.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %a.addr, metadata !24, metadata !DIExpression()), !dbg !25
+ call void @llvm.dbg.declare(metadata ptr %sa, metadata !26, metadata !DIExpression()), !dbg !27
+ %0 = load ptr, ptr %a.addr, align 8, !dbg !28
+ call void @llvm.memcpy.p0.p0.i64(ptr align 4 %agg.tmp, ptr align 4 %sa, i64 4, i1 false), !dbg !28
+ %1 = load i32, ptr %agg.tmp, !dbg !28
+ call void @_ZN1A5testAE2SA(ptr %0, i32 %1), !dbg !28
ret void, !dbg !29
}
declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
; Function Attrs: nounwind ssp uwtable
-define linkonce_odr void @_ZN1A5testAE2SA(%class.A* %this, i32 %a.coerce) #2 align 2 !dbg !20 {
+define linkonce_odr void @_ZN1A5testAE2SA(ptr %this, i32 %a.coerce) #2 align 2 !dbg !20 {
entry:
%a = alloca %struct.SA, align 4
- %this.addr = alloca %class.A*, align 8
- %coerce.dive = getelementptr %struct.SA, %struct.SA* %a, i32 0, i32 0
- store i32 %a.coerce, i32* %coerce.dive
- store %class.A* %this, %class.A** %this.addr, align 8
- call void @llvm.dbg.declare(metadata %class.A** %this.addr, metadata !30, metadata !DIExpression()), !dbg !31
- call void @llvm.dbg.declare(metadata %struct.SA* %a, metadata !32, metadata !DIExpression()), !dbg !33
- %this1 = load %class.A*, %class.A** %this.addr
+ %this.addr = alloca ptr, align 8
+ store i32 %a.coerce, ptr %a
+ store ptr %this, ptr %this.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %this.addr, metadata !30, metadata !DIExpression()), !dbg !31
+ call void @llvm.dbg.declare(metadata ptr %a, metadata !32, metadata !DIExpression()), !dbg !33
+ %this1 = load ptr, ptr %this.addr
ret void, !dbg !34
}
; Function Attrs: nounwind
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i1) #3
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture readonly, i64, i1) #3
attributes #0 = { ssp uwtable "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind readnone }
%struct.SA = type { i32 }
; Function Attrs: ssp uwtable
-define void @_Z4topBP1B2SA(%class.B* %b, i32 %sa.coerce) #0 !dbg !15 {
+define void @_Z4topBP1B2SA(ptr %b, i32 %sa.coerce) #0 !dbg !15 {
entry:
%sa = alloca %struct.SA, align 4
- %b.addr = alloca %class.B*, align 8
+ %b.addr = alloca ptr, align 8
%agg.tmp = alloca %struct.SA, align 4
- %coerce.dive = getelementptr %struct.SA, %struct.SA* %sa, i32 0, i32 0
- store i32 %sa.coerce, i32* %coerce.dive
- store %class.B* %b, %class.B** %b.addr, align 8
- call void @llvm.dbg.declare(metadata %class.B** %b.addr, metadata !24, metadata !DIExpression()), !dbg !25
- call void @llvm.dbg.declare(metadata %struct.SA* %sa, metadata !26, metadata !DIExpression()), !dbg !27
- %0 = load %class.B*, %class.B** %b.addr, align 8, !dbg !28
- %1 = bitcast %struct.SA* %agg.tmp to i8*, !dbg !28
- %2 = bitcast %struct.SA* %sa to i8*, !dbg !28
- call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %1, i8* align 4 %2, i64 4, i1 false), !dbg !28
- %coerce.dive1 = getelementptr %struct.SA, %struct.SA* %agg.tmp, i32 0, i32 0, !dbg !28
- %3 = load i32, i32* %coerce.dive1, !dbg !28
- call void @_ZN1B5testBE2SA(%class.B* %0, i32 %3), !dbg !28
+ store i32 %sa.coerce, ptr %sa
+ store ptr %b, ptr %b.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %b.addr, metadata !24, metadata !DIExpression()), !dbg !25
+ call void @llvm.dbg.declare(metadata ptr %sa, metadata !26, metadata !DIExpression()), !dbg !27
+ %0 = load ptr, ptr %b.addr, align 8, !dbg !28
+ call void @llvm.memcpy.p0.p0.i64(ptr align 4 %agg.tmp, ptr align 4 %sa, i64 4, i1 false), !dbg !28
+ %1 = load i32, ptr %agg.tmp, !dbg !28
+ call void @_ZN1B5testBE2SA(ptr %0, i32 %1), !dbg !28
ret void, !dbg !29
}
declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
; Function Attrs: nounwind ssp uwtable
-define linkonce_odr void @_ZN1B5testBE2SA(%class.B* %this, i32 %sa.coerce) #2 align 2 !dbg !20 {
+define linkonce_odr void @_ZN1B5testBE2SA(ptr %this, i32 %sa.coerce) #2 align 2 !dbg !20 {
entry:
%sa = alloca %struct.SA, align 4
- %this.addr = alloca %class.B*, align 8
- %coerce.dive = getelementptr %struct.SA, %struct.SA* %sa, i32 0, i32 0
- store i32 %sa.coerce, i32* %coerce.dive
- store %class.B* %this, %class.B** %this.addr, align 8
- call void @llvm.dbg.declare(metadata %class.B** %this.addr, metadata !30, metadata !DIExpression()), !dbg !31
- call void @llvm.dbg.declare(metadata %struct.SA* %sa, metadata !32, metadata !DIExpression()), !dbg !33
- %this1 = load %class.B*, %class.B** %this.addr
+ %this.addr = alloca ptr, align 8
+ store i32 %sa.coerce, ptr %sa
+ store ptr %this, ptr %this.addr, align 8
+ call void @llvm.dbg.declare(metadata ptr %this.addr, metadata !30, metadata !DIExpression()), !dbg !31
+ call void @llvm.dbg.declare(metadata ptr %sa, metadata !32, metadata !DIExpression()), !dbg !33
+ %this1 = load ptr, ptr %this.addr
ret void, !dbg !34
}
; Function Attrs: nounwind
-declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i1) #3
+declare void @llvm.memcpy.p0.p0.i64(ptr nocapture, ptr nocapture readonly, i64, i1) #3
attributes #0 = { ssp uwtable "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind readnone }
; RUN: llvm-link -S %s %p/Inputs/type-unique-unrelated2.ll %p/Inputs/type-unique-unrelated3.ll | FileCheck %s
-; CHECK: %t = type { i8* }
+; CHECK: %t = type { ptr }
; CHECK: define %t @f2() {
; CHECK-NEXT: %x = call %t @f2()
; type-unique-unrelated2.ll look unrelated until type-unique-unrelated3.ll
; is merged in.
-%t = type { i8* }
+%t = type { ptr }
declare %t @f()
define %t @f2() {
; CHECK-DAG: @global-c = common unnamed_addr global i32 0
@global-d = external global i32
-define i32* @use-global-d() {
- ret i32* @global-d
+define ptr @use-global-d() {
+ ret ptr @global-d
}
; CHECK-DAG: @global-d = global i32 42
; CHECK-DAG: @global-f = global i32 42
@alias-a = weak global i32 42
-; CHECK-DAG: @alias-a = alias i32, i32* @global-f
+; CHECK-DAG: @alias-a = alias i32, ptr @global-f
@alias-b = weak unnamed_addr global i32 42
-; CHECK-DAG: @alias-b = unnamed_addr alias i32, i32* @global-f
+; CHECK-DAG: @alias-b = unnamed_addr alias i32, ptr @global-f
declare void @func-c()
define void @use-func-c() {
; CHECK-DAG: @global-j = global i32 42
@alias-c = weak global i32 42
-; CHECK-DAG: @alias-c = alias i32, i32* @global-f
+; CHECK-DAG: @alias-c = alias i32, ptr @global-f
@alias-d = weak unnamed_addr global i32 42
-; CHECK-DAG: @alias-d = alias i32, i32* @global-f
+; CHECK-DAG: @alias-d = alias i32, ptr @global-f
declare void @func-g()
@global-e = unnamed_addr global i32 42
@global-f = unnamed_addr global i32 42
-@alias-a = unnamed_addr alias i32, i32* @global-f
-@alias-b = unnamed_addr alias i32, i32* @global-f
+@alias-a = unnamed_addr alias i32, ptr @global-f
+@alias-b = unnamed_addr alias i32, ptr @global-f
define weak void @func-c() unnamed_addr { ret void }
define weak void @func-d() unnamed_addr { ret void }
@global-i = global i32 42
@global-j = global i32 42
-@alias-c = alias i32, i32* @global-f
-@alias-d = alias i32, i32* @global-f
+@alias-c = alias i32, ptr @global-f
+@alias-d = alias i32, ptr @global-f
define weak void @func-g() { ret void }
define weak void @func-h() { ret void }
@v4 = global i32 1, comdat($c1)
; Aliases
-; CHECK: @a1 = hidden alias i32, i32* @v1
-@a1 = alias i32, i32* @v1
+; CHECK: @a1 = hidden alias i32, ptr @v1
+@a1 = alias i32, ptr @v1
-; CHECK: @a2 = protected alias i32, i32* @v2
-@a2 = alias i32, i32* @v2
+; CHECK: @a2 = protected alias i32, ptr @v2
+@a2 = alias i32, ptr @v2
-; CHECK: @a3 = hidden alias i32, i32* @v3
-@a3 = protected alias i32, i32* @v3
+; CHECK: @a3 = hidden alias i32, ptr @v3
+@a3 = protected alias i32, ptr @v3
; Functions
@MyVar = extern_weak global i32
@Inte = extern_weak global i32
-define weak [0 x i8]* @use_kallsyms_names() {
- ret [0 x i8]* @kallsyms_names
+define weak ptr @use_kallsyms_names() {
+ ret ptr @kallsyms_names
}
projects / platform / upstream / llvm.git / commitdiff