]> git.saurik.com Git - apple/objc4.git/blame - test/msgSend.m
projects / apple / objc4.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
objc4-818.2.tar.gz
[apple/objc4.git] / test / msgSend.m
CommitLineData
13ba007e
A		 1/*
2asm-placeholder.exe is used below to disassemble objc_msgSend
3
4TEST_BUILD
5 $C{COMPILE} -x assembler $DIR/asm-placeholder.s -o asm-placeholder.exe
6 $C{COMPILE} $DIR/msgSend.m -o msgSend.exe -Wno-unused-parameter -Wundeclared-selector -D__DARWIN_OPAQUE_ARM_THREAD_STATE64=1
7END
8*/
9
10#include "test.h"
11#include "testroot.i"
12
1807f628 13#include <libkern/OSCacheControl.h>
13ba007e
A		 14#include <sys/stat.h>
15#include <objc/objc.h>
16#include <objc/runtime.h>
17#include <objc/objc-internal.h>
18#include <objc/objc-abi.h>
19#include <simd/simd.h>
20#include <mach-o/loader.h>
21
22// rdar://21694990 simd.h should have a vector_equal(a, b) function
23static bool vector_equal(vector_ulong2 lhs, vector_ulong2 rhs) {
24 return vector_all(lhs == rhs);
25}
26
27#if __arm64__
28 // no stret dispatchers
29# define SUPPORT_STRET 0
30# define objc_msgSend_stret objc_msgSend
31# define objc_msgSendSuper2_stret objc_msgSendSuper2
32# define objc_msgSend_stret_debug objc_msgSend_debug
33# define objc_msgSendSuper2_stret_debug objc_msgSendSuper2_debug
34# define objc_msgLookup_stret objc_msgLookup
35# define objc_msgLookupSuper2_stret objc_msgLookupSuper2
36# define method_invoke_stret method_invoke
37#else
38# define SUPPORT_STRET 1
39#endif
40
41
42#if defined(__arm__)
43// rdar://8331406
44# define ALIGN_()
45#else
46# define ALIGN_() asm(".align 4");
47#endif
48
49@interface Super : TestRoot @end
50
51@interface Sub : Super @end
52
53static int state = 0;
54
55static id SELF;
56
57// for typeof() shorthand only
58id (*idmsg0)(id, SEL) __attribute__((unused));
59long long (*llmsg0)(id, SEL) __attribute__((unused));
60// struct stret (*stretmsg0)(id, SEL) __attribute__((unused));
61double (*fpmsg0)(id, SEL) __attribute__((unused));
62long double (*lfpmsg0)(id, SEL) __attribute__((unused));
63vector_ulong2 (*vecmsg0)(id, SEL) __attribute__((unused));
64
65#define VEC1 ((vector_ulong2){1, 1})
66#define VEC2 ((vector_ulong2){2, 2})
67#define VEC3 ((vector_ulong2){3, 3})
68#define VEC4 ((vector_ulong2){4, 4})
69#define VEC5 ((vector_ulong2){5, 5})
70#define VEC6 ((vector_ulong2){6, 6})
71#define VEC7 ((vector_ulong2){7, 7})
72#define VEC8 ((vector_ulong2){8, 8})
73
74#define CHECK_ARGS(sel) \
75do { \
76 testassert(self == SELF); \
77 testassert(_cmd == sel_registerName(#sel "::::::::::::::::::::::::::::::::::::"));\
78 testassert(i1 == 1); \
79 testassert(i2 == 2); \
80 testassert(i3 == 3); \
81 testassert(i4 == 4); \
82 testassert(i5 == 5); \
83 testassert(i6 == 6); \
84 testassert(i7 == 7); \
85 testassert(i8 == 8); \
86 testassert(i9 == 9); \
87 testassert(i10 == 10); \
88 testassert(i11 == 11); \
89 testassert(i12 == 12); \
90 testassert(i13 == 13); \
91 testassert(f1 == 1.0); \
92 testassert(f2 == 2.0); \
93 testassert(f3 == 3.0); \
94 testassert(f4 == 4.0); \
95 testassert(f5 == 5.0); \
96 testassert(f6 == 6.0); \
97 testassert(f7 == 7.0); \
98 testassert(f8 == 8.0); \
99 testassert(f9 == 9.0); \
100 testassert(f10 == 10.0); \
101 testassert(f11 == 11.0); \
102 testassert(f12 == 12.0); \
103 testassert(f13 == 13.0); \
104 testassert(f14 == 14.0); \
105 testassert(f15 == 15.0); \
106 testassert(vector_all(v1 == 1)); \
107 testassert(vector_all(v2 == 2)); \
108 testassert(vector_all(v3 == 3)); \
109 testassert(vector_all(v4 == 4)); \
110 testassert(vector_all(v5 == 5)); \
111 testassert(vector_all(v6 == 6)); \
112 testassert(vector_all(v7 == 7)); \
113 testassert(vector_all(v8 == 8)); \
114} while (0)
115
116#define CHECK_ARGS_NOARG(sel) \
117do { \
118 testassert(self == SELF); \
119 testassert(_cmd == sel_registerName(#sel "_noarg"));\
120} while (0)
121
122id NIL_RECEIVER;
123id ID_RESULT;
124long long LL_RESULT = __LONG_LONG_MAX__ - 2LL*__INT_MAX__;
125double FP_RESULT = __DBL_MIN__ + __DBL_EPSILON__;
126long double LFP_RESULT = __LDBL_MIN__ + __LDBL_EPSILON__;
127vector_ulong2 VEC_RESULT = { 0x1234567890abcdefULL, 0xfedcba0987654321ULL };
128// STRET_RESULT in test.h
129
130static struct stret zero;
131
132struct stret_i1 {
133 uintptr_t i1;
134};
135struct stret_i2 {
136 uintptr_t i1;
137 uintptr_t i2;
138};
139struct stret_i3 {
140 uintptr_t i1;
141 uintptr_t i2;
142 uintptr_t i3;
143};
144struct stret_i4 {
145 uintptr_t i1;
146 uintptr_t i2;
147 uintptr_t i3;
148};
149struct stret_i5 {
150 uintptr_t i1;
151 uintptr_t i2;
152 uintptr_t i3;
153 uintptr_t i4;
154 uintptr_t i5;
155};
156struct stret_i6 {
157 uintptr_t i1;
158 uintptr_t i2;
159 uintptr_t i3;
160 uintptr_t i4;
161 uintptr_t i5;
162 uintptr_t i6;
163};
164struct stret_i7 {
165 uintptr_t i1;
166 uintptr_t i2;
167 uintptr_t i3;
168 uintptr_t i4;
169 uintptr_t i5;
170 uintptr_t i6;
171 uintptr_t i7;
172};
173struct stret_i8 {
174 uintptr_t i1;
175 uintptr_t i2;
176 uintptr_t i3;
177 uintptr_t i4;
178 uintptr_t i5;
179 uintptr_t i8;
180 uintptr_t i9;
181};
182struct stret_i9 {
183 uintptr_t i1;
184 uintptr_t i2;
185 uintptr_t i3;
186 uintptr_t i4;
187 uintptr_t i5;
188 uintptr_t i6;
189 uintptr_t i7;
190 uintptr_t i8;
191 uintptr_t i9;
192};
193
194struct stret_d1 {
195 double d1;
196};
197struct stret_d2 {
198 double d1;
199 double d2;
200};
201struct stret_d3 {
202 double d1;
203 double d2;
204 double d3;
205};
206struct stret_d4 {
207 double d1;
208 double d2;
209 double d3;
210};
211struct stret_d5 {
212 double d1;
213 double d2;
214 double d3;
215 double d4;
216 double d5;
217};
218struct stret_d6 {
219 double d1;
220 double d2;
221 double d3;
222 double d4;
223 double d5;
224 double d6;
225};
226struct stret_d7 {
227 double d1;
228 double d2;
229 double d3;
230 double d4;
231 double d5;
232 double d6;
233 double d7;
234};
235struct stret_d8 {
236 double d1;
237 double d2;
238 double d3;
239 double d4;
240 double d5;
241 double d8;
242 double d9;
243};
244struct stret_d9 {
245 double d1;
246 double d2;
247 double d3;
248 double d4;
249 double d5;
250 double d6;
251 double d7;
252 double d8;
253 double d9;
254};
255
256
257@interface Super (Prototypes)
258
259// Method prototypes to pacify -Wundeclared-selector.
260
261-(id)idret:
262 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15;
263
264-(long long)llret:
265 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15;
266
267-(struct stret)stret:
268 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15;
269
270-(double)fpret:
271 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15;
272
273-(long double)lfpret:
274 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15;
275
276-(vector_ulong2)vecret:
277 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15;
278
279@end
280
281
282// Zero all volatile registers.
283#if __cplusplus
284extern "C"
285#endif
286void stomp(void);
287
288#if __x86_64__
289asm("\n .text"
290 "\n .globl _stomp"
291 "\n _stomp:"
292 "\n mov $0, %rax"
293 "\n mov $0, %rcx"
294 "\n mov $0, %rdx"
295 "\n mov $0, %rsi"
296 "\n mov $0, %rdi"
297 "\n mov $0, %r8"
298 "\n mov $0, %r9"
299 "\n mov $0, %r10"
300 "\n mov $0, %r11"
301 "\n xorps %xmm0, %xmm0"
302 "\n xorps %xmm1, %xmm1"
303 "\n xorps %xmm2, %xmm2"
304 "\n xorps %xmm3, %xmm3"
305 "\n xorps %xmm4, %xmm4"
306 "\n xorps %xmm5, %xmm5"
307 "\n xorps %xmm6, %xmm6"
308 "\n xorps %xmm7, %xmm7"
309 "\n xorps %xmm8, %xmm8"
310 "\n xorps %xmm9, %xmm9"
311 "\n xorps %xmm10, %xmm10"
312 "\n xorps %xmm11, %xmm11"
313 "\n xorps %xmm12, %xmm12"
314 "\n xorps %xmm13, %xmm13"
315 "\n xorps %xmm14, %xmm14"
316 "\n xorps %xmm15, %xmm15"
317 "\n ret");
318
319#elif __i386__
320asm("\n .text"
321 "\n .globl _stomp"
322 "\n _stomp:"
323 "\n mov $0, %eax"
324 "\n mov $0, %ecx"
325 "\n mov $0, %edx"
326 "\n xorps %xmm0, %xmm0"
327 "\n xorps %xmm1, %xmm1"
328 "\n xorps %xmm2, %xmm2"
329 "\n xorps %xmm3, %xmm3"
330 "\n xorps %xmm4, %xmm4"
331 "\n xorps %xmm5, %xmm5"
332 "\n xorps %xmm6, %xmm6"
333 "\n xorps %xmm7, %xmm7"
334 "\n ret");
335
336#elif __arm64__
337asm("\n .text"
338 "\n .globl _stomp"
339 "\n _stomp:"
340 "\n mov x0, #0"
341 "\n mov x1, #0"
342 "\n mov x2, #0"
343 "\n mov x3, #0"
344 "\n mov x4, #0"
345 "\n mov x5, #0"
346 "\n mov x6, #0"
347 "\n mov x7, #0"
348 "\n mov x8, #0"
349 "\n mov x9, #0"
350 "\n mov x10, #0"
351 "\n mov x11, #0"
352 "\n mov x12, #0"
353 "\n mov x13, #0"
354 "\n mov x14, #0"
355 "\n mov x15, #0"
356 "\n mov x16, #0"
357 "\n mov x17, #0"
358 "\n movi d0, #0"
359 "\n movi d1, #0"
360 "\n movi d2, #0"
361 "\n movi d3, #0"
362 "\n movi d4, #0"
363 "\n movi d5, #0"
364 "\n movi d6, #0"
365 "\n movi d7, #0"
366 "\n ret"
367 );
368
369#elif __arm__
370asm("\n .text"
371 "\n .globl _stomp"
372 "\n .thumb_func _stomp"
373 "\n _stomp:"
374 "\n mov r0, #0"
375 "\n mov r1, #0"
376 "\n mov r2, #0"
377 "\n mov r3, #0"
378 "\n mov r9, #0"
379 "\n mov r12, #0"
380 "\n vmov.i32 q0, #0"
381 "\n vmov.i32 q1, #0"
382 "\n vmov.i32 q2, #0"
383 "\n vmov.i32 q3, #0"
384 "\n vmov.i32 q8, #0"
385 "\n vmov.i32 q9, #0"
386 "\n vmov.i32 q10, #0"
387 "\n vmov.i32 q11, #0"
388 "\n vmov.i32 q12, #0"
389 "\n vmov.i32 q13, #0"
390 "\n vmov.i32 q14, #0"
391 "\n vmov.i32 q15, #0"
392 "\n bx lr"
393 );
394
395#else
396# error unknown architecture
397#endif
398
399
400@implementation Super
401-(struct stret)stret { return STRET_RESULT; }
402
403// The IMPL_ methods are not called directly. Instead the non IMPL_ name is
404// called. The resolver function installs the real method. This allows
405// the resolver function to stomp on registers to help test register
406// preservation in the uncached path.
407
408+(BOOL) resolveInstanceMethod:(SEL)sel
409{
410 const char *name = sel_getName(sel);
411 if (! strstr(name, "::::::::")) return false;
412
413 testprintf("resolving %s\n", name);
414
415 stomp();
416 char *realName;
417 asprintf(&realName, "IMPL_%s", name);
418 SEL realSel = sel_registerName(realName);
419 free(realName);
420
421 IMP imp = class_getMethodImplementation(self, realSel);
422 if (imp == &_objc_msgForward) return false;
423 return class_addMethod(self, sel, imp, "");
424}
425
426-(id)IMPL_idret:
427(vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
428{
429 CHECK_ARGS(idret);
430 state = 1;
431 return ID_RESULT;
432}
433
434-(long long)IMPL_llret:
435 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
436{
437 CHECK_ARGS(llret);
438 state = 2;
439 return LL_RESULT;
440}
441
442-(struct stret)IMPL_stret:
443 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
444{
445 CHECK_ARGS(stret);
446 state = 3;
447 return STRET_RESULT;
448}
449
450-(double)IMPL_fpret:
451 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
452{
453 CHECK_ARGS(fpret);
454 state = 4;
455 return FP_RESULT;
456}
457
458-(long double)IMPL_lfpret:
459 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
460{
461 CHECK_ARGS(lfpret);
462 state = 5;
463 return LFP_RESULT;
464}
465
466-(vector_ulong2)IMPL_vecret:
467 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
468{
469 CHECK_ARGS(vecret);
470 state = 6;
471 return VEC_RESULT;
472}
473
474
475-(id)idret_noarg
476{
477 CHECK_ARGS_NOARG(idret);
478 state = 11;
479 return ID_RESULT;
480}
481
482-(long long)llret_noarg
483{
484 CHECK_ARGS_NOARG(llret);
485 state = 12;
486 return LL_RESULT;
487}
488
489-(struct stret)stret_noarg
490{
491 CHECK_ARGS_NOARG(stret);
492 state = 13;
493 return STRET_RESULT;
494}
495
496-(double)fpret_noarg
497{
498 CHECK_ARGS_NOARG(fpret);
499 state = 14;
500 return FP_RESULT;
501}
502
503-(long double)lfpret_noarg
504{
505 CHECK_ARGS_NOARG(lfpret);
506 state = 15;
507 return LFP_RESULT;
508}
509
510-(vector_ulong2)vecret_noarg
511{
512 CHECK_ARGS_NOARG(vecret);
513 state = 16;
514 return VEC_RESULT;
515}
516
517
518-(struct stret)stret_nop
519{
520 return STRET_RESULT;
521}
522
523
524#define STRET_IMP(n) \
525+(struct stret_##n)stret_##n##_zero \
526{ \
527 struct stret_##n ret; \
528 bzero(&ret, sizeof(ret)); \
529 return ret; \
530} \
531+(struct stret_##n)stret_##n##_nonzero \
532{ \
533 struct stret_##n ret; \
534 memset(&ret, 0xff, sizeof(ret)); \
535 return ret; \
536}
537
538STRET_IMP(i1)
539STRET_IMP(i2)
540STRET_IMP(i3)
541STRET_IMP(i4)
542STRET_IMP(i5)
543STRET_IMP(i6)
544STRET_IMP(i7)
545STRET_IMP(i8)
546STRET_IMP(i9)
547
548STRET_IMP(d1)
549STRET_IMP(d2)
550STRET_IMP(d3)
551STRET_IMP(d4)
552STRET_IMP(d5)
553STRET_IMP(d6)
554STRET_IMP(d7)
555STRET_IMP(d8)
556STRET_IMP(d9)
557
558
559+(id)idret:
560 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
561{
562 fail("+idret called instead of -idret");
563 CHECK_ARGS(idret);
564}
565
566+(long long)llret:
567 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
568{
569 fail("+llret called instead of -llret");
570 CHECK_ARGS(llret);
571}
572
573+(struct stret)stret:
574 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
575{
576 fail("+stret called instead of -stret");
577 CHECK_ARGS(stret);
578}
579
580+(double)fpret:
581 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
582{
583 fail("+fpret called instead of -fpret");
584 CHECK_ARGS(fpret);
585}
586
587+(long double)lfpret:
588 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
589{
590 fail("+lfpret called instead of -lfpret");
591 CHECK_ARGS(lfpret);
592}
593
594+(id)idret_noarg
595{
596 fail("+idret_noarg called instead of -idret_noarg");
597 CHECK_ARGS_NOARG(idret);
598}
599
600+(long long)llret_noarg
601{
602 fail("+llret_noarg called instead of -llret_noarg");
603 CHECK_ARGS_NOARG(llret);
604}
605
606+(struct stret)stret_noarg
607{
608 fail("+stret_noarg called instead of -stret_noarg");
609 CHECK_ARGS_NOARG(stret);
610}
611
612+(double)fpret_noarg
613{
614 fail("+fpret_noarg called instead of -fpret_noarg");
615 CHECK_ARGS_NOARG(fpret);
616}
617
618+(long double)lfpret_noarg
619{
620 fail("+lfpret_noarg called instead of -lfpret_noarg");
621 CHECK_ARGS_NOARG(lfpret);
622}
623
624+(vector_ulong2)vecret_noarg
625{
626 fail("+vecret_noarg called instead of -vecret_noarg");
627 CHECK_ARGS_NOARG(vecret);
628}
629
630@end
631
632
633@implementation Sub
634
635-(id)IMPL_idret:
636 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
637{
638 id result;
639 CHECK_ARGS(idret);
640 state = 100;
641 result = [super idret:v1:v2:v3:v4:v5:v6:v7:v8:i1:i2:i3:i4:i5:i6:i7:i8:i9:i10:i11:i12:i13:f1:f2:f3:f4:f5:f6:f7:f8:f9:f10:f11:f12:f13:f14:f15];
642 testassert(state == 1);
643 testassert(result == ID_RESULT);
644 state = 101;
645 return result;
646}
647
648-(long long)IMPL_llret:
649 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
650{
651 long long result;
652 CHECK_ARGS(llret);
653 state = 100;
654 result = [super llret:v1:v2:v3:v4:v5:v6:v7:v8:i1:i2:i3:i4:i5:i6:i7:i8:i9:i10:i11:i12:i13:f1:f2:f3:f4:f5:f6:f7:f8:f9:f10:f11:f12:f13:f14:f15];
655 testassert(state == 2);
656 testassert(result == LL_RESULT);
657 state = 102;
658 return result;
659}
660
661-(struct stret)IMPL_stret:
662 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
663{
664 struct stret result;
665 CHECK_ARGS(stret);
666 state = 100;
667 result = [super stret:v1:v2:v3:v4:v5:v6:v7:v8:i1:i2:i3:i4:i5:i6:i7:i8:i9:i10:i11:i12:i13:f1:f2:f3:f4:f5:f6:f7:f8:f9:f10:f11:f12:f13:f14:f15];
668 testassert(state == 3);
669 testassert(stret_equal(result, STRET_RESULT));
670 state = 103;
671 return result;
672}
673
674-(double)IMPL_fpret:
675 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
676{
677 double result;
678 CHECK_ARGS(fpret);
679 state = 100;
680 result = [super fpret:v1:v2:v3:v4:v5:v6:v7:v8:i1:i2:i3:i4:i5:i6:i7:i8:i9:i10:i11:i12:i13:f1:f2:f3:f4:f5:f6:f7:f8:f9:f10:f11:f12:f13:f14:f15];
681 testassert(state == 4);
682 testassert(result == FP_RESULT);
683 state = 104;
684 return result;
685}
686
687-(long double)IMPL_lfpret:
688 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
689{
690 long double result;
691 CHECK_ARGS(lfpret);
692 state = 100;
693 result = [super lfpret:v1:v2:v3:v4:v5:v6:v7:v8:i1:i2:i3:i4:i5:i6:i7:i8:i9:i10:i11:i12:i13:f1:f2:f3:f4:f5:f6:f7:f8:f9:f10:f11:f12:f13:f14:f15];
694 testassert(state == 5);
695 testassert(result == LFP_RESULT);
696 state = 105;
697 return result;
698}
699
700-(vector_ulong2)IMPL_vecret:
701 (vector_ulong2)v1 :(vector_ulong2)v2 :(vector_ulong2)v3 :(vector_ulong2)v4 :(vector_ulong2)v5 :(vector_ulong2)v6 :(vector_ulong2)v7 :(vector_ulong2)v8 :(int)i1 :(int)i2 :(int)i3 :(int)i4 :(int)i5 :(int)i6 :(int)i7 :(int)i8 :(int)i9 :(int)i10 :(int)i11 :(int)i12 :(int)i13 :(double)f1 :(double)f2 :(double)f3 :(double)f4 :(double)f5 :(double)f6 :(double)f7 :(double)f8 :(double)f9 :(double)f10 :(double)f11 :(double)f12 :(double)f13 :(double)f14 :(double)f15
702{
703 vector_ulong2 result;
704 CHECK_ARGS(vecret);
705 state = 100;
706 result = [super vecret:v1:v2:v3:v4:v5:v6:v7:v8:i1:i2:i3:i4:i5:i6:i7:i8:i9:i10:i11:i12:i13:f1:f2:f3:f4:f5:f6:f7:f8:f9:f10:f11:f12:f13:f14:f15];
707 testassert(state == 6);
708 testassert(vector_equal(result, VEC_RESULT));
709 state = 106;
710 return result;
711}
712
713
714-(id)idret_noarg
715{
716 id result;
717 CHECK_ARGS_NOARG(idret);
718 state = 100;
719 result = [super idret_noarg];
720 testassert(state == 11);
721 testassert(result == ID_RESULT);
722 state = 111;
723 return result;
724}
725
726-(long long)llret_noarg
727{
728 long long result;
729 CHECK_ARGS_NOARG(llret);
730 state = 100;
731 result = [super llret_noarg];
732 testassert(state == 12);
733 testassert(result == LL_RESULT);
734 state = 112;
735 return result;
736}
737
738-(struct stret)stret_noarg
739{
740 struct stret result;
741 CHECK_ARGS_NOARG(stret);
742 state = 100;
743 result = [super stret_noarg];
744 testassert(state == 13);
745 testassert(stret_equal(result, STRET_RESULT));
746 state = 113;
747 return result;
748}
749
750-(double)fpret_noarg
751{
752 double result;
753 CHECK_ARGS_NOARG(fpret);
754 state = 100;
755 result = [super fpret_noarg];
756 testassert(state == 14);
757 testassert(result == FP_RESULT);
758 state = 114;
759 return result;
760}
761
762-(long double)lfpret_noarg
763{
764 long double result;
765 CHECK_ARGS_NOARG(lfpret);
766 state = 100;
767 result = [super lfpret_noarg];
768 testassert(state == 15);
769 testassert(result == LFP_RESULT);
770 state = 115;
771 return result;
772}
773
774-(vector_ulong2)vecret_noarg
775{
776 vector_ulong2 result;
777 CHECK_ARGS_NOARG(vecret);
778 state = 100;
779 result = [super vecret_noarg];
780 testassert(state == 16);
781 testassert(vector_equal(result, VEC_RESULT));
782 state = 116;
783 return result;
784}
785
786@end
787
788
789#if OBJC_HAVE_TAGGED_POINTERS
790
791@interface TaggedSub : Sub @end
792
793@implementation TaggedSub : Sub
794
795+(void)initialize
796{
797 _objc_registerTaggedPointerClass(OBJC_TAG_1, self);
798}
799
800@end
801
802@interface ExtTaggedSub : Sub @end
803
804@implementation ExtTaggedSub : Sub
805
806+(void)initialize
807{
808 _objc_registerTaggedPointerClass(OBJC_TAG_First52BitPayload, self);
809}
810
811@end
812
813#endif
814
815
816// DWARF checking machinery
817
818#if TARGET_OS_WIN32
819// unimplemented on this platform
820#define NO_DWARF_REASON "(windows)"
821
822#elif TARGET_OS_WATCH
823// fixme unimplemented - ucontext not passed to signal handlers
824#define NO_DWARF_REASON "(watchOS)"
825
826#elif __has_feature(objc_arc)
827// ARC's extra RR calls hit the traps at the wrong times
828#define NO_DWARF_REASON "(ARC)"
829
830#else
831
832#define TEST_DWARF 1
833
834// Classes with no implementations and no cache contents from elsewhere.
835@interface SuperDW : TestRoot @end
836@implementation SuperDW @end
837
838@interface Sub0DW : SuperDW @end
839@implementation Sub0DW @end
840
841@interface SubDW : Sub0DW @end
842@implementation SubDW @end
843
844#include <dlfcn.h>
845#include <signal.h>
846#include <sys/mman.h>
847#include <libunwind.h>
848
849bool caught = false;
850uintptr_t clobbered;
851
852__BEGIN_DECLS
853extern void callit(void *obj, void *sel, void *fn);
854extern struct stret callit_stret(void *obj, void *sel, void *fn);
855__END_DECLS
856
857#if __x86_64__
858
859typedef uint8_t insn_t;
860typedef insn_t clobbered_insn_t;
861#define BREAK_INSN ((insn_t)0x06) // undefined
862#define BREAK_SIGNAL SIGILL
863
864uintptr_t r12 = 0;
865uintptr_t r13 = 0;
866uintptr_t r14 = 0;
867uintptr_t r15 = 0;
868uintptr_t rbx = 0;
869uintptr_t rbp = 0;
870uintptr_t rsp = 0;
871uintptr_t rip = 0;
872
873void handle_exception(x86_thread_state64_t *state)
874{
875 unw_cursor_t curs;
876 unw_word_t reg;
877 int err;
878 int step;
879
880 err = unw_init_local(&curs, (unw_context_t *)state);
881 testassert(!err);
882
883 step = unw_step(&curs);
884 testassert(step > 0);
885
886 err = unw_get_reg(&curs, UNW_X86_64_R12, &reg);
887 testassert(!err);
888 testassert(reg == r12);
889
890 err = unw_get_reg(&curs, UNW_X86_64_R13, &reg);
891 testassert(!err);
892 testassert(reg == r13);
893
894 err = unw_get_reg(&curs, UNW_X86_64_R14, &reg);
895 testassert(!err);
896 testassert(reg == r14);
897
898 err = unw_get_reg(&curs, UNW_X86_64_R15, &reg);
899 testassert(!err);
900 testassert(reg == r15);
901
902 err = unw_get_reg(&curs, UNW_X86_64_RBX, &reg);
903 testassert(!err);
904 testassert(reg == rbx);
905
906 err = unw_get_reg(&curs, UNW_X86_64_RBP, &reg);
907 testassert(!err);
908 testassert(reg == rbp);
909
910 err = unw_get_reg(&curs, UNW_X86_64_RSP, &reg);
911 testassert(!err);
912 testassert(reg == rsp);
913
914 err = unw_get_reg(&curs, UNW_REG_IP, &reg);
915 testassert(!err);
916 testassert(reg == rip);
917
918
919 // set thread state to unwound state
920 state->__r12 = r12;
921 state->__r13 = r13;
922 state->__r14 = r14;
923 state->__r15 = r15;
924 state->__rbx = rbx;
925 state->__rbp = rbp;
926 state->__rsp = rsp;
927 state->__rip = rip;
928
929 caught = true;
930}
931
932
933void break_handler(int sig, siginfo_t *info, void *cc)
934{
935 ucontext_t *uc = (ucontext_t *)cc;
936 mcontext_t mc = (mcontext_t)uc->uc_mcontext;
937
938 testprintf(" handled\n");
939
940 testassert(sig == BREAK_SIGNAL);
941 testassert((uintptr_t)info->si_addr == clobbered);
942
943 handle_exception(&mc->__ss);
944 // handle_exception changed register state for continuation
945}
946
947__asm__(
948"\n .text"
949"\n .globl _callit"
950"\n _callit:"
951// save sp and return address to variables
952"\n movq (%rsp), %r10"
953"\n movq %r10, _rip(%rip)"
954"\n movq %rsp, _rsp(%rip)"
955"\n addq $8, _rsp(%rip)" // rewind to pre-call value
956// save other non-volatile registers to variables
957"\n movq %rbx, _rbx(%rip)"
958"\n movq %rbp, _rbp(%rip)"
959"\n movq %r12, _r12(%rip)"
960"\n movq %r13, _r13(%rip)"
961"\n movq %r14, _r14(%rip)"
962"\n movq %r15, _r15(%rip)"
963"\n jmpq *%rdx"
964 );
965
966__asm__(
967"\n .text"
968"\n .globl _callit_stret"
969"\n _callit_stret:"
970// save sp and return address to variables
971"\n movq (%rsp), %r10"
972"\n movq %r10, _rip(%rip)"
973"\n movq %rsp, _rsp(%rip)"
974"\n addq $8, _rsp(%rip)" // rewind to pre-call value
975// save other non-volatile registers to variables
976"\n movq %rbx, _rbx(%rip)"
977"\n movq %rbp, _rbp(%rip)"
978"\n movq %r12, _r12(%rip)"
979"\n movq %r13, _r13(%rip)"
980"\n movq %r14, _r14(%rip)"
981"\n movq %r15, _r15(%rip)"
982"\n jmpq *%rcx"
983 );
984
985
986// x86_64
987
988#elif __i386__
989
990typedef uint8_t insn_t;
991typedef insn_t clobbered_insn_t;
992#define BREAK_INSN ((insn_t)0xcc) // int3
993#define BREAK_SIGNAL SIGTRAP
994
995uintptr_t eip = 0;
996uintptr_t esp = 0;
997uintptr_t ebx = 0;
998uintptr_t ebp = 0;
999uintptr_t edi = 0;
1000uintptr_t esi = 0;
1001uintptr_t espfix = 0;
1002
1003void handle_exception(i386_thread_state_t *state)
1004{
1005 unw_cursor_t curs;
1006 unw_word_t reg;
1007 int err;
1008 int step;
1009
1010 err = unw_init_local(&curs, (unw_context_t *)state);
1011 testassert(!err);
1012
1013 step = unw_step(&curs);
1014 testassert(step > 0);
1015
1016 err = unw_get_reg(&curs, UNW_REG_IP, &reg);
1017 testassert(!err);
1018 testassert(reg == eip);
1019
1020 err = unw_get_reg(&curs, UNW_X86_ESP, &reg);
1021 testassert(!err);
1022 testassert(reg == esp);
1023
1024 err = unw_get_reg(&curs, UNW_X86_EBX, &reg);
1025 testassert(!err);
1026 testassert(reg == ebx);
1027
1028 err = unw_get_reg(&curs, UNW_X86_EBP, &reg);
1029 testassert(!err);
1030 testassert(reg == ebp);
1031
1032 err = unw_get_reg(&curs, UNW_X86_EDI, &reg);
1033 testassert(!err);
1034 testassert(reg == edi);
1035
1036 err = unw_get_reg(&curs, UNW_X86_ESI, &reg);
1037 testassert(!err);
1038 testassert(reg == esi);
1039
1040
1041 // set thread state to unwound state
1042 state->__eip = eip;
1043 state->__esp = esp + espfix;
1044 state->__ebx = ebx;
1045 state->__ebp = ebp;
1046 state->__edi = edi;
1047 state->__esi = esi;
1048
1049 caught = true;
1050}
1051
1052
1053void break_handler(int sig, siginfo_t *info, void *cc)
1054{
1055 ucontext_t *uc = (ucontext_t *)cc;
1056 mcontext_t mc = (mcontext_t)uc->uc_mcontext;
1057
1058 testprintf(" handled\n");
1059
1060 testassert(sig == BREAK_SIGNAL);
1061 testassert((uintptr_t)info->si_addr-1 == clobbered);
1062
1063 handle_exception(&mc->__ss);
1064 // handle_exception changed register state for continuation
1065}
1066
1067__asm__(
1068"\n .text"
1069"\n .globl _callit"
1070"\n _callit:"
1071// save sp and return address to variables
1072"\n call 1f"
1073"\n 1: popl %edx"
1074"\n movl (%esp), %eax"
1075"\n movl %eax, _eip-1b(%edx)"
1076"\n movl %esp, _esp-1b(%edx)"
1077"\n addl $4, _esp-1b(%edx)" // rewind to pre-call value
1078"\n movl $0, _espfix-1b(%edx)"
1079// save other non-volatile registers to variables
1080"\n movl %ebx, _ebx-1b(%edx)"
1081"\n movl %ebp, _ebp-1b(%edx)"
1082"\n movl %edi, _edi-1b(%edx)"
1083"\n movl %esi, _esi-1b(%edx)"
1084"\n jmpl *12(%esp)"
1085 );
1086
1087__asm__(
1088"\n .text"
1089"\n .globl _callit_stret"
1090"\n _callit_stret:"
1091// save sp and return address to variables
1092"\n call 1f"
1093"\n 1: popl %edx"
1094"\n movl (%esp), %eax"
1095"\n movl %eax, _eip-1b(%edx)"
1096"\n movl %esp, _esp-1b(%edx)"
1097"\n addl $4, _esp-1b(%edx)" // rewind to pre-call value
1098"\n movl $4, _espfix-1b(%edx)"
1099// save other non-volatile registers to variables
1100"\n movl %ebx, _ebx-1b(%edx)"
1101"\n movl %ebp, _ebp-1b(%edx)"
1102"\n movl %edi, _edi-1b(%edx)"
1103"\n movl %esi, _esi-1b(%edx)"
1104"\n jmpl *16(%esp)"
1105 );
1106
1107
1108// i386
1109#elif __arm64__
1110
1111#include <sys/ucontext.h>
1112
1113typedef uint32_t insn_t;
1114typedef insn_t clobbered_insn_t;
1115#define BREAK_INSN ((insn_t)0xd4200020) // brk #1
1116#define BREAK_SIGNAL SIGTRAP
1117
1118uintptr_t x19 = 0;
1119uintptr_t x20 = 0;
1120uintptr_t x21 = 0;
1121uintptr_t x22 = 0;
1122uintptr_t x23 = 0;
1123uintptr_t x24 = 0;
1124uintptr_t x25 = 0;
1125uintptr_t x26 = 0;
1126uintptr_t x27 = 0;
1127uintptr_t x28 = 0;
1128uintptr_t fp = 0;
1129uintptr_t sp = 0;
1130uintptr_t pc = 0;
1131
1132void handle_exception(arm_thread_state64_t *state)
1133{
1134 unw_cursor_t curs;
1135 unw_word_t reg;
1136 int err;
1137 int step;
1138
1139 // libunwind layout differs from mcontext layout
1140 // GPRs are the same but vector registers are not
1141 unw_context_t unwstate;
1142 unw_getcontext(&unwstate);
1143 memcpy(&unwstate, state, sizeof(*state));
1144
1145 // libunwind and xnu sign some pointers differently
1146 // xnu: not signed (fixme this may change?)
1147 // libunwind: PC and LR both signed with return address key and SP
1148 void **pcp = &((arm_thread_state64_t *)&unwstate)->__opaque_pc;
1149 *pcp = ptrauth_sign_unauthenticated((void*)__darwin_arm_thread_state64_get_pc(*state),
1150 ptrauth_key_return_address,
1151 (ptrauth_extra_data_t)__darwin_arm_thread_state64_get_sp(*state));
1152 void **lrp = &((arm_thread_state64_t *)&unwstate)->__opaque_lr;
1153 *lrp = ptrauth_sign_unauthenticated((void*)__darwin_arm_thread_state64_get_lr(*state),
1154 ptrauth_key_return_address,
1155 (ptrauth_extra_data_t)__darwin_arm_thread_state64_get_sp(*state));
1156
1157 err = unw_init_local(&curs, &unwstate);
1158 testassert(!err);
1159
1160 step = unw_step(&curs);
1161 testassert(step > 0);
1162
1163 err = unw_get_reg(&curs, UNW_ARM64_X19, &reg);
1164 testassert(!err);
1165 testassert(reg == x19);
1166
1167 err = unw_get_reg(&curs, UNW_ARM64_X20, &reg);
1168 testassert(!err);
1169 testassert(reg == x20);
1170
1171 err = unw_get_reg(&curs, UNW_ARM64_X21, &reg);
1172 testassert(!err);
1173 testassert(reg == x21);
1174
1175 err = unw_get_reg(&curs, UNW_ARM64_X22, &reg);
1176 testassert(!err);
1177 testassert(reg == x22);
1178
1179 err = unw_get_reg(&curs, UNW_ARM64_X23, &reg);
1180 testassert(!err);
1181 testassert(reg == x23);
1182
1183 err = unw_get_reg(&curs, UNW_ARM64_X24, &reg);
1184 testassert(!err);
1185 testassert(reg == x24);
1186
1187 err = unw_get_reg(&curs, UNW_ARM64_X25, &reg);
1188 testassert(!err);
1189 testassert(reg == x25);
1190
1191 err = unw_get_reg(&curs, UNW_ARM64_X26, &reg);
1192 testassert(!err);
1193 testassert(reg == x26);
1194
1195 err = unw_get_reg(&curs, UNW_ARM64_X27, &reg);
1196 testassert(!err);
1197 testassert(reg == x27);
1198
1199 err = unw_get_reg(&curs, UNW_ARM64_X28, &reg);
1200 testassert(!err);
1201 testassert(reg == x28);
1202
1203 err = unw_get_reg(&curs, UNW_ARM64_FP, &reg);
1204 testassert(!err);
1205 testassert(reg == fp);
1206
1207 err = unw_get_reg(&curs, UNW_ARM64_SP, &reg);
1208 testassert(!err);
1209 testassert(reg == sp);
1210
1211 err = unw_get_reg(&curs, UNW_REG_IP, &reg);
1212 testassert(!err);
1213 // libunwind's return is signed but our value is not
1214 reg = (uintptr_t)ptrauth_strip((void *)reg, ptrauth_key_return_address);
1215 testassert(reg == pc);
1216
1217 // libunwind restores PC into LR and doesn't track LR
1218 // err = unw_get_reg(&curs, UNW_ARM64_LR, &reg);
1219 // testassert(!err);
1220 // testassert(reg == lr);
1221
1222 // set signal handler's thread state to unwound state
1223 state->__x[19] = x19;
1224 state->__x[20] = x20;
1225 state->__x[21] = x21;
1226 state->__x[22] = x22;
1227 state->__x[23] = x23;
1228 state->__x[24] = x24;
1229 state->__x[25] = x25;
1230 state->__x[26] = x26;
1231 state->__x[27] = x27;
1232 state->__x[28] = x28;
1233 state->__opaque_fp = (void *)fp;
1234 state->__opaque_lr = (void *)pc; // libunwind restores PC into LR
1235 state->__opaque_sp = (void *)sp;
1236 state->__opaque_pc = (void *)pc;
1237
1238 caught = true;
1239}
1240
1241
1242void break_handler(int sig, siginfo_t *info, void *cc)
1243{
1244 ucontext_t *uc = (ucontext_t *)cc;
1245 struct __darwin_mcontext64 *mc = (struct __darwin_mcontext64 *)uc->uc_mcontext;
1246
1247 testprintf(" handled\n");
1248
1249 testassert(sig == BREAK_SIGNAL);
1250 testassert((uintptr_t)info->si_addr == clobbered);
1251
1252 handle_exception(&mc->__ss);
1253 // handle_exception changed register state for continuation
1254}
1255
1256
1257__asm__(
1258"\n .text"
1259"\n .globl _callit"
1260"\n _callit:"
1261// save sp and return address to variables
1262"\n mov x16, sp"
1263"\n adrp x17, _sp@PAGE"
1264"\n str x16, [x17, _sp@PAGEOFF]"
1265"\n adrp x17, _pc@PAGE"
1266"\n str lr, [x17, _pc@PAGEOFF]"
1267// save other non-volatile registers to variables
1268"\n adrp x17, _x19@PAGE"
1269"\n str x19, [x17, _x19@PAGEOFF]"
1270"\n adrp x17, _x19@PAGE"
1271"\n str x20, [x17, _x20@PAGEOFF]"
1272"\n adrp x17, _x19@PAGE"
1273"\n str x21, [x17, _x21@PAGEOFF]"
1274"\n adrp x17, _x19@PAGE"
1275"\n str x22, [x17, _x22@PAGEOFF]"
1276"\n adrp x17, _x19@PAGE"
1277"\n str x23, [x17, _x23@PAGEOFF]"
1278"\n adrp x17, _x19@PAGE"
1279"\n str x24, [x17, _x24@PAGEOFF]"
1280"\n adrp x17, _x19@PAGE"
1281"\n str x25, [x17, _x25@PAGEOFF]"
1282"\n adrp x17, _x19@PAGE"
1283"\n str x26, [x17, _x26@PAGEOFF]"
1284"\n adrp x17, _x19@PAGE"
1285"\n str x27, [x17, _x27@PAGEOFF]"
1286"\n adrp x17, _x19@PAGE"
1287"\n str x28, [x17, _x28@PAGEOFF]"
1288"\n adrp x17, _x19@PAGE"
1289"\n str fp, [x17, _fp@PAGEOFF]"
1290"\n br x2"
1291 );
1292
1293
1294// arm64
1295#elif __arm__
1296
1297#include <sys/ucontext.h>
1298
1299typedef uint16_t insn_t;
1300typedef struct {
1301 insn_t first;
1302 insn_t second;
1303 bool thirty_two;
1304} clobbered_insn_t;
1305#define BREAK_INSN ((insn_t)0xdefe) // trap
1306#define BREAK_SIGNAL SIGILL
1307#define BREAK_SIGNAL2 SIGTRAP
1308
1309uintptr_t r4 = 0;
1310uintptr_t r5 = 0;
1311uintptr_t r6 = 0;
1312uintptr_t r7 = 0;
1313uintptr_t r8 = 0;
1314uintptr_t r10 = 0;
1315uintptr_t r11 = 0;
1316uintptr_t sp = 0;
1317uintptr_t pc = 0;
1318
1319void handle_exception(arm_thread_state_t *state)
1320{
1321 // No unwind tables on this architecture so no libunwind checks.
1322 // We run the test anyway to verify instruction-level coverage.
1323
1324 // set thread state to unwound state
1325 state->__r[4] = r4;
1326 state->__r[5] = r5;
1327 state->__r[6] = r6;
1328 state->__r[7] = r7;
1329 state->__r[8] = r8;
1330 state->__r[10] = r10;
1331 state->__r[11] = r11;
1332 state->__sp = sp;
1333 state->__pc = pc;
1334 // clear IT... bits so caller doesn't act on them
1335 state->__cpsr &= ~0x0600fc00;
1336
1337 caught = true;
1338}
1339
1340
1341void break_handler(int sig, siginfo_t *info, void *cc)
1342{
1343 ucontext_t *uc = (ucontext_t *)cc;
1344 struct __darwin_mcontext32 *mc = (struct __darwin_mcontext32 *)uc->uc_mcontext;
1345
1346 testprintf(" handled\n");
1347
1348 testassert(sig == BREAK_SIGNAL || sig == BREAK_SIGNAL2);
1349 testassert((uintptr_t)info->si_addr == clobbered);
1350
1351 handle_exception(&mc->__ss);
1352 // handle_exception changed register state for continuation
1353}
1354
1355
1356__asm__(
1357"\n .text"
1358"\n .syntax unified"
1359"\n .code 16"
1360"\n .align 5"
1361"\n .globl _callit"
1362"\n .thumb_func"
1363"\n _callit:"
1364// save sp and return address to variables
1365"\n movw r12, :lower16:(_sp-1f-4)"
1366"\n movt r12, :upper16:(_sp-1f-4)"
1367"\n 1: add r12, pc"
1368"\n str sp, [r12]"
1369"\n movw r12, :lower16:(_pc-1f-4)"
1370"\n movt r12, :upper16:(_pc-1f-4)"
1371"\n 1: add r12, pc"
1372"\n str lr, [r12]"
1373// save other non-volatile registers to variables
1374"\n movw r12, :lower16:(_r4-1f-4)"
1375"\n movt r12, :upper16:(_r4-1f-4)"
1376"\n 1: add r12, pc"
1377"\n str r4, [r12]"
1378"\n movw r12, :lower16:(_r5-1f-4)"
1379"\n movt r12, :upper16:(_r5-1f-4)"
1380"\n 1: add r12, pc"
1381"\n str r5, [r12]"
1382"\n movw r12, :lower16:(_r6-1f-4)"
1383"\n movt r12, :upper16:(_r6-1f-4)"
1384"\n 1: add r12, pc"
1385"\n str r6, [r12]"
1386"\n movw r12, :lower16:(_r7-1f-4)"
1387"\n movt r12, :upper16:(_r7-1f-4)"
1388"\n 1: add r12, pc"
1389"\n str r7, [r12]"
1390"\n movw r12, :lower16:(_r8-1f-4)"
1391"\n movt r12, :upper16:(_r8-1f-4)"
1392"\n 1: add r12, pc"
1393"\n str r8, [r12]"
1394"\n movw r12, :lower16:(_r10-1f-4)"
1395"\n movt r12, :upper16:(_r10-1f-4)"
1396"\n 1: add r12, pc"
1397"\n str r10, [r12]"
1398"\n movw r12, :lower16:(_r11-1f-4)"
1399"\n movt r12, :upper16:(_r11-1f-4)"
1400"\n 1: add r12, pc"
1401"\n str r11, [r12]"
1402"\n bx r2"
1403 );
1404
1405__asm__(
1406"\n .text"
1407"\n .syntax unified"
1408"\n .code 16"
1409"\n .align 5"
1410"\n .globl _callit_stret"
1411"\n .thumb_func"
1412"\n _callit_stret:"
1413// save sp and return address to variables
1414"\n movw r12, :lower16:(_sp-1f-4)"
1415"\n movt r12, :upper16:(_sp-1f-4)"
1416"\n 1: add r12, pc"
1417"\n str sp, [r12]"
1418"\n movw r12, :lower16:(_pc-1f-4)"
1419"\n movt r12, :upper16:(_pc-1f-4)"
1420"\n 1: add r12, pc"
1421"\n str lr, [r12]"
1422// save other non-volatile registers to variables
1423"\n movw r12, :lower16:(_r4-1f-4)"
1424"\n movt r12, :upper16:(_r4-1f-4)"
1425"\n 1: add r12, pc"
1426"\n str r4, [r12]"
1427"\n movw r12, :lower16:(_r5-1f-4)"
1428"\n movt r12, :upper16:(_r5-1f-4)"
1429"\n 1: add r12, pc"
1430"\n str r5, [r12]"
1431"\n movw r12, :lower16:(_r6-1f-4)"
1432"\n movt r12, :upper16:(_r6-1f-4)"
1433"\n 1: add r12, pc"
1434"\n str r6, [r12]"
1435"\n movw r12, :lower16:(_r7-1f-4)"
1436"\n movt r12, :upper16:(_r7-1f-4)"
1437"\n 1: add r12, pc"
1438"\n str r7, [r12]"
1439"\n movw r12, :lower16:(_r8-1f-4)"
1440"\n movt r12, :upper16:(_r8-1f-4)"
1441"\n 1: add r12, pc"
1442"\n str r8, [r12]"
1443"\n movw r12, :lower16:(_r10-1f-4)"
1444"\n movt r12, :upper16:(_r10-1f-4)"
1445"\n 1: add r12, pc"
1446"\n str r10, [r12]"
1447"\n movw r12, :lower16:(_r11-1f-4)"
1448"\n movt r12, :upper16:(_r11-1f-4)"
1449"\n 1: add r12, pc"
1450"\n str r11, [r12]"
1451"\n bx r3"
1452 );
1453
1454
1455// arm
1456#else
1457
1458#error unknown architecture
1459
1460#endif
1461
1462
1463#if __arm__
1464uintptr_t fnaddr(void *fn) { return (uintptr_t)fn & ~(uintptr_t)1; }
1465#else
1466uintptr_t fnaddr(void *fn) { return (uintptr_t)fn; }
1467#endif
1468
1807f628
A		 1469void flushICache(uintptr_t addr) {
1470 sys_icache_invalidate((void *)addr, sizeof(insn_t));
1471}
1472
13ba007e
A		 1473insn_t set(uintptr_t dst, insn_t newvalue)
1474{
1475 uintptr_t start = dst & ~(PAGE_MAX_SIZE-1);
1476 int err = mprotect((void*)start, PAGE_MAX_SIZE, PROT_READ|PROT_WRITE);
1477 if (err) fail("mprotect(%p, RW-) failed (%d)", start, errno);
1478 insn_t oldvalue = *(insn_t *)dst;
1479 *(insn_t *)dst = newvalue;
1480 err = mprotect((void*)start, PAGE_MAX_SIZE, PROT_READ|PROT_EXEC);
1481 if (err) fail("mprotect(%p, R-X) failed (%d)", start, errno);
1807f628 1482 flushICache(dst);
13ba007e
A		 1483 return oldvalue;
1484}
1485
1486clobbered_insn_t clobber(void *fn, uintptr_t offset)
1487{
1488 clobbered = fnaddr(fn) + offset;
1489 insn_t oldInsn = set(fnaddr(fn) + offset, BREAK_INSN);
1490#if __arm__
1491 // Need to clobber 32-bit Thumb instructions with another 32-bit instruction
1492 // to preserve the behavior of IT... blocks.
1493 clobbered_insn_t result = {oldInsn, 0, false};
1494 if (((oldInsn & 0xf000) == 0xf000) ||
1495 ((oldInsn & 0xf800) == 0xe800))
1496 {
1497 testprintf("clobbering thumb-32 at offset %zu\n", offset);
1498 // Old insn was 32-bit. Clobber all of it.
1499 // First unclobber.
1500 set(fnaddr(fn) + offset, oldInsn);
1501 // f7f0 a0f0 is a "permanently undefined" Thumb-2 instruction.
1502 // Clobber the first half last so `clobbered` gets the right value.
1503 result.second = set(fnaddr(fn) + offset + 2, 0xa0f0);
1504 result.first = set(fnaddr(fn) + offset, 0xf7f0);
1505 result.thirty_two = true;
1506 }
1507 return result;
1508#else
1509 return oldInsn;
1510#endif
1511}
1512
1513void unclobber(void *fn, uintptr_t offset, clobbered_insn_t oldvalue)
1514{
1515#if __arm__
1516 if (oldvalue.thirty_two) {
1517 set(fnaddr(fn) + offset + 2, oldvalue.second);
1518 }
1519 set(fnaddr(fn) + offset, oldvalue.first);
1520#else
1521 set(fnaddr(fn) + offset, oldvalue);
1522#endif
1523}
1524
1525
1526// terminator for the list of instruction offsets
1527#define END_OFFSETS ~0UL
1528
1529// Disassemble instructions symbol..<symbolEnd.
1530// Write the offset of each non-NOP instruction start to *offsets..<end.
1531// Return the incremented offsets pointer.
1532uintptr_t *disassemble(uintptr_t symbol, uintptr_t symbolEnd,
1533 uintptr_t *offsets, uintptr_t *end)
1534{
1535 // To disassemble:
1536 // 1. Copy asm-placeholder.exe into a temporary file.
1537 // 2. Write the instructions into the temp file.
1538 // 3. Run llvm-objdump on the temp file.
1539 // 4. Parse the llvm-objdump output.
1540
1541 // copy asm-placeholder.exe into a new temporary file and open it.
1542 int placeholder = open("asm-placeholder.exe", O_RDONLY);
1543 if (placeholder < 0) {
1544 fail("couldn't open asm-placeholder.exe (%d)", errno);
1545 }
1546
1547 size_t tempdirlen = confstr(_CS_DARWIN_USER_TEMP_DIR, nil, 0);
1548 char tempsuffix[] = "objc-test-msgSend-asm-XXXXXX";
1549 char *tempname = (char *)malloc(tempdirlen + strlen(tempsuffix));
1550 confstr(_CS_DARWIN_USER_TEMP_DIR, tempname, tempdirlen);
1551 strcat(tempname, tempsuffix);
1552
1553 int fd = mkstemp(tempname);
1554 if (fd < 0) {
1555 fail("couldn't create asm temp file %s (%d)", tempname, errno);
1556 }
1557 struct stat st;
1558 if (fstat(placeholder, &st) < 0) {
1559 fail("couldn't stat asm-placeholder.exe (%d)", errno);
1560 }
1807f628
A		 1561 ssize_t sz = (ssize_t)st.st_size;
1562 char *buf = (char *)malloc(sz);
1563 if (pread(placeholder, buf, sz, 0) != sz) {
13ba007e
A		 1564 fail("couldn't read asm-placeholder.exe (%d)", errno);
1565 }
1807f628 1566 if (pwrite(fd, buf, sz, 0) != sz) {
13ba007e
A		 1567 fail("couldn't write asm temp file %s (%d)", tempname, errno);
1568 }
1569 free(buf);
1570 close(placeholder);
1571
1572 // write code into asm-placeholder.exe
1573 // asm-placeholder.exe may have as little as 1024 bytes of space reserved
1574 testassert(symbolEnd - symbol < 1024);
1575 // text section should be 16KB into asm-placeholder.exe
1576 if (pwrite(fd, (void*)symbol, symbolEnd - symbol, 16384) < 0) {
1577 fail("couldn't write code into asm temp file %s (%d)", tempname, errno);
1578 }
1579 close(fd);
1580
1581 // run `llvm-objdump -disassemble`
1582 const char *objdump;
1583 if (0 == access("/usr/local/bin/llvm-objdump", F_OK)) {
1584 objdump = "/usr/local/bin/llvm-objdump";
1585 } else if (0 == access("/usr/bin/llvm-objdump", F_OK)) {
1586 objdump = "/usr/bin/llvm-objdump";
1587 } else {
1588 fail("couldn't find llvm-objdump");
1589 }
1590 char *cmd;
1591 asprintf(&cmd, "%s -disassemble %s", objdump, tempname);
1592 FILE *disa = popen(cmd, "r");
1593 if (!disa) {
1594 fail("couldn't popen %s", cmd);
1595 }
1596 free(cmd);
1597 free(tempname);
1598
1599 // read past "_main:" line
1600 char *line;
1601 size_t len;
1602 while ((line = fgetln(disa, &len))) {
1603 testprintf("ASM: %.*s", (int)len, line);
1604 if (0 == strncmp(line, "_main:", strlen("_main:"))) break;
1605 }
1606
1607 // read instructions and save offsets
1608 char op[128];
1609 long base = 0;
1610 long addr;
1611 uintptr_t *p = offsets;
1612 // disassembly format:
1613 // ADDR:\t ...instruction bytes... \tOPCODE ...etc...\n
1614 while (2 == fscanf(disa, "%lx:\t%*[a-fA-F0-9 ]\t%s%*[^\n]\n", &addr, op)) {
1615 if (base == 0) base = addr;
1616 testprintf("ASM: %lx (+%d) ... %s ...\n", addr, addr - base, op);
1617 // allow longer nops like Intel nopw and nopl
1618 if (0 != strncmp(op, "nop", 3)) {
1619 testassert(offsets < end);
1620 *p++ = addr - base;
1621 } else {
1622 // assume nops are unreached (e.g. alignment padding)
1623 }
1624 }
1625 pclose(disa);
1626
1627#if __x86_64__
1628 // hack: skip last instruction because libunwind blows up if it's
1629 // one byte long and followed by the next function with no NOPs first
1630 if (p > offsets) *p-- = END_OFFSETS;
1631#endif
1632
1633 return p;
1634}
1635
1636
1637uintptr_t *getOffsets(const char *symname, uintptr_t *outBase)
1638{
1639 // Find the start of our function.
1640 uintptr_t symbol = (uintptr_t)dlsym(RTLD_NEXT, symname);
1641 if (!symbol) return nil;
1642#if __has_feature(ptrauth_calls)
1643 symbol = (uintptr_t)
1644 ptrauth_strip((void*)symbol, ptrauth_key_function_pointer);
1645#endif
1646
1647 if (outBase) *outBase = symbol;
1648
1649 // Find the end of our function by finding the start
1650 // of the next symbol after our target symbol.
1651
1652 const int insnIncrement =
1653#if __arm64__
1654 4;
1655#elif __arm__
1656 2; // in case of thumb or thumb-2
1657#elif __i386__ || __x86_64__
1658 1;
1659#else
1660#error unknown architecture
1661#endif
1662
1663 uintptr_t symbolEnd;
1664 Dl_info dli;
1665 int ok;
1666 for (symbolEnd = symbol + insnIncrement;
1667 ((ok = dladdr((void*)symbolEnd, &dli))) && dli.dli_saddr == (void*)symbol;
1668 symbolEnd += insnIncrement)
1669 ;
1670
1671 testprintf("found %s at %p..<%p %d %p %s\n",
1672 symname, (void*)symbol, (void*)symbolEnd, ok, dli.dli_saddr, dli.dli_sname);
1673
1674 // Record the offset to each non-NOP instruction.
1675 uintptr_t *result = (uintptr_t *)malloc(1000 * sizeof(uintptr_t));
1676 uintptr_t *end = result + 1000;
1677 uintptr_t *p = result;
1678
1679 p = disassemble(symbol, symbolEnd, p, end);
1680
1681 // Also record the offsets in _objc_msgSend_uncached when present
1682 // (which is the slow path and has a frame to unwind)
1683 if (!strstr(symname, "_uncached")) {
1684 const char *uncached_symname = strstr(symname, "stret")
1685 ? "_objc_msgSend_stret_uncached" : "_objc_msgSend_uncached";
1686 uintptr_t uncached_symbol;
1687 uintptr_t *uncached_offsets =
1688 getOffsets(uncached_symname, &uncached_symbol);
1689 if (uncached_offsets) {
1690 uintptr_t *q = uncached_offsets;
1691 // Skip prologue and epilogue of objc_msgSend_uncached
1692 // because it's imprecisely modeled in compact unwind
1693 int prologueInstructions, epilogueInstructions;
1694#if __arm64e__
1695 prologueInstructions = 3;
1696 epilogueInstructions = 2;
1697#elif __arm64__ || __x86_64__ || __i386__ || __arm__
1698 prologueInstructions = 2;
1699 epilogueInstructions = 1;
1700#else
1701#error unknown architecture
1702#endif
1703 // skip past prologue
1704 for (int i = 0; i < prologueInstructions; i++) {
1705 testassert(*q != END_OFFSETS);
1706 q++;
1707 }
1708
1709 // copy instructions
1710 while (*q != END_OFFSETS) *p++ = *q++ + uncached_symbol - symbol;
1711
1712 // rewind past epilogue
1713 for (int i = 0; i < epilogueInstructions; i++) {
1714 testassert(p > result);
1715 p--;
1716 }
1717
1718 free(uncached_offsets);
1719 }
1720 }
1721
1722 // Terminate the list of offsets and return.
1723 testassert(p > result);
1724 testassert(p < end);
1725 *p = END_OFFSETS;
1726
1727 return result;
1728}
1729
1730
1731void CALLIT(void *o, void *sel_arg, SEL s, void *f, bool stret) __attribute__((noinline));
1732void CALLIT(void *o, void *sel_arg, SEL s, void *f, bool stret)
1733{
1734 uintptr_t message_ref[2];
1735 if (sel_arg != s) {
1736 // fixup dispatch
1737 // copy to a local buffer to keep sel_arg un-fixed-up
1738 memcpy(message_ref, sel_arg, sizeof(message_ref));
1739 sel_arg = message_ref;
1740 }
1741 if (!stret) callit(o, sel_arg, f);
1742#if SUPPORT_STRET
1743 else callit_stret(o, sel_arg, f);
1744#else
1745 else fail("stret?");
1746#endif
1747}
1748
1749void test_dw_forward(void)
1750{
1751 return;
1752}
1753
1754struct stret test_dw_forward_stret(void)
1755{
1756 return zero;
1757}
1758
1759// sub = ordinary receiver object
1760// tagged = tagged receiver object
1761// SEL = selector to send
1762// sub_arg = arg to pass in receiver register (may be objc_super struct)
1763// tagged_arg = arg to pass in receiver register (may be objc_super struct)
1764// sel_arg = arg to pass in sel register (may be message_ref)
1765// uncaughtAllowed is the number of acceptable unreachable instructions
1766// (for example, the ones that handle the corrupt-cache-error case)
1767void test_dw(const char *name, id sub, id tagged, id exttagged, bool stret,
1768 int uncaughtAllowed)
1769{
1770
1771 testprintf("DWARF FOR %s%s\n", name, stret ? " (stret)" : "");
1772
1773 // We need 2 SELs of each alignment so we can generate hash collisions.
1774 // sel_registerName() never returns those alignments because they
1775 // differ from malloc's alignment. So we create lots of compiled-in
1776 // SELs here and hope something fits.
1777#pragma clang diagnostic push
1778#pragma clang diagnostic ignored "-Wundeclared-selector"
1779 SEL sel = @selector(a);
1780 SEL lotsOfSels[] = {
1781 @selector(a1), @selector(a2), @selector(a3), @selector(a4),
1782 @selector(a5), @selector(a6), @selector(a7), @selector(a8),
1783 @selector(aa), @selector(ab), @selector(ac), @selector(ad),
1784 @selector(ae), @selector(af), @selector(ag), @selector(ah),
1785 @selector(A1), @selector(A2), @selector(A3), @selector(A4),
1786 @selector(A5), @selector(A6), @selector(A7), @selector(A8),
1787 @selector(AA), @selector(Ab), @selector(Ac), @selector(Ad),
1788 @selector(Ae), @selector(Af), @selector(Ag), @selector(Ah),
1789 @selector(bb1), @selector(bb2), @selector(bb3), @selector(bb4),
1790 @selector(bb5), @selector(bb6), @selector(bb7), @selector(bb8),
1791 @selector(bba), @selector(bbb), @selector(bbc), @selector(bbd),
1792 @selector(bbe), @selector(bbf), @selector(bbg), @selector(bbh),
1793 @selector(BB1), @selector(BB2), @selector(BB3), @selector(BB4),
1794 @selector(BB5), @selector(BB6), @selector(BB7), @selector(BB8),
1795 @selector(BBa), @selector(BBb), @selector(BBc), @selector(BBd),
1796 @selector(BBe), @selector(BBf), @selector(BBg), @selector(BBh),
1797 @selector(ccc1), @selector(ccc2), @selector(ccc3), @selector(ccc4),
1798 @selector(ccc5), @selector(ccc6), @selector(ccc7), @selector(ccc8),
1799 @selector(ccca), @selector(cccb), @selector(cccc), @selector(cccd),
1800 @selector(ccce), @selector(cccf), @selector(cccg), @selector(ccch),
1801 @selector(CCC1), @selector(CCC2), @selector(CCC3), @selector(CCC4),
1802 @selector(CCC5), @selector(CCC6), @selector(CCC7), @selector(CCC8),
1803 @selector(CCCa), @selector(CCCb), @selector(CCCc), @selector(CCCd),
1804 @selector(CCCe), @selector(CCCf), @selector(CCCg), @selector(CCCh),
1805 };
1806#pragma clang diagnostic pop
1807
1808 {
1809 IMP imp = stret ? (IMP)test_dw_forward_stret : (IMP)test_dw_forward;
1810 Class cls = object_getClass(sub);
1811 Class tagcls = object_getClass(tagged);
1812 Class exttagcls = object_getClass(exttagged);
1813 class_replaceMethod(cls, sel, imp, "");
1814 class_replaceMethod(tagcls, sel, imp, "");
1815 class_replaceMethod(exttagcls, sel, imp, "");
1816 for (size_t i = 0; i < sizeof(lotsOfSels)/sizeof(lotsOfSels[0]); i++) {
1817 class_replaceMethod(cls, lotsOfSels[i], imp, "");
1818 class_replaceMethod(tagcls, lotsOfSels[i], imp, "");
1819 class_replaceMethod(exttagcls, lotsOfSels[i], imp, "");
1820 }
1821 }
1822
1823 #define ALIGNCOUNT 16
1824 SEL sels[ALIGNCOUNT][2] = {{0}};
1825 for (int align = 0; align < ALIGNCOUNT; align++) {
1826 for (size_t i = 0; i < sizeof(lotsOfSels)/sizeof(lotsOfSels[0]); i++) {
1827 if ((uintptr_t)(void*)lotsOfSels[i] % ALIGNCOUNT == align) {
1828 if (sels[align][0]) {
1829 sels[align][1] = lotsOfSels[i];
1830 } else {
1831 sels[align][0] = lotsOfSels[i];
1832 }
1833 }
1834 }
1835 if (!sels[align][0]) fail("no SEL with alignment %d", align);
1836 if (!sels[align][1]) fail("only one SEL with alignment %d", align);
1837 }
1838
1839 void *fn = dlsym(RTLD_DEFAULT, name);
1840#if __has_feature(ptrauth_calls)
1841 fn = ptrauth_strip(fn, ptrauth_key_function_pointer);
1842#endif
1843 testassert(fn);
1844
1845 // argument substitutions
1846
1847 void *sub_arg = (__bridge void*)sub;
1848 void *tagged_arg = (__bridge void*)tagged;
1849 void *exttagged_arg = (__bridge void*)exttagged;
1850 void *sel_arg = (void*)sel;
1851
1852 struct objc_super sup_st = { sub, object_getClass(sub) };
1853 struct objc_super tagged_sup_st = { tagged, object_getClass(tagged) };
1854 struct objc_super exttagged_sup_st = { exttagged, object_getClass(exttagged) };
1855 struct { void *imp; SEL sel; } message_ref = { fn, sel };
1856
1857 Class cache_cls = object_getClass(sub);
1858 Class tagged_cache_cls = object_getClass(tagged);
1859 Class exttagged_cache_cls = object_getClass(exttagged);
1860
1861 if (strstr(name, "Super")) {
1862 // super version - replace receiver with objc_super
1863 // clear caches of superclass
1864 cache_cls = class_getSuperclass(cache_cls);
1865 tagged_cache_cls = class_getSuperclass(tagged_cache_cls);
1866 exttagged_cache_cls = class_getSuperclass(exttagged_cache_cls);
1867 sub_arg = &sup_st;
1868 tagged_arg = &tagged_sup_st;
1869 exttagged_arg = &exttagged_sup_st;
1870 }
1871
1872 if (strstr(name, "_fixup")) {
1873 // fixup version - replace sel with message_ref
1874 sel_arg = &message_ref;
1875 }
1876
1877
1878 uintptr_t *insnOffsets = getOffsets(name, nil);
1879 testassert(insnOffsets);
1880 uintptr_t offset;
1881 int uncaughtCount = 0;
1882 for (int oo = 0; insnOffsets[oo] != ~0UL; oo++) {
1883 offset = insnOffsets[oo];
1884 testprintf("OFFSET %lu\n", offset);
1885
1886 clobbered_insn_t saved_insn = clobber(fn, offset);
1887 caught = false;
1888
1889 // nil
1890 if ((__bridge void*)sub == sub_arg) {
1891 SELF = nil;
1892 testprintf(" nil\n");
1893 CALLIT(nil, sel_arg, sel, fn, stret);
1894 CALLIT(nil, sel_arg, sel, fn, stret);
1895 }
1896
1897 // uncached
1898 SELF = sub;
1899 testprintf(" uncached\n");
1900 _objc_flush_caches(cache_cls);
1901 CALLIT(sub_arg, sel_arg, sel, fn, stret);
1902 _objc_flush_caches(cache_cls);
1903 CALLIT(sub_arg, sel_arg, sel, fn, stret);
1904
1905 // cached
1906 SELF = sub;
1907 testprintf(" cached\n");
1908 CALLIT(sub_arg, sel_arg, sel, fn, stret);
1909 CALLIT(sub_arg, sel_arg, sel, fn, stret);
1910
1911 // uncached,tagged
1912 SELF = tagged;
1913 testprintf(" uncached,tagged\n");
1914 _objc_flush_caches(tagged_cache_cls);
1915 CALLIT(tagged_arg, sel_arg, sel, fn, stret);
1916 _objc_flush_caches(tagged_cache_cls);
1917 CALLIT(tagged_arg, sel_arg, sel, fn, stret);
1918 _objc_flush_caches(exttagged_cache_cls);
1919 CALLIT(exttagged_arg, sel_arg, sel, fn, stret);
1920 _objc_flush_caches(exttagged_cache_cls);
1921 CALLIT(exttagged_arg, sel_arg, sel, fn, stret);
1922
1923 // cached,tagged
1924 SELF = tagged;
1925 testprintf(" cached,tagged\n");
1926 CALLIT(tagged_arg, sel_arg, sel, fn, stret);
1927 CALLIT(tagged_arg, sel_arg, sel, fn, stret);
1928 CALLIT(exttagged_arg, sel_arg, sel, fn, stret);
1929 CALLIT(exttagged_arg, sel_arg, sel, fn, stret);
1930
1931 // multiple SEL alignments, collisions, wraps
1932 SELF = sub;
1933 for (int a = 0; a < ALIGNCOUNT; a++) {
1934 testprintf(" cached and uncached, SEL alignment %d\n", a);
1935
1936 // Count both up and down to be independent of
1937 // implementation's cache scan direction
1938
1939 _objc_flush_caches(cache_cls);
1940 for (int x2 = 0; x2 < 8; x2++) {
1941 for (int s = 0; s < 4; s++) {
1942 int align = (a+s) % ALIGNCOUNT;
1943 CALLIT(sub_arg, sels[align][0], sels[align][0], fn, stret);
1944 CALLIT(sub_arg, sels[align][1], sels[align][1], fn, stret);
1945 }
1946 }
1947
1948 _objc_flush_caches(cache_cls);
1949 for (int x2 = 0; x2 < 8; x2++) {
1950 for (int s = 0; s < 4; s++) {
1951 int align = abs(a-s) % ALIGNCOUNT;
1952 CALLIT(sub_arg, sels[align][0], sels[align][0], fn, stret);
1953 CALLIT(sub_arg, sels[align][1], sels[align][1], fn, stret);
1954 }
1955 }
1956 }
1957
1958 unclobber(fn, offset, saved_insn);
1959
1960 // remember offsets that were caught by none of the above
1961 if (caught) {
1962 insnOffsets[oo] = 0;
1963 } else {
1964 uncaughtCount++;
1965 testprintf("offset %s+%lu not caught (%d/%d)\n",
1966 name, offset, uncaughtCount, uncaughtAllowed);
1967 }
1968 }
1969
1970 // Complain if too many offsets went uncaught.
1971 // Acceptably-uncaught offsets include the corrupt-cache-error handler.
1972 if (uncaughtCount != uncaughtAllowed) {
1973 for (int oo = 0; insnOffsets[oo] != ~0UL; oo++) {
1974 if (insnOffsets[oo]) {
1975 fprintf(stderr, "BAD: offset %s+%lu not caught\n",
1976 name, insnOffsets[oo]);
1977 }
1978 }
1979 fail("wrong instructions not reached for %s (missed %d, expected %d)",
1980 name, uncaughtCount, uncaughtAllowed);
1981 }
1982
1983 free(insnOffsets);
1984}
1985
1986
1987// TEST_DWARF
1988#endif
1989
1990
1991void test_basic(id receiver)
1992{
1993 id idval;
1994 long long llval;
1995 struct stret stretval;
1996 double fpval;
1997 long double lfpval;
1998 vector_ulong2 vecval;
1999
2000 // message uncached
2001 // message uncached long long
2002 // message uncached stret
2003 // message uncached fpret
2004 // message uncached fpret long double
2005 // message uncached noarg (as above)
2006 // message cached
2007 // message cached long long
2008 // message cached stret
2009 // message cached fpret
2010 // message cached fpret long double
2011 // message cached noarg (as above)
2012 // fixme verify that uncached lookup didn't happen the 2nd time?
2013 SELF = receiver;
2014 _objc_flush_caches(object_getClass(receiver));
2015 for (int i = 0; i < 5; i++) {
2016 testprintf("idret\n");
2017 state = 0;
2018 idval = nil;
2019 idval = [receiver idret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2020 testassert(state == 101);
2021 testassert(idval == ID_RESULT);
2022
2023 testprintf("llret\n");
2024 llval = 0;
2025 llval = [receiver llret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2026 testassert(state == 102);
2027 testassert(llval == LL_RESULT);
2028
2029 testprintf("stret\n");
2030 stretval = zero;
2031 stretval = [receiver stret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2032 testassert(state == 103);
2033 testassert(stret_equal(stretval, STRET_RESULT));
2034
2035 testprintf("fpret\n");
2036 fpval = 0;
2037 fpval = [receiver fpret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2038 testassert(state == 104);
2039 testassert(fpval == FP_RESULT);
2040
2041 testprintf("lfpret\n");
2042 lfpval = 0;
2043 lfpval = [receiver lfpret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2044 testassert(state == 105);
2045 testassert(lfpval == LFP_RESULT);
2046
2047 testprintf("vecret\n");
2048 vecval = 0;
2049 vecval = [receiver vecret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2050 testassert(state == 106);
2051 testassert(vector_equal(vecval, VEC_RESULT));
2052
2053 // explicitly call noarg messenger, even if compiler doesn't emit it
2054 state = 0;
2055 testprintf("idret noarg\n");
2056 idval = nil;
2057 idval = ((typeof(idmsg0))objc_msgSend_noarg)(receiver, @selector(idret_noarg));
2058 testassert(state == 111);
2059 testassert(idval == ID_RESULT);
2060
2061 testprintf("llret noarg\n");
2062 llval = 0;
2063 llval = ((typeof(llmsg0))objc_msgSend_noarg)(receiver, @selector(llret_noarg));
2064 testassert(state == 112);
2065 testassert(llval == LL_RESULT);
2066 /*
2067 no objc_msgSend_stret_noarg
2068 stretval = zero;
2069 stretval = ((typeof(stretmsg0))objc_msgSend_stret_noarg)(receiver, @selector(stret_noarg));
2070 stretval = [receiver stret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2071 testassert(state == 113);
2072 testassert(stret_equal(stretval, STRET_RESULT));
2073 */
2074#if !__i386__
2075 testprintf("fpret noarg\n");
2076 fpval = 0;
2077 fpval = ((typeof(fpmsg0))objc_msgSend_noarg)(receiver, @selector(fpret_noarg));
2078 testassert(state == 114);
2079 testassert(fpval == FP_RESULT);
2080
2081 testprintf("vecret noarg\n");
2082 vecval = 0;
2083 vecval = ((typeof(vecmsg0))objc_msgSend_noarg)(receiver, @selector(vecret_noarg));
2084 testassert(state == 116);
2085 testassert(vector_equal(vecval, VEC_RESULT));
2086#endif
2087#if !__i386__ && !__x86_64__
2088 testprintf("lfpret noarg\n");
2089 lfpval = 0;
2090 lfpval = ((typeof(lfpmsg0))objc_msgSend_noarg)(receiver, @selector(lfpret_noarg));
2091 testassert(state == 115);
2092 testassert(lfpval == LFP_RESULT);
2093#endif
2094 }
2095
2096 testprintf("basic done\n");
2097}
2098
2099int main()
2100{
2101 PUSH_POOL {
2102 id idval;
2103 long long llval;
2104 struct stret stretval;
2105 double fpval;
2106 long double lfpval;
2107 vector_ulong2 vecval;
2108
2109#if __x86_64__
2110 struct stret *stretptr;
2111#endif
2112
2113 Method idmethod;
2114 Method llmethod;
2115 Method stretmethod;
2116 Method fpmethod;
2117 Method lfpmethod;
2118 Method vecmethod;
2119
2120 id (*idfn)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double);
2121 long long (*llfn)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double);
2122 struct stret (*stretfn)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double);
2123 double (*fpfn)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double);
2124 long double (*lfpfn)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double);
2125 vector_ulong2 (*vecfn)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double);
2126
2127 id (*idmsg)(id, SEL, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double) __attribute__((unused));
2128 id (*idmsgsuper)(struct objc_super *, SEL, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double) __attribute__((unused));
2129 long long (*llmsg)(id, SEL, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double) __attribute__((unused));
2130 struct stret (*stretmsg)(id, SEL, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double) __attribute__((unused));
2131 struct stret (*stretmsgsuper)(struct objc_super *, SEL, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double) __attribute__((unused));
2132 double (*fpmsg)(id, SEL, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double) __attribute__((unused));
2133 long double (*lfpmsg)(id, SEL, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double) __attribute__((unused));
2134 vector_ulong2 (*vecmsg)(id, SEL, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double) __attribute__((unused));
2135
2136 // get +initialize out of the way
2137 [Sub class];
2138#if OBJC_HAVE_TAGGED_POINTERS
2139 [TaggedSub class];
2140 [ExtTaggedSub class];
2141#endif
2142
2143 ID_RESULT = [Super new];
2144
2145 Sub *sub = [Sub new];
2146 Super *sup = [Super new];
2147#if OBJC_HAVE_TAGGED_POINTERS
2148 TaggedSub *tagged = (__bridge id)_objc_makeTaggedPointer(OBJC_TAG_1, 999);
2149 ExtTaggedSub *exttagged = (__bridge id)_objc_makeTaggedPointer(OBJC_TAG_First52BitPayload, 999);
2150#endif
2151
2152 // Basic cached and uncached dispatch.
2153 // Do this first before anything below caches stuff.
2154 testprintf("basic\n");
2155 test_basic(sub);
2156#if OBJC_HAVE_TAGGED_POINTERS
2157 testprintf("basic tagged\n");
2158 test_basic(tagged);
2159 testprintf("basic ext tagged\n");
2160 test_basic(exttagged);
2161#endif
2162
2163 idmethod = class_getInstanceMethod([Super class], @selector(idret::::::::::::::::::::::::::::::::::::));
2164 testassert(idmethod);
2165 llmethod = class_getInstanceMethod([Super class], @selector(llret::::::::::::::::::::::::::::::::::::));
2166 testassert(llmethod);
2167 stretmethod = class_getInstanceMethod([Super class], @selector(stret::::::::::::::::::::::::::::::::::::));
2168 testassert(stretmethod);
2169 fpmethod = class_getInstanceMethod([Super class], @selector(fpret::::::::::::::::::::::::::::::::::::));
2170 testassert(fpmethod);
2171 lfpmethod = class_getInstanceMethod([Super class], @selector(lfpret::::::::::::::::::::::::::::::::::::));
2172 testassert(lfpmethod);
2173 vecmethod = class_getInstanceMethod([Super class], @selector(vecret::::::::::::::::::::::::::::::::::::));
2174 testassert(vecmethod);
2175
2176 idfn = (id (*)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)) method_invoke;
2177 llfn = (long long (*)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)) method_invoke;
2178 stretfn = (struct stret (*)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)) method_invoke_stret;
2179 fpfn = (double (*)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)) method_invoke;
2180 lfpfn = (long double (*)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)) method_invoke;
2181 vecfn = (vector_ulong2 (*)(id, Method, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, vector_ulong2, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double)) method_invoke;
2182
2183 // method_invoke
2184 // method_invoke long long
2185 // method_invoke_stret stret
2186 // method_invoke_stret fpret
2187 // method_invoke fpret long double
2188 testprintf("method_invoke\n");
2189
2190 SELF = sup;
2191
2192 state = 0;
2193 idval = nil;
2194 idval = (*idfn)(sup, idmethod, VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2195 testassert(state == 1);
2196 testassert(idval == ID_RESULT);
2197
2198 llval = 0;
2199 llval = (*llfn)(sup, llmethod, VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2200 testassert(state == 2);
2201 testassert(llval == LL_RESULT);
2202
2203 stretval = zero;
2204 stretval = (*stretfn)(sup, stretmethod, VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2205 testassert(state == 3);
2206 testassert(stret_equal(stretval, STRET_RESULT));
2207
2208 fpval = 0;
2209 fpval = (*fpfn)(sup, fpmethod, VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2210 testassert(state == 4);
2211 testassert(fpval == FP_RESULT);
2212
2213 lfpval = 0;
2214 lfpval = (*lfpfn)(sup, lfpmethod, VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2215 testassert(state == 5);
2216 testassert(lfpval == LFP_RESULT);
2217
2218 vecval = 0;
2219 vecval = (*vecfn)(sup, vecmethod, VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2220 testassert(state == 6);
2221 testassert(vector_equal(vecval, VEC_RESULT));
2222
2223
2224 // message to nil
2225 // message to nil long long
2226 // message to nil stret
2227 // message to nil fpret
2228 // message to nil fpret long double
2229 // Use NIL_RECEIVER to avoid compiler optimizations.
2230 testprintf("message to nil\n");
2231
2232 state = 0;
2233 idval = ID_RESULT;
2234 idval = [(id)NIL_RECEIVER idret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2235 testassert(state == 0);
2236 testassert(idval == nil);
2237
2238 state = 0;
2239 llval = LL_RESULT;
2240 llval = [(id)NIL_RECEIVER llret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2241 testassert(state == 0);
2242 testassert(llval == 0LL);
2243
2244 state = 0;
2245 stretval = zero;
2246 stretval = [(id)NIL_RECEIVER stret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2247 testassert(state == 0);
2248 testassert(0 == memcmp(&stretval, &zero, sizeof(stretval)));
2249
2250#if __x86_64__
2251 // check stret return register
2252 state = 0;
2253 stretval = zero;
2254 stretptr = ((struct stret *(*)(struct stret *, id, SEL))objc_msgSend_stret)
2255 (&stretval, nil, @selector(stret_nop));
2256 testassert(stretptr == &stretval);
2257 testassert(state == 0);
2258 // no stret result guarantee for hand-written calls
2259#endif
2260
2261#if __i386__
2262 // check struct-return address stack pop
2263 for (int i = 0; i < 10000000; i++) {
2264 state = 0;
2265 ((struct stret (*)(id, SEL))objc_msgSend_stret)
2266 (nil, @selector(stret_nop));
2267 }
2268#endif
2269
2270 state = 0;
2271 fpval = FP_RESULT;
2272 fpval = [(id)NIL_RECEIVER fpret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2273 testassert(state == 0);
2274 testassert(fpval == 0.0);
2275
2276 state = 0;
2277 lfpval = LFP_RESULT;
2278 lfpval = [(id)NIL_RECEIVER lfpret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2279 testassert(state == 0);
2280 testassert(lfpval == 0.0);
2281
2282 state = 0;
2283 vecval = VEC_RESULT;
2284 vecval = [(id)NIL_RECEIVER vecret :VEC1:VEC2:VEC3:VEC4:VEC5:VEC6:VEC7:VEC8:1:2:3:4:5:6:7:8:9:10:11:12:13:1.0:2.0:3.0:4.0:5.0:6.0:7.0:8.0:9.0:10.0:11.0:12.0:13.0:14.0:15.0];
2285 testassert(state == 0);
2286 testassert(vector_all(vecval == 0));
2287
2288 // message to nil, different struct types
2289 // This verifies that ordinary objc_msgSend() erases enough registers
2290 // for structs that return in registers.
2291#define TEST_NIL_STRUCT(i,n) \
2292 do { \
2293 struct stret_##i##n z; \
2294 bzero(&z, sizeof(z)); \
2295 [Super stret_i##n##_nonzero]; \
2296 [Super stret_d##n##_nonzero]; \
2297 struct stret_##i##n val = [(id)NIL_RECEIVER stret_##i##n##_zero]; \
2298 testassert(0 == memcmp(&z, &val, sizeof(val))); \
2299 } while (0)
2300
2301 TEST_NIL_STRUCT(i,1);
2302 TEST_NIL_STRUCT(i,2);
2303 TEST_NIL_STRUCT(i,3);
2304 TEST_NIL_STRUCT(i,4);
2305 TEST_NIL_STRUCT(i,5);
2306 TEST_NIL_STRUCT(i,6);
2307 TEST_NIL_STRUCT(i,7);
2308 TEST_NIL_STRUCT(i,8);
2309 TEST_NIL_STRUCT(i,9);
2310
2311#if __i386__
2312 testwarn("rdar://16267205 i386 struct{float} and struct{double}");
2313#else
2314 TEST_NIL_STRUCT(d,1);
2315#endif
2316 TEST_NIL_STRUCT(d,2);
2317 TEST_NIL_STRUCT(d,3);
2318 TEST_NIL_STRUCT(d,4);
2319 TEST_NIL_STRUCT(d,5);
2320 TEST_NIL_STRUCT(d,6);
2321 TEST_NIL_STRUCT(d,7);
2322 TEST_NIL_STRUCT(d,8);
2323 TEST_NIL_STRUCT(d,9);
2324
2325
2326 // message to nil noarg
2327 // explicitly call noarg messenger, even if compiler doesn't emit it
2328 state = 0;
2329 idval = ID_RESULT;
2330 idval = ((typeof(idmsg0))objc_msgSend_noarg)(nil, @selector(idret_noarg));
2331 testassert(state == 0);
2332 testassert(idval == nil);
2333
2334 state = 0;
2335 llval = LL_RESULT;
2336 llval = ((typeof(llmsg0))objc_msgSend_noarg)(nil, @selector(llret_noarg));
2337 testassert(state == 0);
2338 testassert(llval == 0LL);
2339
2340 // no stret_noarg messenger
2341
2342#if !__i386__
2343 state = 0;
2344 fpval = FP_RESULT;
2345 fpval = ((typeof(fpmsg0))objc_msgSend_noarg)(nil, @selector(fpret_noarg));
2346 testassert(state == 0);
2347 testassert(fpval == 0.0);
2348
2349 state = 0;
2350 vecval = VEC_RESULT;
2351 vecval = ((typeof(vecmsg0))objc_msgSend_noarg)(nil, @selector(vecret_noarg));
2352 testassert(state == 0);
2353 testassert(vector_all(vecval == 0));
2354#endif
2355#if !__i386__ && !__x86_64__
2356 state = 0;
2357 lfpval = LFP_RESULT;
2358 lfpval = ((typeof(lfpmsg0))objc_msgSend_noarg)(nil, @selector(lfpret_noarg));
2359 testassert(state == 0);
2360 testassert(lfpval == 0.0);
2361#endif
2362
2363
2364 // rdar://8271364 objc_msgSendSuper2 must not change objc_super
2365 testprintf("super struct\n");
2366 struct objc_super sup_st = {
2367 sub,
2368 object_getClass(sub),
2369 };
2370
2371 SELF = sub;
2372
2373 state = 100;
2374 idval = nil;
2375 idval = ((id(*)(struct objc_super *, SEL, vector_ulong2,vector_ulong2,vector_ulong2,vector_ulong2,vector_ulong2,vector_ulong2,vector_ulong2,vector_ulong2, int,int,int,int,int,int,int,int,int,int,int,int,int, double,double,double,double,double,double,double,double,double,double,double,double,double,double,double))objc_msgSendSuper2) (&sup_st, @selector(idret::::::::::::::::::::::::::::::::::::), VEC1,VEC2,VEC3,VEC4,VEC5,VEC6,VEC7,VEC8, 1,2,3,4,5,6,7,8,9,10,11,12,13, 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0);
2376 testassert(state == 1);
2377 testassert(idval == ID_RESULT);
2378 testassert(sup_st.receiver == sub);
2379 testassert(sup_st.super_class == object_getClass(sub));
2380
2381 state = 100;
2382 stretval = zero;
2383 stretval = ((struct stret(*)(struct objc_super *, SEL, vector_ulong2,vector_ulong2,vector_ulong2,vector_ulong2,vector_ulong2,vector_ulong2,vector_ulong2,vector_ulong2, int,int,int,int,int,int,int,int,int,int,int,int,int, double,double,double,double,double,double,double,double,double,double,double,double,double,double,double))objc_msgSendSuper2_stret) (&sup_st, @selector(stret::::::::::::::::::::::::::::::::::::), VEC1,VEC2,VEC3,VEC4,VEC5,VEC6,VEC7,VEC8, 1,2,3,4,5,6,7,8,9,10,11,12,13, 1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0);
2384 testassert(state == 3);
2385 testassert(stret_equal(stretval, STRET_RESULT));
2386 testassert(sup_st.receiver == sub);
2387 testassert(sup_st.super_class == object_getClass(sub));
2388
2389#if !__arm64__
2390 // Debug messengers.
2391 testprintf("debug messengers\n");
2392
2393 state = 0;
2394 idmsg = (typeof(idmsg))objc_msgSend_debug;
2395 idval = nil;
2396 idval = (*idmsg)(sub, @selector(idret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2397 testassert(state == 101);
2398 testassert(idval == ID_RESULT);
2399
2400 state = 0;
2401 llmsg = (typeof(llmsg))objc_msgSend_debug;
2402 llval = 0;
2403 llval = (*llmsg)(sub, @selector(llret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2404 testassert(state == 102);
2405 testassert(llval == LL_RESULT);
2406
2407 state = 0;
2408 stretmsg = (typeof(stretmsg))objc_msgSend_stret_debug;
2409 stretval = zero;
2410 stretval = (*stretmsg)(sub, @selector(stret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2411 testassert(state == 103);
2412 testassert(stret_equal(stretval, STRET_RESULT));
2413
2414 state = 100;
2415 sup_st.receiver = sub;
2416 sup_st.super_class = object_getClass(sub);
2417 idmsgsuper = (typeof(idmsgsuper))objc_msgSendSuper2_debug;
2418 idval = nil;
2419 idval = (*idmsgsuper)(&sup_st, @selector(idret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2420 testassert(state == 1);
2421 testassert(idval == ID_RESULT);
2422
2423 state = 100;
2424 sup_st.receiver = sub;
2425 sup_st.super_class = object_getClass(sub);
2426 stretmsgsuper = (typeof(stretmsgsuper))objc_msgSendSuper2_stret_debug;
2427 stretval = zero;
2428 stretval = (*stretmsgsuper)(&sup_st, @selector(stret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2429 testassert(state == 3);
2430 testassert(stret_equal(stretval, STRET_RESULT));
2431
2432#if __i386__
2433 state = 0;
2434 fpmsg = (typeof(fpmsg))objc_msgSend_fpret_debug;
2435 fpval = 0;
2436 fpval = (*fpmsg)(sub, @selector(fpret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2437 testassert(state == 104);
2438 testassert(fpval == FP_RESULT);
2439#endif
2440#if __x86_64__
2441 state = 0;
2442 lfpmsg = (typeof(lfpmsg))objc_msgSend_fpret_debug;
2443 lfpval = 0;
2444 lfpval = (*lfpmsg)(sub, @selector(lfpret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2445 testassert(state == 105);
2446 testassert(lfpval == LFP_RESULT);
2447
2448 // fixme fp2ret
2449#endif
2450
2451 // debug messengers
2452#endif
2453
2454
2455 // objc_msgLookup
2456
2457#if 1
2458 // fixme objc_msgLookup test hack stopped working after a compiler update
2459
2460#elif __has_feature(objc_arc)
2461 // ARC interferes with objc_msgLookup test hacks
2462
2463#elif __i386__ && TARGET_OS_SIMULATOR
2464 testwarn("fixme msgLookup hack doesn't work");
2465
2466#else
2467 // fixme hack: call the looked-up method
2468# if __arm64__
2469# define CALL_LOOKUP(ret) \
2470 asm volatile ("blr x17 \n mov %x0, x0" : "=r" (ret))
2471# define CALL_LOOKUP_STRET(ret) \
2472 asm volatile ("mov x8, %x1 \n blr x17 \n" : "=m" (ret) : "r" (&ret))
2473
2474# elif __arm__
2475# define CALL_LOOKUP(ret) \
2476 asm volatile ("blx r12 \n mov %0, r0" : "=r" (ret))
2477# define CALL_LOOKUP_STRET(ret) \
2478 asm volatile ("mov r0, %1 \n blx r12 \n" : "=m" (ret) : "r" (&ret))
2479
2480# elif __x86_64__
2481# define CALL_LOOKUP(ret) \
2482 asm volatile ("call *%%r11 \n mov %%rax, %0" : "=r" (ret))
2483# define CALL_LOOKUP_STRET(ret) \
2484 asm volatile ("mov %1, %%rdi \n call *%%r11 \n" : "=m" (ret) : "r" (&ret))
2485
2486# elif __i386__
2487# define CALL_LOOKUP(ret) \
2488 asm volatile ("call *%%eax \n mov %%eax, %0" : "=r" (ret))
2489# define CALL_LOOKUP_STRET(ret) \
2490 asm volatile ("add $4, %%esp \n mov %1, (%%esp) \n call *%%eax \n sub $4, %%esp \n" : "=m" (ret) : "d" (&ret))
2491
2492# else
2493# error unknown architecture
2494# endif
2495
2496 // msgLookup uncached
2497 // msgLookup uncached super
2498 // msgLookup uncached stret
2499 // msgLookup uncached super stret
2500 // msgLookup uncached fpret
2501 // msgLookup uncached fpret long double
2502 // msgLookup cached
2503 // msgLookup cached stret
2504 // msgLookup cached super
2505 // msgLookup cached super stret
2506 // msgLookup cached fpret
2507 // msgLookup cached fpret long double
2508 // fixme verify that uncached lookup didn't happen the 2nd time?
2509 SELF = sub;
2510 _objc_flush_caches(object_getClass(sub));
2511 for (int i = 0; i < 5; i++) {
2512 testprintf("objc_msgLookup\n");
2513 state = 0;
2514 idmsg = (typeof(idmsg))objc_msgLookup;
2515 idval = nil;
2516 (*idmsg)(sub, @selector(idret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2517 CALL_LOOKUP(idval);
2518 testassert(state == 101);
2519 testassert(idval == ID_RESULT);
2520
2521 testprintf("objc_msgLookup_stret\n");
2522 state = 0;
2523 stretmsg = (typeof(stretmsg))objc_msgLookup_stret;
2524 stretval = zero;
2525 (*stretmsg)(sub, @selector(stret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2526 CALL_LOOKUP_STRET(stretval);
2527 testassert(state == 103);
2528 testassert(stret_equal(stretval, STRET_RESULT));
2529
2530 testprintf("objc_msgLookupSuper2\n");
2531 state = 100;
2532 sup_st.receiver = sub;
2533 sup_st.super_class = object_getClass(sub);
2534 idmsgsuper = (typeof(idmsgsuper))objc_msgLookupSuper2;
2535 idval = nil;
2536 idval = (*idmsgsuper)(&sup_st, @selector(idret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2537 CALL_LOOKUP(idval);
2538 testassert(state == 1);
2539 testassert(idval == ID_RESULT);
2540
2541 testprintf("objc_msgLookupSuper2_stret\n");
2542 state = 100;
2543 sup_st.receiver = sub;
2544 sup_st.super_class = object_getClass(sub);
2545 stretmsgsuper = (typeof(stretmsgsuper))objc_msgLookupSuper2_stret;
2546 stretval = zero;
2547 (*stretmsgsuper)(&sup_st, @selector(stret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2548 CALL_LOOKUP_STRET(stretval);
2549 testassert(state == 3);
2550 testassert(stret_equal(stretval, STRET_RESULT));
2551
2552#if __i386__
2553 // fixme fpret, can't test FP stack properly
2554#endif
2555#if __x86_64__
2556 // fixme fpret, can't test FP stack properly
2557 // fixme fp2ret, can't test FP stack properly
2558#endif
2559
2560 }
2561
2562 // msgLookup to nil
2563 // msgLookup to nil stret
2564 // fixme msgLookup to nil long long
2565 // fixme msgLookup to nil fpret
2566 // fixme msgLookup to nil fp2ret
2567
2568 testprintf("objc_msgLookup to nil\n");
2569 state = 0;
2570 idmsg = (typeof(idmsg))objc_msgLookup;
2571 idval = nil;
2572 (*idmsg)(NIL_RECEIVER, @selector(idret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2573 CALL_LOOKUP(idval);
2574 testassert(state == 0);
2575 testassert(idval == nil);
2576
2577 testprintf("objc_msgLookup_stret to nil\n");
2578 state = 0;
2579 stretmsg = (typeof(stretmsg))objc_msgLookup_stret;
2580 stretval = zero;
2581 (*stretmsg)(NIL_RECEIVER, @selector(stret::::::::::::::::::::::::::::::::::::), VEC1, VEC2, VEC3, VEC4, VEC5, VEC6, VEC7, VEC8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0);
2582 CALL_LOOKUP_STRET(stretval);
2583 testassert(state == 0);
2584 // no stret result guarantee
2585
2586#if __i386__
2587 // fixme fpret, can't test FP stack properly
2588#endif
2589#if __x86_64__
2590 // fixme fpret, can't test FP stack properly
2591 // fixme fp2ret, can't test FP stack properly
2592#endif
2593
2594 // objc_msgLookup
2595#endif
2596
2597
2598
2599#if !TEST_DWARF
2600 testwarn("no unwind tables in this configuration " NO_DWARF_REASON);
2601#else
2602 // DWARF unwind tables
2603 testprintf("unwind tables\n");
2604
2605 // Clear simulator-related environment variables.
2606 // Disassembly will run llvm-objdump which is not a simulator executable.
2607 unsetenv("DYLD_ROOT_PATH");
2608 unsetenv("DYLD_FALLBACK_LIBRARY_PATH");
2609 unsetenv("DYLD_FALLBACK_FRAMEWORK_PATH");
2610
2611 // Check mprotect() of objc_msgSend.
2612 // It doesn't work when running on a device with no libobjc root.
2613 // In that case we skip this part of the test without failing.
2614 // fixme make this work
2615 // fixme now it doesn't work even with a libobjc root in place?
2616 int err1 = mprotect((void *)((uintptr_t)&objc_msgSend & ~(PAGE_MAX_SIZE-1)),
2617 PAGE_MAX_SIZE, PROT_READ | PROT_WRITE);
2618 int errno1 = errno;
2619 int err2 = mprotect((void *)((uintptr_t)&objc_msgSend & ~(PAGE_MAX_SIZE-1)),
2620 PAGE_MAX_SIZE, PROT_READ | PROT_EXEC);
2621 int errno2 = errno;
2622 if (err1 || err2) {
2623 testwarn("can't mprotect() objc_msgSend (%d, %d). "
2624 "Skipping unwind table test.",
2625 err1, errno1, err2, errno2);
2626 }
2627 else {
2628 // install exception handler
2629 struct sigaction act;
2630 act.sa_sigaction = break_handler;
2631 act.sa_mask = 0;
2632 act.sa_flags = SA_SIGINFO;
2633 sigaction(BREAK_SIGNAL, &act, nil);
2634#if defined(BREAK_SIGNAL2)
2635 sigaction(BREAK_SIGNAL2, &act, nil);
2636#endif
2637
2638 SubDW *dw = [[SubDW alloc] init];
2639
2640 objc_setForwardHandler((void*)test_dw_forward, (void*)test_dw_forward_stret);
2641
2642# if __x86_64__
2643 test_dw("objc_msgSend", dw, tagged, exttagged, false, 0);
2644 test_dw("objc_msgSend_stret", dw, tagged, exttagged, true, 0);
2645 test_dw("objc_msgSend_fpret", dw, tagged, exttagged, false, 0);
2646 test_dw("objc_msgSend_fp2ret", dw, tagged, exttagged, false, 0);
2647 test_dw("objc_msgSendSuper", dw, tagged, exttagged, false, 0);
2648 test_dw("objc_msgSendSuper2", dw, tagged, exttagged, false, 0);
2649 test_dw("objc_msgSendSuper_stret", dw, tagged, exttagged, true, 0);
2650 test_dw("objc_msgSendSuper2_stret", dw, tagged, exttagged, true, 0);
2651# elif __i386__
2652 test_dw("objc_msgSend", dw, dw, dw, false, 0);
2653 test_dw("objc_msgSend_stret", dw, dw, dw, true, 0);
2654 test_dw("objc_msgSend_fpret", dw, dw, dw, false, 0);
2655 test_dw("objc_msgSendSuper", dw, dw, dw, false, 0);
2656 test_dw("objc_msgSendSuper2", dw, dw, dw, false, 0);
2657 test_dw("objc_msgSendSuper_stret", dw, dw, dw, true, 0);
2658 test_dw("objc_msgSendSuper2_stret", dw, dw, dw, true, 0);
2659# elif __arm64__
2660 test_dw("objc_msgSend", dw, tagged, exttagged, false, 1);
2661 test_dw("objc_msgSendSuper", dw, tagged, exttagged, false, 1);
2662 test_dw("objc_msgSendSuper2", dw, tagged, exttagged, false, 1);
2663# elif __arm__
2664 test_dw("objc_msgSend", dw, dw, dw, false, 0);
2665 test_dw("objc_msgSend_stret", dw, dw, dw, true, 0);
2666 test_dw("objc_msgSendSuper", dw, dw, dw, false, 0);
2667 test_dw("objc_msgSendSuper2", dw, dw, dw, false, 0);
2668 test_dw("objc_msgSendSuper_stret", dw, dw, dw, true, 0);
2669 test_dw("objc_msgSendSuper2_stret", dw, dw, dw, true, 0);
2670# else
2671# error unknown architecture
2672# endif
2673 }
2674
2675 // end DWARF unwind test
2676#endif
2677
2678 } POP_POOL;
2679 succeed(__FILE__);
2680}
mirror of objc4