Converting ASM to Pascal

[Colin]

if the functions that are called by "CallFunction" are 32-bit libraries functions etc, then you should not have a problem to compile this on 64-bit pascal, but if you re-compile the libs it calls into 64-bit then you will have a-lot of work ahead.

What i would suggest is to rename this function to CallFunctionX86(... and make sure all pointers and variables used are 32-bit standard, e.g. pointer should be 32-bit pointer (i don't use freepascal dunno which you will need to use)

then you can create a new function CallFunctionX64(

This would be similar but using 64-bit variables and registers.

[Cybermonkey]

Ok, but I learned that "mov EAX" etc. isn't available on 64 bit processors, is it?

[Colin]

it is, eax is 32-bit part of RAX, maybe TASM or pascal assembler does not support mov with 32-bit regs (eax, ecx etc) in 64-bit mode (if so that is flawed)

so if mov eax, _EAX does not work try either:

movd eax, _EAX

or

mov rax, dword _EAX

[Cybermonkey]

It is even worse, "push esi" isn't known either. I added the compiler directive {$asmmode intel}. Now the problems are:

Chip.pas(2041,13) Error: Asm: [push reg32] invalid combination of opcode and operands
Chip.pas(2042,13) Error: Asm: [push reg32] invalid combination of opcode and operands
Chip.pas(2066,12) Error: Asm: [pop reg32] invalid combination of opcode and operands
Chip.pas(2067,12) Error: Asm: [pop reg32] invalid combination of opcode and operands

Another problem causes this piece of code (it's obviously Pascal, but i don't know to solve it either):

      args.outVal.n.sbuf:=basicstring(resvalue);
      basicstring(resvalue):=''

Error:

Chip.pas(2076,27) Error: Illegal type conversion: "LongInt" to "AnsiString"
Chip.pas(2077,7) Error: Illegal type conversion: "LongInt" to "AnsiString"

With a 32 bit FPC it compiles ... BTW, the complete source of Chip.pas can be found on: http://xmojmr.ohmygod.cz/software/Chip/Chip.pas.htm

[Colin]

I guess the assembler does some checking for stack alignment to prevent problems with other 64-bit libs, this is an issue with the assembler unless it has an override option, maybe try

[32BIT]
push edi
push .. etc

as for the other code, does basicstring return a pchar/pointer? if so try

basicstring(resvalue)^ := ''

better still:

var
  p: PAnsiChar;

p := basicstring(resvalue);
args.outVal.n.sbuf := p;
p^ := ''

[phibermon]

I'm glad you're here, I got as far as "ahh, it's pushing params onto the stack for the routine that's called", I'd worked out we'd need to see more of the code to understand the context, the function that's called etc meanwhile you've already sorted it

[Colin]

1 other thing to try is the pop's, try:

pop dword edi

etc

if all else fails you can always manually solve this by replacing the pop's with something like

mov rdi, dword ptr [rsp+4]
mov rsi, dword ptr [rsp]
add rsp, 8

EDIT

but actually hehe, i'm tired, anyways you just need to keep edi etc so in this case we can solve it easily..

your code:

     asm
       push esi
       push edi
       sub esp, StkUsage      // make room on stack
       mov edi, esp           // set destination of mem copy, it is the stack
       mov esi, StkAdr        // set source of mem copy, it is Addr(ExtStk)
       mov ecx, StkUsage      // prepare ecx to copy StkUsage bytes
       shr ecx, 2             // divide by 4 to perform DWORD-copy (is faster)


       //add edi, StkUsage;
       //sub edi,4
       //add esi, StkUsage;
       //sub esi,4
       cld                    // choose copy direction
       rep movsd              // do DWORD-copy


       cmp RegCall, true
       jnz @@EXEC
       mov EAX, _EAX
       mov EDX, _EDX
       mov ECX, _ECX


       @@EXEC:
       call Adr               // execute the external function
                              // esp is restored by the external function
                              // (except for cdecl-convention)
       pop edi                // restore edi...
       pop esi                // ...and esi
       mov _EAX,eax
     end;                     // asm

so try this:

     asm
       push rsi
       push rdi
       sub rsp, StkUsage      // make room on stack
       mov rdi, rsp           // set destination of mem copy, it is the stack
       mov rsi, StkAdr        // set source of mem copy, it is Addr(ExtStk)
       mov rcx, StkUsage      // prepare ecx to copy StkUsage bytes
       shr rcx, 4             // divide by 8 to perform QWORD-copy (is faster)

       cld                    // choose copy direction
       rep movsq              // do QWORD-copy


       cmp RegCall, true
       jnz @@EXEC
       mov RAX, dword _EAX
       mov RDX, dword _EDX
       mov RCX, dword _ECX


       @@EXEC:
       call Adr               // execute the external function
                              // esp is restored by the external function
                              // (except for cdecl-convention)
       pop rdi                // restore edi...
       pop rsi                // ...and esi
       mov _EAX,eax
     end;                     // asm

for 64-bit you want to change _EAX etc to int64 and then remove dword casts. Note that this is only valid for fastcall, stdcall would be a big trouble for stack alignment across 32/64 bit