示例#1
0
  static void noim() {

    int i;
    wr('n');
    wr('i');
    wr(' ');
    i = Native.getSP(); // sp of noim();
    int sp = Native.rdIntMem(i - 4); // sp of calling function
    int pc = Native.rdIntMem(sp - 3) - 1; // one to high
    i = Native.rdIntMem(sp); // mp
    wrSmall(i);
    wr(' ');
    int start = Native.rdMem(i) >>> 10;
    wrSmall(start);
    wr(' ');
    wrByte(pc);
    wr(' ');

    int val = Native.rdMem(start + (pc >> 2));
    for (i = (pc & 0x03); i < 3; ++i) val >>= 8;
    val &= 0xff;
    wrByte(val);

    Object o = new Object();
    synchronized (o) {
      System.out.println();
      System.out.print("JOP: bytecode ");
      System.out.print(val);
      System.out.println(" not implemented");

      trace(sp);

      for (; ; ) ;
    }
  }
示例#2
0
 public static int[] makeHWArray(int len, int address, int idx, int cp) {
   int p = Native.rdMem(cp - 1);
   p = Native.rdMem(p + 1);
   p += idx * 2;
   Native.wrMem(address, p);
   Native.wrMem(len, p + 1);
   return Native.toIntArray(p);
 }
示例#3
0
 /**
  * Install a handle in two static fields for a hardware object
  *
  * @param o a 'real' instance of the HW object for the class reference
  * @param address IO address of the hardware device
  * @param idx index of the static fields
  * @param cp address of constant pool of the factory class
  * @return reference to the HW object
  */
 public static Object makeHWObject(Object o, int address, int idx, int cp) {
   int ref = Native.toInt(o);
   int pcl = Native.rdMem(ref + 1);
   int p = Native.rdMem(cp - 1);
   p = Native.rdMem(p + 1);
   p += idx * 2;
   Native.wrMem(address, p);
   Native.wrMem(pcl, p + 1);
   return Native.toObject(p);
 }
示例#4
0
 /** Invoked on a hardware generated exception. */
 static void except() {
   saved_sp = Native.getSP();
   if (Native.rdMem(Const.IO_EXCPT) == Const.EXC_SPOV) {
     // reset stack pointer
     Native.setSP(Const.STACK_OFF);
   }
   // we have more stack available now for the stack overflow
   handleException();
 }
示例#5
0
  /**
   * Create interrupt handler and preallocated exceptions in a static method instead of <clinit>.
   * Jikes puts <clinit> as first methods into the table (instead of interrupt()), javac as last
   * method.
   *
   * <p>We could use HWO here.
   */
  static void init() {
    ih = new Runnable[Native.rdMem(Const.IO_CPUCNT)][Const.NUM_INTERRUPTS];
    dh = new DummyHandler();
    for (int core = 0; core < Native.rdMem(Const.IO_CPUCNT); ++core) {
      for (int var = 0; var < Const.NUM_INTERRUPTS; ++var) {
        JVMHelp.addInterruptHandler(core, var, dh);
      }
    }

    sys = IOFactory.getFactory().getSysDevice();

    SOError = new StackOverflowError();
    NPExc = new NullPointerException();
    ABExc = new ArrayIndexOutOfBoundsException();
    ArithExc = new ArithmeticException();
    CCExc = new ClassCastException();

    RetryExc = RetryException.instance;
  }
示例#6
0
  static void trace(int sp) {

    int fp, mp, vp, pc, addr, loc, args;
    int val;

    //		for (int i=0; i<1024; ++i) {
    //			wrSmall(i);
    //			wrSmall(Native.rdIntMem(i));
    //			wr('\n');
    //		}
    wr("saved sp=");
    wrSmall(sp);
    wr('\n');

    fp = sp - 4; // first frame point is easy, since last sp points to the end of the frame

    wr("  mp     pc     fp");
    wr('\n');

    while (fp > Const.STACK_OFF + 5) {
      mp = Native.rdIntMem(fp + 4);
      vp = Native.rdIntMem(fp + 2);
      pc = Native.rdIntMem(fp + 1);
      val = Native.rdMem(mp);
      addr = val >>> 10; // address of callee

      wrSmall(mp);
      //			wrSmall(addr);
      wrSmall(pc);
      wrSmall(fp);
      wr('\n');

      val = Native.rdMem(mp + 1); // cp, locals, args
      args = val & 0x1f;
      loc = (val >>> 5) & 0x1f;
      fp = vp + args + loc; // new fp can be calc. with vp and count of local vars
    }
    wr('\n');
  }
示例#7
0
  static void handleException() {

    if (Const.USE_RTTM) {
      // abort transaction to avoid invoking f_athrow() twice
      Native.wrMem(Const.TM_ABORTED, Const.MEM_TM_MAGIC);
    }

    int i;
    i = Native.rdMem(Const.IO_EXCPT);
    if (i == Const.EXC_SPOV) {
      throw SOError;
    } else if (i == Const.EXC_NP) {
      throw NPExc;
    } else if (i == Const.EXC_AB) {
      throw ABExc;
    } else if (i == Const.EXC_DIVZ) {
      throw ArithExc;
    } else if (i == Const.EXC_ROLLBACK) {
      throw RetryExc;
    }

    for (; ; ) ;
  }
示例#8
0
 /**
  * Remove the interrupt handler
  *
  * @param nr interrupt number
  */
 public static void removeInterruptHandler(int nr) {
   removeInterruptHandler(Native.rdMem(Const.IO_CPU_ID), nr);
 }
示例#9
0
 /**
  * Add a Runnable as a first level interrupt handler. Use the current core.
  *
  * @param nr interrupt number
  * @param r Runnable the represents the interrupt handler
  */
 public static void addInterruptHandler(int nr, Runnable r) {
   addInterruptHandler(Native.rdMem(Const.IO_CPU_ID), nr, r);
 }