ObjFW  Check-in [4628f6bbff]

Overview
Comment:invoke-x86_64.m: Support complex long double
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: 4628f6bbff4d186230087e95ac380f4d3565ba1f09fea9449e5d5700c78721c9
User & Date: js on 2017-09-17 10:48:07
Other Links: manifest | tags
Context
2017-09-21
20:25
invoke-x86_64.m: Minor code style change check-in: 645b4a9e1d user: js tags: trunk
2017-09-17
10:48
invoke-x86_64.m: Support complex long double check-in: 4628f6bbff user: js tags: trunk
03:27
call-x86_64-elf.S: Fix use of overwritten %rdi check-in: 9adb8518bb user: js tags: trunk
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Modified src/invocation/apple-call-x86_64.S from [387ccf9ff7] to [25b2bcb4a7].

︙︙
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


85
86
87



88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105






	movq	0(%rdi), %rdi

	movb	225(%rdi), %r11b

	cmpb	$1, %r11b
	je	Lcall_send_stret

	cmpb	$3, %r11b
	je	_objc_msgSend

	cmpb	$4, %r11b
	je	_objc_msgSend_stret

	call	_objc_msgSend

Lafter_send:
	movq	-8(%rbp), %rdi
	movq	%rax, 48(%rdi)
	movq	%rdx, 56(%rdi)
	movdqa	%xmm0, 64(%rdi)
	movdqa	%xmm1, 80(%rdi)



	cmpb	$2, 225(%rdi)
	je	Lpop_long_double




Lreturn:
	movq	%rbp, %rsp
	popq	%rbp

	ret

Lfix_align:
	xorq	%r11, %r11
	pushq	%r11
	jmp	Lfill_stack

Lcall_send_stret:
	call	_objc_msgSend_stret
	jmp	Lafter_send

Lpop_long_double:
	fstpt	192(%rdi)
	jmp	Lreturn













|


|











>
>
|


>
>
>


















>
>
>
>
>

63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

	movq	0(%rdi), %rdi

	movb	225(%rdi), %r11b

	cmpb	$1, %r11b
	je	Lcall_send_stret

	cmpb	$4, %r11b
	je	_objc_msgSend

	cmpb	$5, %r11b
	je	_objc_msgSend_stret

	call	_objc_msgSend

Lafter_send:
	movq	-8(%rbp), %rdi
	movq	%rax, 48(%rdi)
	movq	%rdx, 56(%rdi)
	movdqa	%xmm0, 64(%rdi)
	movdqa	%xmm1, 80(%rdi)

	movb	225(%rdi), %r11b

	cmpb	$2, %r11b
	je	Lpop_long_double

	cmpb	$3, %r11b
	je	Lpop_complex_long_double

Lreturn:
	movq	%rbp, %rsp
	popq	%rbp

	ret

Lfix_align:
	xorq	%r11, %r11
	pushq	%r11
	jmp	Lfill_stack

Lcall_send_stret:
	call	_objc_msgSend_stret
	jmp	Lafter_send

Lpop_long_double:
	fstpt	192(%rdi)
	jmp	Lreturn

Lpop_complex_long_double:
	fstpt	192(%rdi)
	fstpt	208(%rdi)
	jmp	Lreturn

Modified src/invocation/call-x86_64-elf.S from [dd38e0cbde] to [02e59e10e2].

︙︙
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96


97
98
99



100
101
102
103
104
105
106

	movq	16(%rdi), %rdx
	movq	8(%rdi), %rsi
	movq	0(%rdi), %rdi

	movq	-8(%rbp), %r11
	movb	225(%r11), %r11b

	cmpb	$3, %r11b
	je	.jmp_into_method
	cmpb	$4, %r11b
	je	.jmp_into_method

	movq	-16(%rbp), %r11
	call	*%r11

