OST » Wikis » Infoportal Sie befinden sich hier: start » software » deep » dev » crosscompiler » linker32

Infoportal

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
Letzte ÜberarbeitungBeide Seiten der Revision
software:deep:dev:crosscompiler:linker32 [2014-02-10 09:48] – grafsoftware:deep:dev:crosscompiler:linker32 [2014-02-10 13:21] – graf
Zeile 54: Zeile 54:
  
  
-===== Grösse und Offsets berechnen ===== +===== Calculate Size and Offsets ===== 
-[{{  .:linker_code_methods.png?300px&direct|Maschinencode: Grösse und Offsets}}] +[{{  .:linker_code_methods.png?350px&direct|Machine Code: Size and Offsets}}] 
-Bevor die Memory Map fixiert werden kann, müssen noch ein paar Grössen und Offsets pro Standard-Klasse berechnet werden: +Before the memory map can be fixed, a couple sizes and offsets must be calculated for each class: 
-  * ''void calculateCodeSizeAndOffsets(Class)'': Diese Methode berechnet die Grösse des Maschinencodes für die gesamte Klasse und setzt das Feld ''offset'' jeder Methode dieser Klasse. Dieses beschreibt den Byte-Offset des Maschinencodes einer Methode im Speicher ausgehend von der Startaddresse des Codes der Klasse. Wenn der Offset einer Methode direkt von der Konfiguration vorgegeben ist (für Exception-Handler-Code) wird diese Methode nicht in die Berechnung der Codegrösse miteinbezogen. Der durch die Konfiguration vorgegebene Offset bezieht sich nicht auf die Basis einer Klasse, sondern auf die Basis des zugehörigen Segmentes. +  * ''void calculateCodeSizeAndOffsets(Class)'': This methods determines the size of the machine code of the whole class and sets the field //offset// of each method of this class. //offset// is the byte offset of the machine code of a method in the memory starting from the start address of the code of this class. If a method offset is given by the configuration (e.g. exception handlers), then this method is not included in the culculation of the code size. The offset given by the configuration is not relative to the base of a class but to the base of the appropriate segment. 
-  * ''void calculateGlobalConstantTableSize()'': Berechnet die Grösse der globalen Konstanten-Tabelle.+  * ''void calculateGlobalConstantTableSize()'': This method calculates the size of the global constant table.
  
-===== Systemtabelle erstellen ===== +===== Create System Table ===== 
-Der Linker stellt für das gesamte System eine Systemtabelle zusammen. Diese muss an eine fixe Adresse geladen werden und enthält wichtige Informationen für das Laufzeitsystem. Grundsätzlich muss dabei zwischen drei Fällen unterschieden werden: +The linker assembles a system table for the whole system. This table must be loaded to a prefixed address in the target system and holds information for the [[..:rts:start|Runtime System]]. Various settings must be handled: 
-  - Das gesamte System befindet sich im Flash. +  - The system runs from the flash 
-  - Das gesamte System befindet sich im Ram. +  - The system runs from the RAM. 
-  - Das Basissystem befinden sich im Flash. Weitere Klassen werden nachträglich ins Ram geladen. Für diesen Fall werden zwei Systemtabellen benötigt. Im Flash befindet sich eine Systemtabelle, welche nur die Klassen im Flash abdeckt. Im RAM hingegen befindet sich eine Systemtabelle, die sowohl die Klassen im RAM als auch die im Flash abdeckt. -> IMPORTANT Dies ist zur Zeit noch nicht implementiert IMPORTANT +  - The base system is in the flash. Further classes are later loaded into the RAM. This case needs two system tables. The flash holds a system table which contains only classes which are present in the flash. The system table in the RAM must hold all classes. IMPORTANT This feature is not implemented yet IMPORTANT
-\\ +
-Die Methode ''void createSystemtable()'' erstellt die Systemtabelle. Diese ist als doppelt verkettete Liste realisiert und verwendet die selben von ''BlockEntry'' abgeleiteten Listenelemente wie die Konstantenblöcke der Klassen, zusätzlich noch die Klasse ''SysTabEntry''. Diese referenziert den Konstantenblock einer Klasse.+
  
