// Inform CodeBuffer that incoming code and relocation will be for stubs address AbstractAssembler::start_a_stub(int required_space) { CodeBuffer* cb = code(); CodeSection* cs = cb->stubs(); assert(_code_section == cb->insts(), "not in insts?"); if (cs->maybe_expand_to_ensure_remaining(required_space) && cb->blob() == NULL) { return NULL; } set_code_section(cs); return pc(); }
AbstractAssembler::AbstractAssembler(CodeBuffer* code) { if (code == NULL) return; CodeSection* cs = code->insts(); cs->clear_mark(); // new assembler kills old mark if (cs->start() == NULL) { vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "CodeCache: no room for %s", code->name()); } _code_section = cs; _oop_recorder= code->oop_recorder(); DEBUG_ONLY( _short_branch_delta = 0; ) }
AbstractAssembler::AbstractAssembler(CodeBuffer* code) { if (code == NULL) return; CodeSection* cs = code->insts(); cs->clear_mark(); // new assembler kills old mark _code_section = cs; _code_begin = cs->start(); _code_limit = cs->limit(); _code_pos = cs->end(); _oop_recorder= code->oop_recorder(); if (_code_begin == NULL) { vm_exit_out_of_memory1(0, "CodeCache: no room for %s", code->name()); } }
// Inform CodeBuffer that incoming code and relocation will be for stubs address AbstractAssembler::start_a_const(int required_space, int required_align) { CodeBuffer* cb = code(); CodeSection* cs = cb->consts(); assert(_code_section == cb->insts() || _code_section == cb->stubs(), "not in insts/stubs?"); address end = cs->end(); int pad = -(intptr_t)end & (required_align-1); if (cs->maybe_expand_to_ensure_remaining(pad + required_space)) { if (cb->blob() == NULL) return NULL; end = cs->end(); // refresh pointer } if (pad > 0) { while (--pad >= 0) { *end++ = 0; } cs->set_end(end); } set_code_section(cs); return end; }
void Label::patch_instructions(MacroAssembler* masm) { assert(is_bound(), "Label is bound"); CodeBuffer* cb = masm->code(); int target_sect = CodeBuffer::locator_sect(loc()); address target = cb->locator_address(loc()); while (_patch_index > 0) { --_patch_index; int branch_loc; if (_patch_index >= PatchCacheSize) { branch_loc = _patch_overflow->pop(); } else { branch_loc = _patches[_patch_index]; } int branch_sect = CodeBuffer::locator_sect(branch_loc); address branch = cb->locator_address(branch_loc); if (branch_sect == CodeBuffer::SECT_CONSTS) { // The thing to patch is a constant word. *(address*)branch = target; continue; } #ifdef ASSERT // Cross-section branches only work if the // intermediate section boundaries are frozen. if (target_sect != branch_sect) { for (int n = MIN2(target_sect, branch_sect), nlimit = (target_sect + branch_sect) - n; n < nlimit; n++) { CodeSection* cs = cb->code_section(n); assert(cs->is_frozen(), "cross-section branch needs stable offsets"); } } #endif //ASSERT // Push the target offset into the branch instruction. masm->pd_patch_instruction(branch, target); } }
void LIR_Assembler::check_codespace() { CodeSection* cs = _masm->code_section(); if (cs->remaining() < (int)(NOT_LP64(1*K)LP64_ONLY(2*K))) { BAILOUT("CodeBuffer overflow"); } }
inline void AbstractAssembler::sync() { CodeSection* cs = code_section(); guarantee(cs->start() == _code_begin, "must not shift code buffer"); cs->set_end(_code_pos); }
void CodeBuffer::finalize_oop_references(methodHandle mh) { No_Safepoint_Verifier nsv; GrowableArray<oop> oops; // Make sure that immediate metadata records something in the OopRecorder for (int n = (int) SECT_FIRST; n < (int) SECT_LIMIT; n++) { // pull code out of each section CodeSection* cs = code_section(n); if (cs->is_empty()) continue; // skip trivial section RelocIterator iter(cs); while (iter.next()) { if (iter.type() == relocInfo::metadata_type) { metadata_Relocation* md = iter.metadata_reloc(); if (md->metadata_is_immediate()) { Metadata* m = md->metadata_value(); if (oop_recorder()->is_real(m)) { if (m->is_methodData()) { m = ((MethodData*)m)->method(); } if (m->is_method()) { m = ((Method*)m)->method_holder(); } if (m->is_klass()) { append_oop_references(&oops, (Klass*)m); } else { // XXX This will currently occur for MDO which don't // have a backpointer. This has to be fixed later. m->print(); ShouldNotReachHere(); } } } } } } if (!oop_recorder()->is_unused()) { for (int i = 0; i < oop_recorder()->metadata_count(); i++) { Metadata* m = oop_recorder()->metadata_at(i); if (oop_recorder()->is_real(m)) { if (m->is_methodData()) { m = ((MethodData*)m)->method(); } if (m->is_method()) { m = ((Method*)m)->method_holder(); } if (m->is_klass()) { append_oop_references(&oops, (Klass*)m); } else { m->print(); ShouldNotReachHere(); } } } } // Add the class loader of Method* for the nmethod itself append_oop_references(&oops, mh->method_holder()); // Add any oops that we've found Thread* thread = Thread::current(); for (int i = 0; i < oops.length(); i++) { oop_recorder()->find_index((jobject)thread->handle_area()->allocate_handle(oops.at(i))); } }