Assembler Relative branch out of reach

[TommyB]

Heyho,
recht kurze Frage. Ich bekam grad zum ersten Mal diesen Fehler:

Ok, ich mein ich weiß schon was der bedeutet. Aber wie könnte man diesen Fehler am elegantesten umgehen?

Mir schwebte da grde eine Art Jump Tabelle vor für die Aufrufe wo es nötig wär. z. B.:

(Code)
BREQ tbl_1 ; echtesZiel ist zu weit entfernt
(code)
tml_1:
(R)JMP echtesZiel
(mehr code)
echtesZiel:
(code)

aber das würde die Lesbarkeit doch etwas beeinträchtigen. Vielleicht gibts ja noch elegantere Wege?

 

[oldmax]

Hi
Ich weiß nicht, ob eine Sprungtabelle "eleganter" ist. Irgendwie mußt du ja auch die Sprungadresse in den Befehlszeiger bekommen. Bisher habe ich mir damit beholfen, duch Unterprogramme den Code zusammenzuschieben. Sind viele Entscheidungen zu treffen, so das auch der Aufruf von Unterprogrammen nicht ausreicht, besteht die Möglichkeit, Funktionsgruppen zu benutzen. Also Beispiel:
Auswertung von ASCII-Zeichen A-Z und a-z:

Teste_Zeichen:
  LDS  Reg_A, Read_Char          ; das zu prüfende Zeichen laden
  CPI  Reg_A, "a"
  BRLO Check_Great
  RCALL Check_Low                  ; verzweigen in Prüfung Kleinbuchstaben
  RET                                     ; vorzeitiger Ausstieg aus Unterprogramm
Check_Great:
  CPI  Reg_A, "A"
  BREQ Do_A                           ; springe in Bearbeitung "A"
  CPI  Reg_A, "B"
  BREQ Do_B                           ; springe in Bearbeitung "B"
  CPI  Reg_A, "C"
  BREQ Do_C
  ....
  CPI  Reg_A, "Z"
  BREQ Do_Z
RET
Do_A: RCALL Order_A                    ; bearbeite "A"
   RET                                        ; beende Unterprogramm
Do_B: RCALL Order_B
   RET
Do_C: RCALL Order_C
   RET
   ...
Do_Z: RCALL Order_Z
   RET


Check_Low:                                ; neues Up für Prüfung Kleinbuchstaben
  CPI  Reg_A, "a"
  BREQ Do_aa
  CPI  Reg_A, "b"
  BREQ Do_bb
  CPI  Reg_A, "c"
  BREQ Do_cc

  etc.......

Ich bin zwar kein Freund von vorzeitigen Aussteigen aus einem Unterprogramm, aber manchmal heiligt der Zweck die Mittel. Der Code bleibt lesbar und die Befehle werden auch nicht unnötig aufgebläht.
Wenn du numerische Werte hast, die aufeinander folgen, besteht die Möglichkeit, eventuell mit der Manipulation des Stackpointers zu arbeiten. Hab ich noch nicht gemacht, aber der Weg ist in etwa folgender.

Teste_Zeichen:
  LDS  Reg_A, Read_Char          ; das zu prüfende Zeichen laden
  SUB Reg_A, "A"                     ; dadurch wird der Offset für den Sprung gesetzt 
  CLR  Reg_B
  ROR Reg_A
  ROR REG_B                           ; Wert mit 2 multiplizieren
  LDI	 XL,LOW(Check_A)	     ; x-Pointer auf ersten Sprungbefehl
  LDI	 XH,HIGH(Check_A)
  ADD	 XL, Reg_A
  ADC	 XH, Reg_B	
  Push XL                                ; auf Stackpointer packen, 
  Push XH                               ; (evtl.XL und XH tauschen)
  Ret                                      ; Ret holt die Rücksprungadresse vom Stack
Check_A: RJMP Test_A             ; hier erfolgt ein Sprung, kein Aufruf eines UP
Check_B: RJMP Test_B             ; "test_A" (_B, _C  usw) müssen mit RET 
Check_C: RJMP Test_C             ; abgeschlossen werden
Check_D: RJMP Test_D

Dies ist aber nicht grad leserlich.
Gruß oldmax

 

[TommyB]

Ich habs jetzt erstmal mit ner Sprungtabelle gemacht, klappt soweit auch ganz gut.

Das mit dem Befehlspointer... Damit hab ich damals unter Bascom schon mal rum gespielt. Das war sowas von grausam ^^ Es hat nichts funktioniert und keine Ahnung warum
Glaube das lag aber eher an Bascom