ARM Assembler - Kopieren von Daten

[Peter W. (ja_wasser)]

Hallo,
und zwar sollen wir folgendes machen:
Wir haben eine Liste1:

Liste1: .byte -9, 8, -7, 6, -5, 4, -3, 2, -1, 0, 127, 128

und diese jeweils 1 byte-Zahlen sollen wir in eine Liste2 als 32bit 
Zahlen kopieren. Davor sollen wir aber diese 1 Byte-Zahlen in 32bit 
Zahlen (also 4 Byte) umwandeln (???).

Ich hab da bis jetzt sowas:

Copy:
  mov ip, #0        @ Zähler für Schleife
  LDRB   r1, =Liste1
  LDR   r2, =Liste2
Loop:
  LDRB  r0, [r1], #1
  STR   r0, [r2], #4
  add   ip, ip, #1
  cmp   ip, r3
  blt   Loop

Das funktioniert aber überhaupt gar nicht. Weder funktioniert die 
for-schleife noch das Laden in das Register r0. Im Debugger bleibt r0 
einfach r0, da ändert sich einfach nichts.

Weiß wer was daran falsch ist? Ich wandel hier natürlich nicht diese 
8bit Zahlen aus Liste1 in 32bit Zahlen um, weil ich auch nicht wirklich 
weiß wie das geht. Ich könnt mir vorstellen das man die 8bit Zahlen dann 
halt um 24 Stellen nach rechts shiftet mit LSR, dadurch würde man dann 
ja links von der 8 Bit Zahl alles mit 24 Nullen auffüllen und dann wäre 
es wohl irgendwie 32bit. Aber das hauptproblem ist, dass das hier
LDRB  r0, [r1], #1
überhaupt nicht funktioniert. Da wird einfach kein Wert in r0 
gespeichert. r0 bleibt laut debugger bei 0x0.

Weiß da wer weiter?

[ARMschlumpf (Gast)]

1. Fehler den ich seh:

> LDRB   r1, =Liste1

In r1 soll ein Adresse. Das sind 32 bit.

Weiter guck ich mal nicht...

[Carl D. (jcw2)]

Warum soll es gut sein, von der Adresse eines Speicherblocks nur die 
unteren 8bit zu benutzen?
Was bedeutet wohl das B am Ende von LDRB?

[nfet (Gast)]

godbolt.org
Tipps in C ein und lasse lösen. Du hast Glück, dass jemand Compiler 
erfunden hat.

[. . (Gast)]

copy:
 ldr r1,=Liste1
 ldr r2,=Liste2
 ldr r3,=EndOfListe1
loop:
 ldrb r0,[r1],#1
 sxtb r0
 str r0,[r2],#4
 cmp r1,r3
 bne __loop

[Peter W. (ja_wasser)]

Ah ja danke, daran lag es.

Ich habs jetzt soweit:

Copy:
  mov   ip, #0    @ Zähler für Schleife
  LDR   r1, =Liste1
  LDR   r2, =Liste2
  mov  r3, #13    @ Anzahl der Elemente

Loop:
  LDRB  r0, [r1], #1
  STR   r0, [r2], #4
  add   ip, ip, #1
  cmp   ip, r3
  blt   Loop

Loop funktioniert und er liest zumindest positiven 8bit Zahlen richtig 
ein. Aber das Problem ist jetzt, dass die negativen 8bit Zahlen aus 
Liste1 nicht richtig eingelesen werden. Wenn er eine -3 einlesen soll, 
liest er stattdessen eine 253 ein. Bei den 8Bit Zahlen geht es wohl von 
0 bis 255 und nicht von -128 bis 128.

So wie ich es mir überlege muss ich dann wohl, wenn eine Zahl größer als 
128 eingelesen wird (d.h. die Zahl ist eigentlich negativ), diese Zahl 
minus 1 rechnen, alle Bits umkehren (d.h. das 2er Komplement nur 
rückwärts) und dann mit -1 multiplizieren damit es richtig wird.

[. . (Gast)]

 ldrb r0,[r1],#1
 sxtb r0
 str r0,[r2],#4

[Peter W. (ja_wasser)]

.                                                . schrieb im Beitrag 
#5432381:
>

>  ldrb r0,[r1],#1
>  sxtb r0
>  str r0,[r2],#4
>

Jo danke. Das mach ich, falls mein Weg nicht funktioniert. Denn den 
Befehl sxtb hatten wir noch nicht, bin deshalb nicht sicher ob wir den 
benutzen dürfen.

[(prx) A. K. (prx)]

Oder so?
 mov   ip, #12
 ldr   r1, =liste1+12
 ldr   r2, =liste2+48
loop:
 ldrsb r0, [r1, -ip]
 str   r0, [r2, -ip, lsl #2]
 subs  ip, ip, #1
 bne   Loop

[. . (Gast)]

Peter W. schrieb:
> .                                                . schrieb im Beitrag
> #5432381:
>>

>>  ldrb r0,[r1],#1
>>  sxtb r0
>>  str r0,[r2],#4
>>

>
> Jo danke. Das mach ich, falls mein Weg nicht funktioniert. Denn den
> Befehl sxtb hatten wir noch nicht, bin deshalb nicht sicher ob wir den
> benutzen dürfen.

Kindergarten Zwergengruppe?
Dann eben für Lehrplanleerer (kein Typo :P) eine andere illegale 
Variante. Dürft ihr schon Verschieben?

 ldrb r0,[r1],#1
 lsl r0,r0,#24
 asr r0,r0,#24
 str r0,[r2],#4

[Peter W. (ja_wasser)]

.                                                . schrieb im Beitrag 
#5432481:
> Kindergarten Zwergengruppe?
> Dann eben für Lehrplanleerer (kein Typo :P) eine andere illegale
> Variante. Dürft ihr schon Verschieben? ldrb r0,[r1],#1
>  lsl r0,r0,#24
>  asr r0,r0,#24
>  str r0,[r2],#4

Jop danke, das dürfen wir. Funktioniert auch. So wie ich es verstehe 
wird da dann zuerst die Zahl nach links verschoben mit 24 Nullen 
(logisch weil wir ja von 8bit auf 32bit wollen), und dann wird es wieder 
nach rechts verschoben, wobei dieses ASR jenachdem ob die zahl positiv 
oder negativ ist, es mit 24 0en oder 1en auffüllt.

[(prx) A. K. (prx)]

Diese Variante hat den Vorzug, dass sie auch auf den ersten ARMen 
funktioniert. Die hatten weder SXTB noch LDRSB.