|
0
|
1 /*
|
|
|
2 * Copyright 1998-2006 Sun Microsystems, Inc. All Rights Reserved.
|
|
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
|
4 *
|
|
|
5 * This code is free software; you can redistribute it and/or modify it
|
|
|
6 * under the terms of the GNU General Public License version 2 only, as
|
|
|
7 * published by the Free Software Foundation.
|
|
|
8 *
|
|
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT
|
|
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
12 * version 2 for more details (a copy is included in the LICENSE file that
|
|
|
13 * accompanied this code).
|
|
|
14 *
|
|
|
15 * You should have received a copy of the GNU General Public License version
|
|
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
|
|
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
18 *
|
|
|
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
|
21 * have any questions.
|
|
|
22 *
|
|
|
23 */
|
|
|
24
|
|
|
25 // The verifier class
|
|
|
26 class Verifier : AllStatic {
|
|
|
27 public:
|
|
|
28 enum { STACKMAP_ATTRIBUTE_MAJOR_VERSION = 50 };
|
|
|
29 typedef enum { ThrowException, NoException } Mode;
|
|
|
30
|
|
|
31 /**
|
|
|
32 * Verify the bytecodes for a class. If 'throw_exception' is true
|
|
|
33 * then the appropriate VerifyError or ClassFormatError will be thrown.
|
|
|
34 * Otherwise, no exception is thrown and the return indicates the
|
|
|
35 * error.
|
|
|
36 */
|
|
|
37 static bool verify(instanceKlassHandle klass, Mode mode, TRAPS);
|
|
|
38
|
|
|
39 // Return false if the class is loaded by the bootstrap loader.
|
|
|
40 static bool should_verify_for(oop class_loader);
|
|
|
41
|
|
|
42 // Relax certain verifier checks to enable some broken 1.1 apps to run on 1.2.
|
|
|
43 static bool relax_verify_for(oop class_loader);
|
|
|
44
|
|
|
45 private:
|
|
|
46 static bool is_eligible_for_verification(instanceKlassHandle klass);
|
|
|
47 static symbolHandle inference_verify(
|
|
|
48 instanceKlassHandle klass, char* msg, size_t msg_len, TRAPS);
|
|
|
49 };
|
|
|
50
|
|
|
51 class RawBytecodeStream;
|
|
|
52 class StackMapFrame;
|
|
|
53 class StackMapTable;
|
|
|
54
|
|
|
55 // Summary of verifier's memory usage:
|
|
|
56 // StackMapTable is stack allocated.
|
|
|
57 // StackMapFrame are resource allocated. There is one ResourceMark
|
|
|
58 // for each method.
|
|
|
59 // There is one mutable StackMapFrame (current_frame) which is updated
|
|
|
60 // by abstract bytecode interpretation. frame_in_exception_handler() returns
|
|
|
61 // a frame that has a mutable one-item stack (ready for pushing the
|
|
|
62 // catch type exception object). All the other StackMapFrame's
|
|
|
63 // are immutable (including their locals and stack arrays) after
|
|
|
64 // their constructions.
|
|
|
65 // locals/stack arrays in StackMapFrame are resource allocated.
|
|
|
66 // locals/stack arrays can be shared between StackMapFrame's, except
|
|
|
67 // the mutable StackMapFrame (current_frame).
|
|
|
68 // Care needs to be taken to make sure resource objects don't outlive
|
|
|
69 // the lifetime of their ResourceMark.
|
|
|
70
|
|
|
71 // These macros are used similarly to CHECK macros but also check
|
|
|
72 // the status of the verifier and return if that has an error.
|
|
|
73 #define CHECK_VERIFY(verifier) \
|
|
|
74 CHECK); if ((verifier)->has_error()) return; (0
|
|
|
75 #define CHECK_VERIFY_(verifier, result) \
|
|
|
76 CHECK_(result)); if ((verifier)->has_error()) return (result); (0
|
|
|
77
|
|
|
78 // A new instance of this class is created for each class being verified
|
|
|
79 class ClassVerifier : public StackObj {
|
|
|
80 private:
|
|
|
81 Thread* _thread;
|
|
|
82 symbolHandle _exception_type;
|
|
|
83 char* _message;
|
|
|
84 size_t _message_buffer_len;
|
|
|
85
|
|
|
86 void verify_method(methodHandle method, TRAPS);
|
|
|
87 char* generate_code_data(methodHandle m, u4 code_length, TRAPS);
|
|
|
88 void verify_exception_handler_table(u4 code_length, char* code_data, int& min, int& max, TRAPS);
|
|
|
89 void verify_local_variable_table(u4 code_length, char* code_data, TRAPS);
|
|
|
90
|
|
|
91 VerificationType cp_ref_index_to_type(
|
|
|
92 int index, constantPoolHandle cp, TRAPS) {
|
|
|
93 return cp_index_to_type(cp->klass_ref_index_at(index), cp, THREAD);
|
|
|
94 }
|
|
|
95
|
|
|
96 bool is_protected_access(
|
|
|
97 instanceKlassHandle this_class, klassOop target_class,
|
|
|
98 symbolOop field_name, symbolOop field_sig, bool is_method);
|
|
|
99
|
|
|
100 void verify_cp_index(constantPoolHandle cp, int index, TRAPS);
|
|
|
101 void verify_cp_type(
|
|
|
102 int index, constantPoolHandle cp, unsigned int types, TRAPS);
|
|
|
103 void verify_cp_class_type(int index, constantPoolHandle cp, TRAPS);
|
|
|
104
|
|
|
105 u2 verify_stackmap_table(
|
|
|
106 u2 stackmap_index, u2 bci, StackMapFrame* current_frame,
|
|
|
107 StackMapTable* stackmap_table, bool no_control_flow, TRAPS);
|
|
|
108
|
|
|
109 void verify_exception_handler_targets(
|
|
|
110 u2 bci, bool this_uninit, StackMapFrame* current_frame,
|
|
|
111 StackMapTable* stackmap_table, TRAPS);
|
|
|
112
|
|
|
113 void verify_ldc(
|
|
|
114 int opcode, u2 index, StackMapFrame *current_frame,
|
|
|
115 constantPoolHandle cp, u2 bci, TRAPS);
|
|
|
116
|
|
|
117 void verify_switch(
|
|
|
118 RawBytecodeStream* bcs, u4 code_length, char* code_data,
|
|
|
119 StackMapFrame* current_frame, StackMapTable* stackmap_table, TRAPS);
|
|
|
120
|
|
|
121 void verify_field_instructions(
|
|
|
122 RawBytecodeStream* bcs, StackMapFrame* current_frame,
|
|
|
123 constantPoolHandle cp, TRAPS);
|
|
|
124
|
|
|
125 void verify_invoke_init(
|
|
|
126 RawBytecodeStream* bcs, VerificationType ref_class_type,
|
|
|
127 StackMapFrame* current_frame, u4 code_length, bool* this_uninit,
|
|
|
128 constantPoolHandle cp, TRAPS);
|
|
|
129
|
|
|
130 void verify_invoke_instructions(
|
|
|
131 RawBytecodeStream* bcs, u4 code_length, StackMapFrame* current_frame,
|
|
|
132 bool* this_uninit, VerificationType return_type,
|
|
|
133 constantPoolHandle cp, TRAPS);
|
|
|
134
|
|
|
135 VerificationType get_newarray_type(u2 index, u2 bci, TRAPS);
|
|
|
136 void verify_anewarray(
|
|
|
137 u2 index, constantPoolHandle cp, StackMapFrame* current_frame, TRAPS);
|
|
|
138 void verify_return_value(
|
|
|
139 VerificationType return_type, VerificationType type, u2 offset, TRAPS);
|
|
|
140
|
|
|
141 void verify_iload (u2 index, StackMapFrame* current_frame, TRAPS);
|
|
|
142 void verify_lload (u2 index, StackMapFrame* current_frame, TRAPS);
|
|
|
143 void verify_fload (u2 index, StackMapFrame* current_frame, TRAPS);
|
|
|
144 void verify_dload (u2 index, StackMapFrame* current_frame, TRAPS);
|
|
|
145 void verify_aload (u2 index, StackMapFrame* current_frame, TRAPS);
|
|
|
146 void verify_istore(u2 index, StackMapFrame* current_frame, TRAPS);
|
|
|
147 void verify_lstore(u2 index, StackMapFrame* current_frame, TRAPS);
|
|
|
148 void verify_fstore(u2 index, StackMapFrame* current_frame, TRAPS);
|
|
|
149 void verify_dstore(u2 index, StackMapFrame* current_frame, TRAPS);
|
|
|
150 void verify_astore(u2 index, StackMapFrame* current_frame, TRAPS);
|
|
|
151 void verify_iinc (u2 index, StackMapFrame* current_frame, TRAPS);
|
|
|
152
|
|
|
153 bool name_in_supers(symbolOop ref_name, instanceKlassHandle current);
|
|
|
154
|
|
|
155 instanceKlassHandle _klass; // the class being verified
|
|
|
156 methodHandle _method; // current method being verified
|
|
|
157 VerificationType _this_type; // the verification type of the current class
|
|
|
158
|
|
|
159 public:
|
|
|
160 enum {
|
|
|
161 BYTECODE_OFFSET = 1,
|
|
|
162 NEW_OFFSET = 2
|
|
|
163 };
|
|
|
164
|
|
|
165 // constructor
|
|
|
166 ClassVerifier(instanceKlassHandle klass, char* msg, size_t msg_len, TRAPS);
|
|
|
167
|
|
|
168 // destructor
|
|
|
169 ~ClassVerifier();
|
|
|
170
|
|
|
171 Thread* thread() { return _thread; }
|
|
|
172 methodHandle method() { return _method; }
|
|
|
173 instanceKlassHandle current_class() const { return _klass; }
|
|
|
174 VerificationType current_type() const { return _this_type; }
|
|
|
175
|
|
|
176 // Verifies the class. If a verify or class file format error occurs,
|
|
|
177 // the '_exception_name' symbols will set to the exception name and
|
|
|
178 // the message_buffer will be filled in with the exception message.
|
|
|
179 void verify_class(TRAPS);
|
|
|
180
|
|
|
181 // Return status modes
|
|
|
182 symbolHandle result() const { return _exception_type; }
|
|
|
183 bool has_error() const { return !(result().is_null()); }
|
|
|
184
|
|
|
185 // Called when verify or class format errors are encountered.
|
|
|
186 // May throw an exception based upon the mode.
|
|
|
187 void verify_error(u2 offset, const char* fmt, ...);
|
|
|
188 void verify_error(const char* fmt, ...);
|
|
|
189 void class_format_error(const char* fmt, ...);
|
|
|
190 void format_error_message(const char* fmt, int offset, va_list args);
|
|
|
191
|
|
|
192 klassOop load_class(symbolHandle name, TRAPS);
|
|
|
193
|
|
|
194 int change_sig_to_verificationType(
|
|
|
195 SignatureStream* sig_type, VerificationType* inference_type, TRAPS);
|
|
|
196
|
|
|
197 VerificationType cp_index_to_type(int index, constantPoolHandle cp, TRAPS) {
|
|
|
198 return VerificationType::reference_type(
|
|
|
199 symbolHandle(THREAD, cp->klass_name_at(index)));
|
|
|
200 }
|
|
|
201
|
|
|
202 static bool _verify_verbose; // for debugging
|
|
|
203 };
|
|
|
204
|
|
|
205 inline int ClassVerifier::change_sig_to_verificationType(
|
|
|
206 SignatureStream* sig_type, VerificationType* inference_type, TRAPS) {
|
|
|
207 BasicType bt = sig_type->type();
|
|
|
208 switch (bt) {
|
|
|
209 case T_OBJECT:
|
|
|
210 case T_ARRAY:
|
|
|
211 {
|
|
|
212 symbolOop name = sig_type->as_symbol(CHECK_0);
|
|
|
213 *inference_type =
|
|
|
214 VerificationType::reference_type(symbolHandle(THREAD, name));
|
|
|
215 return 1;
|
|
|
216 }
|
|
|
217 case T_LONG:
|
|
|
218 *inference_type = VerificationType::long_type();
|
|
|
219 *++inference_type = VerificationType::long2_type();
|
|
|
220 return 2;
|
|
|
221 case T_DOUBLE:
|
|
|
222 *inference_type = VerificationType::double_type();
|
|
|
223 *++inference_type = VerificationType::double2_type();
|
|
|
224 return 2;
|
|
|
225 case T_INT:
|
|
|
226 case T_BOOLEAN:
|
|
|
227 case T_BYTE:
|
|
|
228 case T_CHAR:
|
|
|
229 case T_SHORT:
|
|
|
230 *inference_type = VerificationType::integer_type();
|
|
|
231 return 1;
|
|
|
232 case T_FLOAT:
|
|
|
233 *inference_type = VerificationType::float_type();
|
|
|
234 return 1;
|
|
|
235 default:
|
|
|
236 ShouldNotReachHere();
|
|
|
237 return 1;
|
|
|
238 }
|
|
|
239 }
|
