汇编语言：尝试理解一个小函数

Question

对于我的工作，我需要反转这部分代码 (ARM9) 正在执行的操作。我是一名 Java 开发人员我真的不明白与单个函数相关的这部分代码。

当然，我正在寻求帮助，因为原始代码不再可用。任何人都可以帮助我知道这段代码在任何高级语言中使用小算法做了什么？那就太好了。我已经尝试了很多小时没有结果。

sub_FFFF7B38
    PUSH    {LR}
    ADDS    R2, R0, #0
    LDRB    R3, [R2]
    CMP     R3, #0
    BEQ     loc_FFFF7B52
    SUBS    R1, #1
    BCC     loc_FFFF7B52

loc_FFFF7B46:
    ADDS    R0, #1
    LDRB    R3, [R0]
    CMP     R3, #0
    BEQ     loc_FFFF7B52
    SUBS    R1, #1
    BCS     loc_FFFF7B46

loc_FFFF7B52:
    SUBS    R0, R0, R2
    POP     {R1}

Answer 1

除了最后两行之外，它可能类似于以下内容。
如果我不是100%正确，请不要打我。

如果
R0 是 p0 或 p 并且
R1 是 n 并且
R2 是临时值（已编辑；首先我认为：i 或 p0[i] 的地址）
R3 是临时值

。

sub_FFFF7B38
          PUSH {LR}           ; save return address
          ADDS R2, R0, #0     ; move R0 to R2
          LDRB R3, [R2]       ; load *p0
          CMP R3, #0          ; if *p0==0 
          BEQ loc_FFFF7B52    ; then jump to loc_FFFF7B52 
          SUBS R1, #1         ; decrement n
          BCC loc_FFFF7B52    ; if there was a borrow (i.e. n was 0): jump to loc_FFFF7B52


loc_FFFF7B46:
          ADDS R0, #1         ; increment p
          LDRB R3, [R0]       ; load *p
          CMP R3, #0          ; if *p==0
          BEQ loc_FFFF7B52    ; jump to loc_FFFF7B52
          SUBS R1, #1         ; decrement n
          BCS loc_FFFF7B46    ; if there was no borrow (i.e. n was not 0): jump to loc_FFFF7B46


loc_FFFF7B52:
          SUBS R0, R0, R2     ; calculate p - p0
          POP {R1}            ; ??? I don't understand the purpose of this
                              ; isn't there missing something?

或在 C:

int f(char *p0, unsigned int n)
{
  char *p;

  if (*p0==0 || n--==0)
    return 0;

  for(p=p0; *++p && n>0; n--)
  {
  }
  return p - p0;
}

Answer 2

以下是逐行注释的指令

sub_FFFF7B38
    PUSH    {LR}          ; save LR (link register) on the stack
    ADDS    R2, R0, #0    ; R2 = R0 + 0 and set flags (could just have been MOV?)
    LDRB    R3, [R2]      ; Load R3 with a single byte from the address at R2
    CMP     R3, #0        ; Compare R3 against 0...
    BEQ     loc_FFFF7B52  ; ...branch to end if equal
    SUBS    R1, #1        ; R1 = R1 - 1 and set flags
    BCC     loc_FFFF7B52  ; branch to end if carry was clear which for subtraction is
                          ; if the result is not positive

loc_FFFF7B46:
    ADDS    R0, #1        ; R0 = R0 + 1 and set flags
    LDRB    R3, [R0]      ; Load R3 with byte from address at R0
    CMP     R3, #0        ; Compare R3 against 0...
    BEQ     loc_FFFF7B52  ; ...branch to end if equal
    SUBS    R1, #1        ; R1 = R1 - 1 and set flags
    BCS     loc_FFFF7B46  ; loop if carry set  which for subtraction is
                          ; if the result is positive

loc_FFFF7B52:
    SUBS    R0, R0, R2    ; R0 = R0 - R2
    POP     {R1}          ; Load what the previously saved value of LR into R1
                          ; Presumably the missing next line is MOV PC, R1 to
                          ; return from the function.

