First commit

Author: sandeep-datta

.gitignore

@@ -0,0 +1,5 @@
+*.o
+*.so
+main
+mainc
+maind

build

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+#make sure the linux shared library loader is able to find our library.
+export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
+
+#build libtest.so first
+gcc -fpic -g -c test.c
+gcc -shared test.o -o libtest.so
+
+#generate asm file for inspection
+objdump -d -M intel libtest.so > test.asm
+
+#next build main.c
+gcc -g main.c -L. -ltest -o mainc
+
+#generate asm file for inspection
+objdump -d -M intel mainc > mainc.asm
+
+#next build main.d
+dmd -g -c main.d
+gcc main.o -L. -ltest -lphobos2 -lrt -o maind
+
+#generate asm file for inspection
+objdump -d -M intel maind > maind.asm

main.c

@@ -0,0 +1,54 @@
+#include "stdio.h"
+#include "test.h"
+
+//From x86_64 System V EABI Spec...
+//rdi - 1st arg
+//rsi - 2nd arg
+//rdx - 3rd arg or 2nd return reg
+//rcx - 4th arg
+//r8  - 5th arg
+//r9  - 6th arg
+//rax - 1st return reg
+
+
+// 0000000000400634 <main>:
+//   400634:    55                      push   rbp
+//   400635:    48 89 e5                mov    rbp,rsp
+//   400638:    48 83 ec 30             sub    rsp,0x30                         //end of function prologue
+//   40063c:    c7 45 f0 ef be ad de    mov    DWORD PTR [rbp-0x10],0xdeadbeef  //*(rbp-0x10) = p1 = 0xdeadbeef
+//   400643:    c7 45 f4 00 00 00 00    mov    DWORD PTR [rbp-0xc],0x0          //*(rbp-0xc) = 0
+//   40064a:    c7 45 fc 64 00 00 00    mov    DWORD PTR [rbp-0x4],0x64         //*(rbp-0x4) = p2 = 0x64
+//   400651:    8b 55 fc                mov    edx,DWORD PTR [rbp-0x4]          //edx = p2
+//   400654:    48 8b 45 f0             mov    rax,QWORD PTR [rbp-0x10]         //rax = p1
+//   400658:    89 d6                   mov    esi,edx                          //esi = edx = p2
+//   40065a:    48 89 c7                mov    rdi,rax                          //rdi = rax = p1
+//   40065d:    e8 de fe ff ff          call   400540 <test@plt>                //test(rdi = p1, rsi = esi = p2) //Where is the retptr?
+//   400662:    48 89 c1                mov    rcx,rax                          //rcx = rax
+//   400665:    89 d0                   mov    eax,edx                          //eax = edx
+//   400667:    48 89 4d d0             mov    QWORD PTR [rbp-0x30],rcx         //*(rbp-0x30) = rcx
+//   40066b:    89 45 d8                mov    DWORD PTR [rbp-0x28],eax         //*(rbp-0x28) = eax
+//   40066e:    48 8b 45 d0             mov    rax,QWORD PTR [rbp-0x30]         //rax = *(rbp-0x30)
+//   400672:    48 89 45 e0             mov    QWORD PTR [rbp-0x20],rax         //*(rbp-0x20) = rax
+//   400676:    48 8b 45 d8             mov    rax,QWORD PTR [rbp-0x28]         //rax = *(rbp-0x28)
+//   40067a:    48 89 45 e8             mov    QWORD PTR [rbp-0x18],rax         //*(rbp-0x18) = rax
+//   40067e:    8b 55 e8                mov    edx,DWORD PTR [rbp-0x18]         //edx = *(rbp-0x18)
+//   400681:    48 8b 4d e0             mov    rcx,QWORD PTR [rbp-0x20]         //rcx = *(rbp-0x20)
+//   400685:    b8 9c 07 40 00          mov    eax,0x40079c                     //eax = 0x40079c
+//   40068a:    48 89 ce                mov    rsi,rcx                          //rsi = rcx
+//   40068d:    48 89 c7                mov    rdi,rax                          //rdi = rax
+//   400690:    b8 00 00 00 00          mov    eax,0x0                          //eax = 0
+//   400695:    e8 86 fe ff ff          call   400520 <printf@plt>              //printf(fmt, ts.data, ts.flags)
+//   40069a:    b8 00 00 00 00          mov    eax,0x0                          //eax = 0 //return 0;
+//   40069f:    c9                      leave                                   //
+//   4006a0:    c3                      ret                                     //
+
+int main()
+{
+    void *p1 = (void*)0xDEADBEEF;
+    unsigned p2 = 100; //0x64
+
+    TestStruct ts = test(p1, p2);
+
+    printf("ts.data=%p\nts.flags=%u\n", ts.data, ts.flags);
+    return 0;
+}

main.d