.after_send:
	movq	-8(%rbp), %rdi
	movq	%rax, 48(%rdi)
	movq	%rdx, 56(%rdi)
	movdqa	%xmm0, 64(%rdi)
	movdqa	%xmm1, 80(%rdi)



	cmpb	$2, 225(%rdi)
	je	.pop_long_double




.return:
	movq	%rbp, %rsp
	popq	%rbp

	ret

.fix_align:








|

|












>
>
|


>
>
>








75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

	movq	16(%rdi), %rdx
	movq	8(%rdi), %rsi
	movq	0(%rdi), %rdi

	movq	-8(%rbp), %r11
	movb	225(%r11), %r11b

	cmpb	$4, %r11b
	je	.jmp_into_method
	cmpb	$5, %r11b
	je	.jmp_into_method

	movq	-16(%rbp), %r11
	call	*%r11

.after_send:
	movq	-8(%rbp), %rdi
	movq	%rax, 48(%rdi)
	movq	%rdx, 56(%rdi)
	movdqa	%xmm0, 64(%rdi)
	movdqa	%xmm1, 80(%rdi)

	movb	225(%rdi), %r11b

	cmpb	$2, %r11b
	je	.pop_long_double

	cmpb	$3, %r11b
	je	.pop_complex_long_double

.return:
	movq	%rbp, %rsp
	popq	%rbp

	ret

.fix_align:
︙︙
118
119
120
121
122
123
124





125
126
127
128

.jmp_into_method:
	movq	-16(%rbp), %r11
	jmp	*%r11

.pop_long_double:
	fstpt	192(%rdi)
	jmp	.return






#ifdef OF_LINUX
.section .note.GNU-stack, "", %progbits
#endif








>
>
>
>
>





123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

.jmp_into_method:
	movq	-16(%rbp), %r11
	jmp	*%r11

.pop_long_double:
	fstpt	192(%rdi)
	jmp	.return

.pop_complex_long_double:
	fstpt	192(%rdi)
	fstpt	208(%rdi)
	jmp	.return

#ifdef OF_LINUX
.section .note.GNU-stack, "", %progbits
#endif

Modified src/invocation/invoke-x86_64.m from [567ef57186] to [036198eaf0].

︙︙
33
34
35
36
37
38
39

40
41
42
43
44
45
46

#define NUM_SSE_IN 8
#define NUM_X87_OUT 2

enum {
	RETURN_TYPE_NORMAL,
	RETURN_TYPE_STRUCT,
	RETURN_TYPE_X87,

	RETURN_TYPE_JMP,
	RETURN_TYPE_JMP_STRET
};

struct call_context {
	uint64_t gpr[NUM_GPR_IN + NUM_GPR_OUT];
	__m128 sse[NUM_SSE_IN];








>








33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#define NUM_SSE_IN 8
#define NUM_X87_OUT 2

enum {
	RETURN_TYPE_NORMAL,
	RETURN_TYPE_STRUCT,
	RETURN_TYPE_X87,
	RETURN_TYPE_COMPLEX_X87,
	RETURN_TYPE_JMP,
	RETURN_TYPE_JMP_STRET
};

struct call_context {
	uint64_t gpr[NUM_GPR_IN + NUM_GPR_OUT];
	__m128 sse[NUM_SSE_IN];
︙︙
142
143
144
145
146
147
148






















149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

		    sizeof(**context) + ((*context)->stack_size + 2) * 8];
	}

	memcpy(&newContext->stack[newContext->stack_size], &value, 16);
	newContext->stack_size += 2;
	*context = newContext;
}























#if defined(__SIZEOF_INT128__) && !defined(__clang__)
static void
pushInt128(struct call_context **context, uint_fast8_t *currentGPR,
    uint64_t low, uint64_t high)
{
	size_t stackSize;
	struct call_context *newContext;

	if (*currentGPR + 1 < NUM_GPR_IN) {
		(*context)->gpr[(*currentGPR)++] = low;
		(*context)->gpr[(*currentGPR)++] = high;
		return;
	}

	stackSize = OF_ROUND_UP_POW2(2, (*context)->stack_size) + 2;

	if ((newContext = realloc(*context,
	    sizeof(**context) + stackSize * 8)) == NULL) {
		free(*context);
		@throw [OFOutOfMemoryException exceptionWithRequestedSize:
		    sizeof(**context) + stackSize * 8];
	}

	memset(&newContext->stack[newContext->stack_size], '\0',
	    (stackSize - newContext->stack_size) * 8);
	newContext->stack[stackSize - 2] = low;
	newContext->stack[stackSize - 1] = high;
	newContext->stack_size = stackSize;
	*context = newContext;
}
#endif

void
of_invocation_invoke(OFInvocation *invocation)








>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>




|





|
|














|
<








143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

199
200
201
202
203
204
205

		    sizeof(**context) + ((*context)->stack_size + 2) * 8];
	}

	memcpy(&newContext->stack[newContext->stack_size], &value, 16);
	newContext->stack_size += 2;
	*context = newContext;
}

static void
pushLongDoublePair(struct call_context **context, long double value[2])
{
	size_t stackSize;
	struct call_context *newContext;

	stackSize = OF_ROUND_UP_POW2(2, (*context)->stack_size) + 4;

	if ((newContext = realloc(*context,
	    sizeof(**context) + stackSize * 8)) == NULL) {
		free(*context);
		@throw [OFOutOfMemoryException exceptionWithRequestedSize:
		    sizeof(**context) + stackSize * 8];
	}

	memset(&newContext->stack[newContext->stack_size], '\0',
	    (stackSize - newContext->stack_size) * 8);
	memcpy(&newContext->stack[stackSize - 4], value, 32);
	newContext->stack_size = stackSize;
	*context = newContext;
}

#if defined(__SIZEOF_INT128__) && !defined(__clang__)
static void
pushInt128(struct call_context **context, uint_fast8_t *currentGPR,
    uint64_t value[2])
{
	size_t stackSize;
	struct call_context *newContext;

	if (*currentGPR + 1 < NUM_GPR_IN) {
		(*context)->gpr[(*currentGPR)++] = value[0];
		(*context)->gpr[(*currentGPR)++] = value[1];
		return;
	}

	stackSize = OF_ROUND_UP_POW2(2, (*context)->stack_size) + 2;

	if ((newContext = realloc(*context,
	    sizeof(**context) + stackSize * 8)) == NULL) {
		free(*context);
		@throw [OFOutOfMemoryException exceptionWithRequestedSize:
		    sizeof(**context) + stackSize * 8];
	}

	memset(&newContext->stack[newContext->stack_size], '\0',
	    (stackSize - newContext->stack_size) * 8);
	memcpy(&newContext->stack[stackSize - 2], value, 16);

	newContext->stack_size = stackSize;
	*context = newContext;
}
#endif

void
of_invocation_invoke(OFInvocation *invocation)
︙︙
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247

		CASE_GPR('@', uintptr_t)
		CASE_GPR('#', uintptr_t)
		CASE_GPR(':', uintptr_t)
		CASE_GPR('^', uintptr_t)
#ifdef __SIZEOF_INT128__
		case 't':
		case 'T':;
			struct {
				uint64_t low, high;
			} int128Tmp;
			[invocation getArgument: &int128Tmp
					atIndex: i];
# ifndef __clang__
			pushInt128(&context, &currentGPR,
			    int128Tmp.low, int128Tmp.high);
# else
			/* See https://bugs.llvm.org/show_bug.cgi?id=34646 */
			pushGPR(&context, &currentGPR, int128Tmp.low);
			pushGPR(&context, &currentGPR, int128Tmp.high);
# endif
			break;
#endif
		case 'f':;
			float floatTmp;
			[invocation getArgument: &floatTmp
					atIndex: i];








