Question

我有这个代码块：

void CallAnyFunc(void *pfn, const std::vector<char> &arguments, CLR_DataType returnType, AnyFuncReturn &returnValue)
{
    int i4;
    float r4;
    double r8;
    long int i8;

    char* pStack;
    const char* i = arguments.empty() ? NULL : &*arguments.begin();
    const char* end = i + arguments.size();

    // Reserve the space on the stack
    // This is equivalent (in some sense) to 'push' all the parameters into the stack.
    // NOTE: Don't just subtract the stack pointer, better to call _alloca, because it also takes
    // care of ensuring all the consumed memory pages are accessible
#ifdef PLATFORM_WINDOWS
    _alloca(arguments.size());
#else
    alloca(arguments.size());
#endif

    _asm {
        mov pStack, esp
    };

    // Copy all the parameters into the stack
    // NOTE: Don't use the memcpy function. Because the call to it
    // will overwrite the stack (which we're currently building)
    while (i != end)
        *pStack++ = *i++;

    switch (returnType)
    {
        case DATATYPE_R4:
        {
            // Call your function
            _asm {
                call pfn
                fstp r4
            }

            returnValue.r4 = r4;
        } break;

        case DATATYPE_R8:
        {
            // Call your function
            _asm {
                call pfn
                fstp r8
            }

            returnValue.r8 = r8;
        } break;

        case DATATYPE_U8:
        case DATATYPE_I8:
        {
            // Call your function
            _asm {
                call pfn
                mov i8, eax
            }

            returnValue.i8 = i8;
        } break;

        default:
        {
            _asm {
                call pfn
                mov i4, eax
            };

            returnValue.i4 = i4;
        }
    }
}

基本上它是调用CLR微点网的桥梁。

当我使用提供xcode的gcc编译时，我得到：

nmfi/nmf_call.cpp:153:no such instruction: `movlq %esp, -96(%rbp)'
nmfi/nmf_call.cpp:164:indirect call without `*'
nmfi/nmf_call.cpp:175:indirect call without `*'
nmfi/nmf_call.cpp:187:indirect call without `*'
nmfi/nmf_call.cpp:190:no such instruction: `movlq %eax, -88(%rbp)'
nmfi/nmf_call.cpp:197:indirect call without `*'

其中第153行= mov pStack之后的行，尤其是和第190行= returnValue.i8 = i8之后的行，这实际上是mov i8，eax

...

此代码用于工作得很好。我正在考虑这个变化是因为x86_64，但是在找出如何正确编写“mov”以便它可以组装时遇到了问题。

...

相关的编译器标志：

CC := g++
CFLAGS := -c -DLITTLE_ENDIAN=1 -DGCC_V4_2 -fasm-blocks  \
        -DVERSION_MAJOR="4" -DVERSION_MINOR="2" -DVERSION_BUILD="1" -DVERSION_REVISION="0" \
        -DOEMSYSTEMINFOSTRING='"OSXBOI"'

# -DMAC -fvisibility=hidden -fvisibility-inlines-hidden
AR := ar
ARFLAGS := rs

ifeq (,$(findstring Debug,$(CONFIG)))
    CFLAGS += -O3 -DNDEBUG
else
    CFLAGS += -g -D_DEBUG
endif

任何提示？

以下是经过修改的代码，这是未经测试的，但它会编译。

void CallAnyFunc(void *_pfn, const std::vector<char> &arguments, CLR_DataType returnType, AnyFuncReturn &returnValue)
{
    int i4;
    float r4;
    double r8;
    long int i8;
    typedef void (*PFN)();
    PFN pfn = (PFN)_pfn;

    char* pStack;
    const char* i = arguments.empty() ? NULL : &*arguments.begin();
    const char* end = i + arguments.size();

    // Reserve the space on the stack
    // This is equivalent (in some sense) to 'push' all the parameters into the stack.
    // NOTE: Don't just subtract the stack pointer, better to call _alloca, because it also takes
    // care of ensuring all the consumed memory pages are accessible
#ifdef PLATFORM_WINDOWS
    _alloca(arguments.size());
#else
    alloca(arguments.size());
#endif

#ifdef X86_64
    _asm {
        mov pStack, rsp
    };
#else
    _asm {
        mov pStack, esp
    };
#endif

    // Copy all the parameters into the stack
    // NOTE: Don't use the memcpy function. Because the call to it
    // will overwrite the stack (which we're currently building)
    while (i != end)
        *pStack++ = *i++;

    switch (returnType)
    {
        case DATATYPE_R4:
        {
            // Call your function
            _asm {
                call *pfn
                fstp r4
            }

            returnValue.r4 = r4;
        } break;

        case DATATYPE_R8:
        {
            // Call your function
            _asm {
                call *pfn
                fstp r8
            }

            returnValue.r8 = r8;
        } break;

        case DATATYPE_U8:
        case DATATYPE_I8:
        {
#ifdef X86_64
            // Call your function
            _asm {
                call *pfn
                mov i8, rax
            }
#else
            _asm {
                call *pfn
                mov i8, eax
            }
#endif
            returnValue.i8 = i8;
        } break;

        default:
        {
#ifdef X86_64
            // Call your function
            _asm {
                call *pfn
                mov i4, eax
            }
#else
            _asm {
                call *pfn
                mov i4, eax
            }
#endif

            returnValue.i4 = i4;
        }
    }
}

Answer 1

如果要构建64位代码，则指针和long int的大小都将为64位。您可能希望使用rsp而不是esp作为指针，以获取地址的所有位。

对于i8变量，您有一些选择：将其保留为long int（或更好，int64_t）并使用rax代替eax 。或者将其设为int32_t并继续使用eax。

没有这样的指示.. gcc x86_64

1 个答案: