These had to be patched on OSX to get it to compile, but I don't think the generated a

There's a few issues here: AT&T mov syntax is backwards, w

<a class="user-mention notranslate" data-hovercard-type="user" data-hovercard-url="/us

Fix x86/x64 Macros on OSX/Linux about squally HOT 3 CLOSED

squalr commented on June 12, 2024

Fix x86/x64 Macros on OSX/Linux

from squally.

Comments (3)

mattbucci commented on June 12, 2024

There's a few issues here:

AT&T mov syntax is backwards, which is why we ended up flipping the variable order
I don't think we can use the same m(variable) syntax we use in the other ASM format, I don't see mention of it in AT&T syntax.

all registers in AT&T syntax must be prefixed with "%", all literals must be prefixed with "$", dereferencing seems to be done by wrapping the register with "(" and ")" https://csiflabs.cs.ucdavis.edu/~ssdavis/50/att-syntax.htm

Our old definition was

#define ASM_MOV_REG_VAR(register, variable) \
    __asm__ __volatile__("mov %0, %%" EXPAND_AND_QUOTE(register)  : : "m"(variable) : )

I tried

__asm__ __volatile__("mov $" EXPAND_AND_QUOTE(variable) ", %" EXPAND_AND_QUOTE(register) )

but this results in "error: 32-bit absolute addressing is not supported in 64-bit mode"
$(variable) should grab the value held by the pointer and move it into the register if I understand correctly.

from squally.

mattbucci commented on June 12, 2024

@zcanann I'm not sure I understand what the %0 is doing here I understand it points to a stack variable, but yeah we're pretty far from having this right. Here's the example usage

Vec3 ProximityObject::getVelocity()
{
	Vec3 velocityCopy = this->velocity;
	const volatile float* velocityPtrX = &velocityCopy.x;
	const volatile float* velocityPtrY = &velocityCopy.y;
	const volatile float* velocityPtrZ = &velocityCopy.z;
	static const volatile int* freeMemory = new int[128];

	// Push velocity variables onto FPU stack
	ASM(push EAX)
	ASM(push EBX)
	ASM(push ECX)
	ASM(push ESI)
	ASM_MOV_REG_VAR(EAX, velocityPtrX);
	ASM_MOV_REG_VAR(EBX, velocityPtrY);
	ASM_MOV_REG_VAR(ECX, velocityPtrZ);
	ASM_MOV_REG_VAR(ESI, freeMemory);
	ASM(fld dword ptr[ECX])
	ASM(fld dword ptr[EBX])
	ASM(fld dword ptr[EAX])

from squally.

mattbucci commented on June 12, 2024

I think we can avoid at&t syntax here

Here's what stux said

here's how you get your pointer into a register:

int main(){
    int x = 42;
    int* x_ptr = &x;
    asm volatile("nop");
    asm volatile("mov rax, %0" : : "r"(x_ptr) : "rax");
    asm volatile("nop");
    x = 23;
}

generated assembly:

push   rbp
mov    rbp,rsp
sub    rsp,0x20
mov    rax,QWORD PTR fs:0x28
                
mov    QWORD PTR [rbp-0x8],rax
xor    eax,eax
mov    DWORD PTR [rbp-0x14],0x2a    ;write 42 to x
lea    rax,[rbp-0x14]               ; get the address of x
mov    QWORD PTR [rbp-0x10],rax     ; store the address of x into x_ptr
nop                                 ;sequence begin
mov    rdx,QWORD PTR [rbp-0x10]
mov    rax,rdx
nop                                 ;sequence end
mov    DWORD PTR [rbp-0x14],0x17    ;write 23 to x
mov    eax,0x0
mov    rcx,QWORD PTR [rbp-0x8]
xor    rcx,QWORD PTR fs:0x28
                
je     1188 <main+0x4f>
call   1030 <__stack_chk_fail@plt>
leave                                  
ret

from squally.

Fix x86/x64 Macros on OSX/Linux about squally HOT 3 CLOSED

Comments (3)

Related Issues (20)

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent