Die
Erfindung beschreibt ein Verfahren zum Erstellen einer Korrekturanweisung
zur Änderung von
Programmobjektcode eines auf der Ebene der Quelltexte modular aufgebauten
Programms bei Änderungen
im Quelltext eines Moduls gemäß dem Oberbegriff
des Anspruchs 1.The
The invention describes a method for creating a correction instruction
to change
Program object code of modular design at the level of the source code
Program for changes
in the source text of a module according to the generic term
of claim 1.
Ausführbare Computerprogramme
bestehen aus einer binären
Sequenz von Maschinencodebefehlen, dem Programmobjektcode. Entsprechend
der Syntax der Maschinencodebefehle ist der Programmobjektcode prozessorabhängig.Executable computer programs
consist of a binary
Sequence of machine code instructions, the program object code. Corresponding
In the syntax of the machine code instructions, the program object code is processor dependent.
Da
die Maschinencodebefehle in ihrer binären Repräsentation sehr unanschaulich
sind, wird Programmobjektcode üblicherweise
auf eine der drei im folgenden beschriebenen Arten erstellt.There
the machine code instructions are very non-descriptive in their binary representation
program object code usually becomes
created in one of the three ways described below.
Zu
jedem Maschinencodebefehl wird ein mnemonisches Kürzel als
Synonym definiert, wobei die Zuordnung in beide Richtungen eindeutig
ist. Das Programm wird dann als lesbarer Quelltext in dieser Synonymsprache
geschrieben und anschließend
in den ausführbaren
Programmobjektcode übersetzt. Die
Synonymsprache und auch das Programm, das zum Übersetzen benutzt wird, werden
als Assembler, der Vorgang als Assemblieren bezeichnet. In Assembler
geschriebene Programme sind schnell und speichereffizient, erfordern
allerdings hohen Programmieraufwand – insbesondere wenn sie für einen
Prozessor geschrieben werden, der nur über einen sehr eingeschränkten Befehlssatz
verfügt.To
Each machine code command is given a mnemonic abbreviation as
Synonym defined, where the assignment in both directions is unique
is. The program then becomes readable source code in this synonym language
written and then
in the executable
Program object code translated. The
Synonym language and also the program used for translation
as an assembler, the process called assembling. In assembler
written programs are fast and memory-efficient, requiring
However, high programming costs - especially if they are for a
Processor are written, which has only a very limited instruction set
features.
Eine
weitere Möglichkeit,
Programmobjektcode zu erzeugen besteht darin, das Programm in der
Synonymsprache eines Prozessortyps zu schreiben und von einem sogenannten
Cross-Assembler
in Maschinencodebefehle für
einen anderen Prozessortyp zu übersetzen.
Cross-Assembler ermöglichen
damit auch, auf der Basis eines Quellcodes ausführbare Programmobjektcode für verschiedene
Prozessortypen zu erzeugen. Sie erleichtern die Programmierung insofern,
dass die Synonymsprache eines Prozessors, der über einen weiten Befehlssatz
verfügt, benutzt
werden kann.A
another possibility
Creating program object code is to program in the
To write synonym language of a processor type and of a so-called
Cross-Assembler
in machine code commands for
translate another processor type.
Enable cross-assembler
so that, on the basis of a source code executable program object code for various
To create processor types. They make programming easier,
that the synonym language of a processor that has a wide command set
has, used
can be.
Bei
der dritten Methode bedient sich der Programmierer einer sogenannten
Hochsprache, wie Fortran, Pascal, C usw., die unabhängig vom
Prozessortyp ist und komplexe Anweisungen zulässt. Das Übersetzungsprogramm wird in
diesem Fall üblicherweise
Compiler genannt. Der Programmieraufwand ist in diesem Fall am geringsten,
der erzeugte Programmobjektcode ist jedoch weniger speichereffizient
und weniger gut geschwindigkeitsoptimiert.at
In the third method, the programmer uses a so-called
High-level language, such as Fortran, Pascal, C, etc., independent of
Is processor type and allows complex instructions. The translation program will be in
this case usually
Called a compiler. The programming effort is the lowest in this case,
however, the generated program object code is less memory efficient
and less well optimized for speed.
Im
Rahmen dieser Anmeldung umfasst der Begriff Compiler sowohl Assembler,
Cross-Assembler sowie Compiler im obigen Sinne. Quelltext bezeichnet
im folgenden eine Folge von Anweisungen entweder in Assembler oder
einer Hochsprache. Als Objektcode wird die beim Übersetzen des Quellcodes vom
Compiler entstehende Sequenz an Maschinencodebefehlen bezeichnet.in the
For the purposes of this application, the term compiler includes both assembler,
Cross-assembler as well as compiler in the above sense. Source code
following a sequence of statements either in assembler or
a high level language. The object code is the one used when translating the source code from
Compiler resulting sequence referred to machine code commands.
Komplexe
Programme werden üblicherweise nicht
als ein Quelltext-Dokument erstellt, sondern statt dessen in mehrere
kleine funktionelle Untereinheiten, Module genannt, unterteilt.
Module, die nicht programmspezifisch, sondern von universellerem Nutzen
für verschiedenste
Programme sind, werden häufig
in Form einer Zusammenstellung (Bibliothek) abgelegt. Zum Erstellen
des Programmobjektcodes werden die Quelltexte zunächst modulweise
vom Compiler in Objektcode, dann Modulobjektcode genannt, übersetzt.
Ein zweites Programm, der sogenannte Linker, fügt dann den Modulobjektcode
aller von dem Programm benutzten Module zum Programmobjektcode zusammen.
Zusätzlich
wird vom Linker eine Tabelle eingefügt, in der der Name der benutzten
Module sowie die relative Adresse innerhalb des Programmobjektcodes,
unter der diese Module zu finden sind, gespeichert ist. Diese Information ist
wichtig, falls Sprünge
innerhalb des Programms in ein bestimmtes Modul notwendig sind oder
falls Zugriff auf Daten erfolgen soll, die in den Modulen gespeichert
sind.complex
Programs usually do not
created as a source document, but instead in several
small functional subunits, called modules, divided.
Modules that are not program-specific but of more universal use
for different ones
Programs are becoming frequent
filed in the form of a compilation (library). To create
of the program object code, the source texts first become module-wise
from the compiler into object code, then called module object code, translated.
A second program, the so-called linker, then adds the module object code
all of the modules used by the program to program object code together.
additionally
the linker inserts a table in which the name of the used one
Modules as well as the relative address within the program object code,
under which these modules can be found is stored. This information is
important if jumps
within the program in a particular module are necessary or
if access is to be made to data stored in the modules
are.
Der
Vorteil des modularen Konzepts liegt neben der größeren Übersichtlichkeit
darin, dass bei Änderungen
nur der Quelltext der geänderten
Module neu übersetzt
werden muss, nicht der Quelltext des gesamten Programms. Allerdings
muss in jedem Fall das gesamte Programm neu durch Linken zusammengefügt werden.
Auch dieses kann noch sehr aufwändig
sein, insbesondere bei komplexen Programmen mit sehr vielen Modulen,
wie es z.B. Betriebssysteme sind. Hinzu kommt, dass Änderungen im
Quelltext einzelner Module typischerweise vom Programmierer durchgeführt werden,
das Linken allerdings unter Umständen
beim Anwender geschehen muss, da viele benutzerspezifische oder
konfigurationsabhängige
Module im Programm vorhanden sind. Für den Benutzer ist dieser Prozess
nicht nur zeitaufwändig,
sondern birgt darüber
hinaus die Gefahr, dass durch Eingeben falscher Parameter beim Linken
ein nicht funktionstüchtiger
Programmobjektcode erstellt wird.Of the
Advantage of the modular concept is in addition to the greater clarity
in that when changes
only the source code of the changed
Module recompiled
must be, not the source code of the entire program. Indeed
In any case, the entire program must be re-joined by linking.
This too can be very expensive
especially in complex programs with many modules,
as it is e.g. Operating systems are. In addition, changes in the
Source code of individual modules typically performed by the programmer,
the left, however, under certain circumstances
the user must do, as many user-specific or
configuration-dependent
Modules are present in the program. For the user, this process is
not only time consuming,
but harbors it
There is also a risk that by entering wrong parameters in the left
a non-functional
Program object code is created.
Eine
Möglichkeit,
um vom Anwender zumindest kleine Änderungen durchführen zu
lassen, besteht darin, eine Korrekturanweisung in Form einer Datei
zu erstellen, in der einzelne Bytes oder eine Folge von Bytes, die
im Objektcode eines bestimmten Moduls zu tauschen ist, gelistet
sind. Diese Korrekturanweisung wird von einem beim Benutzer vorhandenen
Programm ausgewertet, das die entsprechenden Austauschoperationen
am Programmobjektcode durchführt.
Diese Vorgehensweise ist zwar für
den Anwender unkompliziert durchzuführen, aber nur bei minimalen Änderungen
praktikabel.One way to make at least small changes by the user is to create a correction instruction in the form of a file listing individual bytes or a sequence of bytes to be swapped in the object code of a particular module. This correction instruction is provided by a user evaluated program that carries out the corresponding exchange operations on the program object code. Although this procedure is uncomplicated for the user, it is only practicable with minimal changes.
Eine
Weiterbildung eines solchen Verfahrens ist beispielsweise aus der
Druckschrift US 6,634,026 B1 bekannt.
Das dort offenbarte Verfahren ist geeignet, eine für eine bestimmte
Version eines Programms manuell ausgearbeitete Änderung eines Programmobjektcodes
ohne weiteren Aufwand auf andere Versionen des Programms zu übertragen.A development of such a method is for example from the document US 6,634,026 B1 known. The method disclosed therein is suitable for transferring a change of a program object code manually prepared for a specific version of a program to other versions of the program without further effort.
Die
Korrekturanweisung gibt Änderungen auf
Ebene des Objektcodes an. Sehr kleine Änderungen am Objektcode wie
z.B. falsche Wertezuweisung oder eine falsche Sprungadresse lassen
sich auf dieser Ebene vom Programmierer manuell korrigieren. Weiterreichende Änderungen
lassen sich auf dieser Ebene so gut wie nicht durchführen, sondern
werden von den Programmentwicklern auf Ebene des Quelltextes ausgeführt. Selbst
kleine Änderungen
im Quelltext führen
aber auf schwer vorhersehbare Art zu komplexen Änderungen im Objektcode. Die
zur Anpassung des Programmobjektcodes notwendigen Korrekturanweisungen
sind nur mühevoll
anzugeben, wenn der Objektcode durch einen Assembler erzeugt wird.
Wenn der Quellcode aber durch einen Cross-Assembler oder Hochsprachencompiler
erzeugt wird, ist es für
den Programmierer praktisch nicht mehr möglich, Korrekturanweisungen
manuell anzugeben.The
Correction statement indicates changes
Level of the object code. Very small changes to the object code like
e.g. Leave incorrect value assignment or an incorrect jump address
to manually correct yourself at this level by the programmer. Far-reaching changes
can not be done at this level as well as, but
are executed by the program developers at the source code level. Even
small changes
in the source code
but in a hard-to-predict way to complex changes in the object code. The
correction instructions necessary for adapting the program object code
are only laborious
if the object code is generated by an assembler.
If the source code but through a cross-assembler or high-language compiler
is generated, it is for
the programmer is practically no longer possible, correction instructions
specify manually.
Aus
der Druckschrift US
6,594,822 B1 ist ein Verfahren bekannt, bei dem eine Korrekturanweisung
anhand eines Vergleichs von ursprünglichem Objektcode und korrigiertem
Objektcode erstellt wird, wobei der korrigierte Objektcode aus der Übersetzung
eines geänderten
Quelltextes stammt. Dadurch, dass sich die Struktur von Objektcode
bereits bei kleinen Modifikationen des Quelltextes stark verändern kann,
erfolgt bei diesem Verfahren der Vergleich von ursprünglichem
und korrigiertem Objektcode nicht direkt, sondern anhand vorausgehender aufwändiger Strukturanalysen
mittels sogenannter „reduced
program dependency graphs".From the publication US 6,594,822 B1 For example, a method is known in which a correction instruction is created based on a comparison of the original object code and the corrected object code, wherein the corrected object code originates from the translation of a changed source text. Due to the fact that the structure of object code can change greatly even with small modifications of the source code, in this method the comparison of original and corrected object code does not take place directly, but on the basis of previously complex structural analyzes by means of so-called "reduced program dependency graphs".
Ein ähnliches
Verfahren ist auch aus der Druckschrift JP 10091423 A bekannt. Bei
diesem Verfahren wird ein geänderter
Programmquelltext mit dem ursprüngliche
Programmquelltext verglichen. Die Unterschiede werden ermittelt
und zusammen mit dem ursprüngliche
Programmobjektcode einem Compiler zugeführt, der einen korrigierten
Objektcode und eine Korrekturanweisung erstellt. Auch hier ist eine
Analyse des ursprüngliche
Programmobjektcodes vonnöten,
um die Unterschiede einarbeiten zu können.A similar process is also from the document JP 10091423 A known. This procedure compares a modified program source text with the original program source text. The differences are determined and fed, along with the original program object code, to a compiler that creates a corrected object code and a correction instruction. Again, an analysis of the original program object code is needed to incorporate the differences.
Aufgabe
der Erfindung ist daher, ein Verfahren zu beschreiben, durch das
nach Änderung
des Quelltextes eines oder mehrerer Module eines modular aufgebauten
Programms eine Korrekturanweisung, gemäß der ein neuer Programmobjektcode durch
Veränderung
des ursprünglichen
Programmobjektcodes erzeugt wird, erstellt wird, ohne dass eine
Analyse der Struktur des Programmobjektcodes erforderlich ist.task
The invention is therefore to describe a method by which
after change
the source text of one or more modules of a modular structure
Program a correction instruction according to which a new program object code by
change
of the original one
Program object code is generated, created without a
Analysis of the structure of the program object code is required.
Diese
Aufgabe wird erfindungsgemäß durch ein
Verfahren zum Erstellen einer Korrekturanweisung nach dem kennzeichnenden
Teil des Anspruchs 1 gelöst.These
The object is achieved by a
Method for creating a correction instruction after the characterizing one
Part of claim 1 solved.
Das
erfindungsgemäße Verfahren
basiert auf der Grundidee, dass Änderungen
im Quelltext dem Compiler in Form von Änderungsanweisungen mitgeteilt
werden. Dadurch kann vom Compiler zu einem geänderten Modulquelltext ein
neuer Modulobjektcode erzeugt werden, der bei korrekt geänderter Funktionalität den höchsten Grad
an Kongruenz mit dem alten Modulobjektcode aufweist.The
inventive method
based on the basic idea that changes
in the source text communicated to the compiler in the form of change statements
become. This allows the compiler to change the module source text
new module object code will be generated, which will be the highest grade if the functionality changed correctly
has congruency with the old module object code.
Vorteilhafterweise
kann dann eine Korrekturanweisung für den Programmobjektcode durch
den byte-weisen Vergleich vom geänderten
mit dem ursprünglichen
Modulobjektcode generiert werden.advantageously,
then can a correction instruction for the program object code by
the byte-wise comparison of the changed one
with the original one
Module object code to be generated.
In
einer weiteren Ausführungsform
kann die Korrekturanweisung alternativ während des Übersetzens vom Compiler erstellt
werden.In
a further embodiment
Alternatively, the correction statement can be created by the compiler during translation
become.
In
einer günstigen
Ausgestaltung des Verfahrens besteht die Änderungsanweisung aus der Angabe
von wegfallenden Abschnitten, die aus dem ursprünglichen Modulquelltext entfernt
werden, um den geänderten
Modulquelltext zu erhalten und/oder aus der Angabe von hinzukommenden
Abschnitten und deren Positionen, die zu dem ursprünglichen
Modulquelltext hinzugefügt
werden, um den geänderten Modulquelltext
zu erhalten. Weiterhin ist bevorzugt, diese Änderungsanweisung und den ursprünglichen Modulquelltext
in einem neuen Modulquelltext anzugeben, wobei der neue Modulquelltext
aus dem ursprünglichen
Modulquelltext und hinzukommenden Abschnitten besteht und zusätzlich wegfallende
bzw. hinzukommende Abschnitte durch Schlüsselwörter gekennzeichnet sind.In
a cheap one
The modification of the procedure consists of the specification
of dropping sections that are removed from the original module source text
be changed
Module source text to receive and / or from the indication of added
Sections and their positions corresponding to the original
Module source text added
be the modified module source text
to obtain. It is further preferred that this change statement and the original module source text
in a new module source text, where the new module source text
from the original one
Module source text and additional sections exist and in addition dropping
or additional sections are marked by keywords.
Weitere
Einzelheiten und mögliche
Ausführungsformen
des Verfahrens sind in den Unteransprüchen angegeben.Further
Details and possible
embodiments
of the method are given in the subclaims.
Das
erfindungsgemäße Verfahren
wird im folgenden anhand von Ausführungsbeispielen mit Hilfe
der Figuren näher
erläutert.The inventive method will be in the following with reference to embodiments Help the figures explained in more detail.
Es
zeigen:It
demonstrate:
1 eine
schematische Repräsentation des
Verfahrens zum Erstellen und Ändern
von Programmobjektcode gemäß dem Stand
der Technik, 1 a schematic representation of the method for creating and changing program object code according to the prior art,
2 eine
schematische Repräsentation
eines Ausführungsbeispiels
des erfindungsgemäßen Verfahrens, 2 a schematic representation of an embodiment of the method according to the invention,
3 ein
weiteres Ausführungsbeispiel
des erfindungsgemäßen Verfahrens, 3 a further embodiment of the method according to the invention,
4 ein
Flussdiagramm eines Abschnitts des erfindungsgemäßen Verfahrens in einem Ausführungsbeispiel, 4 a flowchart of a portion of the method according to the invention in an embodiment,
5 einen
Auszug aus einem Quelltext und einem von einem Assembler gemäß dem Flussdiagramm
in 4 erstellten Modulobjektcodes und 5 an excerpt from a source code and an assembler according to the flowchart in 4 created module object codes and
6 einen
Auszug eines von einem Cross-Assembler erstellten Modulobjektcodes
zu dem in 5 angegebenen Quelltext. 6 an excerpt of a module object code created by a cross-assembler to the in 5 specified source code.
In 1 ist
die Erzeugung und Änderung
eines Programmobjektcodes eines komplexen, modular aufgebauten Programms
gemäß dem Stand
der Technik dargestellt. Ein ursprünglicher Modulquelltext 10 wird
von einem Compiler 40 in einen ursprünglichen Modulobjektcode 20 übersetzt.
Dieser ursprüngliche
Modulobjektcode 20 wird mit Objektcode weiterer Module 23 durch
einen Linker 41 zu dem ursprünglichen Programmobjektcode 30 zusammengefügt. Zusätzlich wird
vom Linker 41 eine Tabelle mit Einbindeinformationen 35 erstellt,
in der angegeben ist, an welcher Stelle im Programmobjektcode sich
der Objektcode bestimmter Module befindet.In 1 Fig. 3 shows the generation and modification of a program object code of a complex modular program according to the prior art. An original module source text 10 is from a compiler 40 into an original module object code 20 translated. This original module object code 20 comes with object code of other modules 23 through a linker 41 to the original program object code 30 together. In addition, the linker 41 a table with integration information 35 which specifies the location of the object code of certain modules in the program object code.
Änderungen
im Quelltext, die von dem ursprünglichen
Modulquelltext 10 zu einem geänderten Modulquelltext 11 führen, können typischerweise
nur in der Weise berücksichtigt
werden, dass der geänderte
Modulquelltext 11 auf analoge Weise vom Compiler 40 in
einen geänderten
Modulobjektcode 21 übersetzt
wird, welcher wiederum mit dem Objektcode weiterer Module 23 vom
Linker 41 zu einem geänderten
Programmobjektcode 31 zusammengefügt wird.Changes in the source code from the original module source text 10 to a modified module source text 11 typically can only be considered in such a way that the changed module source text 11 in an analogous way from the compiler 40 into a modified module object code 21 is translated, which in turn with the object code of other modules 23 from the linker 41 to a changed program object code 31 is joined together.
Alternativ
kann das Ändern
von Programmobjektcode auch durch das manuelle Erstellen 42 einer
Korrekturanweisung 33 erfolgen. Diese Korrekturanweisung 33 wird
einem Korrekturprogramm 43 mitgeteilt, das byte-weise Änderungen
am ursprünglichen
Programmobjektcode 30 vornimmt und so zu einem korrigierten
Programmobjektcode 32 kommt. Die Korrekturanweisung 33 besteht
aus einer Folge von Einträgen 34,
die den Namen des Moduls, einen neuen Wert und der Position innerhalb
des Modulobjektcodes, an dem dieser neue Wert gespeichert werden
soll, enthalten. Anhand der Einbindeinformation 35 kennt
das Korrekturprogramm 43 die Position des entsprechenden
Moduls innerhalb des Programmobjektcodes. Damit kann die Position
des zu ändernden wertes
im ursprünglichen
Programmobjektcode 30 berechnet und der Wert entsprechend
der Korrekturanweisung 34 geändert werden, um aus dem ursprünglichen
Programmobjektcode 30 einen korrigierten Programmobjektcode 32 zu
erzeugen. Dieser Weg ist natürlich
nur sinnvoll, wenn es möglich
ist, dass der korrigierte Programmobjektcode 32 dieselbe
Funktionalität
hat, wie ein geänderter
Programmobjektcode 31, der aus Übersetzen des geänderten Modulquelltextes 11 durch
den Compiler 40 und anschließendes Zusammenfügen des
geänderten
Modulobjektcode 21 mit dem Objektcode weiterer Module 23 durch
den Linker 41, entstanden wäre.Alternatively, changing program object code can also be done manually 42 a correction instruction 33 respectively. This correction instruction 33 will be a correction program 43 communicated the byte-by-byte changes to the original program object code 30 and so on to a corrected program object code 32 comes. The correction instruction 33 consists of a sequence of entries 34 containing the name of the module, a new value, and the location within the module object code where this new value should be stored. Based on the integration information 35 knows the correction program 43 the position of the corresponding module within the program object code. This allows the position of the value to be changed in the original program object code 30 calculated and the value according to the correction instruction 34 be changed to from the original program object code 30 a corrected program object code 32 to create. Of course, this way only makes sense if it is possible for the corrected program object code 32 has the same functionality as a modified program object code 31 that translates from the modified module source text 11 through the compiler 40 and then joining the modified module object code 21 with the object code of additional modules 23 through the linker 41 , would have originated.
Das
manuelle Erstellen der Korrekturanweisung 33, die auf der
Ebene von Objektcode arbeitet, bedingt, dass nur kleinste Änderungen
innerhalb des Programmobjektcodes durchgeführt werden können. Dazu
zählen
beispielsweise das Austauschen von fehlerhaften Konstanten oder
Wertezuweisung oder das Ändern
einzelner Sprungadressen. Komplexere Änderungen, die beispielsweise
in die Ablaufstruktur eines Programms eingreifen, sind auf der Abstraktionsebene
von Maschinencodebefehlen fast nicht durchführbar. Insbesondere gilt dies,
wenn der Quelltext mit Hilfe eines Cross-Assemblers oder Hochsprachencompilers übersetzt
wird.The manual creation of the correction instruction 33 operating on the level of object code requires that only minute changes can be made within the program object code. These include, for example, the replacement of incorrect constants or assignment of values or the changing of individual jump addresses. More complex changes, for example, that interfere with the flow structure of a program, are almost impracticable at the abstraction level of machine code instructions. In particular, this applies if the source text is translated using a cross-assembler or high-language compiler.
In 2 ist
an einem Ausführungsbeispiel schematisch
dargestellt, wie die Korrekturanweisung 33 mit ihren Einträgen 34 nach
dem erfindungsgemäßen Verfahren
erstellt wird. Neben dem ursprünglichen
Modulquelltext 10 wird dem Compiler 40 eine Änderungsanweisung 12 bereitgestellt.
Aus dem ursprünglichen
Quelltext 10 und der Änderungsanweisung 12 erzeugt
der Compiler 40 einen korrigierten Modulobjektcode 22.
Dieser korrigierte Modulobjektcode 22 wird zusammen mit
dem ursprünglichen
Modulobjektcode 20, der durch Übersetzen des ursprünglichen
Modulquelltextes 10 entstanden ist, einem Vergleicher 44 bereitgestellt.
Der ursprüngliche Modulobjektcode 20 wird
mit dem korrigierten Modulobjektcode 22 byte-weise verglichen.
Bei Abweichungen wird die Position des abweichenden Bytes relativ
zum Beginn des ursprünglichen
Modulobjektcodes 20 und der Wert des sich unterscheidenden Bytes
des korrigierten Modulobjektcodes 22 ermittelt. Die ermittelte
Position und der Wert sowie der Name des Moduls werden dann als
ein Eintrag 34 zu der Korrekturanweisung 33 hinzugefügt. Falls
mehrerer abweichende Bytes hintereinander folgen, kann alternativ
nur die Position des ersten Bytes und eine Folge von Werten sowie
der Name des Moduls als ein Eintrag 34 zu der Korrekturanweisung 33 hinzugefügt werden.In 2 is shown schematically in one embodiment, as the correction instruction 33 with their entries 34 is created by the method according to the invention. Next to the original module source text 10 will the compiler 40 a change order 12 provided. From the original source code 10 and the change order 12 the compiler generates 40 a corrected module object code 22 , This corrected module object code 22 gets along with the original module object code 20 by translating the original module source text 10 originated, a comparator 44 provided. The original module object code 20 will be with the corrected module object code 22 byte-wise compared. In case of deviations, the position of the deviating byte becomes relative to the beginning of the original module object code 20 and the value of the differing byte of the corrected module object code 22 determined. The determined position and the value as well as the name of the module are then considered as an entry 34 to the correction instruction 33 added. If several different bytes follow each other, alternatively only the position of the first byte and a sequence of values as well as the name of the module as An entry 34 to the correction instruction 33 to be added.
Es
ist möglich,
dass eine Folge von neuen Werten eine Adresse innerhalb des Objektcodes
eines weiteren Moduls 23 angeben. In dem Fall wird auch
der Name des anderen Moduls sowie die Adresse der Korrekturanweisung 33 als
Eintrag 34 hinzugefügt.It is possible for a sequence of new values to be an address within the object code of another module 23 specify. In this case, the name of the other module as well as the address of the correction instruction will be displayed 33 as an entry 34 added.
Gemäß den Informationen
aus den Einträgen 34 der
Korrekturanweisung 33 erstellt das Korrekturprogramm 43 dann
unter Zuhilfenahme der Einbindeinformation 35 aus dem ursprünglichen
Programmobjektcode 30 den korrigierten Programmobjektcode 32.According to the information from the entries 34 the correction instruction 33 creates the correction program 43 then with the help of the integration information 35 from the original program object code 30 the corrected program object code 32 ,
Im
erfindungsgemäßen Verfahren
wird dem Compiler 40 nicht ein geänderter Modulquelltext 11 bereitgestellt,
sondern der ursprüngliche
Modulquelltext 10 und die Änderungsanweisung 12.
Diese Änderungsanweisung 12 beschreibt
in einem vorgegebenen Format, auf welche Weise aus dem ursprünglichen
Modulquelltext 10 der geänderte Modulquelltext 11 entsteht.
Beispielsweise kann angegeben werden, welche Abschnitte beim Übergang
vom ursprünglichen
Modulquelltext 10 zum geänderten Modulquelltext 11 wegfallen
sollen, und welche Abschnitte hinzukommen sollen.In the method according to the invention, the compiler 40 not a modified module source text 11 provided, but the original module source text 10 and the change order 12 , This change instruction 12 Describes in a predetermined format, in which way from the original module source text 10 the modified module source text 11 arises. For example, it is possible to specify which sections transition from the original module source text 10 to the changed module source text 11 should be omitted, and which sections should be added.
Änderungen
an einem Quelltext werden in der Regel von dieser Form sein. In
den seltensten Fällen
werden die Änderungen
so grundlegender Natur sein, dass sich nicht viele Teilstücke oder
Abschnitte des ursprünglichen
Quelltextes 10 auch im geänderten Modulquelltext 11 wiederfinden.
Beim Vorgang des Assemblierens führen
gleiche Abschnitte im Modulquelltext auch notwendigerweise zu gleichen
Abschnitten im Modulobjektcode, beim Crossassemblieren oder beim
Compilen aus einer Hochsprache ist dies nicht mehr zwingend der
Fall, kann beim Einsatz eines geeigneten Compiler 40 aber
erreicht werden.Changes to a source code will usually be of this form. In the rarest of cases, the changes will be so fundamental that not many pieces or sections of the original source code will be 10 also in the changed module source text 11 find. In the process of assembling the same sections in the module source text also necessarily lead to the same sections in the module object code, when cross-assembling or compiling from a high-level language, this is no longer compulsory and can be achieved by using a suitable compiler 40 but be achieved.
Wird
der geänderte
Modulquelltext 11 jedoch vom einem Compiler 40 im üblichen
Verfahren übersetzt,
befinden sich eventuell gleiche Abschnitte des ursprünglichen
Modulobjektcodes 20 und des geänderten Modulobjektcodes 21 bedingt
durch eine unterschiedliche Länge
von hinzukommenden oder wegfallenden Abschnitten an unterschiedlichen
Positionen innerhalb der Dateien wieder. Trotz prinzipiell vorhandener
gleicher Abschnitte unterscheiden sich der ursprüngliche Modulobjektcode 20 und
der geänderte
Modulobjektcode 21 damit in einem byte-weisen Vergleich
grundlegend. wird dem Compiler 40 dagegen statt des geänderten
Modulquelltextes 11 der ursprüngliche Modulquelltext 10 und Änderungsanweisungen 12 mitgeteilt,
sind gleichbleibende Abschnitte im Modulquelltext gekennzeichnet,
und können
vom Compiler 40 in ihrer Entsprechung als Objektcode an
der selben Stelle im Modulobjektcode positioniert werden, an der
sie im ursprünglichen
Modulobjektcode 20 zu finden waren. Der so entstandene Modulobjektcode
weist die gleiche Funktionalität
wie der geänderte
Modulobjektcode 21 auf, unterscheidet sich in einem byte-weisen
Vergleich vom ursprünglichen
Modulobjektcode 20 aber so wenig wie möglich. Er wird zur Unterscheidung
daher korrigierter Modulobjektcode 22 genannt.Will the modified module source text 11 however, from a compiler 40 translated in the usual method, may be the same sections of the original module object code 20 and the modified module object code 21 due to a different length of added or dropped sections at different locations within the files. Despite having the same sections in principle, the original module object code is different 20 and the modified module object code 21 thus fundamentally in a byte-wise comparison. will the compiler 40 instead, instead of the changed module source text 11 the original module source text 10 and change instructions 12 are communicated, consistent sections in the module source text are marked, and can be used by the compiler 40 in their equivalent as object code are positioned in the same place in the module object code where they are in the original module object code 20 were to be found. The resulting module object code has the same functionality as the modified module object code 21 on, differs in a byte-wise comparison from the original module object code 20 but as little as possible. It will therefore be a corrected module object code for differentiation 22 called.
Dieser
korrigierte Modulobjektcode 22 wird in dem Vergleicher 44 byte-weise
mit dem ursprünglichen
Modulobjektcode 20 verglichen. Aus dem Vergleich werden
die Einträge 34 der
Korrekturanweisung 33 erstellt, die in bekannter Art vom
Korrekturprogramm 43 ausgewertet werden.This corrected module object code 22 is in the comparator 44 byte-wise with the original module object code 20 compared. From the comparison, the entries 34 the correction instruction 33 created in the known manner by the correction program 43 be evaluated.
Das
erfindungsgemäße Verfahren
kann dann garantiert ausgeführt
werden, wenn die Länge aller
Objektcodeabschnitte von wegfallenden Abschnitten des Quelltextes
die Länge
aller Objektcodeabschnitte von hinzukommenden Abschnitten des Quelltextes übersteigt.
Im anderen Fall ist nur das Erstellen eines geänderten Programmobjektcodes 31 gemäß dem Stand
der Technik durch Übersetzen
des geänderten
Modulquelltextes 11 und Zusammenfügen der Objektcodes aller Module
durch den Linker 41 möglich.
Ein Ausführungsbeispiel
des Verfahrens zum Erstellen des korrigierten Modulobjektcodes 22 wird
weiter unten in 4 anhand eines Flussdiagramms
im Detail erläutert.The method according to the invention can then be guaranteed to be carried out if the length of all object code sections of omitted sections of the source text exceeds the length of all object code sections of additional sections of the source text. In the other case, only the creation of a modified program object code 31 according to the prior art by translating the modified module source text 11 and merging the object codes of all modules by the linker 41 possible. An embodiment of the method for creating the corrected module object code 22 will be further down in 4 explained in detail using a flowchart.
In 3 ist
eine weitere mögliche
Ausgestaltung des erfindungsgemäßen Verfahrens
dargestellt. Der ursprüngliche
Modulquelltext 10 ist zusammen mit den Änderungsanweisungen 12 sowie
Schlüsselwörtern 14,
die wegfallende und hinzukommende Abschnitte kennzeichnen, als ein
modifizierter Modulquelltext 13 angegeben. Der Compiler 40 erstellt
aus diesem modifizierten Modulquelltext 13 sowohl den korrigierten
Modulobjektcode 22 als auch gleichzeitig die Korrekturanweisung 33,
die in bekannter Art weiterverarbeitet wird.In 3 another possible embodiment of the method according to the invention is shown. The original module source text 10 is together with the change instructions 12 as well as keywords 14 that identify drop-down and incremental sections as a modified module source text 13 specified. The compiler 40 created from this modified module source text 13 both the corrected module object code 22 as well as the correction instruction at the same time 33 , which is further processed in a known manner.
Das
Zusammenfügen
von Änderungsanweisung 12 samt
Schlüsselwörtern 14 mit
dem ursprünglichen
Modulquelltext 10 zu einem modifizierten Modulquelltext 13 stellt
für den
Anwender eine bequeme Art des Einfügens von Änderung in den ursprünglichen
Modulquelltext 10 dar. Die Schlüsselwörter 14 fungieren
als sogenannte Präcompilerdirektiven.
Der Aufbau des modifizierten Modulquelltextes 13 ist dabei
kompatibel mit einer üblichen
Betriebsweise von Compilern, bei der über Präprozessordirektiven Einfluss
auf den Ablauf des Übersetzungsvorgangs
genommen werden kann.The joining of change instruction 12 including keywords 14 with the original module source text 10 to a modified module source text 13 provides the user with a convenient way of inserting change into the original module source text 10 dar. The keywords 14 act as so-called precompiler directives. The structure of the modified module source text 13 is compatible with the usual operation of compilers, where preprocessor directives can influence the process of the translation process.
Der
Compiler 40 ist in diesem Ausführungsbeispiel so ausgelegt,
dass immer dann, wenn dem korrigierten Modulobjektcode 22 Objektabschnitte hinzufügt werden,
die im ursprünglichen
Modulobjektcode 20 nicht vorkommen, bzw. wenn im korrigierten
Modulobjektcode 22 Abschnitte nicht vorkommen, die im ursprünglichen
Modulobjektcode 20 enthalten waren, diese Änderungen
in Form von Einträgen 34 direkt
auch in die Korrekturanweisung 33 geschrieben werden. Falls
das erfindungsgemäße Verfahren
auf Grund des Umfangs der eingefügten
Abschnitte nicht erfolgreich durchgeführt werden kann, kann in diesem
Ausführungsbeispiel
der Compiler 40 so ausgelegt sein, dass nach Ausgabe eines
entsprechenden Hinweises an den Benutzer keine Korrekturanweisung 33 erstellt
wird und statt des korrigierten Modulobjektcodes 22 dann
automatisch der geänderte
Modulobjektcode 21 erstellt wird.The compiler 40 is designed in this embodiment, that whenever, if the corrected module object code 22 Object sections are added in the original module object code 20 not occur, or if in the corrected module object code 22 Sections that do not exist in the original module object code 20 included these changes in the form of entries 34 directly into the correction instruction 33 to be written. If the method according to the invention can not be carried out successfully due to the scope of the inserted sections, the compiler 40 be designed so that after issuing a corresponding note to the user no correction instruction 33 and instead of the corrected module object code 22 then automatically the modified module object code 21 is created.
4 zeigt
in Form eines Flussdiagramms ein Ausführungsbeispiel für den Teil
des Verfahrens, nach dem aus dem modifizierten Modulquelltext 13 der
korrigierte Modulobjektcode 22 erstellt werden kann. 4 shows in the form of a flowchart an embodiment of the part of the method, according to which from the modified module source text 13 the corrected module object code 22 can be created.
Zu
Beginn des Verfahrens wird ein Speicherbereich definiert, der Modulobjektcode
aufnehmen kann und ein Zeiger definiert, der auf die aktuelle Position
des Übersetzungsprozesses
im modifizierten Modulquelltext 13 zeigt. Der Speicherbereich
für den Modulobjektcode
sei zu Beginn leer und die Übersetzungsposition
wird auf den Anfang des Quelltextes gesetzt. Die Bezeichnung der
folgenden Schritte folgt dem Patentanspruch 4.At the beginning of the method, a memory area is defined that can accommodate module object code and defines a pointer to the current position of the translation process in the modified module source text 13 shows. The memory area for the module object code is initially empty and the translation position is set to the beginning of the source text. The name of the following steps follows the patent claim 4.
Im
Schritt a wird der modifizierte Modulquelltext 13 vom Compiler 40 übersetzt,
bis das Schlüsselwort 14 „REPOLD" oder das Ende des
modifizierte Modulquelltextes 13 erreicht sind. Der in
diesem Schritt a entstandene Objektcode wird im Schritt b dem Speicherbereich
für Modulobjektcode
zugefügt. Da
dieser zu Beginn des Verfahrens als leerer Speicherbereich definiert
wurde, entspricht dieser Schritt dem Speichern des Objektcodes.
In Schritt c wird der modifizierte Modulquelltextes 13 weiter übersetzt
bis zum Schlüsselwort 14 „REPNEW" bzw. bis zum Ende
des modifizierte Modulquelltextes 13. Die Länge des
in diesem Schritt entstandenen Objektcodes wird als erste Länge gespeichert,
der Objektcode selber verworfen. Falls die Übersetzungsposition bereits
in Schritt a das Ende des modifizierten Modulquelltextes 13 erreicht
hatte, wird die erste Länge
den Wert Null haben. Im nächsten
Schritt d wird der modifizierte Modulquelltext 13 vom Compiler weiter übersetzt,
bis das Schlüsselwort 14 „REPEND" auftaucht oder das
Ende des modifizierte Modulquelltextes 13 erreicht ist.
Die Länge
des in diesem Schritt entstandenen Objektcodes wird als zweite Länge gespeichert,
der Objektcode in diesem Fall nicht verworfen. Analog zur ersten
Länge wird
die zweite Länge
den Wert Null haben, falls die Übersetzungsposition
in einem der vorangehenden Schritte a oder c bereits das Ende des
modifizierte Modulquelltextes 13 erreicht hatte. In der
danach folgenden Abfrage wird ermittelt, ob die erste Länge kleiner
ist als die zweite Länge.
Falls nicht, bedeutet das, dass der Objektcode des hinzukommenden
Abschnitts länger ist
als der Objektcode des wegfallenden Abschnitts. Damit kann das erfindungsgemäße Verfahren
nicht erfolgreich durchgeführt
werden und wird abgebrochen. In einem nächsten Schritt wird untersucht,
ob die Länge
des Objektcodes kleiner ist als die erste Länge. Wenn das der Fall ist,
wird in Schritt e der Objektcode um eine Null-Operation (NOOP) ergänzt. Abfrage
und eventuelles Ergänzen
einer Null-Operation wird so oft durchgeführt, bis die Länge des
Objektcodes genau gleich der ersten Länge ist. Im dann folgenden
Schritt g wird der Objektcode einschließlich der angehängten Null-Operation
dem Speicherbereich für
Modulobjektcode hinzugefügt.
Für den Fall,
dass bereits in Schritt a oder c die Übersetzungsposition das Ende
des modifizierten Modulquelltextes 13 erreicht hatte, wird
der Objektcode in Schritt g leer sein und somit keine Änderung
am Speicherbereich für
Modulobjektcode hervorrufen. Im folgenden Schritt wird erneut überprüft, ob die Übersetzungsposition
am Ende des modifizierten Modulquelltextes 13 angelangt
ist. Wenn ja, wird das Verfahren erfolgreich beendet und der im
Verlauf des Verfahrens im Speicherbereich für Modulobjektcode angesammelte
Objektcode als korrigierter Modulobjektcode 22 gespeichert.
Falls die Übersetzungsposition
noch nicht am Ende des modifizierten Modulquelltextes 13 angelangt
ist, wird das Verfahren mit Ausnahme des allerersten Schrittes,
in dem der Speicherbereich für
Modulobjektcode definiert und geleert wurde, wiederholt. Ein in
einem zweiten oder eventuellen weiteren Durchläufen im Schritt a entstehendender
Objektcode wird damit an den bereits bestehenden Modulobjektcode
angehängt.In step a, the modified module source text becomes 13 from the compiler 40 translated until the keyword 14 "REPOLD" or the end of the modified module source text 13 are reached. The object code created in this step a is added to the memory area for module object code in step b. Since this was defined as an empty memory area at the beginning of the method, this step corresponds to storing the object code. In step c, the modified module source text becomes 13 further translated to the keyword 14 "REPNEW" or until the end of the modified module source text 13 , The length of the object code created in this step is stored as the first length, the object code itself discarded. If the translation position already in step a the end of the modified module source text 13 reached, the first length will have the value zero. In the next step d is the modified module source text 13 translated by the compiler until the keyword 14 "REPEND" appears or the end of the modified module source text 13 is reached. The length of the object code created in this step is stored as the second length, the object code is not discarded in this case. Analogous to the first length, the second length will have the value zero if the translation position in one of the preceding steps a or c already represents the end of the modified module source text 13 had reached. The next query determines whether the first length is smaller than the second length. If not, it means that the object code of the added section is longer than the object code of the drop-out section. Thus, the inventive method can not be successfully performed and is canceled. In a next step, it is examined whether the length of the object code is smaller than the first length. If this is the case, then in step e the object code is supplemented by a zero operation (NOOP). Query and eventual addition of a null operation is performed until the length of the object code is exactly equal to the first length. In the next step, g, the object code including the attached null operation is added to the module object code memory area. In the case that already in step a or c, the translation position is the end of the modified module source text 13 reached, the object code in step g will be empty and thus cause no change to the memory area for module object code. In the following step, it is checked again whether the translation position at the end of the modified module source text 13 has arrived. If so, the method successfully terminates and the object code accumulated in the Module Object Code memory area during the course of the procedure as the corrected module object code 22 saved. If the translation position is not yet at the end of the modified module source text 13 has arrived, the process is repeated except for the very first step in which the memory area for module object code has been defined and emptied. A resulting in a second or eventual further runs in step a object code is thus attached to the existing module object code.
Das
hier vorgestellte Verfahren wird abgebrochen, wenn der Objektcode
eines wegfallenden Abschnitts kürzer
ist als der Objektcode des direkt darauf folgenden hinzukommenden
Abschnitts. Auch in diesem Fall könnte es jedoch sein, dass der
Objektcode aller wegfallenden Abschnitte aufsummiert länger ist
als der Objektcode aller hinzukommenden Abschnitte. Das Verfahren
könnte
in der Weise ausgestaltet sein, dass die Abbruchbedingung diesen Fall
berücksichtigt.The
procedure presented here is aborted when the object code
a dropped section shorter
is considered the object code of the immediately following it
Section. Even in this case, it could be that the
Object code of all omitted sections added up is longer
as the object code of all added sections. The procedure
could
be designed in such a way that the termination condition this case
considered.
In 3 wurde
ein Verfahren vorgestellt, bei dem die Korrekturanweisung 33 gleich
während
des Übersetzens
vom Compiler 40 erstellt wird. Im gezeigten Flussdiagramm
kann diese Funktion im Schritt g implementiert werden. Die in Schritt
g hinzugefügten
Objektcodeabschnitte entsprechen gerade den Abschnitten des korrigierten
Modulobjektcodes 22, die sich von dem ursprünglichen
Modulobjektcode 20 unterscheiden und können daher an dieser Stelle
leicht in Form von Einträgen 34 in
die Korrekturanweisung 33 übernommen werden.In 3 a procedure was presented in which the correction instruction 33 the same while translating from the compiler 40 is created. In the flowchart shown, this function can be implemented in step g. The object code sections added in step g correspond just to the sections of the corrected module object code 22 that differ from the original module object code 20 can distinguish and therefore at this point easily in the form of entries 34 in the correk turan instructions 33 be taken over.
5 verdeutlicht
anhand eines Beispiels die Funktionsweise des erfindungsgemäßen Verfahrens
für einen
Assembler als Compiler. Im oberen linken Teil ist ein Abschnitt
des ursprünglichen
Modulquelltextes 10 angegeben, der hier aus drei Assemblerbefehlen
besteht. Im oberen rechten Abschnitt ist der modifizierte Modulquelltext 13 angegeben.
Nach einem ersten Assemblerbefehl, der sich gegenüber dem
ursprünglichen
Modulquelltext 10 nicht geändert hat, deutet das Schlüsselwort 14 „REPOLD" den Beginn eines
zu ersetzenden Abschnitts an. Im gezeigten Beispiel besteht der
zu ersetzende Abschnitt aus lediglich einem Befehl. Das darauffolgende
Schlüsselwort 14 „REPNEW" kennzeichnet den
Beginn eines neu hinzukommenden Abschnitts, der in diesem Fall ebenfalls
aus nur einem Befehl besteht und durch das Schlüsselwort 14 „REPEND" beendet wird. Der
sich anschließende
Teil des modifizierten Modulquelltextes 13 entspricht wieder
dem ursprünglichen Modulquelltext 10. 5 illustrates by way of example the operation of the inventive method for an assembler as a compiler. In the upper left part is a section of the original module source text 10 specified here consisting of three assembly instructions. In the upper right section is the modified module source text 13 specified. After a first assembler command, which is opposite to the original module source text 10 has not changed, the keyword suggests 14 "REPOLD" indicates the beginning of a section to be replaced In the example shown, the section to be replaced consists of just one command 14 "REPNEW" marks the beginning of a newly added section, which in this case also consists of only one command and the keyword 14 The subsequent part of the modified module source text 13 corresponds again to the original module source text 10 ,
Im
unteren Teil von 5 sind auf der linken Seite
der ursprüngliche
Modulobjektcode 20, der durch Übersetzen des ursprünglichen
Modulquelltextes 10 entstanden ist, und auf der rechten
Seite der korrigierte Modulobjektcode 22, der nach dem
erfindungsgemäßen Verfahren
aus dem modifizierten Modulquelltext 13 entstanden ist.
Zur Verdeutlichung sind ganz links die Hexadezimaladressen der entsprechenden
Maschinencodebefehle als Position des Objektcodes innerhalb der
entsprechenden Dateien angegeben. Ebenfalls zur Verdeutlichung sind die
dem Objektcode entsprechenden Assemblerbefehle mit angegeben, die
in dieser Form natürlich
im Modulobjektcode nicht enthalten sind. Im korrigierten Modulobjektcode 22 ist
zu sehen, dass die Maschinencoderepräsentation des hinzugekommenen
Befehls eine Länge
von 4 Byte aufweist, wobei ein Byte in der benutzten Kodierung jeweils
zwei Hexadezimalzeichen aufnimmt. Der wegfallende Maschinencodebefehl
hat hingegen im ursprünglichen
Modulobjektcode 20 eine Länge von 6 Bytes hat. Entsprechend
des Verfahrens nach 4 wurde der Längenunterschied
durch das Einfügen
von Null-Operationen ausgeglichen. In diesem Beispiel wurde genau eine
Null-Operation eingefügt, da eine
Null-Operation in der hier dargestellten Maschinencoderepräsentation
eine Länge
von 2 Byte hat.In the lower part of 5 are on the left the original module object code 20 by translating the original module source text 10 is created, and on the right side of the corrected module object code 22 obtained by the method according to the invention from the modified module source text 13 originated. For clarity, the hexadecimal addresses of the corresponding machine code instructions are indicated on the far left as the position of the object code within the corresponding files. Also for clarity, the assembly code corresponding to the object code are indicated, which are of course not included in the module object code in this form. In the corrected module object code 22 It can be seen that the machine code representation of the added instruction has a length of 4 bytes, with one byte in each encoding used holding two hexadecimal digits each. The omitted machine code instruction, however, has the original module object code 20 has a length of 6 bytes. According to the method 4 the difference in length was compensated by the insertion of zero operations. In this example, exactly one null operation was inserted because a null operation in the machine code representation shown here is 2 bytes in length.
Alle
nachfolgenden Maschinencodebefehle befinden sich im korrigierten
Modulobjektcode 22 an der gleichen Position innerhalb der
Datei wie im ursprünglichen
Modulobjektcode 20. Dadurch können zum einen durch einen
byte-weisen Vergleich beider Modulobjektcodes Unterschiede schnell
ausfindig gemacht werden, zum anderen ist sichergestellt, dass alle
Einsprungadressen, die sich im weiteren Verlauf des Modulobjektcodes
befinden, nach wie vor korrekt adressiert werden.All subsequent machine code instructions are in the corrected module object code 22 at the same position within the file as in the original module object code 20 , As a result, differences can be found quickly on the one hand by a byte-wise comparison of both module object codes, on the other hand it is ensured that all entry addresses that are located in the further course of the module object code are still addressed correctly.
In 6 ist
analog zur 5 die Erstellung des korrigierten
Modulobjektcodes 22 anhand des erfindungsgemäßen Verfahrens
durch einen Cross-Assembler dargestellt. Dem Beispiel liegt ebenfalls
der Quelltext von 5 zugrunde. Aus dem ursprünglichen
Modulobjektcode 20 auf der linken Seite ist ersichtlich,
dass die Übertragung
des einen wegfallenden Assemblerbefehls des ursprünglichen
Modulquelltextes 10 zu insgesamt acht Maschinencodebefehlen,
die jeweils 4 Byte lang sind, führt.
Ein solcher Fall entsteht typischerweise, wenn Assemblerbefehle für einen
Prozessor mit CISC-Architektur (Complex Instruction Set Computer)
in den Maschinencode eines Prozessors mit RISC-Architektur (Reduced Instruction Set
Computer) durch einen Cross-Assembler übersetzt wird. Im korrigierten
Modulobjektcode 22 ist ersichtlich, dass der im modifizierten
Modulquelltext 13 hinzugekommene Befehl durch einen einzigen,
4 Byte langen Maschinencodebefehl repräsentiert wird.In 6 is analogous to 5 the creation of the corrected module object code 22 illustrated by the method according to the invention by a cross-assembler. The example is also the source of 5 based. From the original module object code 20 on the left side it can be seen that the transmission of the one dropping assembler instruction of the original module source text 10 to a total of eight machine code instructions, each of which is 4 bytes long. Such a case typically arises when assembler instructions for a Complex Instruction Set Computer (CISC) architecture are translated into the machine code of a Reduced Instruction Set Computer (RISC) architecture by a cross-assembler. In the corrected module object code 22 can be seen that in the modified module source text 13 Added command is represented by a single, 4-byte machine code command.
Entsprechend
wurden vom Compiler 40 nach dem erfindungsgemäßen Verfahren
sieben Null-Operationen eingefügt,
die je ebenfalls eine Länge
von 4 Byte aufweisen.According to the compiler 40 inserted according to the inventive method seven zero operations, each also having a length of 4 bytes.
Beim Übersetzen
von Quelltext durch einen Assembler gibt es eine umkehrbar eindeutige
Beziehung zwischen dem Quelltext und dem Objektcode. Im Fall eines
Cross-Assemblers oder beim Compilieren von Quelltext einer Hochsprache
gibt es diese Eindeutigkeit nicht mehr. Der Compiler hat beim Übersetzungsvorgang
gewisse Freiheitsgrade, die zur Optimierung des erzeugten Objektcodes
genutzt werden. Es kann beispielsweise sein, dass beim Cross-Assemblieren
Maschinencodebefehle für
einen Prozessor erzeugt werden, der eine größere Anzahl von Registern besitzt
als von den Assemblerbefehlen adressiert werden können. Die
nicht adressierbaren Register können
dann vom Compiler zur Speicherung von Zwischenergebnissen eingesetzt werden.
Solche Optimierungsschritte müssen
beim Abarbeiten des modifizierten Modulquelltextes 13 vom
Compiler 40 berücksichtigt
werden. Es kann beispielsweise notwendig sein, dass am Ende von
hinzukommenden Modulcodeabschnitten die in diesen Abschnitten gemachten Änderungen
an Registern, die zuvor zur Zwischenspeicherung von Ergebnissen zur
Optimierung eingesetzt wurden, wieder rückgängig gemacht werden. Ähnliches
kann auftreten, wenn durch den Cross-Assembler Maschinencodebefehle für einen
Prozessor erzeugt werden, der über
einen breiteren Adress- oder Datenbus verfügt, der durch die Assemblersprache
des Modulquelltextes repräsentiert
wird. In diesem Fall muss ein korrektes Be- oder Entladen von Adressierungs-
oder Datenregistern am Beginn und am Ende von hinzukommenden Modulcodeabschnitten
berücksichtigt
werden.When translating source code through an assembler, there is a reversibly unique relationship between the source code and the object code. In the case of a cross-assembler or when compiling source code of a high-level language, this uniqueness no longer exists. The compiler has certain degrees of freedom in the translation process, which are used to optimize the generated object code. For example, cross-assembly may produce machine code instructions for a processor having a larger number of registers than can be addressed by the assembly instructions. The non-addressable registers can then be used by the compiler to store intermediate results. Such optimization steps must be carried out when processing the modified module source text 13 from the compiler 40 be taken into account. It may be necessary, for example, that at the end of incremental module code sections, the changes made in these sections to registers that were previously used for caching results for optimization are reversed. The like can occur when the cross-assembler generates machine code instructions for a processor having a wider address or data bus represented by the assembly language of the module source text. In this case, proper loading or unloading of addressing or data registers must be considered at the beginning and end of additional module code sections.
-
1010
-
ursprünglicher
Modulquelltextoriginal
module source code
-
1111
-
geänderter
Modulquelltextchanged
module source code
-
1212
-
Änderungsanweisungmodification statement
-
1313
-
modifizierter
Modulquelltextmodified
module source code
-
1414
-
Schlüsselwörterkeywords
-
2020
-
ursprünglicher
Modulobjektcodeoriginal
Module object code
-
2121
-
geänderter
Modulobjektcodechanged
Module object code
-
2222
-
korrigierter
Modulobjektcodecorrected
Module object code
-
2323
-
Objektcode
weiterer Moduleobject code
additional modules
-
3030
-
ursprünglicher
Programmobjektcodeoriginal
Program object code
-
3131
-
geänderter
Programmobjektcodechanged
Program object code
-
3232
-
korrigierter
Programmobjektcodecorrected
Program object code
-
3333
-
Korrekturanweisungcorrection instruction
-
3434
-
Eintrag
der Korrekturanweisungentry
the correction instruction
-
3535
-
EinbindeinformationEinbindeinformation
-
4040
-
Compilercompiler
-
4141
-
Linkerleft
-
4242
-
manuelles
Erstellen der Korrekturanweisungmanual
Create the correction instruction
-
4343
-
Korrekturprogrammcorrection program
-
4444
-
Vergleichercomparator