@@ -0,0 +1,76 @@
+import std.stdio;
+import test;
+
+//From x86_64 System V EABI Spec...
+//rdi - 1st arg
+//rsi - 2nd arg
+//rdx - 3rd arg or 2nd return reg
+//rcx - 4th arg
+//r8  - 5th arg
+//r9  - 6th arg
+//rax - 1st return reg
+
+//ASM code appears to be generated correctly for small sized return values
+//extern (C) void* test(void* p1, uint p2);
+//0000000000401f18 <_Dmain>:
+//  401f18:	55                   	push   rbp
+//  401f19:	48 8b ec             	mov    rbp,rsp					//end of function prologue
+//  401f1c:	48 b8 ef be ad de 00 	movabs rax,0xdeadbeef 			//rax = 0xdeadbeef (=p1)
+//  401f23:	00 00 00 
+//  401f26:	b9 64 00 00 00       	mov    ecx,0x64 				//ecx = 0x64 (=p2)
+//  401f2b:	48 89 ce             	mov    rsi,rcx 					//rsi = rcx = ecx = p2
+//  401f2e:	48 89 c7             	mov    rdi,rax 					//rdi = rax = p1
+//  401f31:	e8 d2 fc ff ff       	call   401c08 <test@plt>		//test(rdi  = p1, rsi = p2 )
+
+//This is the problem case...
+//extern (C) TestStruct test(void* p1, uint p2);
+//0000000000401f18 <_Dmain>:
+//  401f18:	55                   	push   rbp
+//  401f19:	48 8b ec             	mov    rbp,rsp					
+//  401f1c:	48 83 ec 10          	sub    rsp,0x10 				//rsp -= 0x10 //reserve space for the return value 
+																	//we can only allocate 8 byte chunks on the 64 bit stack
+																	//hence we have to allocate 16 (0x10) bytes even though we 
+																	//just need 12 (=TestStruct.sizeof)
+//  401f20:	48 b8 ef be ad de 00 	movabs rax,0xdeadbeef 			//rax = 0xdeadbeef
+//  401f27:	00 00 00 
+//  401f2a:	b9 64 00 00 00       	mov    ecx,0x64 				//ecx = p2
+//  401f2f:	48 89 ca             	mov    rdx,rcx   				//rdx = rcx = ecx = p2
+//  401f32:	48 89 c6             	mov    rsi,rax 					//rsi = rax = p1
+//  401f35:	48 8d 7d f0          	lea    rdi,[rbp-0x10]			//rdi = rbp-0x10 = retptr //BUG?
+//  401f39:	e8 ca fc ff ff       	call   401c08 <test@plt> 		//test(rdi = retptr, rsi = p1, rdx = p2 )
+
+//Dont know why the ASM code changed from above to the following (maybe optimisation failed?)!
+//0000000000401f18 <_Dmain>:
+//  401f18:	55                   	push   rbp
+//  401f19:	48 8b ec             	mov    rbp,rsp					
+//  401f1c:	48 83 ec 20          	sub    rsp,0x20 				//rsp -= 0x20 (=32)//reserve space for the locals and return value from test()
+																	//32 = TestStruct.sizeof(=12) + (void*).sizeof(=8) + uint.sizeof (=4)
+																	//It appears that the return value is directly stored in the TestStruct local var
+																	//hence TestStruct is not allocated twice
+//  401f20:	48 b8 ef be ad de 00 	movabs rax,0xdeadbeef 			//rax = 0xdeadbeef
+//  401f27:	00 00 00 
+//  401f2a:	48 89 45 e0          	mov    QWORD PTR [rbp-0x20],rax //p1 = *(rbp-0x20) ~ rax ~ 0xdeadbeef
+//  401f2e:	b9 64 00 00 00       	mov    ecx,0x64					//ecx = 0x64
+//  401f33:	89 4d e8             	mov    DWORD PTR [rbp-0x18],ecx //p2 = *(rbp-0x18) ~ ecx ~ 0x64
+//  401f36:	48 89 ca             	mov    rdx,rcx					//rdx = rcx ~ ecx ~ p2
+//  401f39:	48 89 c6             	mov    rsi,rax					//rsi = rax ~ p1
+//  401f3c:	48 8d 7d f0          	lea    rdi,[rbp-0x10]			//rdi = *(rbp-0x10) ~ retptr?
+//  401f40:	e8 c3 fc ff ff       	call   401c08 <test@plt>		//test(rdi = retptr, rsi = p1, rdx = p2)
+//  401f45:	ff 35 7d 3f 02 00    	push   QWORD PTR [rip+0x23f7d]        # 425ec8 <_TMP0+0x8> //format string?
+//  401f4b:	ff 35 6f 3f 02 00    	push   QWORD PTR [rip+0x23f6f]        # 425ec0 <_TMP0>
+//  401f51:	48 8b 75 f0          	mov    rsi,QWORD PTR [rbp-0x10] //rsi = *retptr ~ ts.data
+//  401f55:	8b 7d f8             	mov    edi,DWORD PTR [rbp-0x8]  //edi = *(retptr-0x8) ~ ts.flags
+//  401f58:	e8 0b 00 00 00       	call   401f68 <_D3std5stdio22__T8writeflnTAyaTPvTkZ8writeflnFAyaPvkZv>
+//  401f5d:	48 83 c4 10          	add    rsp,0x10
+//  401f61:	31 c0                	xor    eax,eax
+//  401f63:	c9                   	leave  
+//  401f64:	c3                   	ret    
+void main()
+{
+	void *p1 = cast(void*)0xDEADBEEF;
+	uint p2 = 100;//0x64
+
+	TestStruct ts = test.test(p1, p2);
+
+	writefln("ts.data=%s\nts.flags=%s", ts.data, ts.flags);
+}