// Print this EntryActivation and all other EntryActivation's that follow it.
void EntryActivation::print_list_on(Stream* st, int indent, int index) {
#if USE_DEBUG_PRINTING
int last_indent = st->indentation();
st->set_indentation(indent);
st->indent();
st->print("[%d] ", index);
Method m = method();
m.print_value_on(st);
st->cr();
for (int i = 0; i < length(); i++) {
st->indent();
st->print(" ");
switch(tag_at(i)) {
case float_tag:
st->print("(float) %f", jvm_f2d(float_at(i)));
break;
case double_tag:
st->print("(double) %d", double_at(i));
i++;
break;
case long_tag:
st->print("(long) ");
st->print(OsMisc_jlong_format_specifier(), long_at(i));
i++;
break;
case obj_tag:
{
st->print("(obj) ");
Oop obj = obj_at(i);
obj.print_value_on(st);
}
break;
case int_tag:
st->print("(int) %d", int_at(i));
break;
default:
SHOULD_NOT_REACH_HERE();
}
st->cr();
}
EntryActivation mynext = next();
if (mynext.not_null()) {
mynext.print_list_on(st, indent, index+1);
}
st->set_indentation(last_indent);
#endif
}
RawLocation::Actions
RawLocation::do_conform_to(int my_index, RawLocation* other, int other_index,
RawLocation::Actions allowed_actions) {
// make sure object registers and locations have object values
if (other->stack_type() == T_OBJECT && stack_type() != T_OBJECT) {
// Conformance code makes it so that this is no longer necessary.
SHOULD_NOT_REACH_HERE();
#if NOT_CURRENTLY_USED
// if we clear an cached object location there's no need to clear
// any registers, since the register cache (due to type conflicts) is
// guaranteed never to be used again
if (other.is_flushed() || other.is_cached()) {
code_generator()->clear_object_location(index());
} else {
GUARANTEE(other.is_changed(), "only case left");
Value other_value(other.type());
other.read_value(other_value);
Oop::Raw null_obj;
code_generator()->move(other_value, &null_obj);
}
return;
#endif
}
// compute the merge action
const Actions required_actions = merge_actions(other);
const Actions actions = required_actions & allowed_actions;
// handle loads/stores from/to locations
if (actions & LOC_LOAD) {
other->update_cache(other_index);
}
if (actions & LOC_STORE) {
write_changes(my_index);
}
// handle register stores
if (actions & REG_STORE && other->in_register()) {
// declare & read values for both source and destination
const Value this_value (this, my_index );
const Value other_value(other, other_index);
// do the register store
if (!other->is_register_identical_to(my_index, this, other_index)) {
code_generator()->move(other_value, this_value);
}
}
return required_actions & ~allowed_actions;
}
/*
* We can't run the VM in the main thread (because it has to handle events).
* So we run the VM in this thread.
*/
static DWORD WINAPI vm_thread_routine(LPVOID lpvParam) {
// Print arguments that we are using
JVMSPI_PrintRaw("Running VM");
JVMSPI_PrintRaw("\n");
for (int i = 1; i < _argc; i++) {
JVMSPI_PrintRaw(" ");
JVMSPI_PrintRaw(_argv[i]);
JVMSPI_PrintRaw("\n");
}
// Call this before any other Jvm_ functions.
JVM_Initialize();
int argc = _argc;
char ** argv = _argv;
// Ignore arg[0] -- the name of the program.
argc --;
argv ++;
while (true) {
int n = JVM_ParseOneArg(argc, argv);
if (n < 0) {
JVMSPI_DisplayUsage(NULL);
return -1;
} else if (n == 0) {
break;
}
argc -= n;
argv += n;
}
if (LogConsole) {
write_console("Console output logged at \n");
write_console(logfilename);
write_console("\n");
for (int index=0; index<_argc; index++) {
log_console(_argv[index]);
log_console(" ");
}
log_console("\n");
}
if (!WriteConsole) {
write_console("On-screen console output disabled.\n");
}
int code = JVM_Start(NULL, NULL, argc, argv);
JVMSPI_Exit(code);
SHOULD_NOT_REACH_HERE();
return 0;
}
void SourceAssembler::beg_segment(Segment *segment, SegmentType segment_type) {
GUARANTEE(_segment == NULL, "no nested segments");
_segment = segment;
int segment_number = 1;
GUARANTEE(segment_type != no_segment, "must specify segment");
if (_segment_type != segment_type) {
if (!GenerateSDTCode && !GenerateGNUCode && !GenerateMicrosoftCode) {
// Generating code for ADS or RVCT. Need to add PRESERVE8
// if we're building for RVCT 2.0 or later
stream()->print_cr("\tIF {ARMASM_VERSION} >= 200000");
stream()->print_cr("\tPRESERVE8");
stream()->print_cr("\tENDIF");
}
_segment_type = segment_type; // Since this controls the stream() below
switch (segment_type) {
case code_segment:
if (GenerateSDTCode) {
stream()->print_cr("\tAREA |.text%d|, CODE", segment_number++);
} else {
stream()->print_cr(GenerateGNUCode? ".text":"\tAREA |.text|, CODE");
}
break;
case data_segment:
if (GenerateSDTCode) {
stream()->print_cr("\tAREA |.data%d|, DATA", segment_number++);
} else if (GenerateGNUCode) {
stream()->print_cr(".data");
} else {
stream()->print_cr("\tAREA |.data|, DATA");
}
break;
case bss_segment:
if (GenerateSDTCode) {
stream()->print_cr("\tAREA |.data%d|, DATA", segment_number++);
} else {
stream()->print_cr(GenerateGNUCode ? ".bss":"\tAREA |.data|, DATA");
}
break;
case gp_segment:
break;
default:
SHOULD_NOT_REACH_HERE();
}
}
}
void TypeArrayClass::print_type_on(Stream* st) {
#if USE_DEBUG_PRINTING
switch(type()) {
case T_BOOLEAN: st->print("Bool"); break;
case T_CHAR: st->print("Char"); break;
case T_FLOAT: st->print("Float"); break;
case T_DOUBLE: st->print("Double"); break;
case T_BYTE: st->print("Byte"); break;
case T_SHORT: st->print("Short"); break;
case T_INT: st->print("Int"); break;
case T_LONG: st->print("Long"); break;
default: SHOULD_NOT_REACH_HERE();
}
#endif
}
void MemoryAddress::fill_in_address_register() {
// In all cases exception for variable arrays indices, we are looking at
// at fixed offset into the object.
jint fixed_offset;
if (has_fixed_offset(fixed_offset)) {
code_generator()->mov(address_register(), fixed_offset + base_offset());
code_generator()->add(address_register(), fixed_register(),
address_register());
set_address_register_includes_base_offset();
} else {
// This is a virtual method, and in this case, we better be calling
// an overriding definition.
SHOULD_NOT_REACH_HERE();
}
}
void Value::set_immediate_from_static_field(InstanceClass* ic, int offset) {
TypeArray::Raw f = ic->fields();
Oop::Raw object;
for (int index = 0; index < f().length(); index += 5) {
Field static_field(ic, index);
if (static_field.offset() == offset) {
// Note: there may be a non-static field with the same 'offset'
// as the static field we're trying to find.
if (static_field.is_final() && static_field.is_static()) {
switch (static_field.type()) {
case T_BOOLEAN : // fall-through - stored as 32-bit
case T_CHAR : // fall-through - stored as 32-bit
case T_BYTE : // fall-through - stored as 32-bit
case T_SHORT : // fall-through - stored as 32-bit
case T_INT : set_int(ic->int_field(offset)); break;
case T_ARRAY : // fall-through
case T_OBJECT :
// Note: if setting immediate for object fields is enabled for cross
// generator, this reference will be written to the TEXT block as a
// part of relocation information for the compiled method. The
// problem is that the referenced object may be put to the HEAP
// block and it would be impossible to write its reference
// in the TEXT block. At this point we don't know the block type of
// the referenced object, so for now we disable setting immediate
// for cross generator.
if (!USE_AOT_COMPILATION || !GenerateROMImage) {
object = ic->obj_field(offset);
set_obj(&object);
}
break;
#if ENABLE_FLOAT
case T_FLOAT : set_float(ic->float_field(offset)); break;
case T_DOUBLE : set_double(ic->double_field(offset)); break;
#endif
case T_LONG : set_long(ic->long_field(offset)); break;
default : SHOULD_NOT_REACH_HERE(); break;
}
}
return;
}
}
// This field is not final and was removed from the fields array
// during romization
}
void Thread::start_lightweight_thread() {
Thread* thread = Thread::current();
// idea here is that some threads can't be terminated
// by throwing an uncatchable exceptions if they're in 'just started'
// state (i.e. never executed), as this exception will be silently ignored
// by shared_entry(), thus we have to check thread status before
// actual execution of pending entries, and null them out,
// if thread is terminating
if (thread->is_terminating()) {
Oop::Raw null;
thread->set_pending_entries(&null);
} else {
invoke_pending_entries(thread);
}
if (!Universe::is_stopping() && !TestCompiler) {
if (CURRENT_HAS_PENDING_EXCEPTION) {
call_on_primordial_stack(lightweight_thread_uncaught_exception);
}
call_on_primordial_stack(finish);
invoke_pending_entries(thread);
// Just in case the append_pending_entry() failed inside
// Thread::finish()
force_terminated(thread);
#if ENABLE_ISOLATES
#if !ARM && !HITACHI_SH
{
call_on_primordial_stack(thread_task_cleanup);
invoke_pending_entries(thread);
}
#endif
#endif
}
// The following returns to another Java thread, unless this is
// the only remaining Java thread.
call_on_primordial_stack(lightweight_thread_exit);
// We can only return here if we are the last thread.
// Running on the Java stack at this point, no handles please
GUARANTEE(Scheduler::get_next_runnable_thread()->is_null(),
"Must be last thread");
// Back to C land
current_thread_to_primordial();
SHOULD_NOT_REACH_HERE();
}
void EventLogger::dump(Stream *s) {
jlong freq = Os::elapsed_frequency();
bool use_usec = (freq > 100 * 1000);
if (use_usec) {
s->print(" msec");
} else {
s->print(" msec");
}
s->print_cr(" hrtick event");
s->print_cr("=======================================");
jlong last_hrticks = 0;
for (LogEntryBlock *blk = _head; blk; blk = blk->_next) {
for (int i=0; i<blk->_used_count; i++) {
LogEntry *entry = &blk->_entries[i];
const char *name = "??";
switch (entry->_type) {
EVENT_LOGGER_TYPES_DO(CASE_OF_EVENT_LOGGER_TYPE);
default:
SHOULD_NOT_REACH_HERE();
break;
}
jlong time = last_hrticks + entry->_hrtick_delta;
jlong usec = time * 1000 * 1000 / freq;
jlong msec = usec / 1000;
usec = usec % 1000;
last_hrticks = time;
s->print("%6d", (jint)msec);
if (use_usec) {
s->print(".");
if (usec < 100) {
s->print("0");
}
if (usec < 10) {
s->print("0");
}
s->print("%d", usec);
}
s->print_cr(" %8d %s", (jint)time, name);
}
s->print_cr("=======================================");
}
}
void check_static(int index JVM_TRAPS) {
ConstantPool::Raw cp = method()->constants();
if (cp().tag_at(index).is_resolved_static_method()) {
Method m = cp().resolved_static_method_at(index);
_owner->add_method(&m JVM_NO_CHECK_AT_BOTTOM);
} else {
// This could be an element we failed to resolve
// when ROMizing an application.
if (!PostponeErrorsUntilRuntime) {
SHOULD_NOT_REACH_HERE();
} else {
GUARANTEE(cp().tag_at(index).is_method(), "Sanity");
// The class must be marked as unverified or non-optimizable,
// since it contains an unresolved entry at this point.
#ifdef AZZERT
InstanceClass klass = method()->holder();
GUARANTEE(!klass.is_verified() || !klass.is_optimizable(),
"Sanity");
#endif
}
}
}
void check_static(int index) {
AllocationDisabler no_allocation_should_happen;
ConstantPool::Raw cp = method()->constants();
if (cp().tag_at(index).is_resolved_static_method()) {
Method::Raw callee = cp().resolved_static_method_at(index);
_owner->try_inline(method(), &callee, bci());
} else {
// This could be an element we failed to resolve
// when ROMizing an application.
if (!PostponeErrorsUntilRuntime) {
SHOULD_NOT_REACH_HERE();
} else {
GUARANTEE(cp().tag_at(index).is_method(), "Sanity");
// The class must be marked as unverified or non-optimizable,
// since it contains an unresolved entry at this point.
#ifdef AZZERT
InstanceClass::Raw klass = method()->holder();
GUARANTEE(!klass().is_verified() || !klass().is_optimizable(), "Sanity");
#endif
}
}
}
void CompiledMethodDesc::set_cache_index ( const int i ) {
const size_t non_index_mask = ~CompiledMethodDesc::INDEX_MASK;
const size_t bits_and_size = _flags_and_size & non_index_mask;
_flags_and_size = bits_and_size |
(size_t(i)<<CompiledMethodDesc::NUMBER_OF_NON_INDEX_BITS);
// Patch the "strb gp, [gp, #xxxx]" instruction. It does not appear
// at a fixed location because of code scheduling.
juint* index_loc = (juint*) (this+1);
#ifdef AZZERT
juint* index_end = index_loc + 10; // we might have debug code at the
// beginning of the compiled method prolog
#else
juint* index_end = index_loc + 3;
#endif
const juint opcode =
(juint)Assembler::always << 28 | 1 << 26 | 1 << 22 | Assembler::gp << 12;
const juint addressing = 3 << 23 | Assembler::gp << 16;
const juint pattern = opcode | addressing;
const juint mask = 0xfffff000;
for (; index_loc < index_end; index_loc++) {
juint instr = *index_loc & mask;
if (instr == pattern) {
*index_loc = instr |
(i + (address(_method_execution_sensor) - address(&gp_base_label)));
return;
}
}
SHOULD_NOT_REACH_HERE();
// set_cach_index is called before major GC
// The worst that may happen in the rare case when icache is not updated
// is just a minor deviation in statistics.
// OsMisc_flush_icache( (address) index_loc, sizeof *index_loc );
}
SourceAssembler::Condition SourceAssembler::negate_cc(Condition condition) {
switch (condition) {
case equal : return not_equal;
case not_equal : return equal;
case less : return greater_equal;
case less_equal : return greater;
case greater : return less_equal;
case greater_equal : return less;
case below : return above_equal;
case below_equal : return above;
case above : return below_equal;
case above_equal : return below;
case overflow : return no_overflow;
case no_overflow : return overflow;
case negative : return positive;
case positive : return negative;
case parity : return no_parity;
case no_parity : return parity;
}
SHOULD_NOT_REACH_HERE();
return zero;
}
void Value::assign_register() {
if (in_register()) return;
switch(stack_type()) {
case T_OBJECT : // fall through
case T_ARRAY : // fall through
case T_INT : set_register(RegisterAllocator::allocate());
break;
case T_LONG : set_registers(RegisterAllocator::allocate(), RegisterAllocator::allocate());
break;
#if ENABLE_ARM_VFP
case T_FLOAT : set_register(RegisterAllocator::allocate_float_register());
break;
case T_DOUBLE : set_vfp_double_register(RegisterAllocator::allocate_double_register());
break;
#else // !ENABLE_ARM_VFP
case T_FLOAT : // fall through
case T_DOUBLE : set_register(RegisterAllocator::allocate_float_register());
break;
#endif // ENABLE_ARM_VFP
default : SHOULD_NOT_REACH_HERE();
break;
}
}
void SourceAssembler::Label::bind(Stream* s, bool is_global) {
switch(_state) {
case undefined: global(s); break;
case anonymous_unused: /* Fall through */
case anonymous_used: _state = anonymous_bound; break;
case anonymous_bound: SHOULD_NOT_REACH_HERE(); break;
default: break;
}
// start a new line if we are not at the beginning
if (s->position() > 0) {
s->cr();
}
GUARANTEE(s->position() == 0, "wrong label position");
print_on(s);
if (GenerateGNUCode) {
s->print(":");
} else {
if (is_global && !GenerateSDTCode) {
s->print(" PROC");
}
}
s->cr();
}
SHORTARRAY createCharArray(const char *utf8stringArg,
int utf8length,
int *unicodelengthP,
bool_t isPermanent) {
GUARANTEE(_in_kvm_native_method, "sanity");
GUARANTEE(!isPermanent, "Permanent char arrays not supported");
(void)isPermanent;
LiteralStream ls((char*)utf8stringArg, 0, utf8length);
int num_chars = ls.length();
if (num_chars >= 0) {
SETUP_ERROR_CHECKER_ARG;
TypeArray::Raw array = Universe::new_char_array(num_chars JVM_CHECK_0);
for (int i=0; i<num_chars; i++) {
array().char_at_put(i, ls.read());
}
*unicodelengthP = num_chars;
return (SHORTARRAY)(array().obj());
} else {
// Bad UTF8 string in utf8stringArg
SHOULD_NOT_REACH_HERE();
return NULL;
}
}
FarClassDesc(): _instance_size(0) { SHOULD_NOT_REACH_HERE(); }
// generate a map of all the field types in this object
int CompiledMethod::generate_fieldmap(TypeArray* field_map) {
SHOULD_NOT_REACH_HERE();
return 0;
}
char *ConstantTag::name_for(jubyte tag, bool use_prefix) {
const char *result = "???";
switch (tag) {
// Defined by JLS (JvmConst.hpp)
JVM_TAG_CASE(Utf8);
JVM_TAG_CASE(Unicode);
JVM_TAG_CASE(Integer);
JVM_TAG_CASE(Float);
JVM_TAG_CASE(Long);
JVM_TAG_CASE(Double);
JVM_TAG_CASE(Class);
JVM_TAG_CASE(String);
JVM_TAG_CASE(Fieldref);
JVM_TAG_CASE(Methodref);
JVM_TAG_CASE(InterfaceMethodref);
JVM_TAG_CASE(NameAndType);
// Defined by the VM (ConstantTag.hpp)
JVM_TAG_CASE(Invalid);
JVM_TAG_CASE(UnresolvedClass);
JVM_TAG_CASE(ClassIndex);
JVM_TAG_CASE(UnresolvedString);
JVM_TAG_CASE(StringIndex);
JVM_TAG_CASE(ResolvedBooleanFieldref);
JVM_TAG_CASE(ResolvedCharFieldref);
JVM_TAG_CASE(ResolvedFloatFieldref);
JVM_TAG_CASE(ResolvedDoubleFieldref);
JVM_TAG_CASE(ResolvedByteFieldref);
JVM_TAG_CASE(ResolvedShortFieldref);
JVM_TAG_CASE(ResolvedIntFieldref);
JVM_TAG_CASE(ResolvedLongFieldref);
JVM_TAG_CASE(ResolvedObjectFieldref);
JVM_TAG_CASE(ResolvedArrayFieldref);
JVM_TAG_CASE(ResolvedStaticBooleanFieldref);
JVM_TAG_CASE(ResolvedStaticCharFieldref);
JVM_TAG_CASE(ResolvedStaticFloatFieldref);
JVM_TAG_CASE(ResolvedStaticDoubleFieldref);
JVM_TAG_CASE(ResolvedStaticByteFieldref);
JVM_TAG_CASE(ResolvedStaticShortFieldref);
JVM_TAG_CASE(ResolvedStaticIntFieldref);
JVM_TAG_CASE(ResolvedStaticLongFieldref);
JVM_TAG_CASE(ResolvedStaticObjectFieldref);
JVM_TAG_CASE(ResolvedStaticArrayFieldref);
JVM_TAG_CASE(ResolvedStaticMethod);
JVM_TAG_CASE(ResolvedBooleanVirtualMethod);
JVM_TAG_CASE(ResolvedCharVirtualMethod);
JVM_TAG_CASE(ResolvedFloatVirtualMethod);
JVM_TAG_CASE(ResolvedDoubleVirtualMethod);
JVM_TAG_CASE(ResolvedByteVirtualMethod);
JVM_TAG_CASE(ResolvedShortVirtualMethod);
JVM_TAG_CASE(ResolvedIntVirtualMethod);
JVM_TAG_CASE(ResolvedLongVirtualMethod);
JVM_TAG_CASE(ResolvedObjectVirtualMethod);
JVM_TAG_CASE(ResolvedArrayVirtualMethod);
JVM_TAG_CASE(ResolvedVoidVirtualMethod);
JVM_TAG_CASE(ResolvedBooleanInterfaceMethod);
JVM_TAG_CASE(ResolvedCharInterfaceMethod);
JVM_TAG_CASE(ResolvedFloatInterfaceMethod);
JVM_TAG_CASE(ResolvedDoubleInterfaceMethod);
JVM_TAG_CASE(ResolvedByteInterfaceMethod);
JVM_TAG_CASE(ResolvedShortInterfaceMethod);
JVM_TAG_CASE(ResolvedIntInterfaceMethod);
JVM_TAG_CASE(ResolvedLongInterfaceMethod);
JVM_TAG_CASE(ResolvedObjectInterfaceMethod);
JVM_TAG_CASE(ResolvedArrayInterfaceMethod);
JVM_TAG_CASE(ResolvedVoidInterfaceMethod);
JVM_TAG_CASE(ResolvedUncommonInterfaceMethod);
JVM_TAG_CASE(ResolvedFinalUncommonInterfaceMethod);
default:
SHOULD_NOT_REACH_HERE();
}
return (char*)result;
}
void* operator new(size_t /*size*/) {
SHOULD_NOT_REACH_HERE();
return (void *)0;
}
void operator delete(void* /*p*/) {
SHOULD_NOT_REACH_HERE();
}
void Macros::arith_imm(Opcode opcode, Register rd, Register rn, int imm32,
const LiteralAccessor* la, CCMode s, Condition cond) {
GUARANTEE(rd <= r15 && rn <= r15, "Invalid register used");
Address1 result;
if (is_rotated_imm(imm32, result)) {
// Simplest case. We can handle the immediate directly
arith(opcode, rd, rn, result, s, cond);
return;
}
int alt_opcode_type = OpcodeInfo::table[opcode].alt_opcode_type;
int alt_imm32 = alt_opcode_type == alt_NEG ? -imm32 : ~imm32;
Opcode alt_opcode = (Opcode)OpcodeInfo::table[opcode].alt_opcode;
if (alt_opcode_type != alt_NONE && is_rotated_imm(alt_imm32, result)) {
// We can handle the negated/complemented immediate
arith(alt_opcode, rd, rn, result, s, cond);
return;
}
// Is the imm32, or some rotated or shifted form of it already available
if (la != NULL && la->has_literal(imm32, result)) {
arith(opcode, rd, rn, result, s, cond);
return;
}
if (alt_opcode_type != alt_NONE &&
la != NULL && la->has_literal(alt_imm32, result)) {
arith(alt_opcode, rd, rn, result, s, cond);
return;
}
// Let's see if we can split either imm32 or alt_imm32 into two pieces,
// each of which can be represented as an immediate.
if ((rd != pc) && (s == no_CC || opcode <= _eor || opcode >= _orr)) {
// Don't even try if we're setting the pc, or if this is an "arithmetic"
// rather than a logical operation. (For arithmetic operations, the C
// and V bit have meanings that cannot be reproduced by splitting)
if (OpcodeInfo::table[opcode].twoword_allowed) {
if (arith2_imm(opcode, rd, rn, imm32, s, cond)) {
return;
}
}
if (alt_opcode_type != alt_NONE
&& OpcodeInfo::table[alt_opcode].twoword_allowed){
// Can we break up alt_imm32 into two pieces, each an immediate?
if (arith2_imm(alt_opcode, rd, rn, alt_imm32, s, cond)) {
return;
}
}
}
if (opcode == _eor && imm32 == -1) {
// This is the only chance we have of optimizing ~X
mvn(rd, reg(rn), s, cond);
return;
}
if (opcode == _mov) {
ldr_big_integer(rd, imm32, cond);
return;
}
// We include the (opcode != _mov) below, even though it isn't necessary,
// since on the XScale we may want to get of the preceding clause.
if (opcode != _mov) {
Register tmp = (la != NULL) ? la->get_literal(imm32) : Assembler::no_reg;
if (tmp != no_reg) {
GUARANTEE(rn != tmp, "register must be different");
arith(opcode, rd, rn, reg(tmp), s, cond);
la->free_literal();
return;
}
}
// We are desperate. We are clearly in some test suite situation that
// is purposely generating a large immediate when that shouldn't
// normally happen. Let's just deal with it
if ((rd != pc) && (s == no_CC || opcode <= _eor || opcode >= _orr)) {
if (OpcodeInfo::table[opcode].twoword_allowed) {
arith4_imm(opcode, rd, rn, imm32, s, cond);
return;
}
if (alt_opcode_type != alt_NONE &&
OpcodeInfo::table[alt_opcode].twoword_allowed){
arith4_imm(alt_opcode, rd, rn, alt_imm32, s, cond);
return;
}
}
SHOULD_NOT_REACH_HERE();
}
void BytecodeClosure::illegal_code(JVM_SINGLE_ARG_TRAPS) {
JVM_IGNORE_TRAPS;
SHOULD_NOT_REACH_HERE();
}
