Mercurial > hg > graal-compiler
comparison src/share/vm/runtime/signature.hpp @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | 98cb887364d3 |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a61af66fc99e |
---|---|
1 /* | |
2 * Copyright 1997-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 // SignatureIterators iterate over a Java signature (or parts of it). | |
26 // (Syntax according to: "The Java Virtual Machine Specification" by | |
27 // Tim Lindholm & Frank Yellin; section 4.3 Descriptors; p. 89ff.) | |
28 // | |
29 // Example: Iterating over ([Lfoo;D)I using | |
30 // 0123456789 | |
31 // | |
32 // iterate_parameters() calls: do_array(2, 7); do_double(); | |
33 // iterate_returntype() calls: do_int(); | |
34 // iterate() calls: do_array(2, 7); do_double(); do_int(); | |
35 // | |
36 // is_return_type() is: false ; false ; true | |
37 // | |
38 // NOTE: The new optimizer has an alternate, for-loop based signature | |
39 // iterator implemented in opto/type.cpp, TypeTuple::make(). | |
40 | |
41 class SignatureIterator: public ResourceObj { | |
42 protected: | |
43 symbolHandle _signature; // the signature to iterate over | |
44 int _index; // the current character index (only valid during iteration) | |
45 int _parameter_index; // the current parameter index (0 outside iteration phase) | |
46 BasicType _return_type; | |
47 | |
48 void expect(char c); | |
49 void skip_optional_size(); | |
50 int parse_type(); // returns the parameter size in words (0 for void) | |
51 void check_signature_end(); | |
52 | |
53 public: | |
54 // Definitions used in generating and iterating the | |
55 // bit field form of the signature generated by the | |
56 // Fingerprinter. | |
57 enum { | |
58 static_feature_size = 1, | |
59 result_feature_size = 4, | |
60 result_feature_mask = 0xF, | |
61 parameter_feature_size = 4, | |
62 parameter_feature_mask = 0xF, | |
63 | |
64 bool_parm = 1, | |
65 byte_parm = 2, | |
66 char_parm = 3, | |
67 short_parm = 4, | |
68 int_parm = 5, | |
69 long_parm = 6, | |
70 float_parm = 7, | |
71 double_parm = 8, | |
72 obj_parm = 9, | |
73 done_parm = 10, // marker for end of parameters | |
74 | |
75 // max parameters is wordsize minus | |
76 // The sign bit, termination field, the result and static bit fields | |
77 max_size_of_parameters = (BitsPerLong-1 - | |
78 result_feature_size - parameter_feature_size - | |
79 static_feature_size) / parameter_feature_size | |
80 }; | |
81 | |
82 // Constructors | |
83 SignatureIterator(symbolOop signature); | |
84 SignatureIterator(Thread *thread, symbolOop signature); | |
85 SignatureIterator(symbolHandle signature); | |
86 | |
87 // Iteration | |
88 void dispatch_field(); // dispatches once for field signatures | |
89 void iterate_parameters(); // iterates over parameters only | |
90 void iterate_parameters( uint64_t fingerprint ); | |
91 void iterate_returntype(); // iterates over returntype only | |
92 void iterate(); // iterates over whole signature | |
93 // Returns the word index of the current parameter; | |
94 int parameter_index() const { return _parameter_index; } | |
95 bool is_return_type() const { return parameter_index() < 0; } | |
96 BasicType get_ret_type() const { return _return_type; } | |
97 | |
98 // Basic types | |
99 virtual void do_bool () = 0; | |
100 virtual void do_char () = 0; | |
101 virtual void do_float () = 0; | |
102 virtual void do_double() = 0; | |
103 virtual void do_byte () = 0; | |
104 virtual void do_short () = 0; | |
105 virtual void do_int () = 0; | |
106 virtual void do_long () = 0; | |
107 virtual void do_void () = 0; | |
108 | |
109 // Object types (begin indexes the first character of the entry, end indexes the first character after the entry) | |
110 virtual void do_object(int begin, int end) = 0; | |
111 virtual void do_array (int begin, int end) = 0; | |
112 }; | |
113 | |
114 | |
115 // Specialized SignatureIterators: Used to compute signature specific values. | |
116 | |
117 class SignatureTypeNames : public SignatureIterator { | |
118 protected: | |
119 virtual void type_name(const char* name) = 0; | |
120 | |
121 void do_bool() { type_name("jboolean"); } | |
122 void do_char() { type_name("jchar" ); } | |
123 void do_float() { type_name("jfloat" ); } | |
124 void do_double() { type_name("jdouble" ); } | |
125 void do_byte() { type_name("jbyte" ); } | |
126 void do_short() { type_name("jshort" ); } | |
127 void do_int() { type_name("jint" ); } | |
128 void do_long() { type_name("jlong" ); } | |
129 void do_void() { type_name("void" ); } | |
130 void do_object(int begin, int end) { type_name("jobject" ); } | |
131 void do_array (int begin, int end) { type_name("jobject" ); } | |
132 | |
133 public: | |
134 SignatureTypeNames(symbolHandle signature) : SignatureIterator(signature) {} | |
135 }; | |
136 | |
137 | |
138 class SignatureInfo: public SignatureIterator { | |
139 protected: | |
140 bool _has_iterated; // need this because iterate cannot be called in constructor (set is virtual!) | |
141 bool _has_iterated_return; | |
142 int _size; | |
143 | |
144 void lazy_iterate_parameters() { if (!_has_iterated) { iterate_parameters(); _has_iterated = true; } } | |
145 void lazy_iterate_return() { if (!_has_iterated_return) { iterate_returntype(); _has_iterated_return = true; } } | |
146 | |
147 virtual void set(int size, BasicType type) = 0; | |
148 | |
149 void do_bool () { set(T_BOOLEAN_size, T_BOOLEAN); } | |
150 void do_char () { set(T_CHAR_size , T_CHAR ); } | |
151 void do_float () { set(T_FLOAT_size , T_FLOAT ); } | |
152 void do_double() { set(T_DOUBLE_size , T_DOUBLE ); } | |
153 void do_byte () { set(T_BYTE_size , T_BYTE ); } | |
154 void do_short () { set(T_SHORT_size , T_SHORT ); } | |
155 void do_int () { set(T_INT_size , T_INT ); } | |
156 void do_long () { set(T_LONG_size , T_LONG ); } | |
157 void do_void () { set(T_VOID_size , T_VOID ); } | |
158 void do_object(int begin, int end) { set(T_OBJECT_size , T_OBJECT ); } | |
159 void do_array (int begin, int end) { set(T_ARRAY_size , T_ARRAY ); } | |
160 | |
161 public: | |
162 SignatureInfo(symbolHandle signature) : SignatureIterator(signature) { | |
163 _has_iterated = _has_iterated_return = false; | |
164 _size = 0; | |
165 _return_type = T_ILLEGAL; | |
166 } | |
167 | |
168 }; | |
169 | |
170 | |
171 // Specialized SignatureIterator: Used to compute the argument size. | |
172 | |
173 class ArgumentSizeComputer: public SignatureInfo { | |
174 private: | |
175 void set(int size, BasicType type) { _size += size; } | |
176 public: | |
177 ArgumentSizeComputer(symbolHandle signature) : SignatureInfo(signature) {} | |
178 | |
179 int size() { lazy_iterate_parameters(); return _size; } | |
180 }; | |
181 | |
182 | |
183 class ArgumentCount: public SignatureInfo { | |
184 private: | |
185 void set(int size, BasicType type) { _size ++; } | |
186 public: | |
187 ArgumentCount(symbolHandle signature) : SignatureInfo(signature) {} | |
188 | |
189 int size() { lazy_iterate_parameters(); return _size; } | |
190 }; | |
191 | |
192 | |
193 // Specialized SignatureIterator: Used to compute the result type. | |
194 | |
195 class ResultTypeFinder: public SignatureInfo { | |
196 private: | |
197 void set(int size, BasicType type) { _return_type = type; } | |
198 public: | |
199 BasicType type() { lazy_iterate_return(); return _return_type; } | |
200 | |
201 ResultTypeFinder(symbolHandle signature) : SignatureInfo(signature) {} | |
202 }; | |
203 | |
204 | |
205 // Fingerprinter computes a unique ID for a given method. The ID | |
206 // is a bitvector characterizing the methods signature (incl. the receiver). | |
207 class Fingerprinter: public SignatureIterator { | |
208 private: | |
209 uint64_t _fingerprint; | |
210 int _shift_count; | |
211 methodHandle mh; | |
212 | |
213 public: | |
214 | |
215 void do_bool() { _fingerprint |= (((uint64_t)bool_parm) << _shift_count); _shift_count += parameter_feature_size; } | |
216 void do_char() { _fingerprint |= (((uint64_t)char_parm) << _shift_count); _shift_count += parameter_feature_size; } | |
217 void do_byte() { _fingerprint |= (((uint64_t)byte_parm) << _shift_count); _shift_count += parameter_feature_size; } | |
218 void do_short() { _fingerprint |= (((uint64_t)short_parm) << _shift_count); _shift_count += parameter_feature_size; } | |
219 void do_int() { _fingerprint |= (((uint64_t)int_parm) << _shift_count); _shift_count += parameter_feature_size; } | |
220 void do_long() { _fingerprint |= (((uint64_t)long_parm) << _shift_count); _shift_count += parameter_feature_size; } | |
221 void do_float() { _fingerprint |= (((uint64_t)float_parm) << _shift_count); _shift_count += parameter_feature_size; } | |
222 void do_double() { _fingerprint |= (((uint64_t)double_parm) << _shift_count); _shift_count += parameter_feature_size; } | |
223 | |
224 void do_object(int begin, int end) { _fingerprint |= (((uint64_t)obj_parm) << _shift_count); _shift_count += parameter_feature_size; } | |
225 void do_array (int begin, int end) { _fingerprint |= (((uint64_t)obj_parm) << _shift_count); _shift_count += parameter_feature_size; } | |
226 | |
227 void do_void() { ShouldNotReachHere(); } | |
228 | |
229 Fingerprinter(methodHandle method) : SignatureIterator(method->signature()) { | |
230 mh = method; | |
231 _fingerprint = 0; | |
232 } | |
233 | |
234 Fingerprinter(Thread *thread, methodHandle method) : SignatureIterator(thread, method->signature()) { | |
235 mh = method; | |
236 _fingerprint = 0; | |
237 } | |
238 | |
239 uint64_t fingerprint() { | |
240 // See if we fingerprinted this method already | |
241 if (mh->constMethod()->fingerprint() != CONST64(0)) { | |
242 return mh->constMethod()->fingerprint(); | |
243 } | |
244 | |
245 if (mh->size_of_parameters() > max_size_of_parameters ) { | |
246 _fingerprint = UCONST64(-1); | |
247 mh->constMethod()->set_fingerprint(_fingerprint); | |
248 return _fingerprint; | |
249 } | |
250 | |
251 assert( (int)mh->result_type() <= (int)result_feature_mask, "bad result type"); | |
252 _fingerprint = mh->result_type(); | |
253 _fingerprint <<= static_feature_size; | |
254 if (mh->is_static()) _fingerprint |= 1; | |
255 _shift_count = result_feature_size + static_feature_size; | |
256 iterate_parameters(); | |
257 _fingerprint |= ((uint64_t)done_parm) << _shift_count;// mark end of sig | |
258 mh->constMethod()->set_fingerprint(_fingerprint); | |
259 return _fingerprint; | |
260 } | |
261 }; | |
262 | |
263 | |
264 // Specialized SignatureIterator: Used for native call purposes | |
265 | |
266 class NativeSignatureIterator: public SignatureIterator { | |
267 private: | |
268 methodHandle _method; | |
269 // We need seperate JNI and Java offset values because in 64 bit mode, | |
270 // the argument offsets are not in sync with the Java stack. | |
271 // For example a long takes up 1 "C" stack entry but 2 Java stack entries. | |
272 int _offset; // The java stack offset | |
273 int _prepended; // number of prepended JNI parameters (1 JNIEnv, plus 1 mirror if static) | |
274 int _jni_offset; // the current parameter offset, starting with 0 | |
275 | |
276 void do_bool () { pass_int(); _jni_offset++; _offset++; } | |
277 void do_char () { pass_int(); _jni_offset++; _offset++; } | |
278 #ifdef _LP64 | |
279 void do_float () { pass_float(); _jni_offset++; _offset++; } | |
280 void do_double() { pass_double(); _jni_offset++; _offset += 2; } | |
281 #else | |
282 void do_float () { pass_int(); _jni_offset++; _offset++; } | |
283 void do_double() { pass_double(); _jni_offset += 2; _offset += 2; } | |
284 #endif | |
285 void do_byte () { pass_int(); _jni_offset++; _offset++; } | |
286 void do_short () { pass_int(); _jni_offset++; _offset++; } | |
287 void do_int () { pass_int(); _jni_offset++; _offset++; } | |
288 #ifdef _LP64 | |
289 void do_long () { pass_long(); _jni_offset++; _offset += 2; } | |
290 #else | |
291 void do_long () { pass_long(); _jni_offset += 2; _offset += 2; } | |
292 #endif | |
293 void do_void () { ShouldNotReachHere(); } | |
294 void do_object(int begin, int end) { pass_object(); _jni_offset++; _offset++; } | |
295 void do_array (int begin, int end) { pass_object(); _jni_offset++; _offset++; } | |
296 | |
297 public: | |
298 methodHandle method() const { return _method; } | |
299 int offset() const { return _offset; } | |
300 int jni_offset() const { return _jni_offset + _prepended; } | |
301 // int java_offset() const { return method()->size_of_parameters() - _offset - 1; } | |
302 bool is_static() const { return method()->is_static(); } | |
303 virtual void pass_int() = 0; | |
304 virtual void pass_long() = 0; | |
305 virtual void pass_object() = 0; | |
306 #ifdef _LP64 | |
307 virtual void pass_float() = 0; | |
308 virtual void pass_double() = 0; | |
309 #else | |
310 virtual void pass_double() { pass_long(); } // may be same as long | |
311 #endif | |
312 | |
313 NativeSignatureIterator(methodHandle method) : SignatureIterator(method->signature()) { | |
314 _method = method; | |
315 _offset = 0; | |
316 _jni_offset = 0; | |
317 | |
318 const int JNIEnv_words = 1; | |
319 const int mirror_words = 1; | |
320 _prepended = !is_static() ? JNIEnv_words : JNIEnv_words + mirror_words; | |
321 } | |
322 | |
323 // iterate() calles the 2 virtual methods according to the following invocation syntax: | |
324 // | |
325 // {pass_int | pass_long | pass_object} | |
326 // | |
327 // Arguments are handled from left to right (receiver first, if any). | |
328 // The offset() values refer to the Java stack offsets but are 0 based and increasing. | |
329 // The java_offset() values count down to 0, and refer to the Java TOS. | |
330 // The jni_offset() values increase from 1 or 2, and refer to C arguments. | |
331 | |
332 void iterate() { iterate(Fingerprinter(method()).fingerprint()); | |
333 } | |
334 | |
335 | |
336 // Optimized path if we have the bitvector form of signature | |
337 void iterate( uint64_t fingerprint ) { | |
338 | |
339 if (!is_static()) { | |
340 // handle receiver (not handled by iterate because not in signature) | |
341 pass_object(); _jni_offset++; _offset++; | |
342 } | |
343 | |
344 SignatureIterator::iterate_parameters( fingerprint ); | |
345 } | |
346 }; | |
347 | |
348 | |
349 // Handy stream for iterating over signature | |
350 | |
351 class SignatureStream : public StackObj { | |
352 private: | |
353 symbolHandle _signature; | |
354 int _begin; | |
355 int _end; | |
356 BasicType _type; | |
357 bool _at_return_type; | |
358 | |
359 public: | |
360 bool at_return_type() const { return _at_return_type; } | |
361 bool is_done() const; | |
362 void next_non_primitive(int t); | |
363 void next() { | |
364 symbolOop sig = _signature(); | |
365 int len = sig->utf8_length(); | |
366 if (_end >= len) { | |
367 _end = len + 1; | |
368 return; | |
369 } | |
370 | |
371 _begin = _end; | |
372 int t = sig->byte_at(_begin); | |
373 switch (t) { | |
374 case 'B': _type = T_BYTE; break; | |
375 case 'C': _type = T_CHAR; break; | |
376 case 'D': _type = T_DOUBLE; break; | |
377 case 'F': _type = T_FLOAT; break; | |
378 case 'I': _type = T_INT; break; | |
379 case 'J': _type = T_LONG; break; | |
380 case 'S': _type = T_SHORT; break; | |
381 case 'Z': _type = T_BOOLEAN; break; | |
382 case 'V': _type = T_VOID; break; | |
383 default : next_non_primitive(t); | |
384 return; | |
385 } | |
386 _end++; | |
387 } | |
388 | |
389 SignatureStream(symbolHandle signature, | |
390 bool is_method = true) : | |
391 _signature(signature), _at_return_type(false) { | |
392 _begin = _end = (is_method ? 1 : 0); // skip first '(' in method signatures | |
393 next(); | |
394 } | |
395 | |
396 bool is_object() const; // True if this argument is an object | |
397 bool is_array() const; // True if this argument is an array | |
398 BasicType type() const { return _type; } | |
399 symbolOop as_symbol(TRAPS); | |
400 | |
401 // return same as_symbol except allocation of new symbols is avoided. | |
402 symbolOop as_symbol_or_null(); | |
403 }; | |
404 | |
405 class SignatureVerifier : public StackObj { | |
406 public: | |
407 // Returns true if the symbol is valid method or type signature | |
408 static bool is_valid_signature(symbolHandle sig); | |
409 | |
410 static bool is_valid_method_signature(symbolHandle sig); | |
411 static bool is_valid_type_signature(symbolHandle sig); | |
412 private: | |
413 | |
414 static ssize_t is_valid_type(const char*, ssize_t); | |
415 static bool invalid_name_char(char); | |
416 }; |