ARM程序集 - 转换字节序

Question

This is currently a homework project that me and my teammate are stuck on. We haven't been given much of an introduction into Assembly, and this is supposed to be our first homework exercise. The task is to create a program that converts 0xAABBCCDD into 0xDDCCBBAA.

I'm not looking for an answer, as that would defeat the purpose, but we are getting severely frustrated over the difficulty of this stupid thing. We think we have a good start in creating a viable solution, but we just cannot come up with the rest of the program.

First, we mask every single tupel (aa), (bb), (cc), (dd) into a different register:

LDR R0, LittleEndian    // 0xAABBCCDD
AND R1, R0, #0xFF000000 // 0xAA
AND R2, R0, #0x00FF0000 // 0xBB
AND R3, R0, #0x0000FF00 // 0xCC
AND R4, R0, #0x000000FF // 0xDD

Then we try to re-align them into the R0 register, but hell if we could come up with a good solution...

Our best effort came from:

ORR R0, R1, LSL #24 
ORR R0, R2, LSL #8
ORR R0, R3, LSR #8
ORR R0, R4, LSR #24

which produced 0xBBBBCCDD for some odd reason; we really don't know.

Any hints would be greatly appreciated. Again, we are asking for help, but not for a solution.

Cheers!

Answer 1

On ARMv6 and above, you can just use the rev instruction, but I assume that you're not allowed to do that for whatever reason.

As to why you got the result you did, I've gone through your code and commented the actual values of the registers being operated upon:

LDR R0, LittleEndian    // r0 = 0xAABBCCDD
AND R1, R0, #0xFF000000 // r1 = 0xAA000000
AND R2, R0, #0x00FF0000 // r2 = 0x00BB0000
AND R3, R0, #0x0000FF00 // r3 = 0x0000CC00
AND R4, R0, #0x000000FF // r4 = 0x000000DD

ORR R0, R1, LSL #24     // r0 = 0xAABBCCDD | 0x00000000 = 0xAABBCCDD
ORR R0, R2, LSL #8      // r0 = 0xAABBCCDD | 0xBB000000 = 0xBBBBCCDD
ORR R0, R3, LSR #8      // r0 = 0xBBBBCCDD | 0x000000CC = 0xBBBBCCDD
ORR R0, R4, LSR #24     // r0 = 0xBBBBCCDD | 0x00000000 = 0xBBBBCCDD

What's happening here is that you have your shift directions backwards; instead of left shifting 0xAA000000 by 24, you want to right shift it by 24, giving 0x000000AA . Furthermore, you never zeroed out the contents of r0 , which you would also need to do for this approach to work. If you fix these problems, your code will work as intended (though there are more compact ways to accomplish the same task).

Answer 2

Your code looks good so far.

Your mistake is, that you have reversed the meaning of LSL and LSR.

Take R0 for example:

AND R1, R0, #0xFF000000 // 0xAA

The result of this operation does not generate 0xAA. It generates 0xAA000000.

The second instruction that processes R1:

ORR R0, R1, LSL #24 

Will shift the data out of the register. There is simply no space left of the top 8 bits.

If otoh you shift the data to the right like this:

ORR R0, R1, LSR #24 

The data ends up in the lowest byte. Where you want it to be. That should give you enough help to get your homework done. :-)

Answer 3

I think you need to do (ARM a bit rusty):

MOV R0, R1, LSR #24 
ORR R0, R2, LSR #8
ORR R0, R3, LSL #8
ORR R0, R4, LSL #24

That is, MOV in the first instruction as you don't want anything from the old R0 to affect the new value.

I can't see any way to make this more 'hint' like as you've effectively done all the work anyway.

Answer 4

While the question is rather old i've wanted to add my suggestion for the code, because it just needs 6 instructions instead of 8. It also needs only 3 Registers instead of 5. This should be the best solution for anything before armv6 (which has the rev instruction).

// We're starting with r0 = 4321
mov r2, r0, lsr #24             // r2 = 0004
and r1, r0, #16711680           // r1 = 0300
orr r2, r2, r0, lsl #24         // r2 = 1004
orr r2, r2, r1, lsr #8          // r2 = 1034
and r0, r0, #65280              // r0 = 0020
orr r0, r2, r0, lsl #8          // r0 = 1234

Answer 5

此外，在使用ORR移回位之前，您可能还没有清除R0寄存器（将其设置为所有零位）。