LOW() und HIGH() funktionieren nicht in AVRStudio

[Luke (Gast)]

Hallo,

ich habe mich mal daran gemacht, diese Sprungtabelle 
(http://www.mikrocontroller.net/articles/AVR-Tutorial:_Mehrfachverzweigung#Sprungtabelle) 
nachzuprogrammieren, bzw. den Quelltext zu kopieren und im Simulator von 
AVR Studio (4.18) laufen zu lassen. Aber es kompiliert erst garnicht:

Für die Zeilen "ldi ZL,low(Sprungtabelle)" und "ldi 
ZH,high(Sprungtabelle)" meckert der Compiler "Error: garbage at end of 
line".

Und wenn ich "low()"/"high()" durch "lo8()"/"hi8()" ersetze, wird nicht 
korrekt gesprungen. Genauso funktionieren "pm_lo8()"/"pm_hi8()" nicht.

Mittlerweile bin ich etwas ratlos. Habt Ihr eine Idee, was hier 
schiefläuft?

Grüße,
Luke

[Robert D. (d0rni)]

zeige doch mal deinen Code. Eventuell hast du beim copy & paste was 
falsch gemacht.

[Karl H. (kbuchegg)]

Luke schrieb:

> AVR Studio (4.18) laufen zu lassen. Aber es kompiliert erst garnicht:

kompiliert -> assembliert.

Ein Assembler ist kein Compiler

> Für die Zeilen "ldi ZL,low(Sprungtabelle)" und "ldi
> ZH,high(Sprungtabelle)" meckert der Compiler "Error: garbage at end of
> line".

Das deutet aber eher darauf hin, dass sich irgend ein nicht sichtbares 
Zeichen im Editor eingeschlichen hat. Ich schätze mal, dass da beim 
Copy&Paste irgendwas mitkopiert wurde, was nicht dort sein soll.

Wenn es ein Problem mit den High/Low Makros gäbe, gibt es keinen 
wirklichen Grund, warum der Assembler das nicht auch in der 
Fehlermeldung anführen sollte. Die Fehlermeldung würde dann eher in die 
Richtung "Unknown Operand 'HIgh'" oder so ähnlich lauten. 'Garbage at 
the end of Line', also 'unbekannter 'Dreck' am Zeilenende ist meistens 
ein Hinweis auf irgendein Zeichen, welches man zwar nicht sieht, welches 
aber trotzdem dort ist und eigentlich nicht dort sein sollte.

[Luke (Gast)]

Hallo,

hier mein Code:

int main(void) {

  // ZL = r30, ZH = r31
  asm goto (

    "ldi r16,2"                  "\n"
    "ldi r30, low(Sprungtabelle)"      "\n"
    "ldi r31, high(Sprungtabelle)"      "\n"
    "add r30, r16"                "\n"
    "ldi r16, 0"                "\n"
    "adc r31, r16"                "\n"  
    "ijmp"                    "\n"

    "Sprungtabelle:"              "\n"
    "jmp %x0"                  "\n"
    "jmp %x1"                  "\n"
    "jmp %x2"
    :::: l1, l2, l3
  );


  l1:
    asm("ldi r16,42");
    goto end;

  l2:
    asm("ldi r16,11");
    goto end;

  l3:
    asm("ldi r16,0xff");
    
  end:
  return 0;
}

Ein Teil der Lösung bestand darin, das ZL und ZH zu ersetzen. Aber "low" 
und "high" funktionieren immer noch nicht!

Ich bin jetzt echt ratlos!

Viele Grüße,
Luke

[spess53 (Gast)]

Hi

>Ich bin jetzt echt ratlos!

Warum nimmst du nicht den richtigen Assembler vom AVR Studio?

MfG Spess

[Luke (Gast)]

Hallo,

spess53 schrieb:
> Warum nimmst du nicht den richtigen Assembler vom AVR Studio?

weil ich schon den C-Code "drumherum" habe und den nicht nochmal neu 
schreiben möchte in Assembler, aber das switch-Statement in C circa 30 
Zyklen benötigt und ich die Zyklen für das Programm brauche!

Viele Grüße!

[Yalu X. (yalu) (Moderator)]

low() und high() heißen beim GNU-Assembler lo8() und hi8(). Aber da 
scheinen noch andere Dinge komisch bis fehlerhaft zu sein.

[Karl H. (kbuchegg)]

Luke schrieb:
> Hallo,
>
> spess53 schrieb:
>> Warum nimmst du nicht den richtigen Assembler vom AVR Studio?
>
> weil ich schon den C-Code "drumherum" habe und den nicht nochmal neu
> schreiben möchte in Assembler, aber das switch-Statement in C circa 30
> Zyklen benötigt und ich die Zyklen für das Programm brauche!

Zeig mal den C-Code.
Da gibt es sicher was, wie man das auch in reinem C schneller kriegt.

[Peter D. (peda)]

Die Compilerbauer sind nicht so dumm, wie Anfänger gerne denken.
Ein Switch kann durchaus als Sprungtabelle implementiert werden, sobald 
es effektiver ist.

Hier wird allerdings ein Array die bessere Lösung sein (eine Zahl in 
eine andere umwandeln).


Karl Heinz schrieb im Beitrag #3560098:
> Zeig mal den C-Code.

Ja.
Der gezeigte Assemblercode ist recht sinnfrei.

[Johann L. (gjlayde)]

LOW und HIGH sind Zeugs vom Atmel-Assembler.

Du verwendest den GNU-Assembler (avr-as)mit avr-gcc als 
Compiler-/Assembler-/Linker-Treiber.

Schau dir einfach an, wie avr-gcc das macht:

  subi r30,lo8(-(gs(.LSprungtabelle)))
  sbci r31,hi8(-(gs(.LSprungtabelle)))
  ijmp
  .section  .progmem.gcc_sw_table,"ax",@progbits
  .p2align  1
.LSprungtabelle:
  rjmp .L1
  rjmp .L2
...
  .text
.L1:
  ...

für die kleinen AVRs (mit RJMP) und für die großen (mit JMP):

  subi r30,lo8(-(gs(.LSprungtabelle)))
  sbci r31,hi8(-(gs(.LSprungtabelle)))
  jmp __tablejump2__
  .section  .progmem.gcc_sw_table,"a",@progbits
  .p2align  1
.LSprungtabelle:
  .word gs(.L1)
  .word gs(.L2)
...
  .text
.L1:
  ...

Was __tablejump2__ macht siehst du in der libgcc:

DEFUN __tablejump2__
  lsl  r30
  rol  r31
    ;; FALLTHRU
ENDF __tablejump2__

DEFUN __tablejump__
#if defined (__AVR_HAVE_LPMX__)
  lpm __tmp_reg__, Z+
  lpm r31, Z
  mov r30, __tmp_reg__
#if defined (__AVR_HAVE_EIJMP_EICALL__)
  eijmp
#else
  ijmp
#endif

#else /* !HAVE_LPMX */
  lpm
  adiw r30, 1
  push r0
  lpm
  push r0
#if defined (__AVR_HAVE_EIJMP_EICALL__)
  in   __tmp_reg__, __EIND__
  push __tmp_reg__
#endif
  ret
#endif /* !HAVE_LPMX */
ENDF __tablejump__