Make more constants offsets thereby fixing a 64bit issue where consta…

…nts weren't getting fully sign extended. Fix Offset.plus(Offset) in VM Magic to better aid this.

common/vmmagic/src/org/vmmagic/unboxed/Offset.java

@@ -55,6 +55,10 @@ public Offset plus(int byteSize) {
     return null;
   }
 
+  public Offset plus(Offset off2) {
+    return null;
+  }
+
   public Offset minus(int byteSize) {
     return null;
   }

rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineCompilerImpl.java

@@ -66,7 +66,7 @@ public abstract class BaselineCompilerImpl extends BaselineCompiler implements B
   }
 
   private final int parameterWords;
-  private int firstLocalOffset;
+  private Offset firstLocalOffset;
 
   static final Offset NO_SLOT = Offset.zero();
   static final Offset ONE_SLOT = NO_SLOT.plus(WORDSIZE);
@@ -100,21 +100,24 @@ public final byte getLastFloatStackRegister() {
 
   @Uninterruptible
   public static short getGeneralLocalLocation(int index, short[] localloc, NormalMethod m) {
-    return offsetToLocation(getStartLocalOffset(m) -
-                            (index << LOG_BYTES_IN_ADDRESS)); //we currently do not use location arrays on intel
+    return offsetToLocation(getStartLocalOffset(m).minus(index << LOG_BYTES_IN_ADDRESS)); //we currently do not use location arrays on intel
   }
 
   @Uninterruptible
   public static short getFloatLocalLocation(int index, short[] localloc, NormalMethod m) {
-    return offsetToLocation(getStartLocalOffset(m) -
-                            (index << LOG_BYTES_IN_ADDRESS)); //we currently do not use location arrays on intel
+    return offsetToLocation(getStartLocalOffset(m).minus(index << LOG_BYTES_IN_ADDRESS)); //we currently do not use location arrays on intel
   }
 
   @Uninterruptible
   public static int locationToOffset(short location) {
     return -location;
   }
 
+  @Uninterruptible
+  private static short offsetToLocation(Offset offset) {
+    return (short)-offset.toInt();
+  }
+
   @Uninterruptible
   public static short offsetToLocation(int offset) {
     return (short)-offset;
@@ -124,8 +127,8 @@ public static short offsetToLocation(int offset) {
    * The last true local
    */
   @Uninterruptible
-  public static int getEmptyStackOffset(NormalMethod m) {
-    return getFirstLocalOffset(m) - (m.getLocalWords() << LG_WORDSIZE) + WORDSIZE;
+  public static short getEmptyStackOffset(NormalMethod m) {
+    return (short)getFirstLocalOffset(m).minus(m.getLocalWords() << LG_WORDSIZE).plus(WORDSIZE).toInt();
   }
 
   /**
@@ -134,19 +137,19 @@ public static int getEmptyStackOffset(NormalMethod m) {
    * TODO!! make sure it is not being used incorrectly
    */
   @Uninterruptible
-  private static int getFirstLocalOffset(NormalMethod method) {
+  private static Offset getFirstLocalOffset(NormalMethod method) {
     if (method.getDeclaringClass().hasBridgeFromNativeAnnotation()) {
-      return STACKFRAME_BODY_OFFSET - (JNICompiler.SAVED_GPRS_FOR_JNI << LG_WORDSIZE);
+      return STACKFRAME_BODY_OFFSET.minus(JNICompiler.SAVED_GPRS_FOR_JNI << LG_WORDSIZE);
     } else if (method.hasBaselineSaveLSRegistersAnnotation()) {
-      return STACKFRAME_BODY_OFFSET - (SAVED_GPRS_FOR_SAVE_LS_REGISTERS << LG_WORDSIZE);
+      return STACKFRAME_BODY_OFFSET.minus(SAVED_GPRS_FOR_SAVE_LS_REGISTERS << LG_WORDSIZE);
     } else {
-      return STACKFRAME_BODY_OFFSET - (SAVED_GPRS << LG_WORDSIZE);
+      return STACKFRAME_BODY_OFFSET.minus(SAVED_GPRS << LG_WORDSIZE);
     }
   }
 
   @Uninterruptible
-  private static int getStartLocalOffset(NormalMethod method) {
-    return getFirstLocalOffset(method) + WORDSIZE;
+  private static Offset getStartLocalOffset(NormalMethod method) {
+    return getFirstLocalOffset(method).plus(WORDSIZE);
   }
 
   /**
@@ -3679,7 +3682,7 @@ private void genPrologue() {
       JNICompiler.generateGlueCodeForJNIMethod(asm, method, compiledMethod.getId());
       // set some constants for the code generation of the rest of the method
       // firstLocalOffset is shifted down because more registers are saved
-      firstLocalOffset = STACKFRAME_BODY_OFFSET - (JNICompiler.SAVED_GPRS_FOR_JNI << LG_WORDSIZE);
+      firstLocalOffset = STACKFRAME_BODY_OFFSET.minus(JNICompiler.SAVED_GPRS_FOR_JNI << LG_WORDSIZE);
     } else {
       /* paramaters are on the stack and/or in registers;  There is space
        * on the stack for all the paramaters;  Parameter slots in the
@@ -3707,7 +3710,7 @@ private void genPrologue() {
       /*
        * NOTE: until the end of the prologue SP holds the framepointer.
        */
-      if (VM.VerifyAssertions) VM._assert(STACKFRAME_METHOD_ID_OFFSET == -WORDSIZE);
+      if (VM.VerifyAssertions) VM._assert(STACKFRAME_METHOD_ID_OFFSET.toInt() == -WORDSIZE);
       asm.emitPUSH_Imm(compiledMethod.getId());
 
       /*
@@ -3757,7 +3760,7 @@ private void genPrologue() {
       }
 
       // copy registers to callee's stackframe
-      firstLocalOffset = STACKFRAME_BODY_OFFSET - savedRegistersSize;
+      firstLocalOffset = STACKFRAME_BODY_OFFSET.minus(savedRegistersSize);
       Offset firstParameterOffset = Offset.fromIntSignExtend(savedRegistersSize + STACKFRAME_HEADER_SIZE + (parameterWords << LG_WORDSIZE) - WORDSIZE);
       genParameterCopy(firstParameterOffset);
       int emptyStackOffset = (method.getLocalWords() << LG_WORDSIZE) - (parameterWords << LG_WORDSIZE);
@@ -4589,7 +4592,7 @@ private Offset localOffset(int local) {
    * start of the current bytecode (biStart)
    */
   private Offset fp2spOffset(Offset offset) {
-    int offsetToFrameHead = (stackHeights[biStart] << LG_WORDSIZE) - firstLocalOffset;
+    Offset offsetToFrameHead = Offset.fromIntSignExtend(stackHeights[biStart] << LG_WORDSIZE).minus(firstLocalOffset);
     return offset.plus(offsetToFrameHead);
   }
 

rvm/src/org/jikesrvm/compilers/baseline/ia32/BaselineMagic.java

@@ -1284,6 +1284,7 @@ void generateMagic(Assembler asm, MethodReference m, RVMMethod cm, Offset sd) {
     generators.put(getMethodReference(Address.class, MagicNames.wordPlus, Offset.class, Address.class), g);
     generators.put(getMethodReference(Address.class, MagicNames.wordPlus, Extent.class, Address.class), g);
     generators.put(getMethodReference(Extent.class, MagicNames.wordPlus, Extent.class, Extent.class), g);
+    generators.put(getMethodReference(Offset.class, MagicNames.wordPlus, Offset.class, Offset.class), g);
     generators.put(getMethodReference(Word.class, MagicNames.wordPlus, Word.class, Word.class), g);
     generators.put(getMethodReference(Word.class, MagicNames.wordPlus, Offset.class, Word.class), g);
     generators.put(getMethodReference(Word.class, MagicNames.wordPlus, Extent.class, Word.class), g);
@@ -1803,9 +1804,9 @@ void generateMagic(Assembler asm, MethodReference m, RVMMethod cm, Offset sd) {
   }
   static {
     generators.put(getMethodReference(Magic.class, MagicNames.getCallerFramePointer, Address.class, Address.class),
-        new GetValueAtDisplacement(Offset.fromIntSignExtend(STACKFRAME_FRAME_POINTER_OFFSET)));
+        new GetValueAtDisplacement(STACKFRAME_FRAME_POINTER_OFFSET));
     generators.put(getMethodReference(Magic.class, MagicNames.getCompiledMethodID, Address.class, int.class),
-        new GetValueAtDisplacement(Offset.fromIntSignExtend(STACKFRAME_METHOD_ID_OFFSET)));
+        new GetValueAtDisplacement(STACKFRAME_METHOD_ID_OFFSET));
     MagicGenerator g = new GetValueAtDisplacement(ObjectModel.getArrayLengthOffset());
     generators.put(getMethodReference(Magic.class, MagicNames.getArrayLength, Object.class, int.class), g);
     Class<?>[] unboxedTypes = new Class<?>[]{AddressArray.class, CodeArray.class, ExtentArray.class, FunctionTable.class, IMT.class, ObjectReferenceArray.class, OffsetArray.class, TIB.class, WordArray.class};
@@ -1835,9 +1836,9 @@ void generateMagic(Assembler asm, MethodReference m, RVMMethod cm, Offset sd) {
   }
   static {
     generators.put(getMethodReference(Magic.class, MagicNames.setCallerFramePointer, Address.class, Address.class, void.class),
-        new SetValueAtDisplacement(Offset.fromIntSignExtend(STACKFRAME_FRAME_POINTER_OFFSET)));
+        new SetValueAtDisplacement(STACKFRAME_FRAME_POINTER_OFFSET));
     generators.put(getMethodReference(Magic.class, MagicNames.setCompiledMethodID, Address.class, int.class, void.class),
-        new SetValueAtDisplacement(Offset.fromIntSignExtend(STACKFRAME_METHOD_ID_OFFSET)));
+        new SetValueAtDisplacement(STACKFRAME_METHOD_ID_OFFSET));
   }
 
   /**
@@ -2016,9 +2017,9 @@ private static final class GetReturnAddressLocation extends MagicGenerator {
     @Override
     void generateMagic(Assembler asm, MethodReference m, RVMMethod cm, Offset sd) {
       if (VM.BuildFor32Addr) {
-        asm.emitADD_RegInd_Imm(SP, STACKFRAME_RETURN_ADDRESS_OFFSET);
+        asm.emitADD_RegInd_Imm(SP, STACKFRAME_RETURN_ADDRESS_OFFSET.toInt());
       } else {
-        asm.emitADD_RegInd_Imm_Quad(SP, STACKFRAME_RETURN_ADDRESS_OFFSET);
+        asm.emitADD_RegInd_Imm_Quad(SP, STACKFRAME_RETURN_ADDRESS_OFFSET.toInt());
       }
     }
   }

rvm/src/org/jikesrvm/compilers/common/BootImageCompiler.java

@@ -27,7 +27,7 @@
  */
 public abstract class BootImageCompiler {
 
-  private static BootImageCompiler compiler =
+  private static final BootImageCompiler compiler =
       VM.BuildWithBaseBootImageCompiler ? new BaselineBootImageCompiler() : new org.jikesrvm.compilers.opt.driver.OptimizingBootImageCompiler();
 
   /**
@@ -59,7 +59,11 @@ public static void init(String[] args) {
   }
 
   public static CompiledMethod compile(NormalMethod method, TypeReference[] params) {
-    return compiler.compileMethod(method, params);
+    try {
+      return compiler.compileMethod(method, params);
+    } catch (Exception e) {
+      throw new Error("Exception during compilation of "+method, e);
+    }
   }
 
   public static CompiledMethod compile(NormalMethod method) {

rvm/src/org/jikesrvm/compilers/opt/bc2ir/ia32/GenerateMachineSpecificMagic.java

@@ -105,7 +105,7 @@ public static boolean generateMagic(BC2IR bc2ir, GenerationContext gc, MethodRef
       bc2ir.appendInstruction(Load.create(REF_LOAD,
                                           val,
                                           fp,
-                                          new IntConstantOperand(STACKFRAME_FRAME_POINTER_OFFSET),
+                                          new IntConstantOperand(STACKFRAME_FRAME_POINTER_OFFSET.toInt()),
                                           null));
       bc2ir.push(val.copyD2U());
     } else if (methodName == MagicNames.setCallerFramePointer) {
@@ -114,15 +114,15 @@ public static boolean generateMagic(BC2IR bc2ir, GenerationContext gc, MethodRef
       bc2ir.appendInstruction(Store.create(REF_STORE,
                                            val,
                                            fp,
-                                           new IntConstantOperand(STACKFRAME_FRAME_POINTER_OFFSET),
+                                           new IntConstantOperand(STACKFRAME_FRAME_POINTER_OFFSET.toInt()),
                                            null));
     } else if (methodName == MagicNames.getCompiledMethodID) {
       Operand fp = bc2ir.popAddress();
       RegisterOperand val = gc.temps.makeTempInt();
       bc2ir.appendInstruction(Load.create(INT_LOAD,
                                           val,
                                           fp,
-                                          new IntConstantOperand(STACKFRAME_METHOD_ID_OFFSET),
+                                          new IntConstantOperand(STACKFRAME_METHOD_ID_OFFSET.toInt()),
                                           null));
       bc2ir.push(val.copyD2U());
     } else if (methodName == MagicNames.setCompiledMethodID) {
@@ -131,15 +131,15 @@ public static boolean generateMagic(BC2IR bc2ir, GenerationContext gc, MethodRef
       bc2ir.appendInstruction(Store.create(INT_STORE,
                                            val,
                                            fp,
-                                           new IntConstantOperand(STACKFRAME_METHOD_ID_OFFSET),
+                                           new IntConstantOperand(STACKFRAME_METHOD_ID_OFFSET.toInt()),
                                            null));
     } else if (methodName == MagicNames.getReturnAddressLocation) {
       Operand fp = bc2ir.popAddress();
       RegisterOperand val = gc.temps.makeTemp(TypeReference.Address);
       bc2ir.appendInstruction(Binary.create(REF_ADD,
                                             val,
                                             fp,
-                                            new IntConstantOperand(STACKFRAME_RETURN_ADDRESS_OFFSET)));
+                                            new IntConstantOperand(STACKFRAME_RETURN_ADDRESS_OFFSET.toInt())));
       bc2ir.push(val.copyD2U());
     } else {
       // Distinguish between magics that we know we don't implement

rvm/src/org/jikesrvm/compilers/opt/runtimesupport/ia32/OptGCMapIterator.java

@@ -134,7 +134,7 @@ public Address getStackLocation(Address framePtr, int offset) {
    *  @return the first spill location
    */
   public Address getFirstSpillLoc() {
-    return framePtr.minus(-StackframeLayoutConstants.STACKFRAME_BODY_OFFSET);
+    return framePtr.plus(StackframeLayoutConstants.STACKFRAME_BODY_OFFSET);
   }
 
   /**

rvm/src/org/jikesrvm/ia32/BaselineConstants.java

@@ -41,22 +41,22 @@ public interface BaselineConstants extends Constants, ArchConstants {
   // Constants describing baseline compiler conventions for
   // saving registers in stackframes.
   //
-  int STACKFRAME_REG_SAVE_OFFSET = STACKFRAME_BODY_OFFSET;
+  Offset STACKFRAME_REG_SAVE_OFFSET = STACKFRAME_BODY_OFFSET;
   // offset from FP of the saved registers.
   // Some registers are saved in all baseline
   // frames, and most register as saved in the
   // dynamic bridge frames.
-  int STACKFRAME_FIRST_PARAMETER_OFFSET = STACKFRAME_REG_SAVE_OFFSET - (2 * WORDSIZE);
+  Offset STACKFRAME_FIRST_PARAMETER_OFFSET = STACKFRAME_REG_SAVE_OFFSET.minus(2 * WORDSIZE);
   // bridge frames save 2 additional GPRs
   int BRIDGE_FRAME_EXTRA_SIZE = (SSE2_FULL ? XMM_STATE_SIZE : FPU_STATE_SIZE) + (2 * WORDSIZE);
 
   int SAVED_GPRS = 2; // EDI and EBX are nonvolatile registers used by baseline compiler
   int SAVED_GPRS_FOR_SAVE_LS_REGISTERS = 3; // save all non-volatiles
-  Offset EDI_SAVE_OFFSET = Offset.fromIntSignExtend(STACKFRAME_REG_SAVE_OFFSET);
-  Offset EBX_SAVE_OFFSET = Offset.fromIntSignExtend(STACKFRAME_REG_SAVE_OFFSET).minus(WORDSIZE);
-  Offset EBP_SAVE_OFFSET = Offset.fromIntSignExtend(STACKFRAME_REG_SAVE_OFFSET).minus(WORDSIZE*2);
-  Offset T0_SAVE_OFFSET = Offset.fromIntSignExtend(STACKFRAME_FIRST_PARAMETER_OFFSET);
-  Offset T1_SAVE_OFFSET = Offset.fromIntSignExtend(STACKFRAME_FIRST_PARAMETER_OFFSET).minus(WORDSIZE);
+  Offset EDI_SAVE_OFFSET = STACKFRAME_REG_SAVE_OFFSET;
+  Offset EBX_SAVE_OFFSET = STACKFRAME_REG_SAVE_OFFSET.minus(WORDSIZE);
+  Offset EBP_SAVE_OFFSET = STACKFRAME_REG_SAVE_OFFSET.minus(WORDSIZE*2);
+  Offset T0_SAVE_OFFSET = STACKFRAME_FIRST_PARAMETER_OFFSET;
+  Offset T1_SAVE_OFFSET = STACKFRAME_FIRST_PARAMETER_OFFSET.minus(WORDSIZE);
   Offset FPU_SAVE_OFFSET = T1_SAVE_OFFSET.minus(FPU_STATE_SIZE);
   Offset XMM_SAVE_OFFSET = T1_SAVE_OFFSET.minus(XMM_STATE_SIZE);
 }

rvm/src/org/jikesrvm/ia32/MachineSpecificIA.java

@@ -84,7 +84,7 @@ public final void baselineEmitLoadTIB(ArchitectureSpecific.Assembler asm, int de
   public final void initializeStack(ArchitectureSpecific.Registers contextRegisters, Address ip, Address sp) {
     Address fp;
     sp = sp.minus(STACKFRAME_HEADER_SIZE);                   // last word of header
-    fp = sp.minus(SizeConstants.BYTES_IN_ADDRESS + STACKFRAME_BODY_OFFSET);
+    fp = sp.minus(SizeConstants.BYTES_IN_ADDRESS).minus(STACKFRAME_BODY_OFFSET);
     Magic.setCallerFramePointer(fp, STACKFRAME_SENTINEL_FP);
     Magic.setCompiledMethodID(fp, INVISIBLE_METHOD_ID);
 

rvm/src/org/jikesrvm/ia32/OutOfLineMachineCode.java

@@ -255,7 +255,7 @@ private static ArchitectureSpecific.CodeArray generateReflectiveMethodInvokerIns
     asm.emitPUSH_RegDisp(TR, fpOffset); // link this frame with next
     ThreadLocalState.emitMoveRegToField(asm, fpOffset, SP); // establish base of new frame
     asm.emitPUSH_Imm(INVISIBLE_METHOD_ID);
-    asm.emitADD_Reg_Imm(SP, STACKFRAME_BODY_OFFSET);
+    asm.emitADD_Reg_Imm(SP, STACKFRAME_BODY_OFFSET.toInt());
 
     /* write parameters on stack
     * move data from memory addressed by Paramaters array, the fourth
@@ -428,9 +428,9 @@ private static ArchitectureSpecific.CodeArray generateReflectiveMethodInvokerIns
     // NOTE: RVM callee has popped the params, so we can simply
     //       add back in the initial SP to FP delta to get SP to be a framepointer again!
     if (VM.BuildFor32Addr) {
-      asm.emitADD_Reg_Imm(SP, -STACKFRAME_BODY_OFFSET + WORDSIZE);
+      asm.emitADD_Reg_Imm(SP, -STACKFRAME_BODY_OFFSET.toInt() + WORDSIZE);
     } else {
-      asm.emitADD_Reg_Imm_Quad(SP, -STACKFRAME_BODY_OFFSET + WORDSIZE);
+      asm.emitADD_Reg_Imm_Quad(SP, -STACKFRAME_BODY_OFFSET.toInt() + WORDSIZE);
     }
     asm.emitPOP_RegDisp(TR, fpOffset);
 

rvm/src/org/jikesrvm/ia32/StackframeLayoutConstants.java

@@ -15,6 +15,7 @@
 import org.jikesrvm.SizeConstants;
 import org.jikesrvm.VM;
 import org.vmmagic.unboxed.Address;
+import org.vmmagic.unboxed.Offset;
 import static org.jikesrvm.ia32.BaselineConstants.WORDSIZE;
 
 /**----------------------------------------------------------------------
@@ -142,13 +143,13 @@ public interface StackframeLayoutConstants {
   int BYTES_IN_STACKSLOT = 1 << LOG_BYTES_IN_STACKSLOT;
 
   /** offset of caller's return address from FP */
-  int STACKFRAME_RETURN_ADDRESS_OFFSET = WORDSIZE;
+  Offset STACKFRAME_RETURN_ADDRESS_OFFSET = Offset.fromIntSignExtend(WORDSIZE);
   /** base of this frame */
-  int STACKFRAME_FRAME_POINTER_OFFSET = 0;
+  Offset STACKFRAME_FRAME_POINTER_OFFSET = Offset.zero();
   /** offset of method id from FP */
-  int STACKFRAME_METHOD_ID_OFFSET = -WORDSIZE;
+  Offset STACKFRAME_METHOD_ID_OFFSET = Offset.fromIntSignExtend(-WORDSIZE);
   /** offset of work area from FP */
-  int STACKFRAME_BODY_OFFSET = -2*WORDSIZE;
+  Offset STACKFRAME_BODY_OFFSET = Offset.fromIntSignExtend(-2*WORDSIZE);
   /** size of frame header, in bytes */
   int STACKFRAME_HEADER_SIZE = 3*WORDSIZE;