hello,
as the topic title says, i want to generate asm code using AngelScript's Jit capability feature using AsmJit
now, for example, i want to decrement a variable, i should do this:

        case asBC_DecVi:
            a.dec(ptr(par1, ASMJIT_OFFSET_OF(asSVMRegisters, stackFramePointer)- asBC_SWORDARG0(bc)));
            break;

dec [ebx+3]

        case asBC_JitEntry:
            a.mov(dword_ptr(par2), a.getOffset()- firstEntry);
            break;

Unfortunately I don't know AsmJit (nor do I know much about JIT compilation at all).

I suggest you study the code for BlindMind's JIT compiler to get an understanding of how to make your own JIT compiler work with AngelScript.

In the VM asBC_DecVi is implemented as:

    // Decrement the local integer variable
    case asBC_DecVi:
        (*(int*)(l_fp - asBC_SWORDARG0(l_bc)))--;
        l_bc++;
        break;

If we translate this to how the JIT compiled function might see it (written as a C++ function) it would be:

void JITcompiledFunction(asSVMRegistrers *reg, asPWORD jitArg)
{
    /* prologue for loading CPU registers and jumping to the right spot in the code based on jitArg (defined by JIT compiler) */
 
    (*(int*)(regs->stackFramePointer - (*(((short*)regs->programPointer)+1)))--;
    (regs->programPointer++;
 
    /* epilogue for cleaning up and returning to the VM */
}

You can compile this function to assembler and determine the assembler instructions that the JIT compiler has to produce to get the correct result.

okay, instead of using for example asBC_SWORDARG0, can i use +1 to retrieve parameters? because in assembly, everything is offset based
and, what about jumps? i want to use jmp, what do you recommend? i think it should be like this:

a.push(a.zax());
a.mov(a.zax(), ptr(regs, ASMJIT_OFFSET_OF(asSVMRegisters, programPointer)));
a.mov(a.zax(), dword_ptr(a.zax(), 2));
a.add(dword_ptr(a.zax()), 1); //asBC_INTARG
a.jmp(a.zax());
a.mov(ptr(regs, ASMJIT_OFFSET_OF(asSVMRegisters, programPointer)), dword_ptr(a.zax());
a.pop(a.zax());

asBC_SWORDARG0 means: read the 16bit argument at the offset of 2 bytes after the current program pointer address. This is what you'll need to implement in assembler instructions.

Yes, you can use jmp instructions the JIT compiled assembler code. As the asBC_JMP instruction in AngelScript refers to the byte code program pointer you'll need to translate this into the corresponding offset in the JIT assembler code. To do that you'll most likely need to perform multiple passes over the JIT assembler code as it won't be easy to predict the exact size of the assembler instructions until you've actually generated them.

so, instead of writing a.mov(a.zax(), dword_ptr(a.zax(), 2)); i have to write a.mov(a.zax(), word_ptr(a.zax(), 2));

Probably, yes. But don't take my word for it. You'll have to test it to make sure. :)

hi again,
i have a question:
in (for example asBC_JMP), do the code in ExecuteNext will be executed or not?
i mean, this code which AngelScript has in asBC_JMP:

        l_bc += 2 + asBC_INTARG(l_bc);

Yes, the code in ExecuteNext for the instruction asBC_JMP is executed.

l_bc += 2 + asBC_INTARG(l_bc);

This code means: move the program pointer 2 + whatever value in the instruction argument.

2 in this case refers to the size of the asBC_JMP instruction itself. So if the argument would be 0, the jump instruction would be the same as a nop instruction, i.e. do nothing and just proceed with the next instruction.

In the JIT compiled code you'll want to translate this into the corresponding jump instruction to the appropriate address in the JIT compiled code. Remember that if your JIT compiled code returns control to the VM you must make sure the asSVMRegisters::programPointer member is correctly updated so the VM can resume the execution from the correct bytecode instruction.