home *** CD-ROM | disk | FTP | other *** search
/ Java 1996 August / Java - Summer 1996.iso / kaffe-0.2 / kaffe / codegen / register.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-12  |  2.9 KB  |  155 lines
  1. /*
  2.  * register.c
  3.  * Manage register file.
  4.  *
  5.  * Copyright (c) 1996 Systems Architecture Research Centre,
  6.  *           City University, London, UK.
  7.  *
  8.  * See the file "license.terms" for information on usage and redistribution
  9.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  10.  *
  11.  * Written by Tim Wilkinson <tim@sarc.city.ac.uk>, February 1996.
  12.  */
  13.  
  14. #include <stdio.h>
  15. #include <assert.h>
  16. #include "register.h"
  17. #include "constants.h"
  18. #include "classMethod.h"
  19.  
  20. static int stackPtr;
  21.  
  22. /*
  23.  * Assign registers to block of instructions.
  24.  */
  25. void
  26. allocateRegisters(methods* m)
  27. {
  28.     int i;
  29.     int nrop;
  30.     instn* ipc;
  31.     int nr;
  32.  
  33.     stackPtr = MAXSTACK / 2;
  34.     initRegisters();
  35.  
  36.     for (nr = m->codelen, ipc = m->insn; nr > 0; nr--, ipc++) {
  37.  
  38.         /* For soft instructions or those which use the stack directly
  39.            (sync), we dont bother with register allocation */
  40.         if (instnTable[ipc->op].coding != i_hard) {
  41.             syncRegisters();
  42.         }
  43.         else {
  44.             nrop = instnTable[ipc->op].in;
  45.             for (i = 0; i < nrop; i++) {
  46.                 ipc->in[i].valid = false;
  47.                 stackPtr--;
  48.                 assert(stackPtr >= 0);
  49.                 readRegister(&ipc->in[i]);
  50.             }
  51.             nrop = instnTable[ipc->op].out;
  52.             for (i = nrop - 1; i >= 0; i--) {
  53.                 ipc->out[i].valid = false;
  54.                 writeRegister(&ipc->out[i]);
  55.                 stackPtr++;
  56.                 assert(stackPtr < MAXSTACK);
  57.             }
  58.             /* At the end of a block it is necessary to make sure that
  59.                eveything is back on the stack */
  60.             if (ipc->type  == i_endblock) {
  61.                 syncRegisters();
  62.             }
  63.         }
  64.     }
  65. }
  66.  
  67. /*
  68.  * Initialise register to all be unused.
  69.  */
  70. void
  71. initRegisters(void)
  72. {
  73.     int i;
  74.     nativeReg* r;
  75.  
  76.     for (i = 0; i < NRREG; i++) {
  77.         r = ®isterFile[i];
  78.         r->stack = MAXSTACK;
  79.         r->lastWrite = 0;
  80.     }
  81. }
  82.  
  83. /*
  84.  * Allocate the register which corresponds to the current stack
  85.  * location.
  86.  */
  87. void
  88. readRegister(operand* op)
  89. {
  90.     nativeReg* r;
  91.  
  92. #if 0
  93.     r = ®isterFile[stackPtr & (NRREG-1)];
  94. #endif
  95.     r = ®isterFile[stackPtr % NRREG];
  96.     /*
  97.      * If r->stack == stackPtr then a register is already
  98.      * available - just reuse it.  If not we will need to
  99.      * reload.
  100.      */
  101.     if (r->stack > stackPtr) {
  102.         op->valid = true;
  103.     }
  104.     r->stack = stackPtr;
  105.     op->reg = r;
  106. }
  107.  
  108. /*
  109.  * Allocate a register to correspond to the current stack
  110.  * location.
  111.  */
  112. void
  113. writeRegister(operand* op)
  114. {
  115.     nativeReg* r;
  116.  
  117. #if 0
  118.     r = ®isterFile[stackPtr & (NRREG-1)];
  119. #endif
  120.     r = ®isterFile[stackPtr % NRREG];
  121.     /*
  122.      * If r->stack == stackPtr then a register is already
  123.      * available - just reuse it.  If not we will need to
  124.      * spill.
  125.      */
  126.     if (r->stack < stackPtr) {
  127.         assert(r->lastWrite != 0);
  128.         assert(r->lastWrite->reg == r);
  129.         r->lastWrite->valid = true;
  130.     }
  131.     r->stack = stackPtr;
  132.     r->lastWrite = op;
  133.     op->reg = r;
  134. }
  135.  
  136. /*
  137.  * Put back any live registers to the stack.
  138.  */
  139. void
  140. syncRegisters(void)
  141. {
  142.     int i;
  143.     nativeReg* r;
  144.  
  145.     for (i = 0; i < NRREG; i++) {
  146.         r = ®isterFile[i];
  147.         if (r->stack < stackPtr) {
  148.             assert(r->lastWrite != 0);
  149.             assert(r->lastWrite->reg == r);
  150.             r->lastWrite->valid = true;
  151.             r->stack = MAXSTACK;
  152.         }
  153.     }
  154. }
  155.