2

我有一些从 Github 获得的程序集合并排序代码,我正在尝试将其嵌入到 C++ 中的内联程序集中,但它不会编译并不断返回这些错误:

1>c:\users\mayank\desktop\assembly\assembly\main.cpp(147): 错误 C2415: 不正确的操作数类型

我试图运行的代码是这样的:

#include <iostream>
#include <cmath>
#include <stdio.h>

using namespace std;
const int ARRAYSIZE = 30;

int main()
{
    int arr[ARRAYSIZE];
    int temp_arr[ARRAYSIZE];
    int number;

    for(int x = 0; x < ARRAYSIZE; x++)
    {
        number = (rand() % 99) + 1;
        arr[x] = number;
    }
/*  
READ_ARR_LEN:
    __asm
    {
        // Read the length of the array
        //GetLInt [30]      // Size of input array
        //PutLInt [30]
    }

GET_ARRAY:
    __asm
    {
         //intel_syntax
         // Get values in arr from the user
         mov   EAX, arr
         mov   ECX, ARR_LEN
         call  Read_Arr

         // Run Merge Sort on the array
         mov   EAX, arr
         mov   EBX, temp_arr
         mov   ECX, ARR_LEN
         call  Merge_Sort

        // EXIT
    };;
*/
Merge_Sort:
    __asm
    {
        // EAX - Array start
        // ECX - array length

        // Arrays of size 0 or 1 are already sorted
        cmp   ARRAYSIZE, 2
        jl    Trivial_Merge_Sort

        // Merge_Sort (first half)
        // Length of the first half
        // ECX /= 2
        push  ARRAYSIZE
        shr   ARRAYSIZE, 1
        call  Merge_Sort
        pop   ARRAYSIZE

        // Merge_Sort (second half)
        push  arr
        push  EBX
        push  ARRAYSIZE

        // Length of the second half
        // ECX = ECX - ECX/2
        mov   EDX, ARRAYSIZE
        shr   EDX, 1
        sub   ARRAYSIZE, EDX
        imul  EDX, 4
        // Start index of the second half
        // EAX = EAX + (ECX/2) * 4
        add   arr, EDX
        push  EDX
        call  Merge_Sort
        pop   EDX

        pop   ARRAYSIZE
        pop   EBX
        pop   arr

        pushad
        // Merge (first half, second half)
        // Length of first half = ECX/2
        // Length of second half = ECX - ECX/2
        mov   EDX, ECX
        shr   ECX, 1
        sub   EDX, ECX

        // Start of second half = EAX + (ECX/2) * 4
        mov   EBX, EAX
        mov   EDI, ECX
        imul  EDI, 4
        add   EBX, EDI
        // Index of temp array = 0
        sub   EDI, EDI
        call  Merge
        popad

        // Copy back the merged array from temp_arr to arr
        call  Merge_Copy_Back_Temp

        ret
    };

Trivial_Merge_Sort:
    __asm
    {
        // In case of arrays of length 0 or 1
        ret
    };
Merge:
    __asm
        {
        // Merge two arrays contents.
        // The final merged array will be in temp_arr
        // Merging is done recursively.

        // Arguments:
        // EAX - First array's start
        // EBX - Second array's start
        // ECX - Length of first array
        // EDX - Length of second array
        // EDI - Index in temp array
        pushad

        // Handle the cases where one array is empty
        cmp   ARRAYSIZE, 0
        jz    First_Array_Over
        cmp   EDX, 0
        jz    Second_Array_Over

        // Compare first elements of both the arrays
        push  ARRAYSIZE
        push  EDI
        mov   ARRAYSIZE, [arr]
        mov   EDI, [ARRAYSIZE]
        cmp   ARRAYSIZE, EDI
        pop   EDI
        pop   ARRAYSIZE

        // Pick which ever is the least and update that array
        jl    Update_First_Array
        jmp   Update_Second_Array
    };

Update_First_Array:
   __asm
   {
        // min_elem = min (first elements of first array and second array)
        // Put min_elem into the temp array
        push  dword ptr [EAX]
        pop   dword ptr [temp_arr + EDI * 4]
        add   EAX, 4
        dec   ECX
        inc   EDI

        // Recursively call Merge on the updated array and the
        // other array
        call  Merge
        popad
        ret
   };

Update_Second_Array:
   __asm
   {
       // min_elem = min (first elements of first array and second array)
        // Put min_elem into the temp array
        push  dword ptr [EBX]
        pop   dword ptr [temp_arr + EDI * 4]
        add   EBX, 4
        dec   EDX
        inc   EDI

        // Recursively call Merge on the updated array and the
        // other array
        call  Merge
        popad
        ret
   };

Merge_Copy_Back_Temp:
   __asm
   {
        // Copy back the temp array into original array
        // Arguments:
        // EAX - original array address
        // ECX - original array length
        pushad

        // For copying back, the destination array is EAX
        mov   EBX, EAX
        // Now, the source array is temp_arr
        mov   EAX, temp_arr
        call  Copy_Array
        popad
        ret
   };

Trivial_Merge:
   __asm
   {
        // Note: One array is empty means no need to merge.
        popad
        ret
   };

First_Array_Over:
   __asm
   {
        // Copy the rest of the second array to the temp arr
        // because the first array is empty
        pushad
        mov   EAX, EBX
        mov   ECX, EDX
        mov   EBX, temp_arr
        imul  EDI, 4
        add   EBX, EDI
        call  Copy_Array
        popad
        popad
        ret
   };

Second_Array_Over:
   __asm
   {
    // Copy the rest of the first array to the temp arr
    // because the second array is empty
    pushad
    mov   EBX, temp_arr
    imul  EDI, 4
    add   EBX, EDI
    call  Copy_Array
    popad
    popad
    ret
   }; 
Copy_Array:
   __asm
   {
    // Copy array to destination array
    // EAX - Array start
    // EBX - Destination array
    // ECX - Array length

    // Trivial case
    cmp   ECX, 0
    jz    Copy_Empty_Array

    push  ECX
    sub   EDI, EDI
   };
copy_loop:
   __asm
   {
    // Copy each element
    push  dword ptr [EAX + EDI * 4]
    pop   dword ptr [EBX + EDI * 4]
    inc   EDI
    loop  copy_loop

    pop   ECX
    ret
   };

Copy_Empty_Array:
   __asm
   {
    ret
   };

Read_Arr:
   __asm
   {
        // EAX - array start
        // ECX - array length
        mov   ESI, EAX
        sub   EDI, EDI
   };
loop1:
   __asm
   {
        // Read each element
        lea eax,[esi+edx*4]
        inc   EDI
        loop  loop1
        ret
   };

    return 0;
}
4

2 回答 2

3

更新:在问题中发布的原始代码中,有人尝试将内存寻址为DWORD [address],这与我在下面的回答中指出的 Visual C++ 内联汇编器使用的语法不兼容。)

Visual C++ 对其内联程序集使用 MASM 语法,因此您需要使用DWORD PTR而不是仅使用DWORD. 这就是导致这些编译错误的原因。

例如,参见The Art of Assembly 中的这张表

于 2013-01-12T18:29:45.477 回答
1

看起来代码来自这个 github 存储库

在该代码中,GetLInt实际上是一个 NASM 宏,它包含在外部宏定义文件中并调用一个函数proc_GetLInt,该函数又在目标文件中提供io.o,源代码不存在。因此,问题很简单

  • 您没有意识到这GetLint是您缺少的外部代码

  • 即使您从该存储库中获取所有文件,它也可以工作,因为 NASM 宏不能直接在 VC++ 内联汇编中工作

  • 即使您修复了宏问题,您仍然没有该GetLInt功能,因为它仅作为 linux 目标文件提供,您必须自己编写


你如何解决这个问题?

该代码旨在提供一个独立的汇编程序,可以自行处理所有输入/输出。由于您在 VC++ 中内联它,因此您已经拥有了更强大的 I/O 处理功能。改用它们,即确保arr在内联汇编开始之前您要排序的值已经存在。

然后,查看代码:Merge_Sort期望数组的开头为EAX,其长度为ECX。您可以从您的 C++ 代码中获取两者。当您这样做时,您不再需要汇编代码中的READ_ARR_LENandGET_ARRAY块。

我不太愿意通过修改来重现部分代码,因为我在 github 上找不到可以说我可以这样做的许可证文件。让我试着描述一下:您需要在汇编程序的一开始就手动将指针移动到in 和arrintoEAX的内容。(*) 如我所见,您已经用数字填充了数组,因此您无需在此处进行任何操作。ARRAYSIZEEBX

然后你需要删除所有不必要的汇编函数和对它们的调用。您还应该将所有单独的__asm块压缩为一个块,或者使用外部变量来保存和恢复块之间的寄存器(或阅读此处的教程,但只使用一个块即可,并且不那么麻烦)。

最后,您必须小心堆栈帧:每个call都必须有一个匹配的ret. 由于合并排序过程是递归的,因此很容易出错。

(*) 小心 VC++ 在 asm 块中处理变量的方式,确保在需要时实际使用指针。

所以总而言之,将它移植到 VC++ 并不是一件容易的事。

于 2013-01-13T18:19:32.057 回答