<
<
|



|
<


|
|








244
245
246
247
248
249
250


251
252
253
254
255

256
257
258
259
260
261
262
263
264
265
266

		CASE_GPR('@', uintptr_t)
		CASE_GPR('#', uintptr_t)
		CASE_GPR(':', uintptr_t)
		CASE_GPR('^', uintptr_t)
#ifdef __SIZEOF_INT128__
		case 't':
		case 'T':;


			uint64_t int128Tmp[2];
			[invocation getArgument: &int128Tmp
					atIndex: i];
# ifndef __clang__
			pushInt128(&context, &currentGPR, int128Tmp);

# else
			/* See https://bugs.llvm.org/show_bug.cgi?id=34646 */
			pushGPR(&context, &currentGPR, int128Tmp[0]);
			pushGPR(&context, &currentGPR, int128Tmp[1]);
# endif
			break;
#endif
		case 'f':;
			float floatTmp;
			[invocation getArgument: &floatTmp
					atIndex: i];
︙︙
272
273
274
275
276
277
278
279






280
281
282
283
284
285
286

			case 'd':;
				double complexDoubleTmp[2];
				[invocation getArgument: &complexDoubleTmp
						atIndex: i];
				pushQuad(&context, &currentSSE,
				    complexDoubleTmp[0], complexDoubleTmp[1]);
				break;
			/* TODO: 'D' */






			default:
				free(context);
				@throw [OFInvalidFormatException exception];
			}

			break;
#endif








|
>
>
>
>
>
>








291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311

			case 'd':;
				double complexDoubleTmp[2];
				[invocation getArgument: &complexDoubleTmp
						atIndex: i];
				pushQuad(&context, &currentSSE,
				    complexDoubleTmp[0], complexDoubleTmp[1]);
				break;
			case 'D':;
				long double complexLongDoubleTmp[2];
				[invocation getArgument: &complexLongDoubleTmp
						atIndex: i];
				pushLongDoublePair(&context,
				    complexLongDoubleTmp);
				break;
			default:
				free(context);
				@throw [OFInvalidFormatException exception];
			}

			break;
#endif
︙︙
330
331
332
333
334
335
336
337


338
339
340
341
342
343
344

#ifndef __STDC_NO_COMPLEX__
	case 'j':
		switch (typeEncoding[1]) {
		case 'f':
		case 'd':
			context->return_type = RETURN_TYPE_NORMAL;
			break;
		/* TODO: 'D' */


		default:
			free(context);
			@throw [OFInvalidFormatException exception];
		}

		break;
#endif








|
>
>








355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371

#ifndef __STDC_NO_COMPLEX__
	case 'j':
		switch (typeEncoding[1]) {
		case 'f':
		case 'd':
			context->return_type = RETURN_TYPE_NORMAL;
			break;
		case 'D':
			context->return_type = RETURN_TYPE_COMPLEX_X87;
			break;
		default:
			free(context);
			@throw [OFInvalidFormatException exception];
		}

		break;
#endif
︙︙
408
409
410
411
412
413
414
415


416
417
418
419
420
421
422

				double complexDoubleTmp[2];
				_mm_store_sd(&complexDoubleTmp[0],
				    (__m128d)context->sse[0]);
				_mm_store_sd(&complexDoubleTmp[1],
				    (__m128d)context->sse[1]);
				[invocation setReturnValue: &complexDoubleTmp];
				break;
			/* TODO: 'D' */


			default:
				free(context);
				@throw [OFInvalidFormatException exception];
			}

			break;
#endif








|
>
>








435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451

				double complexDoubleTmp[2];
				_mm_store_sd(&complexDoubleTmp[0],
				    (__m128d)context->sse[0]);
				_mm_store_sd(&complexDoubleTmp[1],
				    (__m128d)context->sse[1]);
				[invocation setReturnValue: &complexDoubleTmp];
				break;
			case 'D':
				[invocation setReturnValue: context->x87];
				break;
			default:
				free(context);
				@throw [OFInvalidFormatException exception];
			}

			break;
