【问题标题】:NASM Subroutine Call Segmentation FaultNASM 子程序调用分段错误
【发布时间】:2016-12-18 02:03:39
【问题描述】:

我正在从事一个涉及 NASM 的学校项目,虽然该语言对我来说有某种意义,但我最终总是遇到一个毫无意义的问题。

我正在编写的程序涉及 1 个命令行参数,它必须是由 0、1 和/或 2 组成的字符串。如果不是,则会显示错误消息并结束程序。

如果没有错误,则按顺序显示字符串的“后缀”。

例子:

"./sufsort 00100102" should produce

sorted suffixes:
00100102
00102
0100102
0102
02
100102
102
2

现在,当我尝试调用我的子例程 sufcmp 时遇到分段错误

%include "asm_io.inc"

section .data
    arg_error_msg: db "Error, incorrect number of arguments. Only 2 arguments are allowed.", 0
    bad_char_msg: db "Error, invalid character used. Only 0, 1, or 2 are allowed.", 0
    bad_length_msg: db "Error, invalid input length. Length must be between 1 and 30.", 0
    sorted_msg: db "sorted suffixes:", 0
    ; y is an array of suffix indeces, which are sorted later by the main method
    y: dd 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30

section .bss
    argc: resd 1        ; number of command line arguments
    X: resb 31          ; array copy of the input string
    N: resd 1           ; length of the input string

section .text
    global asm_main

sufcmp:                         ; sufcmp(String Z, int i, int j)
    enter 0, 0
    pusha

    mov edx, dword [ebp+16]     ; edx = String Z
    mov esi, dword [ebp+12]     ; esi = int i
    mov edi, dword [ebp+8]      ; edi = int j

    CMP_LOOP:
        cmp byte [edx+esi], byte 0          ; if Z[i] = null, ret -1
        je CMP_NEGATIVE
        cmp byte [edx+edi], byte 0          ; if Z[j] = null, ret 1
        je CMP_POSITIVE
        mov al, byte [edx+edi]
        cmp byte [edx+esi], al  ; if Z[i] < Z[j], ret -1
        jl CMP_NEGATIVE
        cmp byte [edx+esi], al  ; if Z[i] > Z[j], ret 1
        jg CMP_POSITIVE
        inc esi                             ; increment i and j
        inc edi
        jmp CMP_LOOP                        ; repeat

    CMP_NEGATIVE:
        popa
        mov eax, dword -1
        jmp CMP_DONE

    CMP_POSITIVE:
        popa
        mov eax, dword 1
        jmp CMP_DONE

    CMP_DONE:
        leave
        ret

