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

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

这个怎么样：Instruction set for ARM

一些提示/简化的asm

• 推送 - 将某些内容放在“堆栈”/内存中
• 添加 - 通常在 + 中“添加”
• Pop 从“堆栈”/内存中检索某些内容
• CMP - 是比较的缩写，它将某事物与其他事物进行比较。

X: 或：Whatever: 表示下面是一个“子程序”。曾经在 Java 中使用过“goto”吗？其实和那个差不多。

如果您有以下情况（如果它是正确的 arm-asm 则忽略它只是 pseduo）：

PUSH 1
x:     
    POP %eax

首先它会将 1 放入堆栈，然后将其弹出回 eax（扩展 ax 的缩写，这是一个可以放入 32 位数据量的寄存器）

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

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

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

Answer 2

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

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

Answer 3

除了最后两行之外，它可能类似于以下内容。
如果我不是 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 4

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

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

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

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。

（剪断）

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

编辑 - 当我在车里时，Curd 说出了我在试图写出答案时所想的内容，但时间不多了。

Answer 5

这里是逐行注释的说明

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;
}

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

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。