因此，在非常基本的 C 代码中：

void unknown(const char* r0, int r1)
{
    const char* r2 = r0;
    char r3 = *r2;
    if (r3 == '\0')
        goto end;
    if (--r1 <= 0)
        goto end;

loop:
    r3 = *++r0;
    if (r3 == '\0')
        goto end;
    if (--r1 > 0)
        goto loop;

end:
    return r0 - r2;
}

添加一些控制结构以摆脱 goto ：

void unknown(const char* r0, int r1)
{
    const char* r2 = r0;
    char r3 = *r2;

    if (r3 != '\0')
    {
        if (--r1 >= 0)
        do
        {
             if (*++r0 == '\0')
                 break;
        } while (--r1 >= 0);
    }

    return r0 - r2;
}

编辑： 现在，我对进位感到困惑位和 SUBS 已被清除，这更有意义。

简化：

void unknown(const char* r0, int r1)
{
    const char* r2 = r0;

    while (*r0 != '\0' && --r1 >= 0)
        r0++;

    return r0 - r2;
}

换句话说，就是在r0指向的字符串指针的前r1个字符中找到第一个NUL的索引，或者返回r1 如果没有。

Answer 3

Filip 提供了一些指针，您还需要阅读 ARM 调用约定。 （也就是说，哪个寄存器包含入口处的函数参数及其返回值。）

快速阅读后，我认为这段代码是 strnlen 或与之密切相关的代码。

Answer 4

怎么样： ARM 指令集

一些提示/简化的汇编

• Push - 将某些内容放入“堆栈”/内存
• 添加 - 通常“添加”，如 +
• Pop 从“堆栈”中检索某些内容/内存
• CMP - 缺少比较，它将某些内容与其他内容进行比较。

X: 或：Whatever: 表示下面是一个“子例程”。在 Java 中使用过“goto”吗？其实也类似。

如果你有以下内容（忽略它是否正确，arm-asm它只是pseduo）：

PUSH 1
x:     
    POP %eax

首先它将把1放入堆栈，然后将其弹出回eax（它是extended ax的缩写，它是一个寄存器，你可以在其中放置32 位数据量）

现在，x: 做什么呢？好吧，我们假设在此之前还有 100 行 asm，那么您可以使用“jump”指令导航到 x:。

这是对asm的一点介绍。简化了。

尝试理解上面的代码并检查指令集。

Answer 5

我的 ASM 有点生锈了，所以请不要吃烂番茄。假设从 sub_FFFF7B38 开始：

命令 PUSH {LR} 保留链接寄存器，该寄存器是一个特殊寄存器，用于在子例程调用期间保存返回地址。

ADDS 设置标志（就像 CMN 一样）。另外，ADDS R2, R0, #0 将 R0 添加到 0 并存储在 R2 中。 （Charles 在评论中的更正）

LDRB R3，[R2] 正在将 R2 的内容加载到主内存而不是寄存器中，由R3。 LDRB 仅加载单个字节。字中的三个未使用的字节在加载时被清零。基本上，将R2从寄存器中取出并妥善保管（也许）。

CMP R3, #0 在两个操作数之间执行减法并设置寄存器标志，但不存储结果。这些标志导致...

BEQ loc_FFFF7B521，这意味着“如果之前的比较相等，则转到 loc_FFFF7B521”或 if(R3 == 0) {goto loc_FFFF7B521;}

因此，如果 R3 不为零，则 SUBS R1, #1 命令会从 R1 中减一并设置一个标志。

如果设置了进位标志，BCC loc_FFFF7B52 将导致执行跳转到 loc_FFFF7B52。

( snip )

最后，POP {LR} 恢复执行此代码之前链接寄存器中保存的先前返回地址。

编辑 - 当我在车里时，当我试图写下答案并没有时间时，凝乳阐明了我的想法。