asm_main:                           ; sufsort(String inputString)
    enter 0, 0
    pusha

    ARG_CHECK:                      ; Check number of arguments
        mov eax, dword [ebp+8]      ; eax = # of line arguments
        cmp eax, dword 2            ; if there are just 2 line argument, skip the error
        je CHAR_CHECK
        mov eax, arg_error_msg      ; display an error message
        call print_string
        call print_nl
        jmp DONE                    ; terminate the program

    CHAR_CHECK:                     ; Check characters & get length of string
        mov ebx, dword [ebp+12]
        mov ecx, dword [ebx+4]      ; eax = input string
        mov edi, dword 0            ; edi will be the counter
        CHAR_LOOP:
            cmp byte [ecx], byte 0  ; if Z[edi] = null, end the loop
            je CHAR_LOOP_DONE
            mov al, byte [ecx]
            cmp al, '0'     ; if byte [ecx} != '0', '1', '2', complain
            je GOOD_CHAR
            cmp al, '1'
            je GOOD_CHAR
            cmp al, '2'
            je GOOD_CHAR
            BAD_CHAR:
                mov eax, bad_char_msg   ; display an error message
                call print_string
                call print_nl
                jmp DONE                ; terminate the program
            GOOD_CHAR:
                mov [X + edi], al       ; copy the character into X[edi]
            inc ecx
            inc edi
            jmp CHAR_LOOP
        CHAR_LOOP_DONE:
            mov [N], edi                ; N = length of Z
            mov [X + edi], byte 0       ; add a null character to the end of X

    LENGTH_CHECK:               ; Check the length of the input string
        cmp dword [N], 1        ; if N < 1 or N > 30, stop the program
        jl BAD_LENGTH
        cmp dword [N], 30
        jg BAD_LENGTH
        jmp SHOW_COPY           ; else, continue
        BAD_LENGTH:
            mov eax, bad_length_msg     ; display an error message
            call print_string
            call print_nl
            jmp DONE                    ; terminate the program

    SHOW_COPY:              ; output X to check if it copied properly
        mov eax, X
        call print_string
        call print_nl

    BUBBLE_SORT:                ; Bubble sort, which sorts substrings using array y
        mov esi, [N]            ; esi = i (counts from N to 0)
        mov edi, dword 1        ; edi = j (counts from 1 to i)
        BUBBLE_SORT_I:
            cmp esi, dword 0            ; if i = 0, end the outer loop
            je SORTED_SUFFIXES
            BUBBLE_SORT_J:
                cmp esi, edi            ; if i = j, end the inner loop
                je BUBBLE_SORT_J_DONE
                push dword [X]      ; call sufcmp, which takes 3 args (String Z, int i, int j)
                push dword [edi]
                push dword [esi]
                call sufcmp
                add esp, 12             ; move esp back 12 bytes, to undo the 3 pushes
                cmp eax, dword -1
                je NO_SWAP
                    mov ebx, dword [y + edi-1]          ; temp = y[j-1]
                    mov edx, dword [y + edi-1]          ; comparison temp
                    mov edx, dword [y + edi]            ; y[j-1] = y[j]
                    mov [y + edi], ebx
                NO_SWAP:
                inc edi                 ; j += 1
                jmp BUBBLE_SORT_J
            BUBBLE_SORT_J_DONE:
            dec esi             ; i -= 1
            jmp BUBBLE_SORT_I

    SORTED_SUFFIXES_T:          ; print "sorted suffixes"
        mov eax, sorted_msg
        call print_string
        call print_nl

    SORTED_SUFFIXES:
        mov esi, dword 0        ; esi = i
        PRINT_STR_LOOP:
            cmp esi, dword [N-1]            ; if i = N-1, end the outer loop
            je DONE
            mov eax, dword [X]              ; move address of X to eax
            add eax, [y + esi]              ; move eax to address of X[y[i]]
            call print_nl                   ; put each suffix on a separate line
            inc esi                         ; i += 1
            jmp PRINT_STR_LOOP

    DONE:
        popa
        leave
        ret

我得到了这个

我找不到任何会导致分段错误的东西,因为除了推送函数参数和在子例程返回后恢复 esp 之外,我不会以任何方式操作堆栈。

