alpha/calling.doc

   1 /***************************** calling.doc *************************************
   2
   3         Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst
   4
   5         See file COPYRIGHT for information on usage and disclaimer of warranties
   6
   7         Das ist eine kurze Dokumentation "uber die internen Aufrufskonventionen
   8         der Java-Methoden in der DEC-ALHPA-Version.
   9
  10         Author:  Reinhard Grafl      EMAIL: cacao@complang.tuwien.ac.at
  11
  12         Last Change: 1997/02/05
  13
  14 *******************************************************************************/
  15 FILE: calling.doc
  16
  17 Das ist eine kurze Dokumentation "uber die internen Aufrufskonventionen
  18 der Java-Methoden in der DEC-ALHPA-Version.
  19
  20 -------------------------------------------------------------------------------
  21
  22
  23 Die Aufrufskonventionen halten sich weitgehende an die Konventionen
  24 f"ur normale C-Funktionen, allerdings mit einigen zus"atzlichen
  25 Registerbelegungen:
  26
  27 R28 ..... enth"alt bei einem Methodenaufruf auf jeden Fall den Zeiger
  28           auf die zugeh"orige 'methodinfo'-Struktur, die gegebenenfalls an
  29           den JIT-Compiler weitergegeben werden muss.
  30
  31           Wenn von Java-Methoden aus direkt C-Funktionen aufgerufen werden,
  32           (f"ur die nat"urlich auch keine 'methodinfo'-Struktur existiert),
  33           dann hat dieses Register keinen definierten Wert (Alle von der
  34           JavaVM verwendeten Funktionen, z. B. 'builtin_new', etc. werden
  35           so aufgerufen)
  36
  37 R1 ...... enth"alt nach Methodenbeendigung entweder NULL oder einen Zeiger
  38           auf ein Objekt vom Typ java.lang.Throwable (oder einem davon
  39           abgeleiteten Typ).
  40           Wenn das der Fall ist, dann wurde in der Methode eine Exception
  41           geworfen, die nicht abgefangen werden konnte, und jetzt beim
  42           Aufrufer weiter bearbeitet werden muss.
  43
  44
  45
  46 Die restlichen Register folgen den normalen Konventionen, aber ich gebe
  47 hier noch einmal eine kurze "Ubersicht:
  48
  49
  50 INTEGER-REGISTER:
  51
  52 R0 ........ R"uckgabewert von den Methoden f"ur die Typen:
  53                     INT,LONG,ADDRESS
  54
  55 R1 ........ Adresse der geworfenen Exception (oder NULL)
  56
  57 R2-R8 ..... tempor"are Register (werden im Unterprogram zerst"ort)
  58
  59 R9-R15 .... gesicherte Register (werden im Unterprogramm nicht ver"andert)
  60
  61 R16-R21 ... Argumentregister 1 - 6 (hier werden die ersten sechs Methoden-
  62             Argumente eingetragen, sofern sie von den Typen INT,LONG,ADDRESS
  63             sind. Diese Argumentregister werden im Unterprogramm zerst"ort
  64
  65 R22-R24 ... tempor"are Register
  66             (werden im Unterprogramm zerst"ort)
  67
  68 R25 ....... tempor"ares Register f"ur kurzfristige Zwischenergebnisse
  69             (wird im Unterprogramm zerst"ort)
  70
  71 R26 (ra) .. R"ucksprungadresse (bleibt im Unterprogramm erhalten)
  72
  73 R27 (pv) .. Prozedurzeiger. Dieses Register muss auf jeden Fall einen Zeiger
  74             auf die aufgerufene Prozedur enthalten (damit die Zugriffe
  75             auf das Datensegment funktionieren k"onnen).
  76             (der Wert bleibt im Unterprogramm erhalten)
  77
  78 R28 ....... Zeiger auf die 'methodinfo' - Struktur. Muss auf jeden Fall bei
  79             allen Methodenaufrufen richtig gesetzt sein (wegen eines eventuellen
  80             Compiler-Aufrufs)
  81             (wird im Unterprogramm zerst"ort)
  82
  83 R29 ....... tempor"ares Register f"ur kurzfristige Zwischenergebnisse
  84             (wird im Unterprogramm zerst"ort)
  85
  86 R30 (sp) .. Zeiger auf die Untergrenze des Stack (der Stack w"achst von
  87             oben nach unten)
  88
  89 R31 ....... enth"alt immer NULL
  90
  91
  92
  93 FLIESSKOMMA-REGISTER:
  94
  95
  96 F0 ........ enth"alt die R"uckgabewert der Methoden vom Typ:
  97                 FLOAT, DOUBLE
  98 F1 ........ enth"alt den Imagin"aranteil von einem komplexen Funktionswert
  99                 (wird von mir nicht benutzt)
 100
 101 F2-F9 ..... gesicherte Register (werden im Unterprogramm nicht ver"andert)
 102
 103 F10-F15 ... tempor"are Register (werden im Unterprogramm zerst"ort)
 104
 105 F16-F21 ... Argumentregister f"ur die ersten 6 Parameter, sofern diese
 106             vom den Typen FLOAT oder DOUBLE sind
 107
 108 F22-F24 ... tempor"are Register (werden im Unterprogramm zerst"ort)
 109
 110 F25-F31 ... tempor"are Register f"ur kurzfristige Zwischenergebnisse
 111             (werden im Unterprogramm zerst"ort)
 112
 113 F31 ....... enth"alt immer 0.0
 114
 115
 116
 117 PARAMETER"UBERGABE AM STACK:
 118
 119 Bei mehr als sechs Parametern reicht der Platz in den Registern nicht mehr
 120 aus, daf"ur werden alle Parameter ab dem Siebenten am Stack "ubergeben,
 121 und zwar nach folgendem Muster:
 122
 123
 124                   | .....                                          |
 125                                   --------------------------------------------------
 126                   |  Parameter 9  ( 64 bit, egal bei welchem Typ)  |
 127                   --------------------------------------------------
 128                                   |  Parameter 8  ( 64 bit, egal bei welchem Typ   |
 129                   --------------------------------------------------
 130    R30 (sp) --->  |  Parameter 7  ( 64 bit, egal bei welchem Typ)  |
 131                   --------------------------------------------------
 132
 133 Der Stackpointer zeigt dabei auf die Untergrenze des Parameterbereichs.
 134
 135
 136
 137
 138
 139 VOLLST"ANDIGES LAYOUT EINES STACKFRAMES:
 140
 141 Jede Methode muss (wenn es keine Leaf-Methode ist, auf jeden Fall) gewisse
 142 Registerinhalte am Stack sichern.
 143 Eventuell werden auch noch lokale Werte, die nicht mehr in Registern
 144 Platz finden, ebenfalls am Stack aufbewahrt, und die Parameter"ubergabe
 145 bei mehr als 6 Parametern ben"otigt ebenfalls Platz am Stack.
 146
 147 Ein vollst"andiger Stackframe hat also dieses Aussehen (jeder Eintrag
 148 im Stackframe ist unabh"angig vom Typ auf jedem Fall 64 bit lang, die
 149 Gr"ossenangaben der Bereiche sind in solchen Einheiten von 64 Bit
 150 angegeben):
 151
 152                                 ---------------------------------------------
 153                                 |  Parameter n (vom Aufrufer)               |
 154                 ---------------------------------------------
 155                                 |  Parameter n-1                            |
 156                                 ---------------------------------------------
 157                 | ...                                       |
 158                 ---------------------------------------------
 159    SP vorher -> |  Parameter 7                              |
 160                 ============================================= ---
 161                 |  gesichertes RA                           |  savedregs_num
 162                 ---------------------------------------------
 163                 |  andere gesicherte Register               |
 164                 ============================================= ---
 165                 |  Platz f"ur lokale Werte, die nicht mehr  |  localvars_num
 166                 |  in Register passen                       |
 167                 ============================================= ---
 168                 |  ....                                     |  arguments_num
 169                 ---------------------------------------------
 170                 |  Parameter 8                              |
 171                 ---------------------------------------------
 172    SP --->      |  Parameter 7 (f"ur aufgerufenen Methoden) |
 173                 ============================================= ---
 174
 175
 176 Damit die Anf"ange der einzelnen Bereiche (im Codegenerator) leichter
 177 ausgedr"uckt werden k"onnen, sind ein paar Hilfsvariablen vorgesehen, die
 178 die Adressierung der einzelnen Bereiche vereinfachen:
 179         localvars_base  = arguments_num
 180         savedregs_base  = localvars_base + localvars_num
 181         parentargs_base = savedregs_base + savedregs_num
 182