Returning information from Assembly to C++ without registers

[Vintage1983]

I am in my first semester of assembly on the intel 86x processor, basicly I have been working on this problem for about two weeks and my book and net references haven't been able to help me out.

I am doing a call from C++ into Assembly from this code.

enum ResultCode        {ShowSquare, ShowMultiply, ShowDivide, ShowRemainder, ShowDivideFailure};
enum SuccessCode    {Failure, Success};

extern "C" SuccessCode Divide (long, long, long &, long &);
extern "C" void PrintResult (ResultCode, long);

...some code...main....

cout << "Enter mumber to divide into then number to divide by" << endl;
cin >> Num1 >> Num2;
if (Divide (Num1, Num2, Result, Remainder) == Success)
cout << "Result is " << Result << " and remainder is " << Remainder << endl<<endl;
else
cout << "Attempted division by zero" << endl<<endl;

...

void PrintResult (ResultCode PrintCode, long Value)
    {
    switch (PrintCode)
        {
        case ShowDivide:
                cout << "Display of divide is " << Value << endl;
                break;
        case ShowRemainder:
                cout << "Display of remainder is " << Value << endl;
                break;
        case ShowDivideFailure:
                cout << "Display of Division by zero" << endl;
                break;

I have most of the Assembly code up and working but I can't figure out how to modify the result and remainded parameters being passed into the Assembly call after the result and such has been found in my .asm file.

Here is a snippet of my Assembly code

;_Divide    proc dividend:DWORD, divsor:DWORD, result:DWORD, remained:DWORD
_Divide    proc
        push    ebp
        mov    ebp, esp
        
;        mov        eax, dividend
;        mov        eax, divsor
;        mov        eax, result
;        mov        eax, remained
;        jmp        L2        
        
        mov        ecx, [ebp + 12]    ; num1 dividend
        mov        eax, [ebp + 8]    ; num2 divisor
;        cwd
;        mov        edx, eax
;        mov        eax, ecx
;        cwd
;        mov        edx, ebx
;        mov        ecx, eax
;        mov        eax, ebx
        
        cmp        ecx, 0
        jne        DividFunc
        push    0
        push    5
        call _PrintResult
        pop        eax
        pop        eax
        mov        eax, 0
        jmp        L2
DividFunc:    
        sub        edx, edx
        idiv    ecx    ; product should be in eax
        cmp        edx, 0
        jne L1
        push    edx
        push    eax
        push    eax
        push    2
        call _PrintResult
        pop        eax
        pop        eax
        pop        eax
        pop        edx
        
;        mov    dword ptr [ebp+16], eax
;        mov dword ptr [ebp+20], edx
        
;        mov        ebx, dword ptr [ebp+16]
;        mov        ecx, dword  ptr [ebp+20]
;        mov        ebx, eax
;        mov        ecx, edx
        
        mov        eax, 1
        jmp L2
    L1:
        push    edx
        push    eax
        push    0
        push    3
        call _PrintResult
        pop        eax
        pop        eax
        pop        eax
        pop        edx
        mov eax, 1
    L2:
        pop    ebp
        ret
_Divide endp

My results when I run is;

Enter mumber to divide into then number to divide by
250
25
Display of divide is 10
Result is 200 and remainder is -858993460

As you can see I've tried a number of different things since what logically I think should work hasn't...I would think that I should be able to reference the position [ebp+16] & [ebp+20] and do a mov into it. Any clarification would be greatly appreciated!

[kahlinor]

An important thing to remember is what kind of parameters are being passed on the stack. Are you passing by value or by reference?

Also, you have fallen into a trap of referencing off of ebp. Remember you push ebp in your procedure to preserve it and just before that is your return address (pushed by the call instruction), so the very last parameter pushed onto the stack starts at [ebp+8]

Another note: dividend should be in EAX, divisor in ECX.

Here is a sample program in HLA, it should not be too hard to understand the workings, just remember in HLA, source and destination operands are reversed.

program divprog;

	#includeonce ("stdlib.hhf")

	?@nodisplay := true;
	?@noalignstack := true;

	procedure divide (	dividend:dword;	// passed by value
 						divisor:dword;	// passed by value
 						var res:dword;	// passed by reference
 						var remainder:dword);	// passed by reference
		@noframe; 							
	begin divide;
		
		push (ebp);
		mov (esp, ebp);
		mov ([ebp+20], eax); // dividend
		mov ([ebp+16], ecx); // divisor
		cmp (ecx, 0);
		je done;
		xor (edx, edx);
		idiv (ecx);
		
		// save result into res
		mov ([ebp+12], ecx); // address of result 
		mov (eax, [ecx]);
		mov ([ebp+8], ecx); // address of remainder
		mov (edx, [ecx]);
		
	done:
		pop (ebp);
		ret (16);	// return balanced stack
	end divide;

	static
		_res	:dword;
		_rem	:dword;
		

begin divprog;

	pushd (7);	// dividend
	pushd (2);	// divisor
	pushd (&_res);	// address of _res
	pushd (&_rem);	// address of _rem
	call divide;
	stdout.put ("result:", _res, "  remainder:", _rem, nl);

	// output from this program
	//result:0000_0003  remainder:0000_0001

end divprog;

Of course, I don't recommend bouncing off EBP. It looks like you are using MASM, so you should be able to use the labels directly from a proc.

[Vintage1983]

Thank you for the response, I actually managed to figure both of my posts out already but hadn't made it back here yet. Your examples and instructions were very easy to understand, Thank you.