Index: src/invocation/apple-call-x86_64.S
==================================================================
--- src/invocation/apple-call-x86_64.S
+++ src/invocation/apple-call-x86_64.S
@@ -65,14 +65,14 @@
 	movb	225(%rdi), %r11b
 
 	cmpb	$1, %r11b
 	je	Lcall_send_stret
 
-	cmpb	$3, %r11b
+	cmpb	$4, %r11b
 	je	_objc_msgSend
 
-	cmpb	$4, %r11b
+	cmpb	$5, %r11b
 	je	_objc_msgSend_stret
 
 	call	_objc_msgSend
 
 Lafter_send:
@@ -80,13 +80,18 @@
 	movq	%rax, 48(%rdi)
 	movq	%rdx, 56(%rdi)
 	movdqa	%xmm0, 64(%rdi)
 	movdqa	%xmm1, 80(%rdi)
 
-	cmpb	$2, 225(%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
@@ -101,5 +106,10 @@
 	jmp	Lafter_send
 
 Lpop_long_double:
 	fstpt	192(%rdi)
 	jmp	Lreturn
+
+Lpop_complex_long_double:
+	fstpt	192(%rdi)
+	fstpt	208(%rdi)
+	jmp	Lreturn

Index: src/invocation/call-x86_64-elf.S
==================================================================
--- src/invocation/call-x86_64-elf.S
+++ src/invocation/call-x86_64-elf.S
@@ -77,13 +77,13 @@
 	movq	0(%rdi), %rdi
 
 	movq	-8(%rbp), %r11
 	movb	225(%r11), %r11b
 
-	cmpb	$3, %r11b
+	cmpb	$4, %r11b
 	je	.jmp_into_method
-	cmpb	$4, %r11b
+	cmpb	$5, %r11b
 	je	.jmp_into_method
 
 	movq	-16(%rbp), %r11
 	call	*%r11
 
@@ -92,13 +92,18 @@
 	movq	%rax, 48(%rdi)
 	movq	%rdx, 56(%rdi)
 	movdqa	%xmm0, 64(%rdi)
 	movdqa	%xmm1, 80(%rdi)
 
-	cmpb	$2, 225(%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
@@ -120,9 +125,14 @@
 	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

Index: src/invocation/invoke-x86_64.m
==================================================================
--- src/invocation/invoke-x86_64.m
+++ src/invocation/invoke-x86_64.m
@@ -35,10 +35,11 @@
 
 enum {
 	RETURN_TYPE_NORMAL,
 	RETURN_TYPE_STRUCT,
 	RETURN_TYPE_X87,
+	RETURN_TYPE_COMPLEX_X87,
 	RETURN_TYPE_JMP,
 	RETURN_TYPE_JMP_STRET
 };
 
 struct call_context {
@@ -144,22 +145,44 @@
 
 	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 low, uint64_t high)
+    uint64_t value[2])
 {
 	size_t stackSize;
 	struct call_context *newContext;
 
 	if (*currentGPR + 1 < NUM_GPR_IN) {
-		(*context)->gpr[(*currentGPR)++] = low;
-		(*context)->gpr[(*currentGPR)++] = high;
+		(*context)->gpr[(*currentGPR)++] = value[0];
+		(*context)->gpr[(*currentGPR)++] = value[1];
 		return;
 	}
 
 	stackSize = OF_ROUND_UP_POW2(2, (*context)->stack_size) + 2;
 
@@ -170,12 +193,11 @@
 		    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;
+	memcpy(&newContext->stack[stackSize - 2], value, 16);
 	newContext->stack_size = stackSize;
 	*context = newContext;
 }
 #endif
 
@@ -224,22 +246,19 @@
 		CASE_GPR(':', uintptr_t)
 		CASE_GPR('^', uintptr_t)
 #ifdef __SIZEOF_INT128__
 		case 't':
 		case 'T':;
-			struct {
-				uint64_t low, high;
-			} int128Tmp;
+			uint64_t int128Tmp[2];
 			[invocation getArgument: &int128Tmp
 					atIndex: i];
 # ifndef __clang__
-			pushInt128(&context, &currentGPR,
-			    int128Tmp.low, int128Tmp.high);
+			pushInt128(&context, &currentGPR, int128Tmp);
 # else
 			/* See https://bugs.llvm.org/show_bug.cgi?id=34646 */
-			pushGPR(&context, &currentGPR, int128Tmp.low);
-			pushGPR(&context, &currentGPR, int128Tmp.high);
+			pushGPR(&context, &currentGPR, int128Tmp[0]);
+			pushGPR(&context, &currentGPR, int128Tmp[1]);
 # endif
 			break;
 #endif
 		case 'f':;
 			float floatTmp;
@@ -274,11 +293,17 @@
 				[invocation getArgument: &complexDoubleTmp
 						atIndex: i];
 				pushQuad(&context, &currentSSE,
 				    complexDoubleTmp[0], complexDoubleTmp[1]);
 				break;
-			/* TODO: 'D' */
+			case 'D':;
+				long double complexLongDoubleTmp[2];
+				[invocation getArgument: &complexLongDoubleTmp
+						atIndex: i];
+				pushLongDoublePair(&context,
+				    complexLongDoubleTmp);
+				break;
 			default:
 				free(context);
 				@throw [OFInvalidFormatException exception];
 			}
 
@@ -332,11 +357,13 @@
 		switch (typeEncoding[1]) {
 		case 'f':
 		case 'd':
 			context->return_type = RETURN_TYPE_NORMAL;
 			break;
-		/* TODO: 'D' */
+		case 'D':
+			context->return_type = RETURN_TYPE_COMPLEX_X87;
+			break;
 		default:
 			free(context);
 			@throw [OFInvalidFormatException exception];
 		}
 
@@ -410,11 +437,13 @@
 				    (__m128d)context->sse[0]);
 				_mm_store_sd(&complexDoubleTmp[1],
 				    (__m128d)context->sse[1]);
 				[invocation setReturnValue: &complexDoubleTmp];
 				break;
-			/* TODO: 'D' */
+			case 'D':
+				[invocation setReturnValue: context->x87];
+				break;
 			default:
 				free(context);
 				@throw [OFInvalidFormatException exception];
 			}
 

Index: tests/OFInvocationTests.m
==================================================================
--- tests/OFInvocationTests.m
+++ tests/OFInvocationTests.m
@@ -143,15 +143,53 @@
 	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)invocationTestMethod6: (int)i1
+- (__int128)invocationTestMethod7: (int)i1
 				 : (__int128)i2
 				 : (__int128)i3
 				 : (__int128)i4
 				 : (int)i5
 				 : (__int128)i6
@@ -334,15 +372,55 @@
 
 	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] #5 */
-	selector = @selector(invocationTestMethod6::::::::::::::::);
+	/* -[invoke] #6 */
+	selector = @selector(invocationTestMethod7::::::::::::::::);
 	invocation = [OFInvocation invocationWithMethodSignature:
 	    [self methodSignatureForSelector: selector]];
 
 	[invocation setArgument: &self
 			atIndex: 0];
@@ -361,15 +439,15 @@
 			[invocation setArgument: &i128
 					atIndex: i + 1];
 	}
 
 	__extension__ __int128 int128Result;
-	TEST(@"-[invoke] #5", R([invocation invoke]) &&
+	TEST(@"-[invoke] #6", R([invocation invoke]) &&
 	    R([invocation getReturnValue: &int128Result]) &&
 	    int128Result == __extension__ ((__int128)0xFFFFFFFFFFFFFFFF << 64) +
 	    8)
 # endif
 #endif
 
 	[pool drain];
 }
 @end