#endif
︙︙

Modified tests/OFInvocationTests.m from [86c5f0ef13] to [22ff9322e7].

︙︙
141
142
143
144
145
146
147






































148
149
150
151
152
153
154
155
156
157
158
159

	OF_ENSURE(creal(c14) == 14.0 && cimag(c14) == 7.0);
	OF_ENSURE(creal(c15) == 15.0 && cimag(c15) == 7.5);
	OF_ENSURE(creal(c16) == 16.0 && cimag(c16) == 8.0);

	return (c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9 + c10 + c11 +
	    c12 + c13 + c14 + c15 + c16) / 16;
}






































#endif

#ifdef __SIZEOF_INT128__
__extension__
- (__int128)invocationTestMethod6: (int)i1
				 : (__int128)i2
				 : (__int128)i3
				 : (__int128)i4
				 : (int)i5
				 : (__int128)i6
				 : (__int128)i7
				 : (__int128)i8








>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>




|








141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

	OF_ENSURE(creal(c14) == 14.0 && cimag(c14) == 7.0);
	OF_ENSURE(creal(c15) == 15.0 && cimag(c15) == 7.5);
	OF_ENSURE(creal(c16) == 16.0 && cimag(c16) == 8.0);

	return (c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9 + c10 + c11 +
	    c12 + c13 + c14 + c15 + c16) / 16;
}

- (complex long double)invocationTestMethod6: (complex double)c1
					    : (complex float)c2
					    : (complex long double)c3
					    : (complex double)c4
					    : (complex float)c5
					    : (complex long double)c6
					    : (complex double)c7
					    : (complex float)c8
					    : (complex long double)c9
					    : (complex double)c10
					    : (complex float)c11
					    : (complex long double)c12
					    : (complex double)c13
					    : (complex float)c14
					    : (complex long double)c15
					    : (complex double)c16
{
	OF_ENSURE(creal(c1) == 1.0 && cimag(c1) == 0.5);
	OF_ENSURE(creal(c2) == 2.0 && cimag(c2) == 1.0);
	OF_ENSURE(creal(c3) == 3.0 && cimag(c3) == 1.5);
	OF_ENSURE(creal(c4) == 4.0 && cimag(c4) == 2.0);
	OF_ENSURE(creal(c5) == 5.0 && cimag(c5) == 2.5);
	OF_ENSURE(creal(c6) == 6.0 && cimag(c6) == 3.0);
	OF_ENSURE(creal(c7) == 7.0 && cimag(c7) == 3.5);
	OF_ENSURE(creal(c8) == 8.0 && cimag(c8) == 4.0);
	OF_ENSURE(creal(c9) == 9.0 && cimag(c9) == 4.5);
	OF_ENSURE(creal(c10) == 10.0 && cimag(c10) == 5.0);
	OF_ENSURE(creal(c11) == 11.0 && cimag(c11) == 5.5);
	OF_ENSURE(creal(c12) == 12.0 && cimag(c12) == 6.0);
	OF_ENSURE(creal(c13) == 13.0 && cimag(c13) == 6.5);
	OF_ENSURE(creal(c14) == 14.0 && cimag(c14) == 7.0);
	OF_ENSURE(creal(c15) == 15.0 && cimag(c15) == 7.5);
	OF_ENSURE(creal(c16) == 16.0 && cimag(c16) == 8.0);

	return (c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8 + c9 + c10 + c11 +
	    c12 + c13 + c14 + c15 + c16) / 16;
}
#endif

#ifdef __SIZEOF_INT128__
__extension__
- (__int128)invocationTestMethod7: (int)i1
				 : (__int128)i2
				 : (__int128)i3
				 : (__int128)i4
				 : (int)i5
				 : (__int128)i6
				 : (__int128)i7
				 : (__int128)i8
