*** old/src/share/vm/compiler/oopMap.cpp	Mon Sep 14 23:13:31 2015
--- new/src/share/vm/compiler/oopMap.cpp	Mon Sep 14 23:13:30 2015

*** 56,66 ****
--- 56,65 ----
    _size = oop_map->count();
    _position = 0;
    _valid_omv = false;
  }
  
  
  void OopMapStream::find_next() {
    while(_position++ < _size) {
      _omv.read_from(_stream);
      if(((int)_omv.type() & _mask) > 0) {
        _valid_omv = true;

*** 154,166 ****
--- 153,163 ----
    set_xxx(reg, OopMapValue::oop_value, VMRegImpl::Bad());
  }
  
  
  void OopMap::set_value(VMReg reg) {
!   // At this time, we only need value entries in our OopMap when ZapDeadCompiledLocals is active.
    if (ZapDeadCompiledLocals)
      set_xxx(reg, OopMapValue::value_value, VMRegImpl::Bad());
!   // At this time, we don't need value entries in our OopMap.
  }
  
  
  void OopMap::set_narrowoop(VMReg reg) {
    set_xxx(reg, OopMapValue::narrowoop_value, VMRegImpl::Bad());

*** 197,207 ****
--- 194,203 ----
    memcpy(new_data,om_data(),om_size() * sizeof(OopMap*));
    set_om_size(new_size);
    set_om_data(new_data);
  }
  
  
  void OopMapSet::add_gc_map(int pc_offset, OopMap *map ) {
    assert(om_size() != -1,"Cannot grow a fixed OopMapSet");
  
    if(om_count() >= om_size()) {
      grow_om_data();

*** 343,377 ****
--- 339,377 ----
        // derived pointer table in DerivedPointerTable::add().
        MutexLockerEx x(DerivedPointerTableGC_lock, Mutex::_no_safepoint_check_flag);
        do {
          omv = oms.current();
          oop* loc = fr->oopmapreg_to_location(omv.reg(),reg_map);
          if ( loc != NULL ) {
+         guarantee(loc != NULL, "missing saved register");
          oop *base_loc    = fr->oopmapreg_to_location(omv.content_reg(), reg_map);
          oop *derived_loc = loc;
          oop val = *base_loc;
          if (val == (oop)NULL || Universe::is_narrow_oop_base(val)) {
            // Ignore NULL oops and decoded NULL narrow oops which
            // equal to Universe::narrow_oop_base when a narrow oop
            // implicit null check is used in compiled code.
            // The narrow_oop_base could be NULL or be the address
            // of the page below heap depending on compressed oops mode.
            } else
+         } else {
            derived_oop_fn(base_loc, derived_loc);
          }
          oms.next();
        }  while (!oms.is_done());
      }
    }
  
    // We want coop, value and oop oop_types
-   int mask = OopMapValue::oop_value | OopMapValue::value_value | OopMapValue::narrowoop_value;
    {
      for (OopMapStream oms(map,mask); !oms.is_done(); oms.next()) {
        omv = oms.current();
        oop* loc = fr->oopmapreg_to_location(omv.reg(),reg_map);
        if ( loc != NULL ) {
+       // It should be an error if no location can be found for a
+       // register mentioned as contained an oop of some kind.  Maybe
+       // this was allowed previously because value_value items might
+       // be missing?
+       guarantee(loc != NULL, "missing saved register");
        if ( omv.type() == OopMapValue::oop_value ) {
          oop val = *loc;
          if (val == (oop)NULL || Universe::is_narrow_oop_base(val)) {
            // Ignore NULL oops and decoded NULL narrow oops which
            // equal to Universe::narrow_oop_base when a narrow oop

*** 393,421 ****
--- 393,418 ----
            // do the real assert.
            assert(Universe::heap()->is_in_or_null(*loc), "found non oop pointer");
          }
  #endif // ASSERT
          oop_fn->do_oop(loc);
          } else if ( omv.type() == OopMapValue::value_value ) {
            assert((*loc) == (oop)NULL || !Universe::is_narrow_oop_base(*loc),
                   "found invalid value pointer");
            value_fn->do_oop(loc);
        } else if ( omv.type() == OopMapValue::narrowoop_value ) {
          narrowOop *nl = (narrowOop*)loc;
  #ifndef VM_LITTLE_ENDIAN
            if (!omv.reg()->is_stack()) {
+         VMReg vmReg = omv.reg();
+         // Don't do this on SPARC float registers as they can be individually addressed
+         if (!vmReg->is_stack() SPARC_ONLY(&& !vmReg->is_FloatRegister())) {
            // compressed oops in registers only take up 4 bytes of an
            // 8 byte register but they are in the wrong part of the
            // word so adjust loc to point at the right place.
            nl = (narrowOop*)((address)nl + 4);
          }
  #endif
          oop_fn->do_oop(nl);
        }
      }
    }
    }
  }
  
  
  // Update callee-saved register info for the following frame
  void OopMapSet::update_register_map(const frame *fr, RegisterMap *reg_map) {

*** 483,495 ****
--- 480,489 ----
                           outputStream* st) {
    switch( x ) {
    case OopMapValue::oop_value:
      st->print("Oop");
      break;
    case OopMapValue::value_value:
      st->print("Value");
      break;
    case OopMapValue::narrowoop_value:
      st->print("NarrowOop");
      break;
    case OopMapValue::callee_saved_value:
      st->print("Callers_");