1 /*
2 * Copyright (c) 1997, 2025, 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 "runtime/globals.hpp"
26 #include "runtime/os.hpp"
27 #include "runtime/signature.hpp"
28 #include "utilities/globalDefinitions.hpp"
29 #include "utilities/powerOfTwo.hpp"
30
31 // Basic error support
32
33 // Info for oops within a java object. Defaults are zero so
34 // things will break badly if incorrectly initialized.
35 int heapOopSize = 0;
36 int LogBytesPerHeapOop = 0;
37 int LogBitsPerHeapOop = 0;
38 int BytesPerHeapOop = 0;
39 int BitsPerHeapOop = 0;
40
41 // Old CDS options
42 bool RequireSharedSpaces;
43 extern "C" {
44 JNIEXPORT jboolean UseSharedSpaces = true;
45 }
46
47 // Object alignment, in units of HeapWords.
48 // Defaults are -1 so things will break badly if incorrectly initialized.
49 int MinObjAlignment = -1;
50 int MinObjAlignmentInBytes = -1;
51 int MinObjAlignmentInBytesMask = 0;
52
53 int LogMinObjAlignment = -1;
54 int LogMinObjAlignmentInBytes = -1;
55
56 // Oop encoding heap max
57 uint64_t OopEncodingHeapMax = 0;
58
59 // Something to help porters sleep at night
60
61 #ifdef ASSERT
62 static BasicType char2type(int ch) {
63 switch (ch) {
64 #define EACH_SIG(ch, bt, ignore) \
65 case ch: return bt;
66 SIGNATURE_TYPES_DO(EACH_SIG, ignore)
67 #undef EACH_SIG
68 }
69 return T_ILLEGAL;
70 }
71
72 extern bool signature_constants_sane();
73 #endif //ASSERT
74
75 void basic_types_init() {
76 #ifdef ASSERT
77 #ifdef _LP64
78 static_assert(min_intx == (intx)CONST64(0x8000000000000000), "correct constant");
79 static_assert(max_intx == CONST64(0x7FFFFFFFFFFFFFFF), "correct constant");
80 static_assert(max_uintx == CONST64(0xFFFFFFFFFFFFFFFF), "correct constant");
81 static_assert( 8 == sizeof( intx), "wrong size for basic type");
82 static_assert( 8 == sizeof( jobject), "wrong size for basic type");
83 #else
84 static_assert(min_intx == (intx)0x80000000, "correct constant");
85 static_assert(max_intx == 0x7FFFFFFF, "correct constant");
86 static_assert(max_uintx == 0xFFFFFFFF, "correct constant");
87 static_assert( 4 == sizeof( intx), "wrong size for basic type");
88 static_assert( 4 == sizeof( jobject), "wrong size for basic type");
89 #endif
90 static_assert( (~max_juint) == 0, "max_juint has all its bits");
91 static_assert( (~max_uintx) == 0, "max_uintx has all its bits");
92 static_assert( (~max_julong) == 0, "max_julong has all its bits");
93 static_assert( 1 == sizeof( jbyte), "wrong size for basic type");
94 static_assert( 2 == sizeof( jchar), "wrong size for basic type");
95 static_assert( 2 == sizeof( jshort), "wrong size for basic type");
96 static_assert( 4 == sizeof( juint), "wrong size for basic type");
97 static_assert( 4 == sizeof( jint), "wrong size for basic type");
98 static_assert( 1 == sizeof( jboolean), "wrong size for basic type");
99 static_assert( 8 == sizeof( jlong), "wrong size for basic type");
100 static_assert( 4 == sizeof( jfloat), "wrong size for basic type");
101 static_assert( 8 == sizeof( jdouble), "wrong size for basic type");
102 static_assert( 1 == sizeof( u1), "wrong size for basic type");
103 static_assert( 2 == sizeof( u2), "wrong size for basic type");
104 static_assert( 4 == sizeof( u4), "wrong size for basic type");
105 static_assert(wordSize == BytesPerWord, "should be the same since they're used interchangeably");
106 static_assert(wordSize == HeapWordSize, "should be the same since they're also used interchangeably");
107
108 assert(signature_constants_sane(), "");
109
110 int num_type_chars = 0;
111 for (int i = 0; i < 99; i++) {
112 if (type2char((BasicType)i) != 0) {
113 assert(char2type(type2char((BasicType)i)) == i, "proper inverses");
114 assert(Signature::basic_type(type2char((BasicType)i)) == i, "proper inverses");
115 num_type_chars++;
116 }
117 }
118 assert(num_type_chars == 11, "must have tested the right number of mappings");
119 assert(char2type(0) == T_ILLEGAL, "correct illegality");
120
121 {
122 for (int i = T_BOOLEAN; i <= T_CONFLICT; i++) {
123 BasicType vt = (BasicType)i;
124 BasicType ft = type2field[vt];
125 switch (vt) {
126 // the following types might plausibly show up in memory layouts:
127 case T_BOOLEAN:
128 case T_BYTE:
129 case T_CHAR:
130 case T_SHORT:
131 case T_INT:
132 case T_FLOAT:
133 case T_DOUBLE:
134 case T_LONG:
135 case T_OBJECT:
136 case T_ADDRESS: // random raw pointer
137 case T_METADATA: // metadata pointer
138 case T_NARROWOOP: // compressed pointer
139 case T_NARROWKLASS: // compressed klass pointer
140 case T_CONFLICT: // might as well support a bottom type
141 case T_VOID: // padding or other unaddressed word
142 // layout type must map to itself
143 assert(vt == ft, "");
144 break;
145 default:
146 // non-layout type must map to a (different) layout type
147 assert(vt != ft, "");
148 assert(ft == type2field[ft], "");
149 }
150 // every type must map to same-sized layout type:
151 assert(type2size[vt] == type2size[ft], "");
152 }
153 }
154 // These are assumed, e.g., when filling HeapWords with juints.
155 static_assert(is_power_of_2(sizeof(juint)), "juint must be power of 2");
156 static_assert(is_power_of_2(HeapWordSize), "HeapWordSize must be power of 2");
157 static_assert((size_t)HeapWordSize >= sizeof(juint),
158 "HeapWord should be at least as large as juint");
159 #endif
160
161 if( JavaPriority1_To_OSPriority != -1 )
162 os::java_to_os_priority[1] = JavaPriority1_To_OSPriority;
163 if( JavaPriority2_To_OSPriority != -1 )
164 os::java_to_os_priority[2] = JavaPriority2_To_OSPriority;
165 if( JavaPriority3_To_OSPriority != -1 )
166 os::java_to_os_priority[3] = JavaPriority3_To_OSPriority;
167 if( JavaPriority4_To_OSPriority != -1 )
168 os::java_to_os_priority[4] = JavaPriority4_To_OSPriority;
169 if( JavaPriority5_To_OSPriority != -1 )
170 os::java_to_os_priority[5] = JavaPriority5_To_OSPriority;
171 if( JavaPriority6_To_OSPriority != -1 )
172 os::java_to_os_priority[6] = JavaPriority6_To_OSPriority;
173 if( JavaPriority7_To_OSPriority != -1 )
174 os::java_to_os_priority[7] = JavaPriority7_To_OSPriority;
175 if( JavaPriority8_To_OSPriority != -1 )
176 os::java_to_os_priority[8] = JavaPriority8_To_OSPriority;
177 if( JavaPriority9_To_OSPriority != -1 )
178 os::java_to_os_priority[9] = JavaPriority9_To_OSPriority;
179 if(JavaPriority10_To_OSPriority != -1 )
180 os::java_to_os_priority[10] = JavaPriority10_To_OSPriority;
181
182 // Set the size of basic types here (after argument parsing but before
183 // stub generation).
184 if (UseCompressedOops) {
185 // Size info for oops within java objects is fixed
186 heapOopSize = jintSize;
187 LogBytesPerHeapOop = LogBytesPerInt;
188 LogBitsPerHeapOop = LogBitsPerInt;
189 BytesPerHeapOop = BytesPerInt;
190 BitsPerHeapOop = BitsPerInt;
191 } else {
192 heapOopSize = oopSize;
193 LogBytesPerHeapOop = LogBytesPerWord;
194 LogBitsPerHeapOop = LogBitsPerWord;
195 BytesPerHeapOop = BytesPerWord;
196 BitsPerHeapOop = BitsPerWord;
197 }
198 _type2aelembytes[T_OBJECT] = heapOopSize;
199 _type2aelembytes[T_ARRAY] = heapOopSize;
200 }
201
202
203 // Map BasicType to signature character
204 char type2char_tab[T_CONFLICT+1] = {
205 0, 0, 0, 0,
206 JVM_SIGNATURE_BOOLEAN, JVM_SIGNATURE_CHAR,
207 JVM_SIGNATURE_FLOAT, JVM_SIGNATURE_DOUBLE,
208 JVM_SIGNATURE_BYTE, JVM_SIGNATURE_SHORT,
209 JVM_SIGNATURE_INT, JVM_SIGNATURE_LONG,
210 JVM_SIGNATURE_CLASS, JVM_SIGNATURE_ARRAY,
211 JVM_SIGNATURE_VOID,
212 0, 0, 0, 0, 0, 0
213 };
214
215 // Map BasicType to Java type name
216 const char* type2name_tab[T_CONFLICT+1] = {
217 nullptr, nullptr, nullptr, nullptr,
218 "boolean",
219 "char",
220 "float",
221 "double",
222 "byte",
223 "short",
224 "int",
225 "long",
226 "object",
227 "array",
228 "void",
229 "flat element",
230 "*address*",
231 "*narrowoop*",
232 "*metadata*",
233 "*narrowklass*",
234 "*conflict*"
235 };
236 const char* type2name(BasicType t) {
237 if (t < ARRAY_SIZE(type2name_tab)) {
238 return type2name_tab[t];
239 } else if (t == T_ILLEGAL) {
240 return "*illegal*";
241 } else {
242 fatal("invalid type %d", t);
243 return "invalid type";
244 }
245 }
246
247
248
249 BasicType name2type(const char* name) {
250 for (int i = T_BOOLEAN; i <= T_VOID; i++) {
251 BasicType t = (BasicType)i;
252 if (type2name_tab[t] != nullptr && 0 == strcmp(type2name_tab[t], name))
253 return t;
254 }
255 return T_ILLEGAL;
256 }
257
258 // Map BasicType to size in words
259 int type2size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 0, -1, 1, 1, 1, 1, -1};
260
261 BasicType type2field[T_CONFLICT+1] = {
262 (BasicType)0, // 0,
263 (BasicType)0, // 1,
264 (BasicType)0, // 2,
265 (BasicType)0, // 3,
266 T_BOOLEAN, // T_BOOLEAN = 4,
267 T_CHAR, // T_CHAR = 5,
268 T_FLOAT, // T_FLOAT = 6,
269 T_DOUBLE, // T_DOUBLE = 7,
270 T_BYTE, // T_BYTE = 8,
271 T_SHORT, // T_SHORT = 9,
272 T_INT, // T_INT = 10,
273 T_LONG, // T_LONG = 11,
274 T_OBJECT, // T_OBJECT = 12,
275 T_OBJECT, // T_ARRAY = 13,
276 T_VOID, // T_VOID = 14,
277 (BasicType)0, // T_FLAT_ELEMENT = 15,
278 T_ADDRESS, // T_ADDRESS = 16,
279 T_NARROWOOP, // T_NARROWOOP= 17,
280 T_METADATA, // T_METADATA = 18,
281 T_NARROWKLASS, // T_NARROWKLASS = 19,
282 T_CONFLICT // T_CONFLICT = 20
283 };
284
285
286 BasicType type2wfield[T_CONFLICT+1] = {
287 (BasicType)0, // 0,
288 (BasicType)0, // 1,
289 (BasicType)0, // 2,
290 (BasicType)0, // 3,
291 T_INT, // T_BOOLEAN = 4,
292 T_INT, // T_CHAR = 5,
293 T_FLOAT, // T_FLOAT = 6,
294 T_DOUBLE, // T_DOUBLE = 7,
295 T_INT, // T_BYTE = 8,
296 T_INT, // T_SHORT = 9,
297 T_INT, // T_INT = 10,
298 T_LONG, // T_LONG = 11,
299 T_OBJECT, // T_OBJECT = 12,
300 T_OBJECT, // T_ARRAY = 13,
301 T_VOID, // T_VOID = 14,
302 (BasicType)0, // T_FLAT_ELEMENT = 15,
303 T_ADDRESS, // T_ADDRESS = 16,
304 T_NARROWOOP, // T_NARROWOOP = 17,
305 T_METADATA, // T_METADATA = 18,
306 T_NARROWKLASS, // T_NARROWKLASS = 19,
307 T_CONFLICT // T_CONFLICT = 20
308 };
309
310
311 int _type2aelembytes[T_CONFLICT+1] = {
312 0, // 0
313 0, // 1
314 0, // 2
315 0, // 3
316 T_BOOLEAN_aelem_bytes, // T_BOOLEAN = 4,
317 T_CHAR_aelem_bytes, // T_CHAR = 5,
318 T_FLOAT_aelem_bytes, // T_FLOAT = 6,
319 T_DOUBLE_aelem_bytes, // T_DOUBLE = 7,
320 T_BYTE_aelem_bytes, // T_BYTE = 8,
321 T_SHORT_aelem_bytes, // T_SHORT = 9,
322 T_INT_aelem_bytes, // T_INT = 10,
323 T_LONG_aelem_bytes, // T_LONG = 11,
324 T_OBJECT_aelem_bytes, // T_OBJECT = 12,
325 T_ARRAY_aelem_bytes, // T_ARRAY = 13,
326 0, // T_VOID = 14,
327 0, // T_FLAT_ELEMENT = 15,
328 T_OBJECT_aelem_bytes, // T_ADDRESS = 16,
329 T_NARROWOOP_aelem_bytes, // T_NARROWOOP= 17,
330 T_OBJECT_aelem_bytes, // T_METADATA = 18,
331 T_NARROWKLASS_aelem_bytes, // T_NARROWKLASS= 19,
332 0 // T_CONFLICT = 20
333 };
334
335 #ifdef ASSERT
336 int type2aelembytes(BasicType t, bool allow_address) {
337 assert((allow_address || t != T_ADDRESS) && t <= T_CONFLICT, "unexpected basic type");
338 return _type2aelembytes[t];
339 }
340 #endif
341
342 // Support for 64-bit integer arithmetic
343
344 // The following code is mostly taken from JVM typedefs_md.h and system_md.c
345
346 static const jlong high_bit = (jlong)1 << (jlong)63;
347 static const jlong other_bits = ~high_bit;
348
349 jlong float2long(jfloat f) {
350 jlong tmp = (jlong) f;
351 if (tmp != high_bit) {
352 return tmp;
353 } else {
354 if (g_isnan((jdouble)f)) {
355 return 0;
356 }
357 if (f < 0) {
358 return high_bit;
359 } else {
360 return other_bits;
361 }
362 }
363 }
364
365
366 jlong double2long(jdouble f) {
367 jlong tmp = (jlong) f;
368 if (tmp != high_bit) {
369 return tmp;
370 } else {
371 if (g_isnan(f)) {
372 return 0;
373 }
374 if (f < 0) {
375 return high_bit;
376 } else {
377 return other_bits;
378 }
379 }
380 }
381
382 // least common multiple
383 size_t lcm(size_t a, size_t b) {
384 size_t cur, div, next;
385
386 cur = MAX2(a, b);
387 div = MIN2(a, b);
388
389 assert(div != 0, "lcm requires positive arguments");
390
391
392 while ((next = cur % div) != 0) {
393 cur = div; div = next;
394 }
395
396
397 julong result = julong(a) * b / div;
398 assert(result <= (size_t)max_uintx, "Integer overflow in lcm");
399
400 return size_t(result);
401 }
402
403
404 // Test that nth_bit macro and friends behave as
405 // expected, even with low-precedence operators.
406
407 STATIC_ASSERT(nth_bit(3) == 0x8);
408 STATIC_ASSERT(nth_bit(1|2) == 0x8);
409
410 STATIC_ASSERT(right_n_bits(3) == 0x7);
411 STATIC_ASSERT(right_n_bits(1|2) == 0x7);
412
413 // Check for Flush-To-Zero mode
414
415 // On some processors faster execution can be achieved by setting a
416 // mode to return zero for extremely small results, rather than an
417 // IEEE-754 subnormal number. This mode is not compatible with the
418 // Java Language Standard.
419
420 // We need the addition of _large_subnormal and _small_subnormal to be
421 // performed at runtime. _small_subnormal is volatile so that
422 // expressions involving it cannot be evaluated at compile time.
423 static const double large_subnormal_double
424 = jdouble_cast(0x0030000000000000); // 0x1.0p-1020;
425 static const volatile double small_subnormal_double
426 = jdouble_cast(0x0000000000000003); // 0x0.0000000000003p-1022;
427
428 // Quickly test to make sure IEEE-754 subnormal numbers are correctly
429 // handled.
430 bool IEEE_subnormal_handling_OK() {
431 // _small_subnormal is the smallest subnormal number that has two
432 // bits set. _large_subnormal is a number such that, when
433 // _small_subnormal is added to it, must be rounded according to the
434 // mode. These two tests detect the rounding mode in use. If
435 // subnormals are turned off (i.e. subnormals-are-zero) flush-to-
436 // zero mode is in use.
437
438 return (large_subnormal_double + small_subnormal_double > large_subnormal_double
439 && -large_subnormal_double - small_subnormal_double < -large_subnormal_double);
440 }