-Die Systemtabelle hat den folgenden Aufbau: +In the compiler the system table is modeled as list. as elements it uses the same blocks as for the constant block. Additionally ''SysTabEntry'' is used to reference the constant block of a class.
-[{{ .:systemtable.png?450&direct |//Aufbau der Systemtabelle// }}]+
  
-Bevor die Systemtabelle zusammengestellt werden kann, muss der Klassenkonstruktor der Kernel-Klasse gefunden werden. Dazu wird der Klassennamen aus der Konfiguration geladen und anschliessend die Methode ''<clinit>'' gesucht.+The structure of the system table is: 
 +[{{ .:systemtable.png?450&direct |//Structure of the system table// }}]
  
-Nun kann die Systemtabelle aufgebaut werden. Dazu wird als erstes der Offset zum Beginn der Klassenliste (Liste mit der Basisadresse des Konstantenblocks jeder Klasse) eingefügt. Anschliessend werden die Informationen zu Heap und Stack eingefügt. Anschliessend die Anzahl vorhandener Klassen und die bereits erwähnte Liste mit den Basisadressen der Konstantenblöcke. Die Systemtabelle wird mit dem Wert 0x0 abgeschlossen.+First, the class constructor of the class kernel must be found. For this, the class name of the kernel is fetched from the configuration and the method //<clinit>// is searched. Then, the table can be built. The offset to the addresses with the constant blocks is placed at the beginning. Heap and stack information is added. For each class the address of the constant block must be entered. The table ends with the value 0.
  
-Der letzte Teil mit den Referenzen auf den Konstantenblock der einzelnen Klassen ist wie folgt zusammengestellt. Zuerst kommen alle Klassen mit einem Klassenkonstruktor. Diese Klassen sind bereits in der korrekten Reihenfolge gemäss [[class_initialization]] sortiert. Anschliessend kommen alle nicht-initialisierten Klassen. Arrays und Interfaces haben keinen Konstantenblock und kommen nicht in die Liste mit Ausnahme von Interfaces, die einen Klassenkonstruktor haben, siehe //Interfacemethoden// in [[type_descriptor]]. +The references to the constant blocks are assembled as follows. First come the classes with class constructors. These classes are already sorted in correct order as described in [[class_initialization]]. Classes without initialization follow afterwards. Arrays and interfaces have no constant block and are not listed. The exception to this rule are interfaces with class constructor, see [[.:interfaces|Interfaces]].
-\\ +
-Beim MPC555 wird die Systemtabelle in der Dual-Mapped-Section direkt nach dem Exceptioncode positioniert (Addresse 0x2000 -> siehe Memory Map).+
  
-===== Memory Map fixieren ===== +===== Fix Memory Map ===== 
-[{{  .:linker_code.png?300px&direct|Maschinencode: Grösse und Offsets}}] +[{{  .:linker_code.png?350px&direct|Fixing the memory map}}] 
-Das Platzieren des Codes, der statischen Variablen und der Konstanten im Speicher geschieht wie folgt. Als erstes wird jeder Klasse ein Memory-Segment für den Code (''Class.codeSegment''), die statischen Variablen (''Class.varSegment'') und die Konstanten (''Class.constSegment'') zugeteilt. Welche Segmente das sind, wird der Konfiguration entnommen. Dabei läuft der Linker rekursiv durch die möglichen Segmente und wählt das erste passende aus. Während dieser Zuteilung wird der im Segment benutzte Platz gespeichert (''Segment.usedSize'') und der entsprechende Offset (''Class.codeOffset'', ''Class.varOffset'' und ''Class.constOffset'') zugeteilt. Auch für jedes Array und für jedes benötigte Interface wird ein Segment (''Class.constSegment'') für den Typedescriptor gesucht und der Offset (Array.offset, Class.offset) gesetzt. +In this step the code is placed in the memory, as well as the class variables and the constants. First, each class is assigned a memory segment for the code (''Class.codeSegment''), class variables (''Class.varSegment'') and constants (''Class.constSegment''). Which segments to use can be read from the configuration. The linker traverses the possible segments and choses a suitable one. While doing this, the used space of each segment is stored (''Segment.usedSize'') and the appropriate offsets are set (''Class.codeOffset'', ''Class.varOffset'' and ''Class.constOffset''). Arrays and interfaces must be handled as well. Further, the size of the segment for the system table has to be set and also the size of the segment for the global constant table.  
-Anschliessend wird die verwendete Grösse auch noch für das Systemtabellen-Segment gesetzt und das Speichersegment für die globale Konstantentabelle festgelegt. +Now, the base address of each used segment can be determined. \\ 
-In einem weiteren Schritt wird die Grösse für jedes verwendete Segment festgelegt (sofern nicht bereits in der Konfiguration vorgegeben). Nun kann für jedes verwendete Segment die Basisadresse berechnet werden. +IMPORTANT System methods with offsets given by the configuration must be placed in their appropriate segments. This leads to holes. Such holes could be eliminated by a more efficient allocation, which is currently not done.
-\\ Achtung: Ganz zu Beginn müssen Systemmethoden, die einen in von Konfiguration gegebenen Offset haben (Exception-Handlers), bereits im passenden Segment platziert werden. Das führt zu "Löchern" in diesem Segment. Diese Löcher können durch eine effizientere Allokation eliminiert werden, was aber zur Zeit nicht gemacht ist.+
  
-===== Absolute Adressen berechnen ===== +===== Calculate Absolute Addresses ===== 
-Nachdem der Code, die statischen Variablen und der Konstantenblock jeder Klasse und auch die Systemtabelle und die globale Konstantentabelle platziert sind, werden nun die absoluten Adressen berechnet. Dazu steht die Methode ''void calculateAbsoluteAddresses(Class)'' bereit. +First, the addresses of static fields are fixed. For this the linker traverses the list ''Class.classFields'' and sets ''Item.address''. This address has only to be set for non-constant fields. Next, the addresses of methods are set. Here again, methods which are placed at absolute position by the configuration must be handled separately. Third, addresses of the constants in the constant pool and strings in the string pool can be fixed. To conclude, the address of the class itself (''Class.address'') will be set to the field //size// in the type descriptor.
-In einem ersten Schritt werden die Adressen für die statischen Felder bestimmt. Dazu läuft der Linker durch die entsprechende Liste (''Class.classFields'') durch und berechnet die absolute Adresse (''Item.address''). Die Adresse wird nur bei nicht konstanten Feldern gesetzt. +
-Im nächsten Schritt werden die Adressen der Methoden berechnet. Dabei müssen die durch die Konfiguration absolut positionierten Methoden (Exception-Handlers)wiederum speziell behandelt werden. +
-Als drittes werden die Adressen für die Konstanten im //Constant pool// und die Strings im //String pool// berechnet.+
  
-Als letztes wird noch die Adresse der Klasse selbst (''Class.address'') auf den Eintrag //size// im Typ-Deskriptor gesetzt.+===== Refresh Constant Block ===== 
 +After calculating absolute addresses the constant block has to be refreshed.  ''void updateConstantBlock(Class)'' fixes the base address of the code (//codeBase//). After this the base address of the class variables (''varBase'') and their size (''varSize'') is written. As a last step the size of an object of this class (field //size//) in the type descriptor is written.
  
-Diese Methode muss vom //Launcher// für jede Klasse aufgerufen werden.+===== Create Global Constant Table ===== 
 +This table holds constants which do not belong to a specific class. To give an example: Certain constants are needed to convert an //int// to a //float//.
  
-===== Konstantenblock aktualisieren ===== +===== Create Target Image ===== 
-Nach dem Festlegen der Adressen kann nun der Konstantenblock aktualisiert werden. Dazu legt die Methode ''void updateConstantBlock(Class)'' als erstes die Basisadresse des Codes (//codeBase//) fest. Anschliessend werden auch noch die Basisadresse für die Klassen-Variablen (''varBase'') und die Gesamtgrösse der Klassen-Variablen (''varSize'') festgelegt. Als letztes wird noch die Grösse eines Objektes der Klasse (//size//) im Type descriptor aktualisiert.+Finally, the target image is put together. For each method of each class and for each constant block (one for each class, array or interface) a target segment is created and inserted into a list.
  
-===== Globale Konstantentabelle erstellen ===== 
-In der globalen Konstantentabelle werden Konstanten gespeichert, die nicht zu einer Klasse gehören, sondern z.B. zur Laufzeit für die Konvertierung von //int// zu //float// verwendet werden. 
  
-===== Target Image erstellen ===== 
-Zum Schluss wird das Target Image erstellt. Dabei wird für jede Methode jeder Klasse und für Konstantenblock (einer pro Klasse, Array oder Interface) je ein TargetSegment erzeugt und in einer Liste abgelegt.  
- 
----- 
- 
-===== Verwendung von index, offset und address der Klasse Item ===== 
-Die Felder //index//, //offset// und //address// der Klasse ''ch.ntb.inf.deep.classItems.Item'' werden, je nach dem was Item repräsentiert, anders verwendet. Die untenstehende Liste gibt einen Überblick, wann welches Feld wie verwendet wird. 
- 
-**Bemerkung:** Angaben in Eckigen Klammern bezeichnen den Typ. Beispiel: [Class] bedeutet das dieses Objekt vom Typ ''ch.ntb.inf.deep.classItems.Class'' ist. 
- 
-==== Klassen [Class] ==== 
-  * //index//: Wird verwendet, um Interfaces für Interfacemethoden zu nummerieren. 
-  * //offset//: Wird nicht verwendet, ist immer -1. 
-  * //address//: Die absolute Adresse des Typdescriptors (des Eintrags //size//). 
- 
-==== Arrays [Array] ==== 
-  * //index//: Wird nicht verwendet, ist immer -1. 
-  * //offset//: Offset des Typdescriptors im Segment. 
-  * //address//: Die absolute Adresse des Typdescriptors. 
- 
-==== Methoden [Method] ==== 
-  * //index//: Bei Instanzmethoden der Index der Methode in der Methodentabelle (beginnend bei 0). Bei Klassenmethoden ist //index// immer -1. -> Wird vom CFR gesetzt. 
-  * //offset//: Byteoffset der Methode ausgehend von der Startadresse des Codes der Klasse. 
-  * //address//: Absolute Adresse der Methode. 
- 
-==== Felder [DataItem] ==== 
-<box right 30% | IMPORTANT Konstante Referenzen> 
-**Achtung:** bei konstanten, statischen Referenzen ist das Const-Flag (dpfConst) __nicht__ gesetzt, da diese wie normale, nicht konstante statische Felder zu behandeln sind. Dies weil auf solche Felder ein einmaliger Zugriff aus dem Klassenkonstruktor stattfindet! 
- 
-**Beispiel:** 
-  static final Object o = new Object(); 
-</box> 
-  - **Klassen-Felder [DataItem]:** 
-    - Konstante Felder [NamedConst]: 
-      * //index//: Wird nicht verwendet, ist immer -1; 
-      * //offset//: Wird nicht verwendet, ist immer -1; 
-      * //address//: Wird nicht verwendet, ist immer -1; 
-    - Nicht konstante Felder [DataItem]: 
-      * //index//: Wird nicht verwendet, ist immer -1. 
-      * //offset//: Byteoffset des Feldes (beginnend bei 0 für das erste Feld). 
-      * //address//: Absolute Adresse des Feldes. 
-  - **Instanz-Felder [DataItem]:** 
-    * //index//: Wird nicht verwendet, ist immer -1; 
-    * //offset//: Byteoffset des Feldes beginnend bei 0 (inkl. Berücksichtung der Felder der Oberklassen). 
-    * //address//: Wird nicht verwendet, ist immer -1; 
- 
-==== Konstanten [Constant] ==== 
-  - **Zahlen [StdConstant]:** 
-    * //index//: Wenn die Konstante vom Typ //float// oder //double// ist, ist //index// der Index der Konstante im Konstantenpool. Ansonsten immer -1; 
-    * //offset//: Wenn die Konstante vom Typ //float// oder //double// ist, ist //offset// der Byteoffset der Konstante im Konstantenpool. Ansonsten immer -1; 
-    * //address//: Wenn es sich um eine Konstante vom Typ //float// oder //double// handelt, ist //address// die absolute Adresse der Konstante (direkt im Konstantenblock). Ansonsten immer -1. 
-  - **Stings [StringLiteral]:** 
-    * //index//: Wenn es sich bei der Konstante um einen String handelt, so wird in //index// der Index des Strings im Stringpool abgelegt. 
-    * //offset//: Wenn es sich bei der Konstante um einen String handelt, so wird in //offset// der Byteoffset des Strings im Stringpool abgelegt. 
-    * //address//: Absolute Adresse des konstanten Strings (direkt im Konstantenblock). 

Seiten-Werkzeuge

OST - Ostschweizer Fachhochschule - Campus Buchs
Uebersicht