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 #include "precompiled.hpp"
26 #include "classfile/vmSymbols.hpp"
27 #include "memory/oopFactory.hpp"
28 #include "oops/oop.inline.hpp"
29 #include "runtime/handles.inline.hpp"
30 #include "utilities/xmlstream.hpp"
31
32
33 Symbol* vmSymbols::_symbols[vmSymbols::SID_LIMIT];
34
35 Symbol* vmSymbols::_type_signatures[T_VOID+1] = { NULL /*, NULL...*/ };
36
37 inline int compare_symbol(Symbol* a, Symbol* b) {
38 if (a == b) return 0;
39 // follow the natural address order:
40 return (address)a > (address)b ? +1 : -1;
41 }
42
43 static vmSymbols::SID vm_symbol_index[vmSymbols::SID_LIMIT];
44 extern "C" {
45 static int compare_vmsymbol_sid(const void* void_a, const void* void_b) {
46 Symbol* a = vmSymbols::symbol_at(*((vmSymbols::SID*) void_a));
47 Symbol* b = vmSymbols::symbol_at(*((vmSymbols::SID*) void_b));
48 return compare_symbol(a, b);
49 }
50 }
51
52 #ifdef ASSERT
53 #define VM_SYMBOL_ENUM_NAME_BODY(name, string) #name "\0"
54 static const char* vm_symbol_enum_names =
55 VM_SYMBOLS_DO(VM_SYMBOL_ENUM_NAME_BODY, VM_ALIAS_IGNORE)
56 "\0";
57 static const char* vm_symbol_enum_name(vmSymbols::SID sid) {
58 const char* string = &vm_symbol_enum_names[0];
59 int skip = (int)sid - (int)vmSymbols::FIRST_SID;
60 for (; skip != 0; skip--) {
61 size_t skiplen = strlen(string);
62 if (skiplen == 0) return "<unknown>"; // overflow
63 string += skiplen+1;
64 }
65 return string;
66 }
67 #endif //ASSERT
68
69 // Put all the VM symbol strings in one place.
70 // Makes for a more compact libjvm.
71 #define VM_SYMBOL_BODY(name, string) string "\0"
72 static const char* vm_symbol_bodies = VM_SYMBOLS_DO(VM_SYMBOL_BODY, VM_ALIAS_IGNORE);
73
74 void vmSymbols::initialize(TRAPS) {
75 assert((int)SID_LIMIT <= (1<<log2_SID_LIMIT), "must fit in this bitfield");
76 assert((int)SID_LIMIT*5 > (1<<log2_SID_LIMIT), "make the bitfield smaller, please");
77 assert(vmIntrinsics::FLAG_LIMIT <= (1 << vmIntrinsics::log2_FLAG_LIMIT), "must fit in this bitfield");
78
79 if (!UseSharedSpaces) {
80 const char* string = &vm_symbol_bodies[0];
81 for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
82 Symbol* sym = SymbolTable::new_permanent_symbol(string, CHECK);
83 _symbols[index] = sym;
84 string += strlen(string); // skip string body
85 string += 1; // skip trailing null
86 }
87
88 _type_signatures[T_BYTE] = byte_signature();
89 _type_signatures[T_CHAR] = char_signature();
90 _type_signatures[T_DOUBLE] = double_signature();
91 _type_signatures[T_FLOAT] = float_signature();
92 _type_signatures[T_INT] = int_signature();
93 _type_signatures[T_LONG] = long_signature();
94 _type_signatures[T_SHORT] = short_signature();
95 _type_signatures[T_BOOLEAN] = bool_signature();
96 _type_signatures[T_VOID] = void_signature();
97 // no single signatures for T_OBJECT or T_ARRAY
98 }
99
100 #ifdef ASSERT
101 // Check for duplicates:
102 for (int i1 = (int)FIRST_SID; i1 < (int)SID_LIMIT; i1++) {
103 Symbol* sym = symbol_at((SID)i1);
104 for (int i2 = (int)FIRST_SID; i2 < i1; i2++) {
105 if (symbol_at((SID)i2) == sym) {
106 tty->print("*** Duplicate VM symbol SIDs %s(%d) and %s(%d): \"",
107 vm_symbol_enum_name((SID)i2), i2,
108 vm_symbol_enum_name((SID)i1), i1);
109 sym->print_symbol_on(tty);
110 tty->print_cr("\"");
111 }
112 }
113 }
114 #endif //ASSERT
115
116 // Create an index for find_id:
117 {
118 for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
119 vm_symbol_index[index] = (SID)index;
120 }
121 int num_sids = SID_LIMIT-FIRST_SID;
122 qsort(&vm_symbol_index[FIRST_SID], num_sids, sizeof(vm_symbol_index[0]),
123 compare_vmsymbol_sid);
124 }
125
126 #ifdef ASSERT
127 {
128 // Spot-check correspondence between strings, symbols, and enums:
129 assert(_symbols[NO_SID] == NULL, "must be");
130 const char* str = "java/lang/Object";
131 TempNewSymbol jlo = SymbolTable::new_permanent_symbol(str, CHECK);
132 assert(strncmp(str, (char*)jlo->base(), jlo->utf8_length()) == 0, "");
133 assert(jlo == java_lang_Object(), "");
134 SID sid = VM_SYMBOL_ENUM_NAME(java_lang_Object);
135 assert(find_sid(jlo) == sid, "");
136 assert(symbol_at(sid) == jlo, "");
137
138 // Make sure find_sid produces the right answer in each case.
139 for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
140 Symbol* sym = symbol_at((SID)index);
141 sid = find_sid(sym);
142 assert(sid == (SID)index, "symbol index works");
143 // Note: If there are duplicates, this assert will fail.
144 // A "Duplicate VM symbol" message will have already been printed.
145 }
146
147 // The string "format" happens (at the moment) not to be a vmSymbol,
148 // though it is a method name in java.lang.String.
149 str = "format";
150 TempNewSymbol fmt = SymbolTable::new_permanent_symbol(str, CHECK);
151 sid = find_sid(fmt);
152 assert(sid == NO_SID, "symbol index works (negative test)");
153 }
154 #endif
155 }
156
157
158 #ifndef PRODUCT
159 const char* vmSymbols::name_for(vmSymbols::SID sid) {
160 if (sid == NO_SID)
161 return "NO_SID";
162 const char* string = &vm_symbol_bodies[0];
163 for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
164 if (index == (int)sid)
165 return string;
166 string += strlen(string); // skip string body
167 string += 1; // skip trailing null
168 }
169 return "BAD_SID";
170 }
171 #endif
172
173
174
175 void vmSymbols::symbols_do(SymbolClosure* f) {
176 for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
177 f->do_symbol(&_symbols[index]);
178 }
179 for (int i = 0; i < T_VOID+1; i++) {
180 f->do_symbol(&_type_signatures[i]);
181 }
182 }
183
184 void vmSymbols::serialize(SerializeClosure* soc) {
185 soc->do_region((u_char*)&_symbols[FIRST_SID],
186 (SID_LIMIT - FIRST_SID) * sizeof(_symbols[0]));
187 soc->do_region((u_char*)_type_signatures, sizeof(_type_signatures));
188 }
189
190
191 BasicType vmSymbols::signature_type(Symbol* s) {
192 assert(s != NULL, "checking");
193 for (int i = T_BOOLEAN; i < T_VOID+1; i++) {
194 if (s == _type_signatures[i]) {
195 return (BasicType)i;
196 }
197 }
198 return T_OBJECT;
199 }
200
201
202 static int mid_hint = (int)vmSymbols::FIRST_SID+1;
203
204 #ifndef PRODUCT
205 static int find_sid_calls, find_sid_probes;
206 // (Typical counts are calls=7000 and probes=17000.)
207 #endif
208
209 vmSymbols::SID vmSymbols::find_sid(Symbol* symbol) {
210 // Handle the majority of misses by a bounds check.
211 // Then, use a binary search over the index.
212 // Expected trip count is less than log2_SID_LIMIT, about eight.
213 // This is slow but acceptable, given that calls are not
214 // dynamically common. (Method*::intrinsic_id has a cache.)
215 NOT_PRODUCT(find_sid_calls++);
216 int min = (int)FIRST_SID, max = (int)SID_LIMIT - 1;
217 SID sid = NO_SID, sid1;
218 int cmp1;
219 sid1 = vm_symbol_index[min];
220 cmp1 = compare_symbol(symbol, symbol_at(sid1));
221 if (cmp1 <= 0) { // before the first
222 if (cmp1 == 0) sid = sid1;
223 } else {
224 sid1 = vm_symbol_index[max];
225 cmp1 = compare_symbol(symbol, symbol_at(sid1));
226 if (cmp1 >= 0) { // after the last
227 if (cmp1 == 0) sid = sid1;
228 } else {
229 // After checking the extremes, do a binary search.
230 ++min; --max; // endpoints are done
231 int mid = mid_hint; // start at previous success
232 while (max >= min) {
233 assert(mid >= min && mid <= max, "");
234 NOT_PRODUCT(find_sid_probes++);
235 sid1 = vm_symbol_index[mid];
236 cmp1 = compare_symbol(symbol, symbol_at(sid1));
237 if (cmp1 == 0) {
238 mid_hint = mid;
239 sid = sid1;
240 break;
241 }
242 if (cmp1 < 0)
243 max = mid - 1; // symbol < symbol_at(sid)
244 else
245 min = mid + 1;
246
247 // Pick a new probe point:
248 mid = (max + min) / 2;
249 }
250 }
251 }
252
253 #ifdef ASSERT
254 // Perform the exhaustive self-check the first 1000 calls,
255 // and every 100 calls thereafter.
256 static int find_sid_check_count = -2000;
257 if ((uint)++find_sid_check_count > (uint)100) {
258 if (find_sid_check_count > 0) find_sid_check_count = 0;
259
260 // Make sure this is the right answer, using linear search.
261 // (We have already proven that there are no duplicates in the list.)
262 SID sid2 = NO_SID;
263 for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {
264 Symbol* sym2 = symbol_at((SID)index);
265 if (sym2 == symbol) {
266 sid2 = (SID)index;
267 break;
268 }
269 }
270 // Unless it's a duplicate, assert that the sids are the same.
271 if (_symbols[sid] != _symbols[sid2]) {
272 assert(sid == sid2, "binary same as linear search");
273 }
274 }
275 #endif //ASSERT
276
277 return sid;
278 }
279
280 vmSymbols::SID vmSymbols::find_sid(const char* symbol_name) {
281 Symbol* symbol = SymbolTable::probe(symbol_name, (int) strlen(symbol_name));
282 if (symbol == NULL) return NO_SID;
283 return find_sid(symbol);
284 }
285
286 static vmIntrinsics::ID wrapper_intrinsic(BasicType type, bool unboxing) {
287 #define TYPE2(type, unboxing) ((int)(type)*2 + ((unboxing) ? 1 : 0))
288 switch (TYPE2(type, unboxing)) {
289 #define BASIC_TYPE_CASE(type, box, unbox) \
290 case TYPE2(type, false): return vmIntrinsics::box; \
291 case TYPE2(type, true): return vmIntrinsics::unbox
292 BASIC_TYPE_CASE(T_BOOLEAN, _Boolean_valueOf, _booleanValue);
293 BASIC_TYPE_CASE(T_BYTE, _Byte_valueOf, _byteValue);
294 BASIC_TYPE_CASE(T_CHAR, _Character_valueOf, _charValue);
295 BASIC_TYPE_CASE(T_SHORT, _Short_valueOf, _shortValue);
296 BASIC_TYPE_CASE(T_INT, _Integer_valueOf, _intValue);
297 BASIC_TYPE_CASE(T_LONG, _Long_valueOf, _longValue);
298 BASIC_TYPE_CASE(T_FLOAT, _Float_valueOf, _floatValue);
299 BASIC_TYPE_CASE(T_DOUBLE, _Double_valueOf, _doubleValue);
300 #undef BASIC_TYPE_CASE
301 }
302 #undef TYPE2
303 return vmIntrinsics::_none;
304 }
305
306 vmIntrinsics::ID vmIntrinsics::for_boxing(BasicType type) {
307 return wrapper_intrinsic(type, false);
308 }
309 vmIntrinsics::ID vmIntrinsics::for_unboxing(BasicType type) {
310 return wrapper_intrinsic(type, true);
311 }
312
313 vmIntrinsics::ID vmIntrinsics::for_raw_conversion(BasicType src, BasicType dest) {
314 #define SRC_DEST(s,d) (((int)(s) << 4) + (int)(d))
315 switch (SRC_DEST(src, dest)) {
316 case SRC_DEST(T_INT, T_FLOAT): return vmIntrinsics::_intBitsToFloat;
317 case SRC_DEST(T_FLOAT, T_INT): return vmIntrinsics::_floatToRawIntBits;
318
319 case SRC_DEST(T_LONG, T_DOUBLE): return vmIntrinsics::_longBitsToDouble;
320 case SRC_DEST(T_DOUBLE, T_LONG): return vmIntrinsics::_doubleToRawLongBits;
321 }
322 #undef SRC_DEST
323
324 return vmIntrinsics::_none;
325 }
326
327 bool vmIntrinsics::preserves_state(vmIntrinsics::ID id) {
328 assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
329 switch(id) {
330 #ifdef TRACE_HAVE_INTRINSICS
331 case vmIntrinsics::_classID:
332 case vmIntrinsics::_threadID:
333 case vmIntrinsics::_counterTime:
334 #endif
335 case vmIntrinsics::_currentTimeMillis:
336 case vmIntrinsics::_nanoTime:
337 case vmIntrinsics::_floatToRawIntBits:
338 case vmIntrinsics::_intBitsToFloat:
339 case vmIntrinsics::_doubleToRawLongBits:
340 case vmIntrinsics::_longBitsToDouble:
341 case vmIntrinsics::_getClass:
342 case vmIntrinsics::_isInstance:
343 case vmIntrinsics::_currentThread:
344 case vmIntrinsics::_dabs:
345 case vmIntrinsics::_dsqrt:
346 case vmIntrinsics::_dsin:
347 case vmIntrinsics::_dcos:
348 case vmIntrinsics::_dtan:
349 case vmIntrinsics::_dlog:
350 case vmIntrinsics::_dlog10:
351 case vmIntrinsics::_dexp:
352 case vmIntrinsics::_dpow:
353 case vmIntrinsics::_checkIndex:
354 case vmIntrinsics::_Reference_get:
355 case vmIntrinsics::_updateCRC32:
356 case vmIntrinsics::_updateBytesCRC32:
357 case vmIntrinsics::_updateByteBufferCRC32:
358 return true;
359 default:
360 return false;
361 }
362 }
363
364 bool vmIntrinsics::can_trap(vmIntrinsics::ID id) {
365 assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
366 switch(id) {
367 #ifdef TRACE_HAVE_INTRINSICS
368 case vmIntrinsics::_counterTime:
369 #endif
370 case vmIntrinsics::_currentTimeMillis:
371 case vmIntrinsics::_nanoTime:
372 case vmIntrinsics::_floatToRawIntBits:
373 case vmIntrinsics::_intBitsToFloat:
374 case vmIntrinsics::_doubleToRawLongBits:
375 case vmIntrinsics::_longBitsToDouble:
376 case vmIntrinsics::_currentThread:
377 case vmIntrinsics::_dabs:
378 case vmIntrinsics::_dsqrt:
379 case vmIntrinsics::_dsin:
380 case vmIntrinsics::_dcos:
381 case vmIntrinsics::_dtan:
382 case vmIntrinsics::_dlog:
383 case vmIntrinsics::_dlog10:
384 case vmIntrinsics::_dexp:
385 case vmIntrinsics::_dpow:
386 case vmIntrinsics::_updateCRC32:
387 case vmIntrinsics::_updateBytesCRC32:
388 case vmIntrinsics::_updateByteBufferCRC32:
389 return false;
390 default:
391 return true;
392 }
393 }
394
395 bool vmIntrinsics::does_virtual_dispatch(vmIntrinsics::ID id) {
396 assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
397 switch(id) {
398 case vmIntrinsics::_hashCode:
399 case vmIntrinsics::_clone:
400 return true;
401 break;
402 default:
403 return false;
404 }
405 }
406
407 int vmIntrinsics::predicates_needed(vmIntrinsics::ID id) {
408 assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
409 switch (id) {
410 case vmIntrinsics::_cipherBlockChaining_encryptAESCrypt:
411 case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
412 case vmIntrinsics::_counterMode_AESCrypt:
413 return 1;
414 case vmIntrinsics::_digestBase_implCompressMB:
415 return 3;
416 default:
417 return 0;
418 }
419 }
420
421 bool vmIntrinsics::is_disabled_by_flags(const methodHandle& method) {
422 vmIntrinsics::ID id = method->intrinsic_id();
423 assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
424
425 // -XX:-InlineNatives disables nearly all intrinsics except the ones listed in
426 // the following switch statement.
427 if (!InlineNatives) {
428 switch (id) {
429 case vmIntrinsics::_indexOfL:
430 case vmIntrinsics::_indexOfU:
431 case vmIntrinsics::_indexOfUL:
432 case vmIntrinsics::_indexOfIL:
433 case vmIntrinsics::_indexOfIU:
434 case vmIntrinsics::_indexOfIUL:
435 case vmIntrinsics::_indexOfU_char:
436 case vmIntrinsics::_compareToL:
437 case vmIntrinsics::_compareToU:
438 case vmIntrinsics::_compareToLU:
439 case vmIntrinsics::_compareToUL:
440 case vmIntrinsics::_equalsL:
441 case vmIntrinsics::_equalsU:
442 case vmIntrinsics::_equalsC:
443 case vmIntrinsics::_getCharStringU:
444 case vmIntrinsics::_putCharStringU:
445 case vmIntrinsics::_compressStringC:
446 case vmIntrinsics::_compressStringB:
447 case vmIntrinsics::_inflateStringC:
448 case vmIntrinsics::_inflateStringB:
449 case vmIntrinsics::_getAndAddInt:
450 case vmIntrinsics::_getAndAddLong:
451 case vmIntrinsics::_getAndSetInt:
452 case vmIntrinsics::_getAndSetLong:
453 case vmIntrinsics::_getAndSetObject:
454 case vmIntrinsics::_loadFence:
455 case vmIntrinsics::_storeFence:
456 case vmIntrinsics::_fullFence:
457 case vmIntrinsics::_hasNegatives:
458 case vmIntrinsics::_Reference_get:
459 break;
460 default:
461 return true;
462 }
463 }
464
465 switch (id) {
466 case vmIntrinsics::_isInstance:
467 case vmIntrinsics::_isAssignableFrom:
468 case vmIntrinsics::_getModifiers:
469 case vmIntrinsics::_isInterface:
470 case vmIntrinsics::_isArray:
471 case vmIntrinsics::_isPrimitive:
472 case vmIntrinsics::_getSuperclass:
473 case vmIntrinsics::_Class_cast:
474 case vmIntrinsics::_getLength:
475 case vmIntrinsics::_newArray:
476 case vmIntrinsics::_getClass:
477 if (!InlineClassNatives) return true;
478 break;
479 case vmIntrinsics::_currentThread:
480 case vmIntrinsics::_isInterrupted:
481 if (!InlineThreadNatives) return true;
482 break;
483 case vmIntrinsics::_floatToRawIntBits:
484 case vmIntrinsics::_intBitsToFloat:
485 case vmIntrinsics::_doubleToRawLongBits:
486 case vmIntrinsics::_longBitsToDouble:
487 case vmIntrinsics::_dabs:
488 case vmIntrinsics::_dsqrt:
489 case vmIntrinsics::_dsin:
490 case vmIntrinsics::_dcos:
491 case vmIntrinsics::_dtan:
492 case vmIntrinsics::_dlog:
493 case vmIntrinsics::_dexp:
494 case vmIntrinsics::_dpow:
495 case vmIntrinsics::_dlog10:
496 case vmIntrinsics::_datan2:
497 case vmIntrinsics::_min:
498 case vmIntrinsics::_max:
499 case vmIntrinsics::_floatToIntBits:
500 case vmIntrinsics::_doubleToLongBits:
501 if (!InlineMathNatives) return true;
502 break;
503 case vmIntrinsics::_arraycopy:
504 if (!InlineArrayCopy) return true;
505 break;
506 case vmIntrinsics::_updateCRC32:
507 case vmIntrinsics::_updateBytesCRC32:
508 case vmIntrinsics::_updateByteBufferCRC32:
509 if (!UseCRC32Intrinsics) return true;
510 break;
511 case vmIntrinsics::_getObject:
512 case vmIntrinsics::_getBoolean:
513 case vmIntrinsics::_getByte:
514 case vmIntrinsics::_getShort:
515 case vmIntrinsics::_getChar:
516 case vmIntrinsics::_getInt:
517 case vmIntrinsics::_getLong:
518 case vmIntrinsics::_getFloat:
519 case vmIntrinsics::_getDouble:
520 case vmIntrinsics::_putObject:
521 case vmIntrinsics::_putBoolean:
522 case vmIntrinsics::_putByte:
523 case vmIntrinsics::_putShort:
524 case vmIntrinsics::_putChar:
525 case vmIntrinsics::_putInt:
526 case vmIntrinsics::_putLong:
527 case vmIntrinsics::_putFloat:
528 case vmIntrinsics::_putDouble:
529 case vmIntrinsics::_getObjectVolatile:
530 case vmIntrinsics::_getBooleanVolatile:
531 case vmIntrinsics::_getByteVolatile:
532 case vmIntrinsics::_getShortVolatile:
533 case vmIntrinsics::_getCharVolatile:
534 case vmIntrinsics::_getIntVolatile:
535 case vmIntrinsics::_getLongVolatile:
536 case vmIntrinsics::_getFloatVolatile:
537 case vmIntrinsics::_getDoubleVolatile:
538 case vmIntrinsics::_putObjectVolatile:
539 case vmIntrinsics::_putBooleanVolatile:
540 case vmIntrinsics::_putByteVolatile:
541 case vmIntrinsics::_putShortVolatile:
542 case vmIntrinsics::_putCharVolatile:
543 case vmIntrinsics::_putIntVolatile:
544 case vmIntrinsics::_putLongVolatile:
545 case vmIntrinsics::_putFloatVolatile:
546 case vmIntrinsics::_putDoubleVolatile:
547 case vmIntrinsics::_getByte_raw:
548 case vmIntrinsics::_getShort_raw:
549 case vmIntrinsics::_getChar_raw:
550 case vmIntrinsics::_getInt_raw:
551 case vmIntrinsics::_getLong_raw:
552 case vmIntrinsics::_getFloat_raw:
553 case vmIntrinsics::_getDouble_raw:
554 case vmIntrinsics::_putByte_raw:
555 case vmIntrinsics::_putShort_raw:
556 case vmIntrinsics::_putChar_raw:
557 case vmIntrinsics::_putInt_raw:
558 case vmIntrinsics::_putLong_raw:
559 case vmIntrinsics::_putFloat_raw:
560 case vmIntrinsics::_putDouble_raw:
561 case vmIntrinsics::_putOrderedObject:
562 case vmIntrinsics::_putOrderedLong:
563 case vmIntrinsics::_putOrderedInt:
564 case vmIntrinsics::_getAndAddInt:
565 case vmIntrinsics::_getAndAddLong:
566 case vmIntrinsics::_getAndSetInt:
567 case vmIntrinsics::_getAndSetLong:
568 case vmIntrinsics::_getAndSetObject:
569 case vmIntrinsics::_loadFence:
570 case vmIntrinsics::_storeFence:
571 case vmIntrinsics::_fullFence:
572 case vmIntrinsics::_compareAndSwapObject:
573 case vmIntrinsics::_compareAndSwapLong:
574 case vmIntrinsics::_compareAndSwapInt:
575 if (!InlineUnsafeOps) return true;
576 break;
577 case vmIntrinsics::_getShortUnaligned:
578 case vmIntrinsics::_getCharUnaligned:
579 case vmIntrinsics::_getIntUnaligned:
580 case vmIntrinsics::_getLongUnaligned:
581 case vmIntrinsics::_putShortUnaligned:
582 case vmIntrinsics::_putCharUnaligned:
583 case vmIntrinsics::_putIntUnaligned:
584 case vmIntrinsics::_putLongUnaligned:
585 case vmIntrinsics::_allocateInstance:
586 case vmIntrinsics::_getAddress_raw:
587 case vmIntrinsics::_putAddress_raw:
588 if (!InlineUnsafeOps || !UseUnalignedAccesses) return true;
589 break;
590 case vmIntrinsics::_hashCode:
591 if (!InlineObjectHash) return true;
592 break;
593 case vmIntrinsics::_aescrypt_encryptBlock:
594 case vmIntrinsics::_aescrypt_decryptBlock:
595 if (!UseAESIntrinsics) return true;
596 break;
597 case vmIntrinsics::_cipherBlockChaining_encryptAESCrypt:
598 case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
599 if (!UseAESIntrinsics) return true;
600 break;
601 case vmIntrinsics::_counterMode_AESCrypt:
602 if (!UseCTRAESIntrinsics) return true;
603 break;
604 case vmIntrinsics::_sha_implCompress:
605 if (!UseSHA1Intrinsics) return true;
606 break;
607 case vmIntrinsics::_sha2_implCompress:
608 if (!UseSHA256Intrinsics) return true;
609 break;
610 case vmIntrinsics::_sha5_implCompress:
611 if (!UseSHA512Intrinsics) return true;
612 break;
613 case vmIntrinsics::_digestBase_implCompressMB:
614 if (!(UseSHA1Intrinsics || UseSHA256Intrinsics || UseSHA512Intrinsics)) return true;
615 break;
616 case vmIntrinsics::_ghash_processBlocks:
617 if (!UseGHASHIntrinsics) return true;
618 break;
619 case vmIntrinsics::_updateBytesCRC32C:
620 case vmIntrinsics::_updateDirectByteBufferCRC32C:
621 if (!UseCRC32CIntrinsics) return true;
622 break;
623 case vmIntrinsics::_updateBytesAdler32:
624 case vmIntrinsics::_updateByteBufferAdler32:
625 if (!UseAdler32Intrinsics) return true;
626 break;
627 case vmIntrinsics::_copyMemory:
628 if (!InlineArrayCopy || !InlineUnsafeOps) return true;
629 break;
630 #ifdef COMPILER1
631 case vmIntrinsics::_checkIndex:
632 if (!InlineNIOCheckIndex) return true;
633 break;
634 #endif // COMPILER1
635 #ifdef COMPILER2
636 case vmIntrinsics::_clone:
637 case vmIntrinsics::_copyOf:
638 case vmIntrinsics::_copyOfRange:
639 // These intrinsics use both the objectcopy and the arraycopy
640 // intrinsic mechanism.
641 if (!InlineObjectCopy || !InlineArrayCopy) return true;
642 break;
643 case vmIntrinsics::_compareToL:
644 case vmIntrinsics::_compareToU:
645 case vmIntrinsics::_compareToLU:
646 case vmIntrinsics::_compareToUL:
647 if (!SpecialStringCompareTo) return true;
648 break;
649 case vmIntrinsics::_indexOfL:
650 case vmIntrinsics::_indexOfU:
651 case vmIntrinsics::_indexOfUL:
652 case vmIntrinsics::_indexOfIL:
653 case vmIntrinsics::_indexOfIU:
654 case vmIntrinsics::_indexOfIUL:
655 case vmIntrinsics::_indexOfU_char:
656 if (!SpecialStringIndexOf) return true;
657 break;
658 case vmIntrinsics::_equalsL:
659 case vmIntrinsics::_equalsU:
660 if (!SpecialStringEquals) return true;
661 break;
662 case vmIntrinsics::_equalsB:
663 case vmIntrinsics::_equalsC:
664 if (!SpecialArraysEquals) return true;
665 break;
666 case vmIntrinsics::_encodeISOArray:
667 case vmIntrinsics::_encodeByteISOArray:
668 if (!SpecialEncodeISOArray) return true;
669 break;
670 case vmIntrinsics::_getCallerClass:
671 if (!InlineReflectionGetCallerClass) return true;
672 break;
673 case vmIntrinsics::_multiplyToLen:
674 if (!UseMultiplyToLenIntrinsic) return true;
675 break;
676 case vmIntrinsics::_squareToLen:
677 if (!UseSquareToLenIntrinsic) return true;
678 break;
679 case vmIntrinsics::_mulAdd:
680 if (!UseMulAddIntrinsic) return true;
681 break;
682 case vmIntrinsics::_montgomeryMultiply:
683 if (!UseMontgomeryMultiplyIntrinsic) return true;
684 break;
685 case vmIntrinsics::_montgomerySquare:
686 if (!UseMontgomerySquareIntrinsic) return true;
687 break;
688 case vmIntrinsics::_addExactI:
689 case vmIntrinsics::_addExactL:
690 case vmIntrinsics::_decrementExactI:
691 case vmIntrinsics::_decrementExactL:
692 case vmIntrinsics::_incrementExactI:
693 case vmIntrinsics::_incrementExactL:
694 case vmIntrinsics::_multiplyExactI:
695 case vmIntrinsics::_multiplyExactL:
696 case vmIntrinsics::_negateExactI:
697 case vmIntrinsics::_negateExactL:
698 case vmIntrinsics::_subtractExactI:
699 case vmIntrinsics::_subtractExactL:
700 if (!UseMathExactIntrinsics || !InlineMathNatives) return true;
701 break;
702 #endif // COMPILER2
703 default:
704 return false;
705 }
706
707 return false;
708 }
709
710 #define VM_INTRINSIC_INITIALIZE(id, klass, name, sig, flags) #id "\0"
711 static const char* vm_intrinsic_name_bodies =
712 VM_INTRINSICS_DO(VM_INTRINSIC_INITIALIZE,
713 VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
714
715 static const char* vm_intrinsic_name_table[vmIntrinsics::ID_LIMIT];
716
717 const char* vmIntrinsics::name_at(vmIntrinsics::ID id) {
718 const char** nt = &vm_intrinsic_name_table[0];
719 if (nt[_none] == NULL) {
720 char* string = (char*) &vm_intrinsic_name_bodies[0];
721 for (int index = FIRST_ID; index < ID_LIMIT; index++) {
722 nt[index] = string;
723 string += strlen(string); // skip string body
724 string += 1; // skip trailing null
725 }
726 assert(!strcmp(nt[_hashCode], "_hashCode"), "lined up");
727 nt[_none] = "_none";
728 }
729 if ((uint)id < (uint)ID_LIMIT)
730 return vm_intrinsic_name_table[(uint)id];
731 else
732 return "(unknown intrinsic)";
733 }
734
735 // These are flag-matching functions:
736 inline bool match_F_R(jshort flags) {
737 const int req = 0;
738 const int neg = JVM_ACC_STATIC | JVM_ACC_SYNCHRONIZED;
739 return (flags & (req | neg)) == req;
740 }
741 inline bool match_F_Y(jshort flags) {
742 const int req = JVM_ACC_SYNCHRONIZED;
743 const int neg = JVM_ACC_STATIC;
744 return (flags & (req | neg)) == req;
745 }
746 inline bool match_F_RN(jshort flags) {
747 const int req = JVM_ACC_NATIVE;
748 const int neg = JVM_ACC_STATIC | JVM_ACC_SYNCHRONIZED;
749 return (flags & (req | neg)) == req;
750 }
751 inline bool match_F_S(jshort flags) {
752 const int req = JVM_ACC_STATIC;
753 const int neg = JVM_ACC_SYNCHRONIZED;
754 return (flags & (req | neg)) == req;
755 }
756 inline bool match_F_SN(jshort flags) {
757 const int req = JVM_ACC_STATIC | JVM_ACC_NATIVE;
758 const int neg = JVM_ACC_SYNCHRONIZED;
759 return (flags & (req | neg)) == req;
760 }
761 inline bool match_F_RNY(jshort flags) {
762 const int req = JVM_ACC_NATIVE | JVM_ACC_SYNCHRONIZED;
763 const int neg = JVM_ACC_STATIC;
764 return (flags & (req | neg)) == req;
765 }
766
767 // These are for forming case labels:
768 #define ID3(x, y, z) (( jlong)(z) + \
769 ((jlong)(y) << vmSymbols::log2_SID_LIMIT) + \
770 ((jlong)(x) << (2*vmSymbols::log2_SID_LIMIT)) )
771 #define SID_ENUM(n) vmSymbols::VM_SYMBOL_ENUM_NAME(n)
772
773 vmIntrinsics::ID vmIntrinsics::find_id_impl(vmSymbols::SID holder,
774 vmSymbols::SID name,
775 vmSymbols::SID sig,
776 jshort flags) {
777 assert((int)vmSymbols::SID_LIMIT <= (1<<vmSymbols::log2_SID_LIMIT), "must fit");
778
779 // Let the C compiler build the decision tree.
780
781 #define VM_INTRINSIC_CASE(id, klass, name, sig, fcode) \
782 case ID3(SID_ENUM(klass), SID_ENUM(name), SID_ENUM(sig)): \
783 if (!match_##fcode(flags)) break; \
784 return id;
785
786 switch (ID3(holder, name, sig)) {
787 VM_INTRINSICS_DO(VM_INTRINSIC_CASE,
788 VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
789 }
790 return vmIntrinsics::_none;
791
792 #undef VM_INTRINSIC_CASE
793 }
794
795
796 const char* vmIntrinsics::short_name_as_C_string(vmIntrinsics::ID id, char* buf, int buflen) {
797 const char* str = name_at(id);
798 #ifndef PRODUCT
799 const char* kname = vmSymbols::name_for(class_for(id));
800 const char* mname = vmSymbols::name_for(name_for(id));
801 const char* sname = vmSymbols::name_for(signature_for(id));
802 const char* fname = "";
803 switch (flags_for(id)) {
804 case F_Y: fname = "synchronized "; break;
805 case F_RN: fname = "native "; break;
806 case F_SN: fname = "native static "; break;
807 case F_S: fname = "static "; break;
808 case F_RNY:fname = "native synchronized "; break;
809 }
810 const char* kptr = strrchr(kname, '/');
811 if (kptr != NULL) kname = kptr + 1;
812 int len = jio_snprintf(buf, buflen, "%s: %s%s.%s%s",
813 str, fname, kname, mname, sname);
814 if (len < buflen)
815 str = buf;
816 #endif //PRODUCT
817 return str;
818 }
819
820
821 // These are to get information about intrinsics.
822
823 #define ID4(x, y, z, f) ((ID3(x, y, z) << vmIntrinsics::log2_FLAG_LIMIT) | (jlong) (f))
824
825 static const jlong intrinsic_info_array[vmIntrinsics::ID_LIMIT+1] = {
826 #define VM_INTRINSIC_INFO(ignore_id, klass, name, sig, fcode) \
827 ID4(SID_ENUM(klass), SID_ENUM(name), SID_ENUM(sig), vmIntrinsics::fcode),
828
829 0, VM_INTRINSICS_DO(VM_INTRINSIC_INFO,
830 VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE)
831 0
832 #undef VM_INTRINSIC_INFO
833 };
834
835 inline jlong intrinsic_info(vmIntrinsics::ID id) {
836 return intrinsic_info_array[vmIntrinsics::ID_from((int)id)];
837 }
838
839 vmSymbols::SID vmIntrinsics::class_for(vmIntrinsics::ID id) {
840 jlong info = intrinsic_info(id);
841 int shift = 2*vmSymbols::log2_SID_LIMIT + log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
842 assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 1021, "");
843 return vmSymbols::SID( (info >> shift) & mask );
844 }
845
846 vmSymbols::SID vmIntrinsics::name_for(vmIntrinsics::ID id) {
847 jlong info = intrinsic_info(id);
848 int shift = vmSymbols::log2_SID_LIMIT + log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
849 assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 1022, "");
850 return vmSymbols::SID( (info >> shift) & mask );
851 }
852
853 vmSymbols::SID vmIntrinsics::signature_for(vmIntrinsics::ID id) {
854 jlong info = intrinsic_info(id);
855 int shift = log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);
856 assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 1023, "");
857 return vmSymbols::SID( (info >> shift) & mask );
858 }
859
860 vmIntrinsics::Flags vmIntrinsics::flags_for(vmIntrinsics::ID id) {
861 jlong info = intrinsic_info(id);
862 int shift = 0, mask = right_n_bits(log2_FLAG_LIMIT);
863 assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 15, "");
864 return Flags( (info >> shift) & mask );
865 }
866
867
868 #ifndef PRODUCT
869 // verify_method performs an extra check on a matched intrinsic method
870
871 static bool match_method(Method* m, Symbol* n, Symbol* s) {
872 return (m->name() == n &&
873 m->signature() == s);
874 }
875
876 static vmIntrinsics::ID match_method_with_klass(Method* m, Symbol* mk) {
877 #define VM_INTRINSIC_MATCH(id, klassname, namepart, sigpart, flags) \
878 { Symbol* k = vmSymbols::klassname(); \
879 if (mk == k) { \
880 Symbol* n = vmSymbols::namepart(); \
881 Symbol* s = vmSymbols::sigpart(); \
882 if (match_method(m, n, s)) \
883 return vmIntrinsics::id; \
884 } }
885 VM_INTRINSICS_DO(VM_INTRINSIC_MATCH,
886 VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);
887 return vmIntrinsics::_none;
888 #undef VM_INTRINSIC_MATCH
889 }
890
891 void vmIntrinsics::verify_method(ID actual_id, Method* m) {
892 Symbol* mk = m->method_holder()->name();
893 ID declared_id = match_method_with_klass(m, mk);
894
895 if (declared_id == actual_id) return; // success
896
897 if (declared_id == _none && actual_id != _none && mk == vmSymbols::java_lang_StrictMath()) {
898 // Here are a few special cases in StrictMath not declared in vmSymbols.hpp.
899 switch (actual_id) {
900 case _min:
901 case _max:
902 case _dsqrt:
903 declared_id = match_method_with_klass(m, vmSymbols::java_lang_Math());
904 if (declared_id == actual_id) return; // acceptable alias
905 break;
906 }
907 }
908
909 const char* declared_name = name_at(declared_id);
910 const char* actual_name = name_at(actual_id);
911 methodHandle mh = m;
912 m = NULL;
913 ttyLocker ttyl;
914 if (xtty != NULL) {
915 xtty->begin_elem("intrinsic_misdeclared actual='%s' declared='%s'",
916 actual_name, declared_name);
917 xtty->method(mh);
918 xtty->end_elem("%s", "");
919 }
920 if (PrintMiscellaneous && (WizardMode || Verbose)) {
921 tty->print_cr("*** misidentified method; %s(%d) should be %s(%d):",
922 declared_name, declared_id, actual_name, actual_id);
923 mh()->print_short_name(tty);
924 tty->cr();
925 }
926 }
927 #endif //PRODUCT