︙︙
332
333
334
335
336
337
338








































339
340
341
342
343
344
345
346
347
348
349
350

					atIndex: i + 1];
	}

	complex double complexDoubleResult;
	TEST(@"-[invoke] #4", R([invocation invoke]) &&
	    R([invocation getReturnValue: &complexDoubleResult]) &&
	    complexDoubleResult == 8.5 + 4.25 * I)








































# endif

# ifdef __SIZEOF_INT128__
	/* -[invoke] #5 */
	selector = @selector(invocationTestMethod6::::::::::::::::);
	invocation = [OFInvocation invocationWithMethodSignature:
	    [self methodSignatureForSelector: selector]];

	[invocation setArgument: &self
			atIndex: 0];
	[invocation setArgument: &selector
			atIndex: 1];








>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>



|
|








370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428

					atIndex: i + 1];
	}

	complex double complexDoubleResult;
	TEST(@"-[invoke] #4", R([invocation invoke]) &&
	    R([invocation getReturnValue: &complexDoubleResult]) &&
	    complexDoubleResult == 8.5 + 4.25 * I)

	/* Only when encoding complex long doubles is supported */
	if (strcmp(@encode(complex double),
	    @encode(complex long double)) != 0) {
		/* -[invoke] #5 */
		selector = @selector(invocationTestMethod6::::::::::::::::);
		invocation = [OFInvocation invocationWithMethodSignature:
		    [self methodSignatureForSelector: selector]];

		[invocation setArgument: &self
				atIndex: 0];
		[invocation setArgument: &selector
				atIndex: 1];

		for (int i = 1; i <= 16; i++) {
			complex double cd = i + 0.5 * i * I;
			complex float cf = i + 0.5 * i * I;
			complex long double cld = i + 0.5 * i * I;

			switch (i % 3) {
			case 0:
				[invocation setArgument: &cld
						atIndex: i + 1];
				break;
			case 1:
				[invocation setArgument: &cd
						atIndex: i + 1];
				break;
			case 2:
				[invocation setArgument: &cf
						atIndex: i + 1];
				break;
			}
		}

		complex long double complexLongDoubleResult;
		TEST(@"-[invoke] #5", R([invocation invoke]) &&
		    R([invocation getReturnValue: &complexLongDoubleResult]) &&
		    complexLongDoubleResult == 8.5 + 4.25 * I)
	}
# endif

# ifdef __SIZEOF_INT128__
	/* -[invoke] #6 */
	selector = @selector(invocationTestMethod7::::::::::::::::);
	invocation = [OFInvocation invocationWithMethodSignature:
	    [self methodSignatureForSelector: selector]];

	[invocation setArgument: &self
			atIndex: 0];
	[invocation setArgument: &selector
			atIndex: 1];
︙︙
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375

					atIndex: i + 1];
		else
			[invocation setArgument: &i128
					atIndex: i + 1];
	}

	__extension__ __int128 int128Result;
	TEST(@"-[invoke] #5", R([invocation invoke]) &&
	    R([invocation getReturnValue: &int128Result]) &&
	    int128Result == __extension__ ((__int128)0xFFFFFFFFFFFFFFFF << 64) +
	    8)
# endif
#endif

	[pool drain];
}
@end








|










437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453

					atIndex: i + 1];
		else
			[invocation setArgument: &i128
					atIndex: i + 1];
	}

	__extension__ __int128 int128Result;
	TEST(@"-[invoke] #6", R([invocation invoke]) &&
	    R([invocation getReturnValue: &int128Result]) &&
	    int128Result == __extension__ ((__int128)0xFFFFFFFFFFFFFFFF << 64) +
	    8)
# endif
#endif

	[pool drain];
}
@end

Fossil 2.23 [47362306a7] 2023-11-01 18:56:47
This page was generated in about 0.022s