< prev index next >
src/share/vm/classfile/verifier.hpp
Print this page
rev 4131 : 8014431: cleanup warnings indicated by the -Wunused-value compiler option on linux
8015265: revise the fix for 8007037
Reviewed-by: sspitsyn, dholmes, dcubed, coleenp
Contributed-by: jeremymanson@google.com, calvin.cheung@oracle.com
rev 4134 : 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
Summary: Change constMethodOop::_exception_table to optionally inlined u2 table.
Reviewed-by: bdelsart, coleenp, kamg
rev 4136 : 7116786: RFE: Detailed information on VerifyErrors
Summary: Provide additional detail in VerifyError messages
Reviewed-by: sspitsyn, acorn
*** 1,7 ****
/*
! * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
--- 1,7 ----
/*
! * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*** 83,108 ****
// the mutable StackMapFrame (current_frame).
// These macros are used similarly to CHECK macros but also check
// the status of the verifier and return if that has an error.
#define CHECK_VERIFY(verifier) \
! CHECK); if ((verifier)->has_error()) return; (0
#define CHECK_VERIFY_(verifier, result) \
! CHECK_(result)); if ((verifier)->has_error()) return (result); (0
// A new instance of this class is created for each class being verified
class ClassVerifier : public StackObj {
private:
Thread* _thread;
Symbol* _exception_type;
char* _message;
! size_t _message_buffer_len;
! GrowableArray<Symbol*>* _symbols; // keep a list of symbols created
void verify_method(methodHandle method, TRAPS);
char* generate_code_data(methodHandle m, u4 code_length, TRAPS);
! void verify_exception_handler_table(u4 code_length, char* code_data, int& min, int& max, TRAPS);
void verify_local_variable_table(u4 code_length, char* code_data, TRAPS);
VerificationType cp_ref_index_to_type(
int index, constantPoolHandle cp, TRAPS) {
return cp_index_to_type(cp->klass_ref_index_at(index), cp, THREAD);
--- 83,268 ----
// the mutable StackMapFrame (current_frame).
// These macros are used similarly to CHECK macros but also check
// the status of the verifier and return if that has an error.
#define CHECK_VERIFY(verifier) \
! CHECK); if ((verifier)->has_error()) return; ((void)0
#define CHECK_VERIFY_(verifier, result) \
! CHECK_(result)); if ((verifier)->has_error()) return (result); ((void)0
!
! class TypeOrigin VALUE_OBJ_CLASS_SPEC {
! private:
! typedef enum {
! CF_LOCALS, // Comes from the current frame locals
! CF_STACK, // Comes from the current frame expression stack
! SM_LOCALS, // Comes from stackmap locals
! SM_STACK, // Comes from stackmap expression stack
! CONST_POOL, // Comes from the constant pool
! SIG, // Comes from method signature
! IMPLICIT, // Comes implicitly from code or context
! BAD_INDEX, // No type, but the index is bad
! FRAME_ONLY, // No type, context just contains the frame
! NONE
! } Origin;
!
! Origin _origin;
! u2 _index; // local, stack, or constant pool index
! StackMapFrame* _frame; // source frame if CF or SM
! VerificationType _type; // The actual type
!
! TypeOrigin(
! Origin origin, u2 index, StackMapFrame* frame, VerificationType type)
! : _origin(origin), _index(index), _frame(frame), _type(type) {}
!
! public:
! TypeOrigin() : _origin(NONE), _index(0), _frame(NULL) {}
!
! static TypeOrigin null();
! static TypeOrigin local(u2 index, StackMapFrame* frame);
! static TypeOrigin stack(u2 index, StackMapFrame* frame);
! static TypeOrigin sm_local(u2 index, StackMapFrame* frame);
! static TypeOrigin sm_stack(u2 index, StackMapFrame* frame);
! static TypeOrigin cp(u2 index, VerificationType vt);
! static TypeOrigin signature(VerificationType vt);
! static TypeOrigin bad_index(u2 index);
! static TypeOrigin implicit(VerificationType t);
! static TypeOrigin frame(StackMapFrame* frame);
!
! void reset_frame();
! void details(outputStream* ss) const;
! void print_frame(outputStream* ss) const;
! const StackMapFrame* frame() const { return _frame; }
! bool is_valid() const { return _origin != NONE; }
! u2 index() const { return _index; }
!
! #ifdef ASSERT
! void print_on(outputStream* str) const;
! #endif
! };
!
! class ErrorContext VALUE_OBJ_CLASS_SPEC {
! private:
! typedef enum {
! INVALID_BYTECODE, // There was a problem with the bytecode
! WRONG_TYPE, // Type value was not as expected
! FLAGS_MISMATCH, // Frame flags are not assignable
! BAD_CP_INDEX, // Invalid constant pool index
! BAD_LOCAL_INDEX, // Invalid local index
! LOCALS_SIZE_MISMATCH, // Frames have differing local counts
! STACK_SIZE_MISMATCH, // Frames have different stack sizes
! STACK_OVERFLOW, // Attempt to push onto a full expression stack
! STACK_UNDERFLOW, // Attempt to pop and empty expression stack
! MISSING_STACKMAP, // No stackmap for this location and there should be
! BAD_STACKMAP, // Format error in stackmap
! NO_FAULT, // No error
! UNKNOWN
! } FaultType;
!
! int _bci;
! FaultType _fault;
! TypeOrigin _type;
! TypeOrigin _expected;
!
! ErrorContext(int bci, FaultType fault) :
! _bci(bci), _fault(fault) {}
! ErrorContext(int bci, FaultType fault, TypeOrigin type) :
! _bci(bci), _fault(fault), _type(type) {}
! ErrorContext(int bci, FaultType fault, TypeOrigin type, TypeOrigin exp) :
! _bci(bci), _fault(fault), _type(type), _expected(exp) {}
!
! public:
! ErrorContext() : _bci(-1), _fault(NO_FAULT) {}
!
! static ErrorContext bad_code(u2 bci) {
! return ErrorContext(bci, INVALID_BYTECODE);
! }
! static ErrorContext bad_type(u2 bci, TypeOrigin type) {
! return ErrorContext(bci, WRONG_TYPE, type);
! }
! static ErrorContext bad_type(u2 bci, TypeOrigin type, TypeOrigin exp) {
! return ErrorContext(bci, WRONG_TYPE, type, exp);
! }
! static ErrorContext bad_flags(u2 bci, StackMapFrame* frame) {
! return ErrorContext(bci, FLAGS_MISMATCH, TypeOrigin::frame(frame));
! }
! static ErrorContext bad_flags(u2 bci, StackMapFrame* cur, StackMapFrame* sm) {
! return ErrorContext(bci, FLAGS_MISMATCH,
! TypeOrigin::frame(cur), TypeOrigin::frame(sm));
! }
! static ErrorContext bad_cp_index(u2 bci, u2 index) {
! return ErrorContext(bci, BAD_CP_INDEX, TypeOrigin::bad_index(index));
! }
! static ErrorContext bad_local_index(u2 bci, u2 index) {
! return ErrorContext(bci, BAD_LOCAL_INDEX, TypeOrigin::bad_index(index));
! }
! static ErrorContext locals_size_mismatch(
! u2 bci, StackMapFrame* frame0, StackMapFrame* frame1) {
! return ErrorContext(bci, LOCALS_SIZE_MISMATCH,
! TypeOrigin::frame(frame0), TypeOrigin::frame(frame1));
! }
! static ErrorContext stack_size_mismatch(
! u2 bci, StackMapFrame* frame0, StackMapFrame* frame1) {
! return ErrorContext(bci, STACK_SIZE_MISMATCH,
! TypeOrigin::frame(frame0), TypeOrigin::frame(frame1));
! }
! static ErrorContext stack_overflow(u2 bci, StackMapFrame* frame) {
! return ErrorContext(bci, STACK_OVERFLOW, TypeOrigin::frame(frame));
! }
! static ErrorContext stack_underflow(u2 bci, StackMapFrame* frame) {
! return ErrorContext(bci, STACK_UNDERFLOW, TypeOrigin::frame(frame));
! }
! static ErrorContext missing_stackmap(u2 bci) {
! return ErrorContext(bci, MISSING_STACKMAP);
! }
! static ErrorContext bad_stackmap(int index, StackMapFrame* frame) {
! return ErrorContext(0, BAD_STACKMAP, TypeOrigin::frame(frame));
! }
!
! bool is_valid() const { return _fault != NO_FAULT; }
! int bci() const { return _bci; }
!
! void reset_frames() {
! _type.reset_frame();
! _expected.reset_frame();
! }
!
! void details(outputStream* ss, methodOop method) const;
!
! #ifdef ASSERT
! void print_on(outputStream* str) const {
! str->print("error_context(%d, %d,", _bci, _fault);
! _type.print_on(str);
! str->print(",");
! _expected.print_on(str);
! str->print(")");
! }
! #endif
!
! private:
! void location_details(outputStream* ss, methodOop method) const;
! void reason_details(outputStream* ss) const;
! void frame_details(outputStream* ss) const;
! void bytecode_details(outputStream* ss, methodOop method) const;
! void handler_details(outputStream* ss, methodOop method) const;
! void stackmap_details(outputStream* ss, methodOop method) const;
! };
// A new instance of this class is created for each class being verified
class ClassVerifier : public StackObj {
private:
Thread* _thread;
+ GrowableArray<Symbol*>* _symbols; // keep a list of symbols created
+
Symbol* _exception_type;
char* _message;
!
! ErrorContext _error_context; // contains information about an error
void verify_method(methodHandle method, TRAPS);
char* generate_code_data(methodHandle m, u4 code_length, TRAPS);
! void verify_exception_handler_table(u4 code_length, char* code_data,
! int& min, int& max, TRAPS);
void verify_local_variable_table(u4 code_length, char* code_data, TRAPS);
VerificationType cp_ref_index_to_type(
int index, constantPoolHandle cp, TRAPS) {
return cp_index_to_type(cp->klass_ref_index_at(index), cp, THREAD);
*** 110,123 ****
bool is_protected_access(
instanceKlassHandle this_class, klassOop target_class,
Symbol* field_name, Symbol* field_sig, bool is_method);
! void verify_cp_index(constantPoolHandle cp, int index, TRAPS);
! void verify_cp_type(
! int index, constantPoolHandle cp, unsigned int types, TRAPS);
! void verify_cp_class_type(int index, constantPoolHandle cp, TRAPS);
u2 verify_stackmap_table(
u2 stackmap_index, u2 bci, StackMapFrame* current_frame,
StackMapTable* stackmap_table, bool no_control_flow, TRAPS);
--- 270,283 ----
bool is_protected_access(
instanceKlassHandle this_class, klassOop target_class,
Symbol* field_name, Symbol* field_sig, bool is_method);
! void verify_cp_index(u2 bci, constantPoolHandle cp, int index, TRAPS);
! void verify_cp_type(u2 bci, int index, constantPoolHandle cp,
! unsigned int types, TRAPS);
! void verify_cp_class_type(u2 bci, int index, constantPoolHandle cp, TRAPS);
u2 verify_stackmap_table(
u2 stackmap_index, u2 bci, StackMapFrame* current_frame,
StackMapTable* stackmap_table, bool no_control_flow, TRAPS);
*** 136,170 ****
void verify_field_instructions(
RawBytecodeStream* bcs, StackMapFrame* current_frame,
constantPoolHandle cp, TRAPS);
void verify_invoke_init(
! RawBytecodeStream* bcs, VerificationType ref_class_type,
StackMapFrame* current_frame, u4 code_length, bool in_try_block,
bool* this_uninit, constantPoolHandle cp, StackMapTable* stackmap_table,
TRAPS);
// Used by ends_in_athrow() to push all handlers that contain bci onto
// the handler_stack, if the handler is not already on the stack.
! void push_handlers(typeArrayHandle exhandlers,
GrowableArray<u4>* handler_stack,
u4 bci);
// Returns true if all paths starting with start_bc_offset end in athrow
// bytecode or loop.
! bool ends_in_athrow(u4 start_bc_offset, TRAPS);
void verify_invoke_instructions(
RawBytecodeStream* bcs, u4 code_length, StackMapFrame* current_frame,
bool in_try_block, bool* this_uninit, VerificationType return_type,
constantPoolHandle cp, StackMapTable* stackmap_table, TRAPS);
VerificationType get_newarray_type(u2 index, u2 bci, TRAPS);
! void verify_anewarray(
! u2 index, constantPoolHandle cp, StackMapFrame* current_frame, TRAPS);
void verify_return_value(
! VerificationType return_type, VerificationType type, u2 offset, TRAPS);
void verify_iload (u2 index, StackMapFrame* current_frame, TRAPS);
void verify_lload (u2 index, StackMapFrame* current_frame, TRAPS);
void verify_fload (u2 index, StackMapFrame* current_frame, TRAPS);
void verify_dload (u2 index, StackMapFrame* current_frame, TRAPS);
--- 296,331 ----
void verify_field_instructions(
RawBytecodeStream* bcs, StackMapFrame* current_frame,
constantPoolHandle cp, TRAPS);
void verify_invoke_init(
! RawBytecodeStream* bcs, u2 ref_index, VerificationType ref_class_type,
StackMapFrame* current_frame, u4 code_length, bool in_try_block,
bool* this_uninit, constantPoolHandle cp, StackMapTable* stackmap_table,
TRAPS);
// Used by ends_in_athrow() to push all handlers that contain bci onto
// the handler_stack, if the handler is not already on the stack.
! void push_handlers(ExceptionTable* exhandlers,
GrowableArray<u4>* handler_stack,
u4 bci);
// Returns true if all paths starting with start_bc_offset end in athrow
// bytecode or loop.
! bool ends_in_athrow(u4 start_bc_offset);
void verify_invoke_instructions(
RawBytecodeStream* bcs, u4 code_length, StackMapFrame* current_frame,
bool in_try_block, bool* this_uninit, VerificationType return_type,
constantPoolHandle cp, StackMapTable* stackmap_table, TRAPS);
VerificationType get_newarray_type(u2 index, u2 bci, TRAPS);
! void verify_anewarray(u2 bci, u2 index, constantPoolHandle cp,
! StackMapFrame* current_frame, TRAPS);
void verify_return_value(
! VerificationType return_type, VerificationType type, u2 offset,
! StackMapFrame* current_frame, TRAPS);
void verify_iload (u2 index, StackMapFrame* current_frame, TRAPS);
void verify_lload (u2 index, StackMapFrame* current_frame, TRAPS);
void verify_fload (u2 index, StackMapFrame* current_frame, TRAPS);
void verify_dload (u2 index, StackMapFrame* current_frame, TRAPS);
*** 199,209 ****
BYTECODE_OFFSET = 1,
NEW_OFFSET = 2
};
// constructor
! ClassVerifier(instanceKlassHandle klass, char* msg, size_t msg_len, TRAPS);
// destructor
~ClassVerifier();
Thread* thread() { return _thread; }
--- 360,370 ----
BYTECODE_OFFSET = 1,
NEW_OFFSET = 2
};
// constructor
! ClassVerifier(instanceKlassHandle klass, TRAPS);
// destructor
~ClassVerifier();
Thread* thread() { return _thread; }
*** 217,233 ****
void verify_class(TRAPS);
// Return status modes
Symbol* result() const { return _exception_type; }
bool has_error() const { return result() != NULL; }
// Called when verify or class format errors are encountered.
// May throw an exception based upon the mode.
! void verify_error(u2 offset, const char* fmt, ...);
! void verify_error(const char* fmt, ...);
void class_format_error(const char* fmt, ...);
- void format_error_message(const char* fmt, int offset, va_list args);
klassOop load_class(Symbol* name, TRAPS);
int change_sig_to_verificationType(
SignatureStream* sig_type, VerificationType* inference_type, TRAPS);
--- 378,398 ----
void verify_class(TRAPS);
// Return status modes
Symbol* result() const { return _exception_type; }
bool has_error() const { return result() != NULL; }
+ char* exception_message() {
+ stringStream ss;
+ ss.print(_message);
+ _error_context.details(&ss, _method());
+ return ss.as_string();
+ }
// Called when verify or class format errors are encountered.
// May throw an exception based upon the mode.
! void verify_error(ErrorContext ctx, const char* fmt, ...);
void class_format_error(const char* fmt, ...);
klassOop load_class(Symbol* name, TRAPS);
int change_sig_to_verificationType(
SignatureStream* sig_type, VerificationType* inference_type, TRAPS);
*** 238,251 ****
// Keep a list of temporary symbols created during verification because
// their reference counts need to be decrememented when the verifier object
// goes out of scope. Since these symbols escape the scope in which they're
// created, we can't use a TempNewSymbol.
! Symbol* create_temporary_symbol(const Symbol* s, int begin, int end, TRAPS);
Symbol* create_temporary_symbol(const char *s, int length, TRAPS);
! static bool _verify_verbose; // for debugging
};
inline int ClassVerifier::change_sig_to_verificationType(
SignatureStream* sig_type, VerificationType* inference_type, TRAPS) {
--- 403,417 ----
// Keep a list of temporary symbols created during verification because
// their reference counts need to be decrememented when the verifier object
// goes out of scope. Since these symbols escape the scope in which they're
// created, we can't use a TempNewSymbol.
! Symbol* create_temporary_symbol(
! const Symbol* s, int begin, int end, TRAPS);
Symbol* create_temporary_symbol(const char *s, int length, TRAPS);
! TypeOrigin ref_ctx(const char* str, TRAPS);
};
inline int ClassVerifier::change_sig_to_verificationType(
SignatureStream* sig_type, VerificationType* inference_type, TRAPS) {
< prev index next >