C++ StubCodeDesc::name方法代码示例

void CodeBlobCollector::collect() {   
  assert_locked_or_safepoint(CodeCache_lock);
  assert(_global_code_blobs == NULL, "checking");

  // create the global list
  _global_code_blobs = new (ResourceObj::C_HEAP) GrowableArray<JvmtiCodeBlobDesc*>(50,true);

  // iterate over the stub code descriptors and put them in the list first.
  int index = 0;
  StubCodeDesc* desc;
  while ((desc = StubCodeDesc::desc_for_index(++index)) != NULL) {   
    _global_code_blobs->append(new JvmtiCodeBlobDesc(desc->name(), desc->begin(), desc->end()));
  }

  // next iterate over all the non-nmethod code blobs and add them to
  // the list - as noted above this will filter out duplicates and
  // enclosing blobs.
  Unimplemented();
  //CodeCache::blobs_do(do_blob);

  // make the global list the instance list so that it can be used
  // for other iterations.
  _code_blobs = _global_code_blobs;
  _global_code_blobs = NULL;
}  

void CodeBlobCollector::collect() {
  assert_locked_or_safepoint(CodeCache_lock);
  assert(_global_code_blobs == NULL, "checking");

  // create the global list
  _global_code_blobs = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<JvmtiCodeBlobDesc*>(50,true);

  // iterate over the stub code descriptors and put them in the list first.
  for (StubCodeDesc* desc = StubCodeDesc::first(); desc != NULL; desc = StubCodeDesc::next(desc)) {
    _global_code_blobs->append(new JvmtiCodeBlobDesc(desc->name(), desc->begin(), desc->end()));
  }

  // Vtable stubs are not described with StubCodeDesc,
  // process them separately
  VtableStubs::vtable_stub_do(do_vtable_stub);

  // next iterate over all the non-nmethod code blobs and add them to
  // the list - as noted above this will filter out duplicates and
  // enclosing blobs.
  CodeCache::blobs_do(do_blob);

  // make the global list the instance list so that it can be used
  // for other iterations.
  _code_blobs = _global_code_blobs;
  _global_code_blobs = NULL;
}

void i486_env::print_label(intptr_t value) {
  address adr = (address) value;
  if (StubRoutines::contains(adr)) {
    StubCodeDesc* desc = StubCodeDesc::desc_for(adr);
    const char * desc_name = "unknown stub";
    if (desc != NULL) {
      desc_name = desc->name();
    }
    output->print("Stub::%s", desc_name);
    if (WizardMode) output->print(" " INTPTR_FORMAT, value);
  } else {
    output->print(INTPTR_FORMAT, value); 
  }
}

void sparc_env::print_address(address adr, outputStream* st) {
  if (StubRoutines::contains(adr)) {
    StubCodeDesc *desc = StubCodeDesc::desc_for(adr);
    if (desc == NULL)
      desc = StubCodeDesc::desc_for(adr + frame::pc_return_offset);
    if (desc == NULL)
      st->print("Unknown stub at " INTPTR_FORMAT, adr);
    else {
      st->print("Stub::%s", desc->name());
      if (desc->begin() != adr)
	st->print("%+d 0x%p",adr - desc->begin(), adr);
      else if (WizardMode) st->print(" " INTPTR_FORMAT, adr);
    }
  } else {
    BarrierSet* bs = Universe::heap()->barrier_set();
    if (bs->kind() == BarrierSet::CardTableModRef &&
	adr == (address)((CardTableModRefBS*)(bs))->byte_map_base) {
      st->print("word_map_base");
      if (WizardMode) st->print(" " INTPTR_FORMAT, (intptr_t)adr);
    } else {
      st->print(INTPTR_FORMAT, (intptr_t)adr); 
    }
  }
}

