ARM7: unaligned memory access

[Peter (Gast)]

Hallo NG,

nehmen wir mal an, ich habe im Speicher folgendes:

ALIGN 4
memory:
00 | 4c | 31 | ea | 00 | 00

dann kann ich ja mit
ldr r8, [memory]
32 Bit ins Register laden.

mit

ldr r8, [memory + 1]
funktioniert das nicht, da das ja ein "unaligned access" ist...

Ich könnte (mach ich bisher) das Ganze mit ldrb machen und mir dann die 
Bytes über mehrere Befehle hinweg zusammensammeln. Gibts da auch ne 
schönere Methode, um sowas zu machen?

Vielen Dank und viele Grüße,
Peter

[Marcus H. (mharnisch)]

Peter schrieb:
> Ich könnte (mach ich bisher) das Ganze mit ldrb machen und mir dann die
> Bytes über mehrere Befehle hinweg zusammensammeln. Gibts da auch ne
> schönere Methode, um sowas zu machen?

Nein. Erst neuere ARM Prozessoren unterstützen unaligned access.

--
Marcus

[Marcus H. (mharnisch)]

Korrektur. Vorausgesetzt unaligned access löst keinen data abort aus 
(erst ab v5TE konfigurierbar), kannst Du die Daten möglicherweise 
geringfügig schneller laden, indem Du folgendes verwendest:

;; int load_word((__packed int) *ptr);
load_word PROC

ptr     RN 0
word    RN 0
lower   RN 2
upper   RN 0
align   RN 1

        ;; check alignment
        ANDS    align, ptr, #0x3
        ;; if aligned
        ;;   load word from address and return
        LDREQ   word, [ptr]
        BXEQ    lr

        LSL     align, #3 ; convert align into shift value
        MVN     mask, #0

        ;; else
        ;;   load rotated word from word address
        ;;   and mask top
        LDR     lower, [ptr]
        AND     lower, mask, LSR align
        
        ;;   load rotated word from word address + 4
        ;;   mask, and combine both words
        LDR     upper, [ptr, #4]
        AND     upper, mask, LSL align
        ORR     word, lower, upper
        BX      lr
        ENDP

(ungetestet, da ich gerade Probleme mit dem Lizenzserver habe)

Der Code basiert auf einem in der ARM Architektur definierten Verhalten 
bei unaligned access.

Gruß
Marcus

[Peter P. (uncle-sam7)]

Hallo Marcus,

bei mir gehts eigentlich immer um max. 2 Bytes. Momentan löse ich das 
so:

abs:  // get address for #$xxxx into r5
  ldrb r4, [r8, #1]
  ldrb r5, [r8, #2]
  add r5, r4, r5, lsl #8
  mov pc, r14

r8 ist in diesem Fall dann "pc" des 6502. In "pc"+1 und "pc"+2 steckt 
die 16 Bit Adresse zum Opcode an "pc".

Gruß,
Peter

[Marcus H. (mharnisch)]

Peter Pippinger schrieb:
> bei mir gehts eigentlich immer um max. 2 Bytes.

Na dann mach' Dir keinen Stress.

> Momentan löse ich das so:
> [...]

Was ist den daran unelegant?

--
Marcus

[Peter P. (uncle-sam7)]

> Was ist den daran unelegant?
...weiss auch noch nicht...

Bin noch recht unerfahren mit ARM7 Assembler. Und die Emulation des 6502 
macht eigentlich nicht viel. Deswegen würde ich alles so kurz wie 
möglich halten. Hab auch nur den Software-Debugger von der IAR 
Workbench, um das Programm schrittweise durchzugehen.

Was ich eigentlich noch optimierbar sehe:

Die Auflösung der Adresse nicht als Subroutine zu machen, sondern als 
Makro. Würde einen BL und den dazugehörigen Rücksprung weniger 
ergeben...

MfG
Peter