【问题讨论】:

  • 分段错误并不意味着堆栈一定有问题。这意味着某处的某个指针无效。我注意到您在 32 位代码中使用 pusha,这并没有按照您的想法进行。 (你可能想要 `pushad'。)在调试器中单步执行代码以查找错误指针。
  • @RaymondChen: pushad 是pusha 的别名,操作码相同。 CPU 将通过它运行的任何模式来执行该操作。但无论如何他肯定需要调试器,而且无效的指针注释也很明显。
  • 使用调试器(如 gdb)查看哪些指令错误(以及此时的寄存器值是什么)。见stackoverflow.com/tags/x86/info,尤其是底部有gdb提示的地方
  • 32 位代码中的 pusha 使用 16 位覆盖前缀进行编码。但也许 nasm 会自动将 ousha 转换为 pushad。 (但是你怎么会说你想要一个真正的 16 位 pusha?)

标签: assembly x86 nasm


【解决方案1】:

好吧,您将需要调试器,因为您的代码中有几个问题,而且它对于我来说有点太大而无法准确地运行它(比如 100% 保护堆栈/等),所以我只看到了几件事:

在CHAR_CHECK: 循环中测试循环期间的长度,所以当有人给你太长的字符串时,你不会覆盖.bss 内存。您可以将长度检查移到CHAR_LOOP: 的正下方,当edi 超出范围时,停止循环。

还要在存储N 之前添加空字符(交换这两个mov 行),因为N 存储在内存中X 之后,因此使用31(?)长输入字符串您将覆盖@ 987654330@ 到 0 (这特别是不可利用的,但长字符串的副本可能是)。

jl/jg 用于长度检查,但长度是无符号的,所以 jb/ja 对我来说更有意义(不是错误,签名测试 &gt;=1 &amp;&amp; &lt;= 30 将与无符号测试同时失败,只是不会如果你有编程强迫症感觉不错)。

好/坏字符测试 - 你可以通过只做两个测试来缩短它('0' &lt;= char &amp;&amp; char &lt;= '2'),因为['0', '1', '2'] 是值[48, 49, 50]。

现在更严重的事情接踵而至。

在 I/J 循环中,您不会重置 J,因此内部循环的逻辑将有缺陷。

push dword [X] 我不认为这会像你认为的那样。字符串的地址是X,[X] 是内存的内容(字符串的字符)。 (这将使sufcmp 代码提前出现段错误,此时它将尝试访问“地址”'0010',这是不合法的。

在交换中,例如 mov edx, dword [y + edi] ...您将 edi 增加 1,但 Y 被定义为 dwords 数组,因此任何地方的索引都应该是 edi*4。

cmp esi, dword [N-1] ; if i = N-1 嗯,不,它会将esi 与地址N-1 的值进行比较,因此如果[N] 包含16 并且前面是单个零字节,cmp 将比较esi 与值4096(N-1 处的内存是:00 10 00 00 00,所以[N] == 0x00000010 和[N-1] == 0x00001000)。

mov eax, dword [X] ; move address of X to eax - 不,lea 会按照评论所说的去做。 mov 将获取地址 X 的内容。

add eax, [y + esi] - 再次使用带有 dword 数组的 +-1 索引。

而你忘记调用 print_string,只调用了新行。

您可以将该部分重写为:

mov eax,[y + esi*4]   ; eax = Y[i]
lea eax,[X + eax]     ; eax = address X + Y[i]

而且,因为我又残忍又累,所以我把最大的担心留到了最后一个音符上。

我认为这根本行不通。您的冒泡排序正在迭代原始 X 字符串(嗯,它不是,但是一旦您使用正确的地址解决了参数问题,它就会)。

每次。因此,您在每次迭代中都根据原始字符串不断改组 Y 数组的内容。


我的回答中最重要的部分是第一句话。你绝对需要调试器。如果到目前为止您觉得该语言对您有意义,那么您的来源并不能证明这一点。实际上我可以看到一些理解,所以你基本上是对的,但你必须是完全的神童才能在合理的时间内在没有调试器的情况下完成这个。我只会给你打分高于平均水平,也许不错,但离惊人的地方还很远。

如果您仍想不使用调试器,请更改技术。不要在不编译+运行的情况下编写这么多代码。用小得多的步骤来做,并不断显示各种各样的东西,以确保你的新 3 行代码做他们应该做的。例如,如果您为 sufcmp 创建空存根,只是从指针打印字符串,它会在尝试访问字符串后立即出现段错误。

与几乎最终的应用程序代码出现段错误相比,这可能会给您更好的提示,因此您不必在最近 10 行上寻找问题,而是有 50 多行需要推理。


编辑:算法建议:

除非你真的必须使用冒泡排序,否则我会避免这样做,并使用蛮力愚蠢的“计数”排序变体。

i:[0,N): count[i] = countif(j:[0,N): X[j] < X[i])
i:[0,N): j:[0,N): if (i == count[j]) print X[j]

我希望你能够破译它......这意味着我会为每个后缀计算有多少后缀在字典上“更小”,即。完整的 O(N2) 循环循环(实际上是 N^3,因为比较字符串是另一个 O(N) ...但谁在乎 N=30,甚至 N5 可以忍受)。

然后要以正确的顺序打印后缀,您只需一次又一次地搜索 count 数组,第一次是 0 较小的计数(这是最小的),然后是 1,... 等等。直到你把它们都打印出来。

实际上你可以遍历所有的后缀,计算出有多少个更小,然后将该后缀的索引放入sorted[smaller_count],所以打印时你只需从0到N-1循环sorted数组,不涉及搜索.

【讨论】:

  • 当然我没有调试你的代码(不是minimal reproducible example),所以我可能在某些假设上是错误的,什么是bug,什么不起作用,也许你的算法是正确,我只是不明白
  • 非常感谢!抱歉,我对这些东西太无能了,但就像我说的,组装对我来说很有意义,但不是很多。我不使用调试器的原因是因为我不知道怎么做;我从来没有在我的课程中学会如何使用一个。感谢您的建议和更多的摆弄,它有效!
  • @Matt:不,实际上你做得很好。有点错过了整体算法,它有缺陷,对吧?但通常你表现出一些原则层面的理解你在做什么。我的“问题”列表有点过于迂腐,而且你需要多年的经验才能“看到”这些,尤其是在你自己的来源上。通常,您只需解决问题,然后在调试+重构期间修复它,此时将思维转换为“阅读外来资源,而不是我的”很重要。关于调试器:要么放弃课程,要么自学一门。 gdb 适用于任何二进制文件,而不仅仅是 asm(投资)。
猜你喜欢
  • 1970-01-01
  • 2012-06-26
  • 2014-12-27
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2023-01-11
  • 1970-01-01
  • 2023-03-13
相关资源
最近更新 更多