Back to General and Gameplay Programming

CALL-instruction to constant 8-byte address

Julian Watzinger · 2022-04-27T17:20:52

Ok, back with another JIT-related question. In my custom machine-code, I need to be able to embedd calls to native functions that are part of the compiled program. The easiest working way I found is this: void JitGenerator::WriteCallFunctionPointer(const void* pAddress) { WriteStoreConstant(std::uintptr_t(pAddress), RegisterType::RAX); WriteLine({ 0xff, 0xd0 }); // call rax } void test(void) {} WriteCallFunctionPointer(&test); However, this is using an “indirect” call, which is slower (ranging from neglegible to exterme depending on the branch-prediction as far as I've read). So I'd like to change this to use a direct call instead, however I'm not 100% sure about how I'd go about changing it. From the documentation (https://www.felixcloutier.com/x86/call), it seems I'm looking for: E8 cd => Call near, relative, displacement relative to next instruction. 32-bit displacement sign extended to 64-bits in 64-bit mode. So basically I'd take the address I have and convert it to an offset relative to the address of the start of the next instruction, like you'd do to reference cdata.But later on, it says: Near Call — A call to a procedure in the current code segment (the segment currently pointed to by the CS register), sometimes referred to as an intra-segment call. So thats where I'm a bit lost. What exactly does CS contain? I'm feeling a bit dumb but I've not been able to find a definitive answer. Is a “code segment” the address range for a given piece of executable code, ie. the compiled exe, as opposed to the page I allocate for my JIT-code? If so, is there any better alternative than indirect-call? I'm assuming that "9A cp" while not specifying “indirect” still having to fetch the address from the "ptr16:32" will be equally slow, but I'm not sure. If CS actually means something different and I can just take the difference of address of my function to the next instruction in the JIT-code, is there any way to ensure that the memory is always in a region that is near the executable? On a 64-bit machine with a 32-bit register, if both values are 2^32 apart from each other than I couldn't use a near call eigther way. Those are also all just my presumptions anyways. Anybody with a bit more knowledge about this topic able to anser the question?

General and Gameplay Programming Programming

Started by Juliean April 25, 2022 03:48 PM

12 comments, last by Beosar 2 years, 6 months ago

Beosar

572

April 27, 2022 04:34 PM

Try OpCode FF /2: https://www.felixcloutier.com/x86/call

That seems to be a 64 bit near call.

Juliean

Author

7,364

April 27, 2022 04:53 PM

Beosar said:
Try OpCode FF /2: https://www.felixcloutier.com/x86/call

Yes, thats what I've been doing originally. But it requires using a separate MOV into the rax-register, which makes the code a bit worse to decypher (which I currently really need to be able to) and it also uses an indirect call which has the potential to be slower.

Beosar

572

April 27, 2022 05:20 PM

Oh, sorry. So, basically you are generating code and storing it in memory on the heap. I don't think there is a guarantee that the address is within range of your program's code. It may work on one OS on one machine but not on another. You could potentially copy the program's code to the heap and then put the JIT compiled code directly after that, then it would definitely be in range (unless your program gets very large).

CALL-instruction to constant 8-byte address

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

CALL-instruction to constant 8-byte address

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Reticulating splines