Question

.global reverse

.data
start: .word 1
end: .word 1
loopcount: .word 0

reverse:     
   ldr r3, =end
   str r1, [r3]    

next:
    ldr r3,=end
    ldr r2,=start
    ldr r3, [r3]
    ldr r2, [r2]

    cmp r2,r3
    bgt done
    cmp r2,r3
    beq done

    sub r3,r2
    mov r2,#0
    mov r1,#0

loop:
    cmp r2,r3
    beq next2

    add r2, r2, #1
    add r1, r1, #4
    b loop

next2:
    ldr r3, [r0]
    add r0, r0, r1
    ldr r2, [r0]
    str r3, [r0]
    sub r0, r0, r1
    str r2, [r0]

    add r0, r0, #4
    ldr r3,=end
    ldr r1, [r3]
    sub r1, r1, #1
    str r1, [r3]
    ldr r3,=start
    ldr r1, [r3]
    add r1, r1, #1
    str r1, [r3]
    b next


done:
    bx lr

我正在尝试反转数组，这是我在汇编中的反向函数，函数是反向的（int data *，size）; data是一个数组，size是大小。它适用于任何大小为5的数组，但是对于较长的数组，例如大小为10，它将忽略最后的2并且就像数组大小为8并且将它们全部交换，好像数组中的最后2个数字没有存在，它将返回：

Array:
1 2 3 4 5 6 7 8 9 10 
My Return:
8 7 6 5 4 3 2 1 9 10

我似乎无法找出我的问题。

Answer 1

以下是将一个数组反向复制到另一个数组的原始且可能效率低下的示例;这可能不一定是你想要的，但可能会培养一些想法。

硬件：Marvell Armada 370 / XP 型号名称：ARMv7 Processor rev 2（v7l）

.bss
        rArray: .zero
.data
        Array:  .word 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,32, 64, 128, 256, 512
        .equ    len.Array,.-Array
.text
        .global main
main:
        ldr r1,=Array                   // Array
        mov r2, #len.Array              // length of array
        mov r3, #0                      // zero init counter Array

        ldr r4,=rArray                  // rArray
        sub r5,r2, #4                   // rArray counter - 1 element

        1:
                ldr r10, [r1,r3]        // load word size element position x from Array
                str r10, [r4,r5]        // store word size element position x from Array into word size position y in rArray
        add r3, r3, #4                  // inc Array counter by 4 since word size is 4 bytes
        subs r5, r5, #4                 // decement rArray counter by 4 & get status (s)
        bpl 1b                          // branch back to loop if positive or zero; i.e., N condition flag is clear

使用GDB的结果：

(gdb) x/21d $r1
0x1102d:        1       2       3       4
0x1103d:        5       6       7       8
0x1104d:        9       10      11      12
0x1105d:        13      14      15      16
0x1106d:        32      64      128     256
0x1107d:        512
(gdb) x/21d $r4
0x11082:        512     256     128     64
0x11092:        32      16      15      14
0x110a2:        13      12      11      10
0x110b2:        9       8       7       6
0x110c2:        5       4       3       2
0x110d2:        1

汇编，分不清我的代码ARM处理器有什么问题

1 个答案: