<Desc/Clms Page number 1>
Die Erfindung betrifft ein Verfahren zur Konvertierung eines in einer niederen Programmiersprache abgefassten Programmes in ein Programm höherer Programmiersprache, wobei schrittweise jeder Befehl der Befehisabfolge des in der niederen Programmiersprache abgefassten Programms und diesem Befehl jeweils zugeordnete Status-Informationen in entsprechende Befehle der höheren Programmiersprache übersetzt werden, und wobei zu jedem zu übersetzenden Befehl die diesem zugeordneten Status-Informationen ermittelt werden.
Das Erstellen von Computer-Programmen geschieht in vielen Fällen über höhere Program- miersprachen, wie z. B. C, C+, Fortran, Turbo-Pascal, usw., die üblicherweise eine relativ komfortable Anwendung ermöglichen. Diese Hochsprachen haben neben ihrer übersichtlichen Strukturie- rung auch den Vorteil einer universellen Verwendbarkeit unabhängig vom Computer, auf dem das
Programm läuft.
Da jeder Befehl einer solchen höheren Programmiersprache mehreren Anweisen- gen an den ausführenden Prozessor entspricht, erfordert die Anwendung einer solchen Sprache einen höheren Speicherbedarf als eine niedere Programmiersprache, der früher aus Kostengründen nicht immer zur Verfügung stand, weshalb eine Vielzahl von Anwendungen in Assemblersprache geschrieben worden ist, welche den jeweiligen Mikroprozessor direkt instruiert und daher nur auf den verwendeten Prozessor-Typ bezogen ist.
Am Beginn der Mikroprozessor-Entwicklung standen eine Vielzahl von Prozessortypen zur Verfügung, die z. B. über einen 8Bit-Datenbus und einen 16Bit-Adressbus verfügten. Bei jüngeren Prozessorgenerationen erhöhte sich die Datenbusbreite auf 16,32 oder 64Bit und mit dieser der zur Verfügung stehende Speicherplatz. Es wird daher immer mehr dazu übergegangen, alle Programme in einer höheren Programmiersprache zu verfassen und damit die Unabhängigkeit vom Prozessortyp zu gewährleisten. Andererseits trachten die Hersteller danach, die Produktvielfalt zu beschränken und stellen alte Prozessor-Modelle zu Gunsten neuer Typen ein, wodurch die alten Assemblerprogramme umprogammiert werden müssten.
Hersteller elektronischer Geräte mit Prozessoren einer älteren Generation kommen dadurch in Bedrängnis. Ein Assemblercode ist sehr unübersichtlich und oft sind die Programmierer, die ihn erstellt haben, nicht mehr verfügbar, da sie das betreffende Unternehmen bereits verlassen haben.
Die im folgenden genannten Wege zur Lösung dieses Problems sind bereits beschritten worden.
Das betreffende Programm wird, möglichst in einer höheren Programmiersprache für einen modernen Prozessor neu geschrieben, was von einem technischen Standpunkt aus sicher die beste Lösung ist, insbesonders wenn die Programme ständig gewartet werden müssen. Die Neuprogrammierung ist aber besonders bei über viele Jahre gewachsenen Programmstrukturen so zeit- und kostenaufwendig, dass sie nicht durchführbar ist.
Eine weitere Methode der Anpassung besteht darin, den alten Prozessor mit Hilfe einer Emulations-Software auf einem modernen Prozessor nachzubilden, was relativ rasch durchführbar ist, dafür aber den Nachteil hat, dass ein schneller moderner Prozessor nur mehr die Leistung eines alten, langsamen Prozessors erbringt und darüber hinaus relativ teuer ist.
Weiters kann der alte Mikroprozessor als kundenspezifischer Baustein (ASIC) neu entwickelt werden. Diese Lösung scheitert oft an Lizenz- und Patentrechten und ist in der Entwicklungsphase sehr teuer.
Schliesslich besteht eine weitere Möglichkeit darin, das alte Assemblerprogramm für moderne Prozessoren zu konvertieren. Auf bekannte Weise konvertierte Programme sind jedoch unübersichtlich, daher schlecht zu warten und langsam sowie ineffizient.
Es wurden auch Verfahren zur automatischen Umwandlung eines Assemblerprogrammes in ein Hochsprachenprogramm entwickelt. Ausgangspunkt dafür waren bestehende Assemblerprogramme, deren Erstellung einen beträchtlichen Arbeitsaufwand mit sich brachten, die aber aufgrund der technischen Entwicklung nicht mehr den Anforderungen der Anwender entsprachen und daher in eine passende Hochsprache, z. B. C+, transformiert werden sollten.
Im Artikel von Morris P. und Filman R. "Mandrake : A tool for reverse-engineering IBM Assembly code" in "Reverse Engineering, 1996, Proceedings of the Third Working Conference on", 8-10 Nov. 1996, Seiten 57-66 wird bei der Umwandlung in einem Zwischenschritt der AssemblerCode Befehiszeile für Befehlszeile in eine Arbeitssprache umgesetzt, die sowohl maschinenorientierte als auch Hochsprache-Befehle beherrscht, bevor die weitere Übersetzung in eine Hochsprache erfolgt. Beim Übergang von der Arbeitssprache zur Hochsprache werden vorübergehend definierte Variablen und Sprungbefehle eliminiert. Allerdings wird in diesem Dokument nicht auf die
<Desc/Clms Page number 2>
Befreiung des übersetzten Hochsprachenprogrammes von überflüssigen Register-oder Statusbe- fehlen eingegangen.
In ähnlicher Weise ist im Artikel von Cristina Cifuentes :"Partial automation of an integrated reverse engineering environment of binary code" in "Reverse Engineering, 1996, Proceedings of the Third Working Conference on", 8-10 Nov. 1996, Seiten 50-56 eine automatisierte ReverseEngineering-Umgebung angegeben, mit der Systemkomponenten eines zu übersetzenden Assembler-Programmes und ihre gegenseitige Beziehung analysiert und auf eine höhere Abstraktionsebene gehoben werden. Die Umsetzung von einem binären Kode in eine höhere Programmiersprache erfolgt über drei Verarbeitungsstufen, in denen aber keine Vereinfachungen des Programmcodes vorgenommen werden.
In "An Environment for the Reverse Engineering of Executable Programs" in "Software Engineering Conference, 1995, Proceedings, 1995 Asia Pacific, 6-9 Dec. 1995, Seiten 410-419 von Cifuentes ist ein Dissassembler beschrieben, welcher die Aufgabe hat, das Verständnis für die Strukturen eines bestehenden Hochsprachen-Programmes zu verbessern und der zu diesem Zweck ein solches Programm in ein gleichwertiges Assembler-Programm übersetzt. Dieses wird anschliessend einem Decompiler zugeführt, mit dessen Hilfe eine Umwandlung des AssemblerProgrammes in ein Hochsprachen-Programm, z. B. C, vorgenommen wird. Der Decompiler wendet unter anderem eine Datenfluss-Analyse an, mit deren Hilfe z. B. Registerbefehle bei der Übersetzung vom Assembler-Kode in den Hochsprachen-Kode beseitigt werden.
Auf welche Art diese Registerbefehle eliminiert werden, ist in diesem Artikel allerdings nicht angegeben.
Ebenfalls mit Reverse-Engineering und der dabei angewandten Analyse von Registerständen in einem Assembler-Programm beschäftigt sich der Artikel von Roberts, Piazza und Katz :"A portable Assembler reverse engineering environment (PARE)" in "Reverse Engineering, 1996, Proceedings of the Third Working Conference on", 8-10 Nov. 1996, Seiten 76-85. Ein dabei erstellter Register-Bericht identifiziert alle Stellen innerhalb eines Programmablaufes, an denen ein Register gesetzt oder verwendet wird. Es wird in diesem Dokument aber nur von der Möglichkeit gesprochen, diese Registerstand-Analyse als Ausgangspunkt für eine manuelle Überarbeitung des Programms anzusehen (Seite 85, dritter Absatz von unten), das automatisierte Eliminieren von überflüssigen Register- und Statusoperationen wird jedoch nicht erwähnt oder angeregt.
StatusInformationen des Computers werden zwar explizit nicht überwacht, scheinen jedoch indirekt auch Teil der Analyse zu sein.
Schliesslich offenbart die US 5 664 769 A eine Methode zur Beseitigung von unnötigen Befehlen innerhalb eines Programmes zum Zwecke der Erhöhung der Programm-Ablaufgeschwindigkeit, wobei die Programmschritte des betreffenden Programmes ausgeführt und dabei der interne Zustand, z. B. ein Registerstand oder der Wert eines Status-Bits (Flag) des Computers, auf dem das Programm läuft, überwacht und gespeichert wird. Ändert sich der interne Zustand des Computers nach Durchführung des jeweils nachfolgenden Befehlsschrittes nicht, wird der betreffende Befehlsschritt gelöscht, welcher als eine unnötige Wiederholung des vorhergehenden Befehlsschrittes angesehen wird. Auf diese Weise können Befehle eliminiert werden, deren Funktionslosigkeit sonst nicht feststellbar wäre.
Dieses Verfahren ist somit lediglich auf eine Optimierung des Programmablaufs gerichtet, welche durch Beseitigung von unnötigen Befehlsschritten erreicht wird, die keine Veränderung eines Registerstandes oder einer Statusinformation bewirken. Grundsätzlich ist somit die Verringerung der Anzahl an durchzuführenden Befehlen als Folge der Analyse von Registerständen und Statusinformationen bekannt. Hinsichtlich der Übersetzung in eine Hochsprache sind in dieser Druckschrift jedoch keine Angaben enthalten.
Aufgabe der Erfindung ist es, ein Verfahren der eingangs genannten Art anzugeben, mit dem eine effiziente Übersetzung von Programmen niederer Programmiersprache in Programme mit höherer Programmiersprache ermöglicht wird.
Erfindungsgemäss wird dies dadurch erreicht, dass die dem zu übersetzenden Befehl jeweils nachfolgenden Befehle der Befehlsabfolge der niederen Programmiersprache daraufhin durchsucht werden, ob sie die dem zu übersetzenden Befehl zugeordneten Status-Informationen verwenden, und dass jene Status-Informationen, die durch die nachfolgenden Befehle keine Verwendung erfahren, von der Übersetzung in Befehle der höheren Programmiersprache ausgenommen werden.
Untersuchungen haben gezeigt, dass eine Vielzahl der den Befehlen einer niederen Program-
<Desc/Clms Page number 3>
miersprache zugeordneten Status-Informationen während des gesamten Programmablaufes nicht verwendet bzw. nicht neu gesetzt werden und daher eine Beeinflussung nachfolgender Befehle nicht gegeben ist. Es wird nur für diejenige Status-Information ein übersetzter Befehl generiert, welche von einem der nachfolgenden Befehle im Programmcode der niederen Programmiersprache verwendet wird. Durch das Weglassen der überflüssigen Status-Informationen kann die Übersichtlichkeit des in der höheren Programmiersprache verfassten Programmes gesteigert und die Anzahl der auszuführenden Befehle verringert werden.
In weiterer Ausbildung der Erfindung kann vorgesehen sein, dass bei der Ubersetzung eines Sprungbefehls aus dem zu konvertierenden oder in das zu konvertierende Programm, weicher eine in einem anderen Programm durchzuführende Operation bewirkt oder bewirkt hat, oder eines anderen unvollständig definierten Befehls entweder alle diesem Befehl zugeordneten Statusinformationen übersetzt werden oder das durch diesen Befehl zu durchlaufende andere Programm und gegebenenfalls weitere zu durchlaufende Programme auf eine Verwendung der diesem Befehl zugeordneten Status-Informationen untersucht wird und die keiner Verwendung zugeführten Status-Informationen von einer Übersetzung in Befehle der höheren Programmiersprache ausgenommen werden.
Sollte ein einem zu übersetzenden Befehl nachfolgender Befehl, z. B. aufgrund von Verzweigungen oder Abfragen nicht eindeutig definiert sein, können folglich alle Status-Informationen übersetzt oder die Suche auf alle in Frage kommenden Programme ausgeweitet werden.
Weiters betrifft die Erfindung ein Verfahren zur Konvertierung eines in einer niederen Programmiersprache abgefassten Programmes in ein Programm höherer Programmiersprache, wobei schrittweise jeder Befehl der Befehisabfolge des in der niederen Programmiersprache abgefassten Programms und zugeordnete Rechenregisteroperationen in entsprechende Befehle und Rechenregisterzuweisungen der höheren Programmiersprache übersetzt werden, und wobei zu jedem zu übersetzenden Befehl der Inhalt des Rechenregisters ermittelt wird.
Aufgabe der Erfindung ist es, ein derartiges Verfahren anzugeben, mit dem es möglich ist, bei der Übersetzung in eine höhere Programmiersprache die Befehlsabfolge von nicht erforderlichen Befehlsstrukturen, die für eine niedere Programmiersprache charakteristisch sind, zu befreien.
Erfindungsgemäss wird dies dadurch erreicht, dass die dem zu übersetzenden Befehl jeweils nachfolgenden Befehle der Befehlsabfolge der niederen Programmiersprache daraufhin durchsucht werden, ob der Inhalt des Rechenregisters von diesen Befehlen verwendet oder überschrieben wird, und dass jene Rechenregisteroperationen in der niederen Programmiersprache, die zu keiner weiteren Verwendung des Registerinhalt durch nachfolgende Befehle führen, bei der Übersetzung in Rechenregisterzuweisungen der höheren Programmiersprache ausgenommen werden bzw. die entsprechenden Rechenregisterzuweisungen in der höheren Programmiersprache unterdrückt werden.
Auf diese Weise können die Rechenregisteroperationen in der niederen Programmiersprache, die ohne weitere Folgen für den weiteren Befehlsablauf bleiben, in die höhere Programmiersprache registerfrei übersetzt und damit Befehle eingespart werden, wodurch die Lesbarkeit erhöht wird.
Die Lesbarkeit des generierten Programms der höheren Programmiersprache kann in weiterer Ausbildung der Erfindung dadurch verbessert werden, dass Adressbezeichnungen übersetzt werden.
Gemäss einem weiteren Merkmal der Erfindung kann vorgesehen sein, dass Makro-Programmteile und Unterfunktionen einer zum zu übersetzenden Programm gehörigen Bibliotheksdatei durch in der höheren Programmiersprache verfasste Programmteile ersetzt werden.
Auf diese Weise wird die Leistungsfähigkeit des übersetzten Programms weiter erhöht.
Eine Weiterbildung der Erfindung kann darin bestehen, dass alle möglichen Einsprungadressen für Befehle im Programm der niederen Programmiersprache in einer Zuordnungstabelle gespeichert werden, aus der die entsprechenden Adressen für Befehle des Programms der höheren Programmiersprache ausgelesen werden können.
Dadurch können Probleme vermieden werden, die bei der Berechnung von Sprungadressen über Variablen, z. B. Tabellen oder Register entstehen.
Weiters können die Einsprungadressen für das Programm der niederen Programmiersprache durch Aneinanderreihung der Einsprungadressen für das Programm der höheren Programmiersprache In der Zuordnungstabelle gebildet werden.
Die so entstehenden Adressen für die Labels des Programms der niederen Programmierspra-
<Desc/Clms Page number 4>
che können für die effektive Zuweisung zu den Registern und Tabellen benutzt werden.
Nachstehend wird die Erfindung anhand von Ausführungsbeispielen eingehend erläutert. Die Beispiele beziehen sich auf die Konvertierung eines in Assembler, einer niederen Programmiersprache, verfassten Programms in ein Programm der Programmiersprache C, welches eine höhere Programmiersprache repräsentiert. Das erfindungsgemässe Verfahren kann jedoch für die Übersetzung einer niederen in eine höhere Programmiersprache beliebiger Art verwendet werden.
Die unterschiedliche Funktionsweise eines Programmes niederer Programmiersprache und eines Programmes höherer Programmiersprache kann anhand des nachfolgenden Beispiels verdeutlich werden.
Der Befehl "Addiere Akkumulator und Inhalt von Speicherzelle 1234 (HEX)" wird in der niederen Programmiersprache Assembler wie folgt ausgedrückt :
ADD ACC, (1234H)
Bei einer direkten Übersetzung des vorstehenden Befehls in die Hochsprache C ergibt sich :
EMI4.1
ACC = ACC + RAM[Ox1234] ;
Das Ergebnis der Übersetzung ist jedoch deshalb nicht vollständig, weil ein Mikroprozessor in der Regel eine Vielzahl von Status-Informationen, sogenannte Status-Bits oder Flags besitzt, die bei Registeroperationen gesetzt werden.
Zum Beispiel
Zero Register= 0, Null-Bit
Carry Bereichsüberschreitung bzw. Übertrag
Neg Negatives Ergebnis
Daher müssen in Abhängigkeit vom Prozessortyp zusätzliche Befehle eingefügt werden :
EMI4.2
0000] ; "Definiere RAM-Speicher'flag carry, zero, neg ;"Definiere Status-Bits" ACC = ACC + RAM[Ox1234] (+carry) ; "Ergebnis (event. mit carry) if (ACC= = 0) zero=1 ; else zero = 0 ;"Erzeuge Null-Bit' if (int (ACC+RAM[Ox1234]) > 255) carry =1 ; else carry = 0; "erzeugte Übertrags-Bit" neg= 0 ; "erzeugte Neg-Bit"
Bei Berücksichtigung der Tatsache, dass ausser den im vorstehenden Beispiel verwendeten noch weitere Status-Bits, z. B.
Haifcarry, Overflow, o. a. definiert sein können, ist die Umwandlung des Assembler-Codes in eine höhere Programmiersprache, wie C, C+, Turbo-Pascal o. a. relativ aufwendig, der umgewandelte Programmcode ist nur schwer lesbar und nicht sehr effizient. Die betreffenden Anweisungen in einem Makro zusammenzufassen beschleunigt das Programm nicht, es entsteht wieder ein 1 : 1 Abbild des Assembierprogrammes mit den äquivalenten C-Makros, das auf der Ebene der höheren Programmiersprache nur mit sehr grossen Schwierigkeiten gewartet werden kann.
Um die Übersichtlichkeit des übersetzten Programms zu verbessern, ist erfindungsgemäss vorgesehen, dass zu jedem zu übersetzenden Befehl die diesem zugeordneten Status-Informationen ermittelt und die jeweils nachfolgenden Befehle der Befehlsabfolge der niederen Programmiersprache daraufhin durchsucht werden, ob sie die dem zu übersetzenden Befehl zugeordneten StatusInformationen verwenden. Jene Status-Informationen, die durch die nachfolgenden Befehle keine Verwendung erfahren, werden von der Übersetzung in Befehle der höhere Programmiersprache ausgenommen und somit nicht übersetzt.
<Desc/Clms Page number 5>
Dadurch wird die Erzeugung unnötiger Status-Bits oder Flags bei der Übersetzung in die höhere Programmiersprache vermieden. Es werden nur für jene Status-Bits Code-Zeilen eingefügt, die von einem der nachfolgenden Befehle verwendet werden. Die Suche wird dann abgebrochen, sobald festgestellt worden ist, dass ein nachfolgender Befehl die Status-Bits neu erzeugt.
Sollte die einem Befehl nachfolgende Befehlssequenz nicht eindeutig feststellbar sein, z. B. bel der Übersetzung eines Sprungbefehls aus dem zu konvertierenden oder in das zu konvertierende Programm, welcher eine in einem anderen Programm durchzuführende Operation bewirkt oder bewirkt hat, oder eines anderen unvollständig definierten Befehls, so werden entweder alle diesem Befehl zugeordneten Statusinformationen übersetzt oder das durch diesen Befehl zu durchlaufende andere Programm und gegebenenfalls weitere zu durchlaufende Programme auf eine Verwendung der diesem Befehl zugeordneten Status-Informationen untersucht. Die keiner Verwendung zugeführten Status-Informationen werden dann von einer Übersetzung in Befehle der höheren Programmiersprache ausgenommen.
Die auf diese Weise durchgeführte Eliminierung unnötiger Status-Bits erbringt einen kürzeren und effizienten Sourcecode, der aber immer noch auf der alten Mikroprozessor-Architektur basiert.
Besonders bei bedingten Sprungbefehlen, Datenkopierfunktionen und Rechenoperationen wird in einer niederen Programmiersprache, z. B. Assembler, ein Rechenregister bzw. ein Akkumulator eingesetzt, der das Ergebnis von durchgeführten Operationen speichert Bei einer direkten Konvertierung in die höhere Programmiersprache ergibt dies eine sehr aufwendige Befehlsabfolge, wie nachstehend gezeigt wird :
MOV (1234h), ACC "Lade Akku mit Inhalt von 1234" JZ Routine2 "Wenn Null, springe zu Routine 2"
EMI5.1
:Sollte der Akkumulator nach seiner Anwendung gleich wieder überschrieben werden, der Inhalt also nicht verwendet werden, kann die Zuweisung zum Akkumulator in der höheren Programmiersprache gleich unterdrückt werden if (RAM[Ox1234] = = 0) zero =1 ; else zero = 0 ; if (zero = 0) goto Routine2 ;
Es wird dabei zu jedem zu übersetzenden Befehl der Inhalt des Rechenregisters ermittelt und es werden die jeweils nachfolgenden Befehle der Befehisabfolge der niederen Programmiersprache daraufhin durchsucht werden, ob der Inhalt des Rechenregisters von diesen Befehlen verwendet oder überschrieben wird.
Jene Rechenregisteroperationen in der niederen Programmiersprache, die zu keiner weiteren Verwendung des Registerinhalt durch nachfolgende Befehle führen, werden bel der Übersetzung in Rechenregisterzuweisungen der höheren Programmiersprache ausgenommen bzw. es werden die entsprechenden Rechenregisterzuweisungen in der höheren Programmiersprache unterdrückt.
Sollte das Null-Bit im nachfolgenden Programmcode auch nicht benutzt werden, kann dessen Erzeugung auch unterdrückt werden. if (RAM[Ox1234] = = 0) goto Routine2 ;
Um die Lesbarkeit des generierten Programms höherer Programmiersprache weiter zu erhöhen, ist es notwendig Adressbezeichnungen bzw. Labels ebenfalls zu übernehmen.
Beispiel eines solchen Labels in Assembler-Sprache :
<Desc/Clms Page number 6>
Var1 equ 1234h
Bei geeignetem Ersetzen durch #define var1=Ox1234 oder #define var1=RAM[0x1234] wird aus if (RAM[Ox1234] = = 0) goto Routine2 ; dann if (var1 = =0) goto Routine 2 ;
Zur weiteren Erhöhung der Leistungsfähigkeit des übersetzten Programms kann die Überset- zerfunktion erweiterbar gestaltet sein, z. B. indem in einer zusätzlich Bibliotheksdatei Programmteile für Assembler-Makros und Unterfunktionen bereitgestellt sind. Unter Makros sind dabei Kürzel zu verstehen, die beim Übersetzen und Assemblieren durch ihre entsprechenden Programmteile ersetzt werden.
Da definierte Makros und Unterfunktionen in einem Programm normalerweise häufig verwendet werden, kann die Effizienz des Programms erhöht werden, wenn diese durch einen neu geschriebenen Kode ersetzt werden.
Beispiel : MACRO Add16bit (Var1, Var2, Result) :"Addiere 16Bit Werte" MOV [Var1], ACC ADD [Var2], ACC "Addiere niederwertige Bits" MOV ACC, [Result] MOV [Var1+1], ACC ADDC [Var2+1], ACC "Addiere höherwertige Bits mit Übertrag MOV ACC, [Result + 1] der vorherigen Addition" ENDM
Nach Anwendung des erfindungsgemässen Verfahrens, bei dem Statusinformationen und Registerdaten entfernt werden, wird das folgende Ergebnis erreicht : #define Add16bit (Var1, Var2, Result)
EMI6.1
Durch manuelle Neukodierung könnte die Effizienz der Übersetzung noch gesteigert werden :
#define Add16bit (Var1, Var2, Result) (short*) & RAM[Result] = (short*) & RAM [Varl] + (short*) & RAM[Var2] ;
Bei 32bit-Worten oder Fliesskommaberechnungen ist die Verbesserung noch deutlicher. Wird bei der Anwendung des erfindungsgemässen Verfahrens In der Bibliotheksdatei eine Funktion oder ein Makro gleichen Namens gefunden, wird nicht das entsprechende Assembler-Programm übersetzt, sondern das Programm aus der Bibliothek eingefügt.
Neben diesen Möglichkeiten zur Erhöhung von Ausführungsgeschwindigkeit und Lesbarkeit
<Desc/Clms Page number 7>
des Programmes niederer Programmiersprache müssen noch Übersetzungsmethoden für spezielle Techniken der Assemblerprogrammierung angegeben werden. Für Programmverzweigungen und Unterfunktionen sind bereits Methoden bekannt, die übernommen werden können. Es kann auch ein Einfügen gleichwertiger Befehle in der höheren Programmiersprache vorgenommen werden. Probleme entstehen dabei dann, wenn Sprungadressen berechnet und über Variablen bzw. Tabellen oder Register ausgeführt werden MOV Eintrag, ACC MOV Tabstart, X ;"Lade Start der Sprungtabelle" ADD X, ACC ; Wähle Eintrag entsprechend Akkumulatorinhalt aus" JSR X ;"Rufe Routine entsprechend Register X auf.
Dies funktioniert normalerweise nicht, da die Adressen des Assemblerprogrammes (typ. 16bit Adressraum) nicht mit denen des übersetzten Programms höherer Programmiersprache übereinstimmen (typ. 20-32bit Adressraum). Um Schwierigkeiten zu vermeiden, müssen alle möglichen Einsprungadresssen in einer Zuordnungstabelle gespeichert werden. Diese Tabelle übersetzt die Adressen des Programmes niederer Sprache in die Adressen des Programmes höherer Sprache.
Um die Adresstabelle kurz zu halten, sind im Normalfall nicht alle vom Programm belegten Speicherzellen einzutragen, sondern nur jene, die durch Kennzeichnung mit einem Label als Einsprungadresse in Frage kommen. Durch Aneinanderreihung der Einsprungadressen in der Sprungtabelle entstehen Adressen für die Labels des Assemblerprogrammes, die Eintragsnummern In der Tabelle entsprechen, die für die effektive Zuweisung zu den Registern und Tabellen benutzt werden kann.
PATENTANSPRÜCHE :
1. Verfahren zur Konvertierung eines in einer niederen Programmiersprache abgefassten
Programmes in ein Programm höherer Programmiersprache, wobei schrittweise jeder Be- fehl der Befehisabfolge des in der niederen Programmiersprache abgefassten Programms und diesem Befehl jeweils zugeordnete Status-Informationen in entsprechende Befehle der höheren Programmiersprache übersetzt werden, und wobei zu jedem zu übersetzen- den Befehl die diesem zugeordneten Status-Informationen ermittelt werden, dadurch gekennzeichnet, dass die dem zu übersetzenden Befehl jeweils nachfolgenden Befehle der Befehlsabfolge der niederen Programmiersprache daraufhin durchsucht werden, ob sie die dem zu übersetzenden Befehl zugeordneten Status-Informationen verwenden, und dass jene Status-Informationen, die durch die nachfolgenden Befehle keine Verwendung erfah- ren,
von der Übersetzung in Befehle der höheren Programmiersprache ausgenommen werden.