Index: src/invocation/invoke-x86_64.m ================================================================== --- src/invocation/invoke-x86_64.m +++ src/invocation/invoke-x86_64.m @@ -96,10 +96,41 @@ memcpy(&newContext->stack[newContext->stack_size], &value, 8); newContext->stack_size++; *context = newContext; } + +static void +pushQuad(struct call_context **context, uint_fast8_t *currentSSE, + double low, double high) +{ + size_t stackSize; + struct call_context *newContext; + + if (*currentSSE + 1 < NUM_SSE_IN) { + (*context)->sse[(*currentSSE)++] = (__m128)_mm_set_sd(low); + (*context)->sse[(*currentSSE)++] = (__m128)_mm_set_sd(high); + (*context)->num_sse_used += 2; + return; + } + + stackSize = (*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], &low, 8); + memcpy(&newContext->stack[stackSize - 1], &high, 8); + newContext->stack_size = stackSize; + *context = newContext; +} static void pushLongDouble(struct call_context **context, long double value) { struct call_context *newContext; @@ -119,12 +150,12 @@ #if defined(__SIZEOF_INT128__) && !defined(__clang__) static void pushInt128(struct call_context **context, uint_fast8_t *currentGPR, uint64_t low, uint64_t high) { - struct call_context *newContext; size_t stackSize; + struct call_context *newContext; if (*currentGPR + 1 < NUM_GPR_IN) { (*context)->gpr[(*currentGPR)++] = low; (*context)->gpr[(*currentGPR)++] = high; return; @@ -184,10 +215,16 @@ CASE_GPR('S', unsigned short) CASE_GPR('l', long) CASE_GPR('L', unsigned long) CASE_GPR('q', long long) CASE_GPR('Q', unsigned long long) + CASE_GPR('B', _Bool) + CASE_GPR('*', uintptr_t) + 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; @@ -196,10 +233,11 @@ atIndex: i]; # ifndef __clang__ pushInt128(&context, ¤tGPR, int128Tmp.low, int128Tmp.high); # else + /* See https://bugs.llvm.org/show_bug.cgi?id=34646 */ pushGPR(&context, ¤tGPR, int128Tmp.low); pushGPR(&context, ¤tGPR, int128Tmp.high); # endif break; #endif @@ -219,22 +257,38 @@ long double longDoubleTmp; [invocation getArgument: &longDoubleTmp atIndex: i]; pushLongDouble(&context, longDoubleTmp); break; - CASE_GPR('B', _Bool) - CASE_GPR('*', uintptr_t) - CASE_GPR('@', uintptr_t) - CASE_GPR('#', uintptr_t) - CASE_GPR(':', uintptr_t) +#ifndef __STDC_NO_COMPLEX__ + case 'j': + switch (typeEncoding[1]) { + case 'f':; + double complexFloatTmp; + [invocation getArgument: &complexFloatTmp + atIndex: i]; + pushDouble(&context, ¤tSSE, + complexFloatTmp); + break; + case 'd':; + double complexDoubleTmp[2]; + [invocation getArgument: &complexDoubleTmp + atIndex: i]; + pushQuad(&context, ¤tSSE, + complexDoubleTmp[0], complexDoubleTmp[1]); + break; + /* TODO: 'D' */ + default: + free(context); + @throw [OFInvalidFormatException exception]; + } + + break; +#endif /* TODO: '[' */ /* TODO: '{' */ /* TODO: '(' */ - CASE_GPR('^', uintptr_t) -#ifndef __STDC_NO_COMPLEX__ - /* TODO: 'j' */ -#endif default: free(context); @throw [OFInvalidFormatException exception]; #undef CASE_GPR } @@ -254,33 +308,45 @@ case 'S': case 'l': case 'L': case 'q': case 'Q': -#ifdef __SIZEOF_INT128__ - case 't': - case 'T': -#endif - case 'f': - case 'd': case 'B': case '*': case '@': case '#': case ':': case '^': +#ifdef __SIZEOF_INT128__ + case 't': + case 'T': +#endif + case 'f': + case 'd': context->return_type = RETURN_TYPE_NORMAL; break; case 'D': context->return_type = RETURN_TYPE_X87; break; +#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 /* TODO: '[' */ /* TODO: '{' */ /* TODO: '(' */ -#ifndef __STDC_NO_COMPLEX__ - /* TODO: 'j' */ -#endif default: free(context); @throw [OFInvalidFormatException exception]; } @@ -302,10 +368,16 @@ CASE_GPR('S', unsigned short) CASE_GPR('l', long) CASE_GPR('L', unsigned long) CASE_GPR('q', long long) CASE_GPR('Q', unsigned long long) + CASE_GPR('B', _Bool) + CASE_GPR('*', uintptr_t) + CASE_GPR('@', uintptr_t) + CASE_GPR('#', uintptr_t) + CASE_GPR(':', uintptr_t) + CASE_GPR('^', uintptr_t) #ifdef __SIZEOF_INT128__ case 't': case 'T':; [invocation setReturnValue: &context->gpr[NUM_GPR_IN]]; break; @@ -321,25 +393,41 @@ [invocation setReturnValue: &doubleTmp]; break; case 'D': [invocation setReturnValue: &context->x87[0]]; break; - CASE_GPR('B', _Bool) - CASE_GPR('*', uintptr_t) - CASE_GPR('@', uintptr_t) - CASE_GPR('#', uintptr_t) - CASE_GPR(':', uintptr_t) +#ifndef __STDC_NO_COMPLEX__ + case 'j': + switch (typeEncoding[1]) { + case 'f':; + double complexFloatTmp; + _mm_store_sd(&complexFloatTmp, + (__m128d)context->sse[0]); + [invocation setReturnValue: &complexFloatTmp]; + break; + case 'd':; + 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 /* TODO: '[' */ /* TODO: '{' */ /* TODO: '(' */ - CASE_GPR('^', uintptr_t) -#ifndef __STDC_NO_COMPLEX__ - /* TODO: 'j' */ -#endif default: free(context); @throw [OFInvalidFormatException exception]; #undef CASE_GPR } free(context); } Index: tests/OFInvocationTests.m ================================================================== --- tests/OFInvocationTests.m +++ tests/OFInvocationTests.m @@ -15,10 +15,14 @@ */ #include "config.h" #include + +#ifndef __STDC_NO_COMPLEX__ +# include +#endif #import "OFInvocation.h" #import "OFMethodSignature.h" #import "OFAutoreleasePool.h" @@ -100,14 +104,54 @@ : (long double)d16 { return (d1 + d2 + d3 + d4 + d5 + d6 + d7 + d8 + d9 + d10 + d11 + d12 + d13 + d14 + d15 + d16) / 16; } + +#ifndef __STDC_NO_COMPLEX__ +- (complex double)invocationTestMethod5: (complex float)c1 + : (complex double)c2 + : (complex float)c3 + : (complex double)c4 + : (complex float)c5 + : (complex double)c6 + : (complex float)c7 + : (complex double)c8 + : (complex float)c9 + : (complex double)c10 + : (complex float)c11 + : (complex double)c12 + : (complex float)c13 + : (complex double)c14 + : (complex float)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)invocationTestMethod5: (int)i1 +- (__int128)invocationTestMethod6: (int)i1 : (__int128)i2 : (__int128)i3 : (__int128)i4 : (int)i5 : (__int128)i6 @@ -263,16 +307,45 @@ TEST(@"-[invoke] #3", R([invocation invoke]) && R([invocation getReturnValue: &longDoubleResult]) && longDoubleResult == 8.5) } -# ifdef __SIZEOF_INT128__ +# ifndef __STDC_NO_COMPLEX__ /* -[invoke] #4 */ selector = @selector(invocationTestMethod5::::::::::::::::); invocation = [OFInvocation invocationWithMethodSignature: [self methodSignatureForSelector: selector]]; + [invocation setArgument: &self + atIndex: 0]; + [invocation setArgument: &selector + atIndex: 1]; + + for (int i = 1; i <= 16; i++) { + complex float cf = i + 0.5 * i * I; + complex double cd = i + 0.5 * i * I; + + if (i & 1) + [invocation setArgument: &cf + atIndex: i + 1]; + else + [invocation setArgument: &cd + 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]; @@ -288,15 +361,15 @@ [invocation setArgument: &i128 atIndex: i + 1]; } __extension__ __int128 int128Result; - TEST(@"-[invoke] #4", R([invocation invoke]) && + TEST(@"-[invoke] #5", R([invocation invoke]) && R([invocation getReturnValue: &int128Result]) && int128Result == __extension__ ((__int128)0xFFFFFFFFFFFFFFFF << 64) + 8) # endif #endif [pool drain]; } @end