@assoc = private constant i8 2, !associated !1
!0 = !{i32 0, !"typeid"}
-!1 = !{i8* @g}
+!1 = !{ptr @g}
!4 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "o<i, int, &i::m_fn1>", file: !5, line: 22, size: 8, flags: DIFlagTypePassByValue | DIFlagNonTrivial, elements: !2, templateParams: !6, identifier: "_ZTS1oI1iiXadL_ZNKS0_5m_fn1EvEEE")
!5 = !DIFile(filename: "t.ii", directory: "/tmp")
!6 = !{!7}
-!7 = !DITemplateValueParameter(type: !8, value: i64 ptrtoint (i32* @_ZNK1i5m_fn1Ev to i64))
+!7 = !DITemplateValueParameter(type: !8, value: i64 ptrtoint (ptr @_ZNK1i5m_fn1Ev to i64))
!8 = !DIDerivedType(tag: DW_TAG_ptr_to_member_type, baseType: !9, size: 128, extraData: !13)
!9 = !DISubroutineType(types: !10)
!10 = !{!11, !12}
!13 = distinct !DICompositeType(tag: DW_TAG_class_type, name: "i", file: !5, line: 13, size: 8, flags: DIFlagTypePassByValue | DIFlagNonTrivial, elements: !2, identifier: "_ZTS1i")
!14 = !{i32 2, !"Debug Info Version", i32 3}
!15 = !{i32 4, !"CFI Canonical Jump Tables", i32 0}
-!16 = !{i64 ptrtoint (i32* @_ZNK1i5m_fn1Ev to i64)}
+!16 = !{i64 ptrtoint (ptr @_ZNK1i5m_fn1Ev to i64)}
!17 = !{i64 0, !"_ZTSFvM1iKFivEE"}
!18 = !{i64 0, !"_ZTSFvM1iKFivEE.generalized"}
; CHECK: module asm ".lto_set_conditional a,a.[[HASH:[0-9a-f]+]]"
define void @b() {
- %f = alloca void ()*, align 8
+ %f = alloca ptr, align 8
; CHECK: store{{.*}} @a.[[HASH]],{{.*}} %f
- store void ()* @a, void ()** %f, align 8
- ; CHECK: %1 = call void ()* asm sideeffect "leaq a(%rip)
- %1 = call void ()* asm sideeffect "leaq a(%rip), $0\0A\09", "=r,~{dirflag},~{fpsr},~{flags}"()
+ store ptr @a, ptr %f, align 8
+ ; CHECK: %1 = call ptr asm sideeffect "leaq a(%rip)
+ %1 = call ptr asm sideeffect "leaq a(%rip), $0\0A\09", "=r,~{dirflag},~{fpsr},~{flags}"()
ret void
}
; M0: @g = external constant
; M1: @g = constant
-@g = constant i8* bitcast (i8** @g to i8*), !type !0
+@g = constant ptr @g, !type !0
!0 = !{i32 0, !"typeid"}
; MERGED: @lwt_aliasee = private unnamed_addr global
; MERGED-SAME: comdat(${{"?lwt[^ ]+}})
-@lwt_aliasee = private unnamed_addr global [1 x i8*] [i8* null], comdat($lwt), !type !0
+@lwt_aliasee = private unnamed_addr global [1 x ptr] [ptr null], comdat($lwt), !type !0
; MERGED: {{@"?lwt_nl[^ ]+}} = hidden unnamed_addr global
; MERGED-SAME: comdat(${{"?lwt[^ ]+}})
; MERGED: @nlwt_aliasee = private unnamed_addr global
; MERGED-SAME: comdat($nlwt)
-@nlwt_aliasee = private unnamed_addr global [1 x i8*] [i8* null], comdat($nlwt), !type !0
+@nlwt_aliasee = private unnamed_addr global [1 x ptr] [ptr null], comdat($nlwt), !type !0
; MERGED: @nlwt = unnamed_addr global
; MERGED-SAME: comdat
; THIN: @nt = internal
; THIN-SAME: comdat
-@nt = internal unnamed_addr global [1 x i8*] [i8* null], comdat
+@nt = internal unnamed_addr global [1 x ptr] [ptr null], comdat
; THIN: @nt_nl = internal
; THIN-SAME: comdat($nt)
; MERGED: {{@"?lwt[^ ]+}} = hidden unnamed_addr alias
; THIN: {{@"?lwt[^ ]+}} = external hidden
-@lwt = internal unnamed_addr alias [1 x i8*], [1 x i8*]* @lwt_aliasee
+@lwt = internal unnamed_addr alias [1 x ptr], ptr @lwt_aliasee
; MERGED: {{@"?nlwt_nl[^ ]+}} = hidden unnamed_addr alias
; THIN: {{@"?nlwt_nl[^ ]+}} = external hidden
-@nlwt_nl = internal unnamed_addr alias [1 x i8*], [1 x i8*]* @nlwt_aliasee
+@nlwt_nl = internal unnamed_addr alias [1 x ptr], ptr @nlwt_aliasee
; The functions below exist just to make sure the globals are used.
-define i8* @lwt_fun() {
- %1 = load i32, i32* @lwt_nl
- %2 = getelementptr inbounds [1 x i8*], [1 x i8*]* @lwt, i32 0, i32 %1
- %3 = load i8*, i8** %2
- ret i8* %3
+define ptr @lwt_fun() {
+ %1 = load i32, ptr @lwt_nl
+ %2 = getelementptr inbounds [1 x ptr], ptr @lwt, i32 0, i32 %1
+ %3 = load ptr, ptr %2
+ ret ptr %3
}
-define i8* @nlwt_fun() {
- %1 = load i32, i32* @nlwt
- %2 = getelementptr inbounds [1 x i8*], [1 x i8*]* @nlwt_nl, i32 0, i32 %1
- %3 = load i8*, i8** %2
- ret i8* %3
+define ptr @nlwt_fun() {
+ %1 = load i32, ptr @nlwt
+ %2 = getelementptr inbounds [1 x ptr], ptr @nlwt_nl, i32 0, i32 %1
+ %3 = load ptr, ptr %2
+ ret ptr %3
}
-define i8* @nt_fun() {
- %1 = load i32, i32* @nt_nl
- %2 = getelementptr inbounds [1 x i8*], [1 x i8*]* @nt, i32 0, i32 %1
- %3 = load i8*, i8** %2
- ret i8* %3
+define ptr @nt_fun() {
+ %1 = load i32, ptr @nt_nl
+ %2 = getelementptr inbounds [1 x ptr], ptr @nt, i32 0, i32 %1
+ %3 = load ptr, ptr %2
+ ret ptr %3
}
!0 = !{i64 8, !"?AVA@@"}
; RUN: llvm-modextract -n 0 -o - %t | llvm-dis | FileCheck --check-prefix=CHECK0 %s
; RUN: llvm-modextract -n 1 -o - %t | llvm-dis | FileCheck --check-prefix=CHECK1 %s
; CHECK0-NOT: @{{.*}}anon{{.*}}=
-; CHECK0: @al = external global i8*
+; CHECK0: @al = external global ptr
; CHECK0-NOT: @{{.*}}anon{{.*}}=
-; CHECK1: @al = unnamed_addr alias i8*,
+; CHECK1: @al = unnamed_addr alias ptr,
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215"
$al = comdat any
-@anon = private unnamed_addr constant { [1 x i8*] } { [1 x i8*] [i8* null] }, comdat($al), !type !0
+@anon = private unnamed_addr constant { [1 x ptr] } { [1 x ptr] [ptr null] }, comdat($al), !type !0
-@al = external unnamed_addr alias i8*, getelementptr inbounds ({ [1 x i8*] }, { [1 x i8*] }* @anon, i32 0, i32 0, i32 1)
+@al = external unnamed_addr alias ptr, getelementptr inbounds ({ [1 x ptr] }, ptr @anon, i32 0, i32 0, i32 1)
@foo = global i32 1
; CHECK1: ![[A1]] = !{!"Alias", !"Func", i8 1, i8 0}
; CHECK1: ![[A2]] = !{!"Hidden_Alias", !"Func", i8 1, i8 0}
; CHECK1: ![[A3]] = !{!"Weak_Alias", !"Func", i8 0, i8 1}
-@Alias = hidden alias void (), void ()* @Func
-@Hidden_Alias = hidden alias void (), void ()* @Func
-@Weak_Alias = weak alias void (), void ()* @Func
+@Alias = hidden alias void (), ptr @Func
+@Hidden_Alias = hidden alias void (), ptr @Func
+@Weak_Alias = weak alias void (), ptr @Func
@Variable = global i32 0
; Only generate summary alias information for aliases to functions
; CHECK1-NOT: Variable_Alias
-@Variable_Alias = alias i32, i32* @Variable
+@Variable_Alias = alias i32, ptr @Variable
!0 = !{i64 0, !"_ZTSFvvE"}
target triple = "x86_64-unknown-linux-gnu"
%struct.hoge = type { %struct.widget }
-%struct.widget = type { i32 (...)** }
+%struct.widget = type { ptr }
; M0: @global = local_unnamed_addr global
; M1-NOT: @global
-@global = local_unnamed_addr global %struct.hoge { %struct.widget { i32 (...)** bitcast (i8** getelementptr inbounds ({ [3 x i8*] }, { [3 x i8*] }* @global.1, i32 0, inrange i32 0, i32 2) to i32 (...)**) } }, align 8
+@global = local_unnamed_addr global %struct.hoge { %struct.widget { ptr getelementptr inbounds ({ [3 x ptr] }, ptr @global.1, i32 0, inrange i32 0, i32 2) } }, align 8
; M0: @global.1 = external unnamed_addr constant
; M1: @global.1 = linkonce_odr unnamed_addr constant
-@global.1 = linkonce_odr unnamed_addr constant { [3 x i8*] } { [3 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @global.4 to i8*), i8* bitcast (i32 (%struct.widget*)* @quux to i8*)] }, align 8, !type !0
+@global.1 = linkonce_odr unnamed_addr constant { [3 x ptr] } { [3 x ptr] [ptr null, ptr @global.4, ptr @quux] }, align 8, !type !0
; M0: @global.2 = external global
; M1-NOT: @global.2
-@global.2 = external global i8*
+@global.2 = external global ptr
; M0: @global.3 = linkonce_odr constant
; M1-NOT: @global.3
; M0: @global.4 = linkonce_odr constant
; M1: @global.4 = external constant
-@global.4 = linkonce_odr constant { i8*, i8* }{ i8* bitcast (i8** getelementptr inbounds (i8*, i8** @global.2, i64 2) to i8*), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @global.3, i32 0, i32 0) }
+@global.4 = linkonce_odr constant { ptr, ptr }{ ptr getelementptr inbounds (ptr, ptr @global.2, i64 2), ptr @global.3 }
-@llvm.global_ctors = appending global [0 x { i32, void ()*, i8* }] zeroinitializer
+@llvm.global_ctors = appending global [0 x { i32, ptr, ptr }] zeroinitializer
-declare i32 @quux(%struct.widget*) unnamed_addr
+declare i32 @quux(ptr) unnamed_addr
!0 = !{i64 16, !"yyyyyyyyyyyyyyyyyyyyyyyyy"}
; M1: @default = dso_local constant [1 x i8] c"0", !type !0
; M1: @hidden = hidden constant [1 x i8] c"0", !type !0
-; M1: @al = dso_local alias [1 x i8], [1 x i8]* @default
+; M1: @al = dso_local alias [1 x i8], ptr @default
@default = dso_local constant [1 x i8] c"0", !type !0
@hidden = dso_local hidden constant [1 x i8] c"0", !type !0
-@al = dso_local alias [1 x i8], [1 x i8]* @default
+@al = dso_local alias [1 x i8], ptr @default
-define [1 x i8]* @f_default() { ret [1 x i8]* @default }
-define [1 x i8]* @f_hidden() { ret [1 x i8]* @hidden }
-define [1 x i8]* @f_al() { ret [1 x i8]* @al }
+define ptr @f_default() { ret ptr @default }
+define ptr @f_hidden() { ret ptr @hidden }
+define ptr @f_al() { ret ptr @al }
!0 = !{i32 0, !"typeid"}
; M1-NOT: @f()
define void @f() {
; M0: llvm.type.test{{.*}}metadata !"1.f50b51a12bb012bebbeff978335e34cf"
- %p = call i1 @llvm.type.test(i8* null, metadata !0)
+ %p = call i1 @llvm.type.test(ptr null, metadata !0)
; M0: llvm.type.checked.load{{.*}}metadata !"2.f50b51a12bb012bebbeff978335e34cf"
- %q = call {i8*, i1} @llvm.type.checked.load(i8* null, i32 0, metadata !3)
+ %q = call {ptr, i1} @llvm.type.checked.load(ptr null, i32 0, metadata !3)
ret void
}
-declare i1 @llvm.type.test(i8*, metadata)
-declare {i8*, i1} @llvm.type.checked.load(i8*, i32, metadata)
+declare i1 @llvm.type.test(ptr, metadata)
+declare {ptr, i1} @llvm.type.checked.load(ptr, i32, metadata)
!0 = distinct !{}
; M1: !0 = !{i32 0, !"1.f50b51a12bb012bebbeff978335e34cf"}
; M1: @g.581d7631532fa146ba4061179da39272 = hidden global i8 42, !type !0
@g = internal global i8 42, !type !0
-; M0: define i8* @f()
+; M0: define ptr @f()
; M1-NOT: @f()
-define i8* @f() {
- ; M0: ret i8* @g.581d7631532fa146ba4061179da39272
- ret i8* @g
+define ptr @f() {
+ ; M0: ret ptr @g.581d7631532fa146ba4061179da39272
+ ret ptr @g
}
; M1: !0 = !{i32 0, !"typeid"}
; BCA0: <GLOBALVAL_SUMMARY_BLOCK
; BCA1-NOT: <GLOBALVAL_SUMMARY_BLOCK
-; M0: @g = external global void ()*{{$}}
-; M1: @g = global void ()* @f.13757e0fb71915e385efa4dc9d1e08fd, !type !0
-@g = global void ()* @f, !type !0
+; M0: @g = external global ptr{{$}}
+; M1: @g = global ptr @f.13757e0fb71915e385efa4dc9d1e08fd, !type !0
+@g = global ptr @f, !type !0
; M0: define hidden void @f.13757e0fb71915e385efa4dc9d1e08fd()
; M1: declare hidden void @f.13757e0fb71915e385efa4dc9d1e08fd()
@g3 = global i8 42
@g4 = global i8 42
-; M0: @llvm.used = appending global [2 x i8*] [i8* @g1, i8* @g3]
-; M0: @llvm.compiler.used = appending global [2 x i8*] [i8* @g2, i8* @g4]
-; M1: @llvm.used = appending global [1 x i8*] [i8* @g1]
-; M1: @llvm.compiler.used = appending global [1 x i8*] [i8* @g2]
-@llvm.used = appending global [2 x i8*] [ i8* @g1, i8* @g3]
-@llvm.compiler.used = appending global [2 x i8*] [ i8* @g2, i8* @g4]
+; M0: @llvm.used = appending global [2 x ptr] [ptr @g1, ptr @g3]
+; M0: @llvm.compiler.used = appending global [2 x ptr] [ptr @g2, ptr @g4]
+; M1: @llvm.used = appending global [1 x ptr] [ptr @g1]
+; M1: @llvm.compiler.used = appending global [1 x ptr] [ptr @g2]
+@llvm.used = appending global [2 x ptr] [ ptr @g1, ptr @g3]
+@llvm.compiler.used = appending global [2 x ptr] [ ptr @g2, ptr @g4]
; M1: !0 = !{i32 0, !"typeid"}
!0 = !{i32 0, !"typeid"}
target triple = "x86_64-unknown-linux-gnu"
-define [1 x i8*]* @source() {
- ret [1 x i8*]* @g
+define ptr @source() {
+ ret ptr @g
}
-; M0: @g.84f59439b469192440047efc8de357fb = external hidden constant [1 x i8*]{{$}}
-; M1: @g.84f59439b469192440047efc8de357fb = hidden constant [1 x i8*] [i8* bitcast (i64 (i8*)* @ok.84f59439b469192440047efc8de357fb to i8*)]
-@g = internal constant [1 x i8*] [
- i8* bitcast (i64 (i8*)* @ok to i8*)
+; M0: @g.84f59439b469192440047efc8de357fb = external hidden constant [1 x ptr]{{$}}
+; M1: @g.84f59439b469192440047efc8de357fb = hidden constant [1 x ptr] [ptr @ok.84f59439b469192440047efc8de357fb]
+@g = internal constant [1 x ptr] [
+ ptr @ok
], !type !0
; M0: define hidden i64 @ok.84f59439b469192440047efc8de357fb
; M1: define available_externally hidden i64 @ok.84f59439b469192440047efc8de357fb
-define internal i64 @ok(i8* %this) {
+define internal i64 @ok(ptr %this) {
ret i64 42
}
; RUN: llvm-modextract -b -n 0 -o - %t | llvm-dis | FileCheck --check-prefix=M0 %s
; RUN: llvm-modextract -b -n 1 -o - %t | llvm-dis | FileCheck --check-prefix=M1 %s
-; M0: @g = external constant [10 x i8*]{{$}}
-; M1: @g = constant [10 x i8*]
-@g = constant [10 x i8*] [
- i8* bitcast (i64 (i8*)* @ok1 to i8*),
- i8* bitcast (i64 (i8*, i64)* @ok2 to i8*),
- i8* bitcast (void (i8*)* @wrongtype1 to i8*),
- i8* bitcast (i128 (i8*)* @wrongtype2 to i8*),
- i8* bitcast (i64 ()* @wrongtype3 to i8*),
- i8* bitcast (i64 (i8*, i8*)* @wrongtype4 to i8*),
- i8* bitcast (i64 (i8*, i128)* @wrongtype5 to i8*),
- i8* bitcast (i64 (i8*)* @usesthis to i8*),
- i8* bitcast (i8 (i8*)* @reads to i8*),
- i8* bitcast (i8* (i8*, i8)* @attributedFunc to i8*)
+; M0: @g = external constant [10 x ptr]{{$}}
+; M1: @g = constant [10 x ptr]
+@g = constant [10 x ptr] [
+ ptr @ok1,
+ ptr @ok2,
+ ptr @wrongtype1,
+ ptr @wrongtype2,
+ ptr @wrongtype3,
+ ptr @wrongtype4,
+ ptr @wrongtype5,
+ ptr @usesthis,
+ ptr @reads,
+ ptr @attributedFunc
], !type !0
; M0: define i64 @ok1
; M1: define available_externally i64 @ok1
-define i64 @ok1(i8* %this) {
+define i64 @ok1(ptr %this) {
ret i64 42
}
; M0: define i64 @ok2
; M1: define available_externally i64 @ok2
-define i64 @ok2(i8* %this, i64 %arg) {
+define i64 @ok2(ptr %this, i64 %arg) {
%1 = tail call { i64, i1 } @llvm.sadd.with.overflow.i64(i64 %arg, i64 %arg)
ret i64 %arg
}
; M0: define void @wrongtype1
; M1: declare void @wrongtype1()
-define void @wrongtype1(i8*) {
+define void @wrongtype1(ptr) {
ret void
}
; M0: define i128 @wrongtype2
; M1: declare void @wrongtype2()
-define i128 @wrongtype2(i8*) {
+define i128 @wrongtype2(ptr) {
ret i128 0
}
; M0: define i64 @wrongtype4
; M1: declare void @wrongtype4()
-define i64 @wrongtype4(i8*, i8*) {
+define i64 @wrongtype4(ptr, ptr) {
ret i64 0
}
; M0: define i64 @wrongtype5
; M1: declare void @wrongtype5()
-define i64 @wrongtype5(i8*, i128) {
+define i64 @wrongtype5(ptr, i128) {
ret i64 0
}
; M0: define i64 @usesthis
; M1: declare void @usesthis()
-define i64 @usesthis(i8* %this) {
- %i = ptrtoint i8* %this to i64
+define i64 @usesthis(ptr %this) {
+ %i = ptrtoint ptr %this to i64
ret i64 %i
}
; M0: define i8 @reads
; M1: declare void @reads()
-define i8 @reads(i8* %this) {
- %l = load i8, i8* %this
+define i8 @reads(ptr %this) {
+ %l = load i8, ptr %this
ret i8 %l
}
; Check function attributes are copied over splitted module
-; M0: declare dso_local noundef i8* @attributedFunc(i8* noalias, i8 zeroext) unnamed_addr #[[ATTR0:[0-9]+]]
+; M0: declare dso_local noundef ptr @attributedFunc(ptr noalias, i8 zeroext) unnamed_addr #[[ATTR0:[0-9]+]]
; M1: declare dso_local void @attributedFunc() unnamed_addr #[[ATTR1:[0-9]+]]
-declare dso_local noundef i8* @attributedFunc(i8* noalias, i8 zeroext) unnamed_addr alwaysinline willreturn
+declare dso_local noundef ptr @attributedFunc(ptr noalias, i8 zeroext) unnamed_addr alwaysinline willreturn
; M0: attributes #[[ATTR0]] = { alwaysinline willreturn }
; M1: attributes #[[ATTR1]] = { alwaysinline willreturn }
; M1: @g = global i8 42, comdat, !type !0
@g = global i8 42, comdat, !type !0
-; M0: define i8* @f()
+; M0: define ptr @f()
; M1-NOT: @f()
-define i8* @f() {
- ret i8* @g
+define ptr @f() {
+ ret ptr @g
}
; M1: !0 = !{i32 0, !"typeid"}
declare !type !0 void @unused()
@variable = global i32 0
-define i32* @use() {
+define ptr @use() {
call void @used()
- ret i32* @variable
+ ret ptr @variable
}
; CHECK: !symvers = !{![[SYMVER:[0-9]+]]}
; BCA-NOT: <GLOBALVAL_SUMMARY_BLOCK
; CHECK: @llvm.global_ctors = appending global
-@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 }]
; CHECK: @g = internal global i8 42, !type !0
@g = internal global i8 42, !type !0
-declare void @sink(i8*)
+declare void @sink(ptr)
; CHECK: define internal void @f()
define internal void @f() {
- call void @sink(i8* @g)
+ call void @sink(ptr @g)
ret void
}