Re: [rvm-research] Approach for fixing the RVM-1017(Implicit unlock in synchronized method relies on local variable 0 )

diff -urB ./rvm/src/org/jikesrvm/compilers/opt/bc2ir/GenerationContext.java ../New_UnMd/rvm/src/org/jikesrvm/compilers/opt/bc2ir/GenerationContext.java
--- ./rvm/src/org/jikesrvm/compilers/opt/bc2ir/GenerationContext.java	2013-03-14 15:01:46.000000000 -0700
+++ ../New_UnMd/rvm/src/org/jikesrvm/compilers/opt/bc2ir/GenerationContext.java	2013-04-29 16:35:09.261783204 -0700
@@ -83,6 +83,7 @@
    */
   CompiledMethod original_cm;
 
+  public int numberOfArgs;
   /**
    * The method to be generated
    */
@@ -156,7 +156,7 @@
    * synchronized methods.
    */
   BasicBlock unlockAndRethrow;
-
+  public TypeReference thisTypeRef;
   /**
    * The Register to which BC2IR should assign the return value(s)
    * of the method. It will be null when the method has a void return.
@@ -192,7 +192,8 @@
    * Did BC2IR encounter a magic that requires us to allocate a stack frame?
    */
   public boolean allocFrame;
-
+  public RegisterOperand cachedThis;
+  public Register thisReg;
   /**
    * Used to communicate the meet of the return values back to the caller
    * Mainly useful when BC2IR is doing inlining....allows the caller
@@ -249,6 +250,7 @@
     int numParams = params.length;
     int argIdx = 0;
     int localNum = 0;
+    //arguments = new Operand[method.isStatic() ? numParams : numParams + 1];
     arguments = new Operand[method.isStatic() ? numParams : numParams + 1];
     // Insert IR_PROLOGUE instruction.  Loop below will fill in its operands
     Instruction prologueInstr = Prologue.create(IR_PROLOGUE, arguments.length);
@@ -257,7 +259,10 @@
     if (!method.isStatic()) {
       TypeReference thisType = meth.getDeclaringClass().getTypeRef();
       RegisterOperand thisOp = makeLocal(localNum, thisType);
-      // The this param of a virtual method is by definition non null
+     //makeLocal(method.getLocalWords()-1, thisType);
+      thisTypeRef = thisType;
+      numberOfArgs = numParams+1;
+     // The this param of a virtual method is by definition non null
       RegisterOperand guard = makeNullCheckGuard(thisOp.getRegister());
       BC2IR.setGuard(thisOp, guard);
       appendInstruction(prologue, Move.create(GUARD_MOVE, guard.copyRO(), new TrueGuardOperand()), PROLOGUE_BCI);
@@ -268,6 +273,11 @@
       }
       arguments[0] = thisOp;
       Prologue.setFormal(prologueInstr, 0, thisOp.copyU2D());
+      /* simulating aload0 , astore_method.getLocalWords-1*/
+       thisReg = temps.getReg(thisType);
+      //thisReg.setLocal();
+      cachedThis  = new RegisterOperand(thisReg,thisType);
+      appendInstruction(prologue, Move.create(IRTools.getMoveOp(thisType),cachedThis, thisOp), PROLOGUE_BCI);
       argIdx++;
       localNum++;
     }
@@ -330,11 +338,15 @@
     // Now inherit state based on callSite
     child.inlineSequence = new InlineSequence(child.method, callSite.position, callSite);
     child.enclosingHandlers = ebag;
-    child.arguments = new Operand[Call.getNumberOfParams(callSite)];
+    child.numberOfArgs = Call.getNumberOfParams(callSite);
+   // child.arguments = new Operand[Call.getNumberOfParams(callSite)];
+    child.arguments = new Operand[child.numberOfArgs];
+   // for (int i = 0; i < child.arguments.length; i++) {
     for (int i = 0; i < child.arguments.length; i++) {
       child.arguments[i] = Call.getParam(callSite, i).copy(); // copy instead
       // of clearing in case inlining aborts.
     }
+    //child.arguments[child.numberOfArgs-1]=Call.getParam(callSite, 0).copy();
     if (Call.hasResult(callSite)) {
       child.resultReg = Call.getResult(callSite).copyD2D().getRegister();
       child.resultReg.setSpansBasicBlock(); // it will...
@@ -369,9 +379,23 @@
           objPtr.setDeclaredType();
           objPtr.setType(child.method.getDeclaringClass().getTypeRef());
         }
+        RegisterOperand myOp = objPtr.copyRO();
         local = child.makeLocal(localNum, objPtr);
         localNum++;
-        child.arguments[0] = local; // Avoid confusion in BC2IR of callee
+        child.arguments[0] = local;
+        //child.makeLocal(child.method.getLocalWords()-1, myOp);
+      /*receiver = child.arguments[0];
+        objPtr = receiver.asRegister();
+        if (ClassLoaderProxy.includesType(child.method.getDeclaringClass().getTypeRef(), objPtr.getType()) != YES) {
+            // narrow type of actual to match formal static type implied by method
+            objPtr.clearPreciseType(); // Can be precise but not assignable if enough classes aren't loaded
+            objPtr.setDeclaredType();
+            objPtr.setType(child.method.getDeclaringClass().getTypeRef());
+          }
+        child.arguments[child.numberOfArgs-1]=child.makeLocal(child.method.getLocalWords(), objPtr);
+       */
+        //child.thisTypeRef =child.makeLocal(child.method.getLocalWords(), objPtr).type;
+        //child.arguments[child.numberOfArgs-1] = child.makeLocal(child.method.getLocalWords(),objPtr );// Avoid confusion in BC2IR of callee
         // when objPtr is a local in the caller.
       } else if (receiver.isConstant()) {
         local = child.makeLocal(localNum, receiver.getType());
@@ -384,11 +408,20 @@
       } else {
         OptimizingCompilerException.UNREACHABLE("Unexpected receiver operand");
       }
-      Instruction s = Move.create(REF_MOVE, local, receiver);
+
+      if(local!=null){
+child.thisReg = child.temps.getReg(local.getType());
+    //child.thisReg.setLocal();
+      child.cachedThis  = new RegisterOperand(child.thisReg,local.getType());
+  Instruction n = Move.create(IRTools.getMoveOp(local.getType()),child.cachedThis, local);
+  //s.bcIndex = PROLOGUE_BCI;
+  child.prologue.appendInstruction(n);
+ }
+    Instruction s = Move.create(REF_MOVE, local, receiver);
       s.bcIndex = PROLOGUE_BCI;
       s.position = callSite.position;
       child.prologue.appendInstruction(s);
-    }
+   }
     for (int paramIdx = 0; paramIdx < numParams; paramIdx++, argIdx++) {
       TypeReference argType = params[paramIdx];
       RegisterOperand formal;
@@ -774,8 +806,10 @@
       Offset offs = Offset.fromIntSignExtend(Statics.findOrCreateObjectLiteral(klass));
       return new ClassConstantOperand(klass, offs);
     } else {
-      return makeLocal(0, arguments[0].getType());
-    }
+   return new RegisterOperand(cachedThis.getRegister(), method.getDeclaringClass().getTypeRef());
+ //return new RegisterOperand(addressLocals[method.getLocalWords()],arguments[arguments.length-1].getType());
+   //new RegisterOperand(, type);
+   }
   }
 
   private void appendInstruction(BasicBlock b, Instruction s, int bcIndex) {
Only in ../New_UnMd/rvm/src/org/jikesrvm/compilers/opt/bc2ir: GenerationContext.java~