int AbstractInterpreter::BasicType_as_index(BasicType type) {
int i = 0; switch (type) { case T_BOOLEAN: i = 0; break; case T_CHAR : i = 1; break; case T_BYTE : i = 2; break; case T_SHORT : i = 3; break; case T_INT : i = 4; break; case T_LONG : i = 5; break; case T_VOID : i = 6; break; case T_FLOAT : i = 7; break; case T_DOUBLE : i = 8; break; case T_OBJECT : i = 9; break; case T_ARRAY : i = 9; break; default : ShouldNotReachHere();
}
assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers, "index out of bounds"); return i;
}
// How much stack a method activation needs in stack slots. // We must calc this exactly like in generate_fixed_frame. // Note: This returns the conservative size assuming maximum alignment.
int AbstractInterpreter::size_top_interpreter_activation(Method* method) { const int max_alignment_size = 2; const int abi_scratch = frame::abi_reg_args_size; return method->max_locals() + method->max_stack() +
frame::interpreter_frame_monitor_size() + max_alignment_size + abi_scratch;
}
// Returns number of stackElementWords needed for the interpreter frame with the // given sections. // This overestimates the stack by one slot in case of alignments.
int AbstractInterpreter::size_activation(int max_stack,
int temps,
int extra_args,
int monitors,
int callee_params,
int callee_locals, bool is_top_frame) { // Note: This calculation must exactly parallel the frame setup // in TemplateInterpreterGenerator::generate_fixed_frame.
assert(Interpreter::stackElementWords == 1, "sanity"); const int max_alignment_space = StackAlignmentInBytes / Interpreter::stackElementSize; const int abi_scratch = is_top_frame ? (frame::abi_reg_args_size / Interpreter::stackElementSize) :
(frame::abi_minframe_size / Interpreter::stackElementSize); const int size =
max_stack +
(callee_locals - callee_params) +
monitors * frame::interpreter_frame_monitor_size() +
max_alignment_space +
abi_scratch +
frame::ijava_state_size / Interpreter::stackElementSize;
// Fixed size of an interpreter frame, align to 16-byte. return (size & -2);
}
// Fills a sceletal interpreter frame generated during deoptimizations. // // Parameters: // // interpreter_frame != NULL: // set up the method, locals, and monitors. // The frame interpreter_frame, if not NULL, is guaranteed to be the // right size, as determined by a previous call to this method. // It is also guaranteed to be walkable even though it is in a skeletal state // // is_top_frame == true: // We're processing the *oldest* interpreter frame! // // pop_frame_extra_args: // If this is != 0 we are returning to a deoptimized frame by popping // off the callee frame. We want to re-execute the call that called the // callee interpreted, but since the return to the interpreter would pop // the arguments off advance the esp by dummy popframe_extra_args slots. // Popping off those will establish the stack layout as it was before the call. // void AbstractInterpreter::layout_activation(Method* method,
int tempcount,
int popframe_extra_args,
int moncount,
int caller_actual_parameters,
int callee_param_count,
int callee_locals_count,
frame* caller,
frame* interpreter_frame, bool is_top_frame, bool is_bottom_frame) {
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
