Mercurial > hg > CbC > CbC_llvm

annotate clang/test/CodeGenObjC/arc-literals.m @ 180:680fa57a2f20

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fix compile errors.
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Sat, 30 May 2020 17:44:06 +0900
parents 1d019706d866
children 2e18cbf3894f
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
150
anatofuz
parents:
diff changeset
1 // RUN: %clang_cc1 -I %S/Inputs -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -O2 -disable-llvm-passes -o - %s | FileCheck %s
anatofuz
parents:
diff changeset
2
anatofuz
parents:
diff changeset
3 #include "literal-support.h"
anatofuz
parents:
diff changeset
4
anatofuz
parents:
diff changeset
5 // Check the various selector names we'll be using, in order.
anatofuz
parents:
diff changeset
6
anatofuz
parents:
diff changeset
7 // CHECK: c"numberWithInt:\00"
anatofuz
parents:
diff changeset
8 // CHECK: c"numberWithUnsignedInt:\00"
anatofuz
parents:
diff changeset
9 // CHECK: c"numberWithUnsignedLongLong:\00"
anatofuz
parents:
diff changeset
10 // CHECK: c"numberWithChar:\00"
anatofuz
parents:
diff changeset
11 // CHECK: c"arrayWithObjects:count:\00"
anatofuz
parents:
diff changeset
12 // CHECK: c"dictionaryWithObjects:forKeys:count:\00"
anatofuz
parents:
diff changeset
13 // CHECK: c"prop\00"
anatofuz
parents:
diff changeset
14
anatofuz
parents:
diff changeset
15 // CHECK-LABEL: define void @test_numeric()
anatofuz
parents:
diff changeset
16 void test_numeric() {
anatofuz
parents:
diff changeset
17 // CHECK: {{call.*objc_msgSend.*i32 17}}
anatofuz
parents:
diff changeset
18 // CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue
anatofuz
parents:
diff changeset
19 id ilit = @17;
anatofuz
parents:
diff changeset
20 // CHECK: {{call.*objc_msgSend.*i32 25}}
anatofuz
parents:
diff changeset
21 // CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue
anatofuz
parents:
diff changeset
22 id ulit = @25u;
anatofuz
parents:
diff changeset
23 // CHECK: {{call.*objc_msgSend.*i64 42}}
anatofuz
parents:
diff changeset
24 // CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue
anatofuz
parents:
diff changeset
25 id ulllit = @42ull;
anatofuz
parents:
diff changeset
26 // CHECK: {{call.*objc_msgSend.*i8 signext 97}}
anatofuz
parents:
diff changeset
27 // CHECK: call i8* @llvm.objc.retainAutoreleasedReturnValue
anatofuz
parents:
diff changeset
28 id charlit = @'a';
anatofuz
parents:
diff changeset
29 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
30 // CHECK: call void @llvm.lifetime.end
anatofuz
parents:
diff changeset
31 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
32 // CHECK: call void @llvm.lifetime.end
anatofuz
parents:
diff changeset
33 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
34 // CHECK: call void @llvm.lifetime.end
anatofuz
parents:
diff changeset
35 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
36 // CHECK: call void @llvm.lifetime.end
anatofuz
parents:
diff changeset
37 // CHECK-NEXT: ret void
anatofuz
parents:
diff changeset
38 }
anatofuz
parents:
diff changeset
39
anatofuz
parents:
diff changeset
40 // CHECK-LABEL: define void @test_array
anatofuz
parents:
diff changeset
41 void test_array(id a, id b) {
anatofuz
parents:
diff changeset
42 // CHECK: [[A:%.*]] = alloca i8*,
anatofuz
parents:
diff changeset
43 // CHECK: [[B:%.*]] = alloca i8*,
anatofuz
parents:
diff changeset
44
anatofuz
parents:
diff changeset
45 // Retaining parameters
anatofuz
parents:
diff changeset
46 // CHECK: call i8* @llvm.objc.retain(i8*
anatofuz
parents:
diff changeset
47 // CHECK: call i8* @llvm.objc.retain(i8*
anatofuz
parents:
diff changeset
48
anatofuz
parents:
diff changeset
49 // Constructing the array
anatofuz
parents:
diff changeset
50 // CHECK: [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS:%[A-Za-z0-9]+]], i64 0, i64 0
anatofuz
parents:
diff changeset
51 // CHECK-NEXT: [[V0:%.*]] = load i8*, i8** [[A]],
anatofuz
parents:
diff changeset
52 // CHECK-NEXT: store i8* [[V0]], i8** [[T0]]
anatofuz
parents:
diff changeset
53 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS]], i64 0, i64 1
anatofuz
parents:
diff changeset
54 // CHECK-NEXT: [[V1:%.*]] = load i8*, i8** [[B]],
anatofuz
parents:
diff changeset
55 // CHECK-NEXT: store i8* [[V1]], i8** [[T0]]
anatofuz
parents:
diff changeset
56
anatofuz
parents:
diff changeset
57 // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T:%.*]]*, [[CLASS_T:%.*]]** @"OBJC_CLASSLIST
anatofuz
parents:
diff changeset
58 // CHECK-NEXT: [[SEL:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES
anatofuz
parents:
diff changeset
59 // CHECK-NEXT: [[T1:%.*]] = bitcast [[CLASS_T]]* [[T0]] to i8*
anatofuz
parents:
diff changeset
60 // CHECK-NEXT: [[T2:%.*]] = bitcast [2 x i8*]* [[OBJECTS]] to i8**
anatofuz
parents:
diff changeset
61 // CHECK-NEXT: [[T3:%.*]] = call i8* bitcast ({{.*@objc_msgSend.*}})(i8* [[T1]], i8* [[SEL]], i8** [[T2]], i64 2)
anatofuz
parents:
diff changeset
62 // CHECK-NEXT: [[T4:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T3]])
anatofuz
parents:
diff changeset
63 // CHECK: call void (...) @llvm.objc.clang.arc.use(i8* [[V0]], i8* [[V1]])
anatofuz
parents:
diff changeset
64 id arr = @[a, b];
anatofuz
parents:
diff changeset
65
anatofuz
parents:
diff changeset
66 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
67 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
68 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
69 // CHECK-NEXT: ret void
anatofuz
parents:
diff changeset
70 }
anatofuz
parents:
diff changeset
71
anatofuz
parents:
diff changeset
72 // CHECK-LABEL: define void @test_dictionary
anatofuz
parents:
diff changeset
73 void test_dictionary(id k1, id o1, id k2, id o2) {
anatofuz
parents:
diff changeset
74 // CHECK: [[K1:%.*]] = alloca i8*,
anatofuz
parents:
diff changeset
75 // CHECK: [[O1:%.*]] = alloca i8*,
anatofuz
parents:
diff changeset
76 // CHECK: [[K2:%.*]] = alloca i8*,
anatofuz
parents:
diff changeset
77 // CHECK: [[O2:%.*]] = alloca i8*,
anatofuz
parents:
diff changeset
78
anatofuz
parents:
diff changeset
79 // Retaining parameters
anatofuz
parents:
diff changeset
80 // CHECK: call i8* @llvm.objc.retain(i8*
anatofuz
parents:
diff changeset
81 // CHECK: call i8* @llvm.objc.retain(i8*
anatofuz
parents:
diff changeset
82 // CHECK: call i8* @llvm.objc.retain(i8*
anatofuz
parents:
diff changeset
83 // CHECK: call i8* @llvm.objc.retain(i8*
anatofuz
parents:
diff changeset
84
anatofuz
parents:
diff changeset
85 // Constructing the arrays
anatofuz
parents:
diff changeset
86 // CHECK: [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[KEYS:%[A-Za-z0-9]+]], i64 0, i64 0
anatofuz
parents:
diff changeset
87 // CHECK-NEXT: [[V0:%.*]] = load i8*, i8** [[K1]],
anatofuz
parents:
diff changeset
88 // CHECK-NEXT: store i8* [[V0]], i8** [[T0]]
anatofuz
parents:
diff changeset
89 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS:%[A-Za-z0-9]+]], i64 0, i64 0
anatofuz
parents:
diff changeset
90 // CHECK-NEXT: [[V1:%.*]] = load i8*, i8** [[O1]],
anatofuz
parents:
diff changeset
91 // CHECK-NEXT: store i8* [[V1]], i8** [[T0]]
anatofuz
parents:
diff changeset
92 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[KEYS]], i64 0, i64 1
anatofuz
parents:
diff changeset
93 // CHECK-NEXT: [[V2:%.*]] = load i8*, i8** [[K2]],
anatofuz
parents:
diff changeset
94 // CHECK-NEXT: store i8* [[V2]], i8** [[T0]]
anatofuz
parents:
diff changeset
95 // CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* [[OBJECTS]], i64 0, i64 1
anatofuz
parents:
diff changeset
96 // CHECK-NEXT: [[V3:%.*]] = load i8*, i8** [[O2]],
anatofuz
parents:
diff changeset
97 // CHECK-NEXT: store i8* [[V3]], i8** [[T0]]
anatofuz
parents:
diff changeset
98
anatofuz
parents:
diff changeset
99 // Constructing the dictionary
anatofuz
parents:
diff changeset
100 // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T:%.*]]*, [[CLASS_T:%.*]]** @"OBJC_CLASSLIST
anatofuz
parents:
diff changeset
101 // CHECK-NEXT: [[SEL:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES
anatofuz
parents:
diff changeset
102 // CHECK-NEXT: [[T1:%.*]] = bitcast [[CLASS_T]]* [[T0]] to i8*
anatofuz
parents:
diff changeset
103 // CHECK-NEXT: [[T2:%.*]] = bitcast [2 x i8*]* [[OBJECTS]] to i8**
anatofuz
parents:
diff changeset
104 // CHECK-NEXT: [[T3:%.*]] = bitcast [2 x i8*]* [[KEYS]] to i8**
anatofuz
parents:
diff changeset
105 // CHECK-NEXT: [[T4:%.*]] = call i8* bitcast ({{.*@objc_msgSend.*}})(i8* [[T1]], i8* [[SEL]], i8** [[T2]], i8** [[T3]], i64 2)
anatofuz
parents:
diff changeset
106 // CHECK-NEXT: [[T5:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T4]])
anatofuz
parents:
diff changeset
107 // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.use(i8* [[V0]], i8* [[V1]], i8* [[V2]], i8* [[V3]])
anatofuz
parents:
diff changeset
108
anatofuz
parents:
diff changeset
109 id dict = @{ k1 : o1, k2 : o2 };
anatofuz
parents:
diff changeset
110
anatofuz
parents:
diff changeset
111 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
112 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
113 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
114 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
115 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
116 // CHECK-NEXT: ret void
anatofuz
parents:
diff changeset
117 }
anatofuz
parents:
diff changeset
118
anatofuz
parents:
diff changeset
119 @interface A
anatofuz
parents:
diff changeset
120 @end
anatofuz
parents:
diff changeset
121
anatofuz
parents:
diff changeset
122 @interface B
anatofuz
parents:
diff changeset
123 @property (retain) A* prop;
anatofuz
parents:
diff changeset
124 @end
anatofuz
parents:
diff changeset
125
anatofuz
parents:
diff changeset
126 // CHECK-LABEL: define void @test_property
anatofuz
parents:
diff changeset
127 void test_property(B *b) {
anatofuz
parents:
diff changeset
128 // Retain parameter
anatofuz
parents:
diff changeset
129 // CHECK: call i8* @llvm.objc.retain
anatofuz
parents:
diff changeset
130
anatofuz
parents:
diff changeset
131 // CHECK: [[T0:%.*]] = getelementptr inbounds [1 x i8*], [1 x i8*]* [[OBJECTS:%.*]], i64 0, i64 0
anatofuz
parents:
diff changeset
132
anatofuz
parents:
diff changeset
133 // Invoke 'prop'
anatofuz
parents:
diff changeset
134 // CHECK: [[SEL:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES
anatofuz
parents:
diff changeset
135 // CHECK-NEXT: [[T1:%.*]] = bitcast
anatofuz
parents:
diff changeset
136 // CHECK-NEXT: [[T2:%.*]] = call [[B:%.*]]* bitcast ({{.*}} @objc_msgSend to {{.*}})(i8* [[T1]], i8* [[SEL]])
anatofuz
parents:
diff changeset
137 // CHECK-NEXT: [[T3:%.*]] = bitcast [[B]]* [[T2]] to i8*
anatofuz
parents:
diff changeset
138 // CHECK-NEXT: [[T4:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T3]])
anatofuz
parents:
diff changeset
139 // CHECK-NEXT: [[V0:%.*]] = bitcast i8* [[T4]] to [[B]]*
anatofuz
parents:
diff changeset
140 // CHECK-NEXT: [[V1:%.*]] = bitcast [[B]]* [[V0]] to i8*
anatofuz
parents:
diff changeset
141
anatofuz
parents:
diff changeset
142 // Store to array.
anatofuz
parents:
diff changeset
143 // CHECK-NEXT: store i8* [[V1]], i8** [[T0]]
anatofuz
parents:
diff changeset
144
anatofuz
parents:
diff changeset
145 // Invoke arrayWithObjects:count:
anatofuz
parents:
diff changeset
146 // CHECK-NEXT: [[T0:%.*]] = load [[CLASS_T]]*, [[CLASS_T]]** @"OBJC_CLASSLIST
anatofuz
parents:
diff changeset
147 // CHECK-NEXT: [[SEL:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES
anatofuz
parents:
diff changeset
148 // CHECK-NEXT: [[T1:%.*]] = bitcast [[CLASS_T]]* [[T0]] to i8*
anatofuz
parents:
diff changeset
149 // CHECK-NEXT: [[T2:%.*]] = bitcast [1 x i8*]* [[OBJECTS]] to i8**
anatofuz
parents:
diff changeset
150 // CHECK-NEXT: [[T3:%.*]] = call i8* bitcast ({{.*}} @objc_msgSend to {{.*}}(i8* [[T1]], i8* [[SEL]], i8** [[T2]], i64 1)
anatofuz
parents:
diff changeset
151 // CHECK-NEXT: call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T3]])
anatofuz
parents:
diff changeset
152 // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.use(i8* [[V1]])
anatofuz
parents:
diff changeset
153 // CHECK-NEXT: bitcast
anatofuz
parents:
diff changeset
154 // CHECK-NEXT: bitcast
anatofuz
parents:
diff changeset
155 // CHECK-NEXT: store
anatofuz
parents:
diff changeset
156 id arr = @[ b.prop ];
anatofuz
parents:
diff changeset
157
anatofuz
parents:
diff changeset
158 // Release b.prop
anatofuz
parents:
diff changeset
159 // CHECK-NEXT: [[T0:%.*]] = bitcast [[B]]* [[V0]] to i8*
anatofuz
parents:
diff changeset
160 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]])
anatofuz
parents:
diff changeset
161
anatofuz
parents:
diff changeset
162 // Destroy arr
anatofuz
parents:
diff changeset
163 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
164
anatofuz
parents:
diff changeset
165 // Destroy b
anatofuz
parents:
diff changeset
166 // CHECK: call void @llvm.objc.release
anatofuz
parents:
diff changeset
167 // CHECK-NEXT: ret void
anatofuz
parents:
diff changeset
168 }