--- a/src/gpu/hsail/vm/gpu_hsail_Frame.hpp	Thu Jun 26 13:42:29 2014 +0200
+++ b/src/gpu/hsail/vm/gpu_hsail_Frame.hpp	Thu Jun 26 18:25:35 2014 +0200
@@ -37,36 +37,85 @@
   jbyte _num_d_regs;
   jshort _num_stack_slots; 
 
+  jbyte* data_start() {return (jbyte*) this  + sizeof(*this); }
+  int sreg_ofst_start() { return 0; }
+  int dreg_ofst_start() { return sreg_ofst_start() + num_s_regs() * sizeof(jint); } 
+  int stackslot_ofst_start() { return dreg_ofst_start() + num_d_regs() * sizeof(jlong); } 
+
+  int sreg_ofst(int idx) {
+    assert(idx >= 0 && idx < num_s_regs(), "bad sreg index");
+    return sreg_ofst_start() + idx * sizeof(jint);
+  }
+
+  int dreg_ofst(int idx) {
+    assert(idx >= 0 && idx < num_d_regs(), "bad dreg index");
+    return dreg_ofst_start() + idx * sizeof(jlong);
+  }
+
+  int stackslot_ofst(int stackOffset) {
+    assert(stackOffset >= 0 && (unsigned int) stackOffset < num_stack_slots() * sizeof(jlong), "bad stackoffset");
+    return stackslot_ofst_start() + stackOffset;
+  }
+
+  // the _ptr versions just return a pointer to the indicated d reg or stackslot64
+  // some of these are used for oops_do processing
+  jint* get_s_reg_ptr(int idx) {
+    return((jint*) (data_start() + sreg_ofst(idx)));
+  }
+
+  jlong* get_d_reg_ptr(int idx) {
+    return((jlong*) (data_start() + dreg_ofst(idx)));
+  }
+
+  jlong* get_stackslot64_ptr(int stackOffset) {
+    return((jlong*) (data_start() + stackslot_ofst(stackOffset)));
+  }
+
+  jint* get_stackslot32_ptr(int stackOffset) {
+    return((jint*) (data_start() + stackslot_ofst(stackOffset)));
+  }
+
+  void* get_oop_ptr_for_bit(int bit) {
+    void* oop_ptr;
+    if (bit < num_d_regs()) {
+      // d register
+      oop_ptr = (void*) get_d_reg_ptr(bit);
+    } else {
+      // stack slot
+      int stackOffset = (bit - num_d_regs()) * 8;  // 8 bytes per stack slot
+      oop_ptr = (void*) get_stackslot64_ptr(stackOffset);
+    }
+    return oop_ptr;
+  }
+
 public:
   // Accessors
   jint pc_offset() { return _pc_offset; }
   jint num_s_regs() {return _num_s_regs; }
   jint num_d_regs() {return _num_d_regs; }
   jint num_stack_slots() {return _num_stack_slots; }
-  jbyte* data_start() {return (jbyte*) this  + sizeof(*this); }
-  jlong get_d_reg(int idx) {
-    int ofst = num_s_regs() * 4 + idx * 8;
-    return(*(jlong*) (data_start() + ofst));
-  }
-  jint get_s_reg(int idx) {
-    int ofst = idx * 4;
-    return(*(jint*) (data_start() + ofst));
+
+  jlong get_oop_for_bit(int bit) {
+    return * (jlong *) get_oop_ptr_for_bit(bit);
   }
-  void put_d_reg(int idx, jlong val) {
-    int ofst = num_s_regs() * 4 + idx * 8;
-    (*(jlong*) (data_start() + ofst)) = val;
-  }
-  jint get_stackslot32(int stackOffset) {
-    int ofst = num_s_regs() * 4 + num_d_regs() * 8 + stackOffset;
-    return(*(jint*) (data_start() + ofst));
-  }
-  jlong get_stackslot64(int stackOffset) {
-    int ofst = num_s_regs() * 4 + num_d_regs() * 8 + stackOffset;
-    return(*(jlong*) (data_start() + ofst));
-  }
-  void put_stackslot64(int stackOffset, jlong val) {
-    int ofst = num_s_regs() * 4 + num_d_regs() * 8 + stackOffset;
-    (*(jlong*) (data_start() + ofst)) = val;
+    
+  // do the oops from this frame
+  void oops_do(OopClosure* f, HSAILOopMapHelper* oopMapHelper) {
+    int oops_per_deopt = num_d_regs() + num_stack_slots();
+
+    // handle the dregister and stackSlot based oops
+    for (int bit = 0; bit < oops_per_deopt; bit++) {
+      if (oopMapHelper->is_oop(pc_offset(), bit)) {
+        void* oop_ptr = get_oop_ptr_for_bit(bit);
+        // the oops we are dealing with here in the hsailFrame are always uncompressed
+        oop old_oop = oopDesc::load_heap_oop((oop *)oop_ptr);
+        f->do_oop((oop*) oop_ptr);
+        if (TraceGPUInteraction) {
+          oop new_oop = oopDesc::load_heap_oop((oop *)oop_ptr);
+          tty->print_cr("bit=%d, oop_ptr=%p, old=%p, new=%p", bit, oop_ptr, (void *)old_oop, (void *)new_oop);
+        }
+      }
+    }
   }
 };