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