// --- oops_arguments_do -----------------------------------------------------
// oops-do just for arguments when args are passed but the caller is
// not yet claiming responsibility for them (e.g., mid-call resolution).
void CodeBlob::oops_arguments_do(frame fr, OopClosure* f) const {

  // Native calls have all their args handlized.
  if( _type == native ) return;

  // C1 and C2 can call directly into the C++ runtime without a stub but these
  // calls all do not need their arguments GC'd (i.e., by the time a GC point
  // is reached all arguments get handlized).
  if( _type == c1 || _type == c2 ) return;

  guarantee( _type == runtime_stubs, "we only get here for runtime stubs" );

  StubCodeDesc *stub = StubCodeDesc::desc_for(fr.pc());
  Runtime1::StubID id = Runtime1::contains(fr.pc());
  // In a resolve_and_patch_call stub, we have to parse the outgoing signature
  // to find any argument oops.  The call site itself doesn't cover the
  // outgoing oops, and there is no target method yet.
  if( fr.pc() == CodeCache::_caller_must_gc_args_0 ||
      fr.pc() == CodeCache::_caller_must_gc_args_1 ) {
    assert0( (stub && !strcmp(stub->name(), "resolve_and_patch_handler")) ||
             id == Runtime1::frequency_counter_overflow_wrapper_id);
    oops_arguments_do_impl(fr,f);
    return;
  }

  // Assert sanity for stub-generator stubs
  if( stub ) {
    if( !strcmp(stub->name(), "sba_escape_handler") ) return; // no unhandled args from a failed STA/SVB
    if( !strcmp(stub->name(), "new_handler") ) return; // no unhandled args from a new allocation request
    // If we are at an inline-cache we need to construct an official j.l.NPE
    // object.  However, no oops are in callee-save registers and the caller's
    // args are dead because the call isn't happening.  (If we are not at an
    // inline-cache then we just reset the PC to the proper handler and do not
    // do any object construction).
    if( !strcmp(stub->name(), "handler_for_null_ptr_exception") ) return;
    // If we are throwing, then the callers args are long long gone.
    if( !strcmp(stub->name(), "forward_exception") ) return;
    // For safepoints, we generously allow any register to hold oops.
    if( !strcmp(stub->name(), "safepoint_handler") ) return;
    // The args for a blocking lock will be handlerized in the VM
    if( !strcmp(stub->name(), "blocking_lock_stub") ) return;
    // The args for registering a finalized object will be handlerized in the VM
    if( !strcmp(stub->name(), "register_finalizer") ) return;
    // The args for a blocking lock will be handlerized in the VM
    // There are no args saved in registers across an uncommon trap
    if( !strcmp(stub->name(), "deoptimize") ) return;
    if( !strcmp(stub->name(), "uncommon_trap") ) return;
    ShouldNotReachHere();
  }

  // Not a StubGenerator stub; check for sane C1 stubs
  if (id != -1) {
    switch(id) {
    case Runtime1::access_field_patching_id:        return;
    case Runtime1::load_klass_patching_id:          return;
    case Runtime1::monitorenter_id:                 return;
    case Runtime1::new_array_id:                    return;
    case Runtime1::new_instance_id:                 return;
    case Runtime1::new_multi_array_id:              return;
    case Runtime1::register_finalizer_id:           return;
    case Runtime1::throw_array_store_exception_id:  return;
    case Runtime1::throw_class_cast_exception_id:   return;
    case Runtime1::throw_div0_exception_id:         return;
    case Runtime1::throw_index_exception_id:        return;
    case Runtime1::throw_null_pointer_exception_id: return;
    case Runtime1::throw_range_check_failed_id:     return;
    default: tty->print_cr("Unimplemented Runtime1 stub ID %s (%d)", Runtime1::name_for(id), id); Unimplemented();
    }
  }

  // Probably most other stubs are simple returns, but a few need special handling.
  ShouldNotReachHere();
}

const char* StubCodeDesc::name_for(address pc) {
  StubCodeDesc* p = desc_for(pc);
  return p == NULL ? NULL : p->name();
}