130 #endif //PRODUCT
131 vm_exit_during_initialization("Invalid layout of preloaded class: use -XX:+TraceClassLoading to see the origin of the problem class");
132 }
133 dest_offset = fd.offset();
134 }
135
136 // Same as above but for "optional" offsets that might not be present in certain JDK versions
137 static void
138 compute_optional_offset(int& dest_offset,
139 Klass* klass_oop, Symbol* name_symbol, Symbol* signature_symbol,
140 bool allow_super = false) {
141 fieldDescriptor fd;
142 InstanceKlass* ik = InstanceKlass::cast(klass_oop);
143 if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {
144 dest_offset = fd.offset();
145 }
146 }
147
148
149 int java_lang_String::value_offset = 0;
150 int java_lang_String::offset_offset = 0;
151 int java_lang_String::count_offset = 0;
152 int java_lang_String::hash_offset = 0;
153
154 bool java_lang_String::initialized = false;
155
156 bool java_lang_String::is_instance(oop obj) {
157 return is_instance_inlined(obj);
158 }
159
160 void java_lang_String::compute_offsets() {
161 assert(!initialized, "offsets should be initialized only once");
162
163 Klass* k = SystemDictionary::String_klass();
164 compute_offset(value_offset, k, vmSymbols::value_name(), vmSymbols::char_array_signature());
165 compute_optional_offset(offset_offset, k, vmSymbols::offset_name(), vmSymbols::int_signature());
166 compute_optional_offset(count_offset, k, vmSymbols::count_name(), vmSymbols::int_signature());
167 compute_optional_offset(hash_offset, k, vmSymbols::hash_name(), vmSymbols::int_signature());
168
169 initialized = true;
170 }
171
172 Handle java_lang_String::basic_create(int length, TRAPS) {
173 assert(initialized, "Must be initialized");
174 // Create the String object first, so there's a chance that the String
175 // and the char array it points to end up in the same cache line.
176 oop obj;
177 obj = InstanceKlass::cast(SystemDictionary::String_klass())->allocate_instance(CHECK_NH);
178
179 // Create the char array. The String object must be handlized here
180 // because GC can happen as a result of the allocation attempt.
181 Handle h_obj(THREAD, obj);
182 typeArrayOop buffer;
183 buffer = oopFactory::new_charArray(length, CHECK_NH);
184
185 // Point the String at the char array
186 obj = h_obj();
187 set_value(obj, buffer);
188 // No need to zero the offset, allocation zero'ed the entire String object
189 assert(offset(obj) == 0, "initial String offset should be zero");
190 //set_offset(obj, 0);
191 set_count(obj, length);
192
193 return h_obj;
194 }
195
196 Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) {
197 Handle h_obj = basic_create(length, CHECK_NH);
198 typeArrayOop buffer = value(h_obj());
199 for (int index = 0; index < length; index++) {
200 buffer->char_at_put(index, unicode[index]);
201 }
202 return h_obj;
203 }
204
205 oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) {
206 Handle h_obj = create_from_unicode(unicode, length, CHECK_0);
207 return h_obj();
208 }
209
210 Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) {
211 if (utf8_str == NULL) {
212 return Handle();
213 }
214 int length = UTF8::unicode_length(utf8_str);
215 Handle h_obj = basic_create(length, CHECK_NH);
216 if (length > 0) {
217 UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length);
218 }
219 return h_obj;
220 }
221
222 oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) {
223 Handle h_obj = create_from_str(utf8_str, CHECK_0);
224 return h_obj();
225 }
226
227 Handle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) {
228 int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length());
229 Handle h_obj = basic_create(length, CHECK_NH);
230 if (length > 0) {
231 UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length);
232 }
233 return h_obj;
234 }
235
236 // Converts a C string to a Java String based on current encoding
237 Handle java_lang_String::create_from_platform_dependent_str(const char* str, TRAPS) {
238 assert(str != NULL, "bad arguments");
239
240 typedef jstring (*to_java_string_fn_t)(JNIEnv*, const char *);
241 static to_java_string_fn_t _to_java_string_fn = NULL;
242
243 if (_to_java_string_fn == NULL) {
244 void *lib_handle = os::native_java_library();
245 _to_java_string_fn = CAST_TO_FN_PTR(to_java_string_fn_t, os::dll_lookup(lib_handle, "NewStringPlatform"));
246 if (_to_java_string_fn == NULL) {
247 fatal("NewStringPlatform missing");
248 }
249 }
250
251 jstring js = NULL;
252 { JavaThread* thread = (JavaThread*)THREAD;
253 assert(thread->is_Java_thread(), "must be java thread");
254 HandleMark hm(thread);
255 ThreadToNativeFromVM ttn(thread);
256 js = (_to_java_string_fn)(thread->jni_environment(), str);
257 }
258 return Handle(THREAD, JNIHandles::resolve(js));
259 }
260
261 // Converts a Java String to a native C string that can be used for
262 // native OS calls.
263 char* java_lang_String::as_platform_dependent_str(Handle java_string, TRAPS) {
264
265 typedef char* (*to_platform_string_fn_t)(JNIEnv*, jstring, bool*);
266 static to_platform_string_fn_t _to_platform_string_fn = NULL;
267
268 if (_to_platform_string_fn == NULL) {
269 void *lib_handle = os::native_java_library();
270 _to_platform_string_fn = CAST_TO_FN_PTR(to_platform_string_fn_t, os::dll_lookup(lib_handle, "GetStringPlatformChars"));
271 if (_to_platform_string_fn == NULL) {
272 fatal("GetStringPlatformChars missing");
273 }
274 }
275
276 char *native_platform_string;
277 { JavaThread* thread = (JavaThread*)THREAD;
278 assert(thread->is_Java_thread(), "must be java thread");
279 JNIEnv *env = thread->jni_environment();
280 jstring js = (jstring) JNIHandles::make_local(env, java_string());
281 bool is_copy;
282 HandleMark hm(thread);
283 ThreadToNativeFromVM ttn(thread);
284 native_platform_string = (_to_platform_string_fn)(env, js, &is_copy);
285 assert(is_copy == JNI_TRUE, "is_copy value changed");
286 JNIHandles::destroy_local(js);
287 }
288 return native_platform_string;
289 }
290
291 Handle java_lang_String::char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS) {
292 oop obj = java_string();
293 // Typical usage is to convert all '/' to '.' in string.
294 typeArrayOop value = java_lang_String::value(obj);
295 int offset = java_lang_String::offset(obj);
296 int length = java_lang_String::length(obj);
297
298 // First check if any from_char exist
299 int index; // Declared outside, used later
300 for (index = 0; index < length; index++) {
301 if (value->char_at(index + offset) == from_char) {
302 break;
303 }
304 }
305 if (index == length) {
306 // No from_char, so do not copy.
307 return java_string;
308 }
309
310 // Create new UNICODE buffer. Must handlize value because GC
311 // may happen during String and char array creation.
312 typeArrayHandle h_value(THREAD, value);
313 Handle string = basic_create(length, CHECK_NH);
314
315 typeArrayOop from_buffer = h_value();
316 typeArrayOop to_buffer = java_lang_String::value(string());
317
318 // Copy contents
319 for (index = 0; index < length; index++) {
320 jchar c = from_buffer->char_at(index + offset);
321 if (c == from_char) {
322 c = to_char;
323 }
324 to_buffer->char_at_put(index, c);
325 }
326 return string;
327 }
328
329 jchar* java_lang_String::as_unicode_string(oop java_string, int& length, TRAPS) {
330 typeArrayOop value = java_lang_String::value(java_string);
331 int offset = java_lang_String::offset(java_string);
332 length = java_lang_String::length(java_string);
333
334 jchar* result = NEW_RESOURCE_ARRAY_RETURN_NULL(jchar, length);
335 if (result != NULL) {
336 for (int index = 0; index < length; index++) {
337 result[index] = value->char_at(index + offset);
338 }
339 } else {
340 THROW_MSG_0(vmSymbols::java_lang_OutOfMemoryError(), "could not allocate Unicode string");
341 }
342 return result;
343 }
344
345 unsigned int java_lang_String::hash_code(oop java_string) {
346 int length = java_lang_String::length(java_string);
347 // Zero length string will hash to zero with String.hashCode() function.
348 if (length == 0) return 0;
349
350 typeArrayOop value = java_lang_String::value(java_string);
351 int offset = java_lang_String::offset(java_string);
352 return java_lang_String::hash_code(value->char_at_addr(offset), length);
353 }
354
355 char* java_lang_String::as_quoted_ascii(oop java_string) {
356 typeArrayOop value = java_lang_String::value(java_string);
357 int offset = java_lang_String::offset(java_string);
358 int length = java_lang_String::length(java_string);
359
360 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
361 if (base == NULL) return NULL;
362
363 int result_length = UNICODE::quoted_ascii_length(base, length) + 1;
364 char* result = NEW_RESOURCE_ARRAY(char, result_length);
365 UNICODE::as_quoted_ascii(base, length, result, result_length);
366 assert(result_length >= length + 1, "must not be shorter");
367 assert(result_length == (int)strlen(result) + 1, "must match");
368 return result;
369 }
370
371 unsigned int java_lang_String::hash_string(oop java_string) {
372 int length = java_lang_String::length(java_string);
373 // Zero length string doesn't hash necessarily hash to zero.
374 if (length == 0) {
375 return StringTable::hash_string(NULL, 0);
376 }
377
378 typeArrayOop value = java_lang_String::value(java_string);
379 int offset = java_lang_String::offset(java_string);
380 return StringTable::hash_string(value->char_at_addr(offset), length);
381 }
382
383 Symbol* java_lang_String::as_symbol(Handle java_string, TRAPS) {
384 oop obj = java_string();
385 typeArrayOop value = java_lang_String::value(obj);
386 int offset = java_lang_String::offset(obj);
387 int length = java_lang_String::length(obj);
388 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
389 Symbol* sym = SymbolTable::lookup_unicode(base, length, THREAD);
390 return sym;
391 }
392
393 Symbol* java_lang_String::as_symbol_or_null(oop java_string) {
394 typeArrayOop value = java_lang_String::value(java_string);
395 int offset = java_lang_String::offset(java_string);
396 int length = java_lang_String::length(java_string);
397 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
398 return SymbolTable::probe_unicode(base, length);
399 }
400
401
402 int java_lang_String::utf8_length(oop java_string) {
403 typeArrayOop value = java_lang_String::value(java_string);
404 int offset = java_lang_String::offset(java_string);
405 int length = java_lang_String::length(java_string);
406 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
407 return UNICODE::utf8_length(position, length);
408 }
409
410 char* java_lang_String::as_utf8_string(oop java_string) {
411 typeArrayOop value = java_lang_String::value(java_string);
412 int offset = java_lang_String::offset(java_string);
413 int length = java_lang_String::length(java_string);
414 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
415 return UNICODE::as_utf8(position, length);
416 }
417
418 char* java_lang_String::as_utf8_string(oop java_string, char* buf, int buflen) {
419 typeArrayOop value = java_lang_String::value(java_string);
420 int offset = java_lang_String::offset(java_string);
421 int length = java_lang_String::length(java_string);
422 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
423 return UNICODE::as_utf8(position, length, buf, buflen);
424 }
425
426 char* java_lang_String::as_utf8_string(oop java_string, int start, int len) {
427 typeArrayOop value = java_lang_String::value(java_string);
428 int offset = java_lang_String::offset(java_string);
429 int length = java_lang_String::length(java_string);
430 assert(start + len <= length, "just checking");
431 jchar* position = value->char_at_addr(offset + start);
432 return UNICODE::as_utf8(position, len);
433 }
434
435 char* java_lang_String::as_utf8_string(oop java_string, int start, int len, char* buf, int buflen) {
436 typeArrayOop value = java_lang_String::value(java_string);
437 int offset = java_lang_String::offset(java_string);
438 int length = java_lang_String::length(java_string);
439 assert(start + len <= length, "just checking");
440 jchar* position = value->char_at_addr(offset + start);
441 return UNICODE::as_utf8(position, len, buf, buflen);
442 }
443
444 bool java_lang_String::equals(oop java_string, jchar* chars, int len) {
445 assert(java_string->klass() == SystemDictionary::String_klass(),
446 "must be java_string");
447 typeArrayOop value = java_lang_String::value(java_string);
448 int offset = java_lang_String::offset(java_string);
449 int length = java_lang_String::length(java_string);
450 if (length != len) {
451 return false;
452 }
453 for (int i = 0; i < len; i++) {
454 if (value->char_at(i + offset) != chars[i]) {
455 return false;
456 }
457 }
458 return true;
459 }
460
461 bool java_lang_String::equals(oop str1, oop str2) {
462 assert(str1->klass() == SystemDictionary::String_klass(),
463 "must be java String");
464 assert(str2->klass() == SystemDictionary::String_klass(),
465 "must be java String");
466 typeArrayOop value1 = java_lang_String::value(str1);
467 int offset1 = java_lang_String::offset(str1);
468 int length1 = java_lang_String::length(str1);
469 typeArrayOop value2 = java_lang_String::value(str2);
470 int offset2 = java_lang_String::offset(str2);
471 int length2 = java_lang_String::length(str2);
472
473 if (length1 != length2) {
474 return false;
475 }
476 for (int i = 0; i < length1; i++) {
477 if (value1->char_at(i + offset1) != value2->char_at(i + offset2)) {
478 return false;
479 }
480 }
481 return true;
482 }
483
484 void java_lang_String::print(oop java_string, outputStream* st) {
485 assert(java_string->klass() == SystemDictionary::String_klass(), "must be java_string");
486 typeArrayOop value = java_lang_String::value(java_string);
487
488 if (value == NULL) {
489 // This can happen if, e.g., printing a String
490 // object before its initializer has been called
491 st->print("NULL");
492 return;
493 }
494
495 int offset = java_lang_String::offset(java_string);
496 int length = java_lang_String::length(java_string);
497
498 st->print("\"");
499 for (int index = 0; index < length; index++) {
500 st->print("%c", value->char_at(index + offset));
501 }
502 st->print("\"");
503 }
504
505
506 static void initialize_static_field(fieldDescriptor* fd, Handle mirror, TRAPS) {
507 assert(mirror.not_null() && fd->is_static(), "just checking");
508 if (fd->has_initial_value()) {
509 BasicType t = fd->field_type();
510 switch (t) {
511 case T_BYTE:
512 mirror()->byte_field_put(fd->offset(), fd->int_initial_value());
513 break;
514 case T_BOOLEAN:
515 mirror()->bool_field_put(fd->offset(), fd->int_initial_value());
516 break;
517 case T_CHAR:
518 mirror()->char_field_put(fd->offset(), fd->int_initial_value());
519 break;
520 case T_SHORT:
1152 };
1153 }
1154 int java_lang_ThreadGroup::_parent_offset = 0;
1155 int java_lang_ThreadGroup::_name_offset = 0;
1156 int java_lang_ThreadGroup::_threads_offset = 0;
1157 int java_lang_ThreadGroup::_groups_offset = 0;
1158 int java_lang_ThreadGroup::_maxPriority_offset = 0;
1159 int java_lang_ThreadGroup::_destroyed_offset = 0;
1160 int java_lang_ThreadGroup::_daemon_offset = 0;
1161 int java_lang_ThreadGroup::_vmAllowSuspension_offset = 0;
1162 int java_lang_ThreadGroup::_nthreads_offset = 0;
1163 int java_lang_ThreadGroup::_ngroups_offset = 0;
1164
1165 oop java_lang_ThreadGroup::parent(oop java_thread_group) {
1166 assert(java_thread_group->is_oop(), "thread group must be oop");
1167 return java_thread_group->obj_field(_parent_offset);
1168 }
1169
1170 // ("name as oop" accessor is not necessary)
1171
1172 typeArrayOop java_lang_ThreadGroup::name(oop java_thread_group) {
1173 oop name = java_thread_group->obj_field(_name_offset);
1174 // ThreadGroup.name can be null
1175 return name == NULL ? (typeArrayOop)NULL : java_lang_String::value(name);
1176 }
1177
1178 int java_lang_ThreadGroup::nthreads(oop java_thread_group) {
1179 assert(java_thread_group->is_oop(), "thread group must be oop");
1180 return java_thread_group->int_field(_nthreads_offset);
1181 }
1182
1183 objArrayOop java_lang_ThreadGroup::threads(oop java_thread_group) {
1184 oop threads = java_thread_group->obj_field(_threads_offset);
1185 assert(threads != NULL, "threadgroups should have threads");
1186 assert(threads->is_objArray(), "just checking"); // Todo: Add better type checking code
1187 return objArrayOop(threads);
1188 }
1189
1190 int java_lang_ThreadGroup::ngroups(oop java_thread_group) {
1191 assert(java_thread_group->is_oop(), "thread group must be oop");
1192 return java_thread_group->int_field(_ngroups_offset);
1193 }
1194
1195 objArrayOop java_lang_ThreadGroup::groups(oop java_thread_group) {
3524 // Check the hard-coded field offsets of all the classes in this file
3525
3526 void JavaClasses::check_offsets() {
3527 bool valid = true;
3528 HandleMark hm;
3529
3530 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
3531 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig)
3532
3533 #define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
3534 valid &= check_offset(klass_name, cpp_klass_name :: long_ ## field_name ## _offset, #field_name, field_sig)
3535
3536 #define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
3537 valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig)
3538
3539 #define CHECK_CONSTANT(klass_name, cpp_klass_name, field_name, field_sig) \
3540 valid &= check_constant(klass_name, cpp_klass_name :: field_name, #field_name, field_sig)
3541
3542 // java.lang.String
3543
3544 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[C");
3545 if (java_lang_String::has_offset_field()) {
3546 CHECK_OFFSET("java/lang/String", java_lang_String, offset, "I");
3547 CHECK_OFFSET("java/lang/String", java_lang_String, count, "I");
3548 }
3549 if (java_lang_String::has_hash_field()) {
3550 CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I");
3551 }
3552
3553 // java.lang.Class
3554
3555 // Fake fields
3556 // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked
3557 // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked
3558
3559 // java.lang.Throwable
3560
3561 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;");
3562 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;");
3563 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;");
3564 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;");
3565
3566 // Boxed primitive objects (java_lang_boxing_object)
3567
3568 CHECK_OFFSET("java/lang/Boolean", java_lang_boxing_object, value, "Z");
3569 CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C");
3570 CHECK_OFFSET("java/lang/Float", java_lang_boxing_object, value, "F");
|
130 #endif //PRODUCT
131 vm_exit_during_initialization("Invalid layout of preloaded class: use -XX:+TraceClassLoading to see the origin of the problem class");
132 }
133 dest_offset = fd.offset();
134 }
135
136 // Same as above but for "optional" offsets that might not be present in certain JDK versions
137 static void
138 compute_optional_offset(int& dest_offset,
139 Klass* klass_oop, Symbol* name_symbol, Symbol* signature_symbol,
140 bool allow_super = false) {
141 fieldDescriptor fd;
142 InstanceKlass* ik = InstanceKlass::cast(klass_oop);
143 if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {
144 dest_offset = fd.offset();
145 }
146 }
147
148
149 int java_lang_String::value_offset = 0;
150 int java_lang_String::hash_offset = 0;
151 int java_lang_String::coder_offset = 0;
152
153 bool java_lang_String::initialized = false;
154
155 bool java_lang_String::is_instance(oop obj) {
156 return is_instance_inlined(obj);
157 }
158
159 void java_lang_String::compute_offsets() {
160 assert(!initialized, "offsets should be initialized only once");
161
162 Klass* k = SystemDictionary::String_klass();
163 compute_offset(value_offset, k, vmSymbols::value_name(), vmSymbols::byte_array_signature());
164 compute_optional_offset(hash_offset, k, vmSymbols::hash_name(), vmSymbols::int_signature());
165 compute_optional_offset(coder_offset, k, vmSymbols::coder_name(), vmSymbols::byte_signature());
166
167 initialized = true;
168 }
169
170 class CompactStringsFixup : public FieldClosure {
171 private:
172 bool _value;
173
174 public:
175 CompactStringsFixup(bool value) : _value(value) {}
176
177 void do_field(fieldDescriptor* fd) {
178 if (fd->name() == vmSymbols::compact_strings_name()) {
179 oop mirror = fd->field_holder()->java_mirror();
180 assert(fd->field_holder() == SystemDictionary::String_klass(), "Should be String");
181 assert(mirror != NULL, "String must have mirror already");
182 mirror->bool_field_put(fd->offset(), _value);
183 }
184 }
185 };
186
187 void java_lang_String::set_compact_strings(bool value) {
188 CompactStringsFixup fix(value);
189 InstanceKlass::cast(SystemDictionary::String_klass())->do_local_static_fields(&fix);
190 }
191
192 Handle java_lang_String::basic_create(int length, bool is_latin1, TRAPS) {
193 assert(initialized, "Must be initialized");
194 assert(CompactStrings || !is_latin1, "Must be UTF16 without CompactStrings");
195
196 // Create the String object first, so there's a chance that the String
197 // and the char array it points to end up in the same cache line.
198 oop obj;
199 obj = InstanceKlass::cast(SystemDictionary::String_klass())->allocate_instance(CHECK_NH);
200
201 // Create the char array. The String object must be handlized here
202 // because GC can happen as a result of the allocation attempt.
203 Handle h_obj(THREAD, obj);
204 int arr_length = is_latin1 ? length : length << 1; // 2 bytes per UTF16.
205 typeArrayOop buffer = oopFactory::new_byteArray(arr_length, CHECK_NH);;
206
207 // Point the String at the char array
208 obj = h_obj();
209 set_value(obj, buffer);
210 // No need to zero the offset, allocation zero'ed the entire String object
211 set_coder(obj, is_latin1 ? CODER_LATIN1 : CODER_UTF16);
212 return h_obj;
213 }
214
215 Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) {
216 bool is_latin1 = CompactStrings && UNICODE::is_latin1(unicode, length);
217 Handle h_obj = basic_create(length, is_latin1, CHECK_NH);
218 typeArrayOop buffer = value(h_obj());
219 assert(TypeArrayKlass::cast(buffer->klass())->element_type() == T_BYTE, "only byte[]");
220 if (is_latin1) {
221 for (int index = 0; index < length; index++) {
222 buffer->byte_at_put(index, (jbyte)unicode[index]);
223 }
224 } else {
225 for (int index = 0; index < length; index++) {
226 buffer->char_at_put(index, unicode[index]);
227 }
228 }
229
230 #ifdef ASSERT
231 {
232 ResourceMark rm;
233 char* expected = UNICODE::as_utf8(unicode, length);
234 char* actual = as_utf8_string(h_obj());
235 if (strcmp(expected, actual) != 0) {
236 tty->print_cr("Unicode conversion failure: %s --> %s", expected, actual);
237 ShouldNotReachHere();
238 }
239 }
240 #endif
241
242 return h_obj;
243 }
244
245 oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) {
246 Handle h_obj = create_from_unicode(unicode, length, CHECK_0);
247 return h_obj();
248 }
249
250 Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) {
251 if (utf8_str == NULL) {
252 return Handle();
253 }
254 bool has_multibyte, is_latin1;
255 int length = UTF8::unicode_length(utf8_str, is_latin1, has_multibyte);
256 if (!CompactStrings) {
257 has_multibyte = true;
258 is_latin1 = false;
259 }
260
261 Handle h_obj = basic_create(length, is_latin1, CHECK_NH);
262 if (length > 0) {
263 if (!has_multibyte) {
264 strncpy((char*)value(h_obj())->byte_at_addr(0), utf8_str, length);
265 } else if (is_latin1) {
266 UTF8::convert_to_unicode(utf8_str, value(h_obj())->byte_at_addr(0), length);
267 } else {
268 UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length);
269 }
270 }
271
272 #ifdef ASSERT
273 // This check is too strict because the input string is not necessarily valid UTF8.
274 // For example, it may be created with arbitrary content via jni_NewStringUTF.
275 /*
276 {
277 ResourceMark rm;
278 const char* expected = utf8_str;
279 char* actual = as_utf8_string(h_obj());
280 if (strcmp(expected, actual) != 0) {
281 tty->print_cr("String conversion failure: %s --> %s", expected, actual);
282 ShouldNotReachHere();
283 }
284 }
285 */
286 #endif
287
288 return h_obj;
289 }
290
291 oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) {
292 Handle h_obj = create_from_str(utf8_str, CHECK_0);
293 return h_obj();
294 }
295
296 Handle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) {
297 const char* utf8_str = (char*)symbol->bytes();
298 int utf8_len = symbol->utf8_length();
299
300 bool has_multibyte, is_latin1;
301 int length = UTF8::unicode_length(utf8_str, utf8_len, is_latin1, has_multibyte);
302 if (!CompactStrings) {
303 has_multibyte = true;
304 is_latin1 = false;
305 }
306
307 Handle h_obj = basic_create(length, is_latin1, CHECK_NH);
308 if (length > 0) {
309 if (!has_multibyte) {
310 strncpy((char*)value(h_obj())->byte_at_addr(0), utf8_str, length);
311 } else if (is_latin1) {
312 UTF8::convert_to_unicode(utf8_str, value(h_obj())->byte_at_addr(0), length);
313 } else {
314 UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length);
315 }
316 }
317
318 #ifdef ASSERT
319 {
320 ResourceMark rm;
321 const char* expected = symbol->as_utf8();
322 char* actual = as_utf8_string(h_obj());
323 if (strncmp(expected, actual, utf8_len) != 0) {
324 tty->print_cr("Symbol conversion failure: %s --> %s", expected, actual);
325 ShouldNotReachHere();
326 }
327 }
328 #endif
329
330 return h_obj;
331 }
332
333 // Converts a C string to a Java String based on current encoding
334 Handle java_lang_String::create_from_platform_dependent_str(const char* str, TRAPS) {
335 assert(str != NULL, "bad arguments");
336
337 typedef jstring (*to_java_string_fn_t)(JNIEnv*, const char *);
338 static to_java_string_fn_t _to_java_string_fn = NULL;
339
340 if (_to_java_string_fn == NULL) {
341 void *lib_handle = os::native_java_library();
342 _to_java_string_fn = CAST_TO_FN_PTR(to_java_string_fn_t, os::dll_lookup(lib_handle, "NewStringPlatform"));
343 if (_to_java_string_fn == NULL) {
344 fatal("NewStringPlatform missing");
345 }
346 }
347
348 jstring js = NULL;
349 { JavaThread* thread = (JavaThread*)THREAD;
350 assert(thread->is_Java_thread(), "must be java thread");
351 HandleMark hm(thread);
352 ThreadToNativeFromVM ttn(thread);
353 js = (_to_java_string_fn)(thread->jni_environment(), str);
354 }
355 return Handle(THREAD, JNIHandles::resolve(js));
356 }
357
358 // Converts a Java String to a native C string that can be used for
359 // native OS calls.
360 char* java_lang_String::as_platform_dependent_str(Handle java_string, TRAPS) {
361 typedef char* (*to_platform_string_fn_t)(JNIEnv*, jstring, bool*);
362 static to_platform_string_fn_t _to_platform_string_fn = NULL;
363
364 if (_to_platform_string_fn == NULL) {
365 void *lib_handle = os::native_java_library();
366 _to_platform_string_fn = CAST_TO_FN_PTR(to_platform_string_fn_t, os::dll_lookup(lib_handle, "GetStringPlatformChars"));
367 if (_to_platform_string_fn == NULL) {
368 fatal("GetStringPlatformChars missing");
369 }
370 }
371
372 char *native_platform_string;
373 { JavaThread* thread = (JavaThread*)THREAD;
374 assert(thread->is_Java_thread(), "must be java thread");
375 JNIEnv *env = thread->jni_environment();
376 jstring js = (jstring) JNIHandles::make_local(env, java_string());
377 bool is_copy;
378 HandleMark hm(thread);
379 ThreadToNativeFromVM ttn(thread);
380 native_platform_string = (_to_platform_string_fn)(env, js, &is_copy);
381 assert(is_copy == JNI_TRUE, "is_copy value changed");
382 JNIHandles::destroy_local(js);
383 }
384 return native_platform_string;
385 }
386
387 Handle java_lang_String::char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS) {
388 oop obj = java_string();
389 // Typical usage is to convert all '/' to '.' in string.
390 typeArrayOop value = java_lang_String::value(obj);
391 int length = java_lang_String::length(obj);
392 bool is_latin1 = java_lang_String::is_latin1(obj);
393
394 // First check if any from_char exist
395 int index; // Declared outside, used later
396 for (index = 0; index < length; index++) {
397 jchar c = !is_latin1 ? value->char_at(index) :
398 ((jchar) value->byte_at(index)) & 0xff;
399 if (c == from_char) {
400 break;
401 }
402 }
403 if (index == length) {
404 // No from_char, so do not copy.
405 return java_string;
406 }
407
408 // Check if result string will be latin1
409 bool to_is_latin1 = false;
410
411 // Replacement char must be latin1
412 if (CompactStrings && UNICODE::is_latin1(to_char)) {
413 if (is_latin1) {
414 // Source string is latin1 as well
415 to_is_latin1 = true;
416 } else if (!UNICODE::is_latin1(from_char)) {
417 // We are replacing an UTF16 char. Scan string to
418 // check if result can be latin1 encoded.
419 to_is_latin1 = true;
420 for (index = 0; index < length; index++) {
421 jchar c = value->char_at(index);
422 if (c != from_char && !UNICODE::is_latin1(c)) {
423 to_is_latin1 = false;
424 break;
425 }
426 }
427 }
428 }
429
430 // Create new UNICODE (or byte) buffer. Must handlize value because GC
431 // may happen during String and char array creation.
432 typeArrayHandle h_value(THREAD, value);
433 Handle string = basic_create(length, to_is_latin1, CHECK_NH);
434 typeArrayOop from_buffer = h_value();
435 typeArrayOop to_buffer = java_lang_String::value(string());
436
437 // Copy contents
438 for (index = 0; index < length; index++) {
439 jchar c = (!is_latin1) ? from_buffer->char_at(index) :
440 ((jchar) from_buffer->byte_at(index)) & 0xff;
441 if (c == from_char) {
442 c = to_char;
443 }
444 if (!to_is_latin1) {
445 to_buffer->char_at_put(index, c);
446 } else {
447 to_buffer->byte_at_put(index, (jbyte) c);
448 }
449 }
450 return string;
451 }
452
453 jchar* java_lang_String::as_unicode_string(oop java_string, int& length, TRAPS) {
454 typeArrayOop value = java_lang_String::value(java_string);
455 length = java_lang_String::length(java_string);
456 bool is_latin1 = java_lang_String::is_latin1(java_string);
457
458 jchar* result = NEW_RESOURCE_ARRAY_RETURN_NULL(jchar, length);
459 if (result != NULL) {
460 if (!is_latin1) {
461 for (int index = 0; index < length; index++) {
462 result[index] = value->char_at(index);
463 }
464 } else {
465 for (int index = 0; index < length; index++) {
466 result[index] = ((jchar) value->byte_at(index)) & 0xff;
467 }
468 }
469 } else {
470 THROW_MSG_0(vmSymbols::java_lang_OutOfMemoryError(), "could not allocate Unicode string");
471 }
472 return result;
473 }
474
475 unsigned int java_lang_String::hash_code(oop java_string) {
476 int length = java_lang_String::length(java_string);
477 // Zero length string will hash to zero with String.hashCode() function.
478 if (length == 0) return 0;
479
480 typeArrayOop value = java_lang_String::value(java_string);
481 bool is_latin1 = java_lang_String::is_latin1(java_string);
482
483 if (is_latin1) {
484 return java_lang_String::hash_code(value->byte_at_addr(0), length);
485 } else {
486 return java_lang_String::hash_code(value->char_at_addr(0), length);
487 }
488 }
489
490 char* java_lang_String::as_quoted_ascii(oop java_string) {
491 typeArrayOop value = java_lang_String::value(java_string);
492 int length = java_lang_String::length(java_string);
493 bool is_latin1 = java_lang_String::is_latin1(java_string);
494
495 if (length == 0) return NULL;
496
497 char* result;
498 int result_length;
499 if (!is_latin1) {
500 jchar* base = value->char_at_addr(0);
501 result_length = UNICODE::quoted_ascii_length(base, length) + 1;
502 result = NEW_RESOURCE_ARRAY(char, result_length);
503 UNICODE::as_quoted_ascii(base, length, result, result_length);
504 } else {
505 jbyte* base = value->byte_at_addr(0);
506 result_length = UNICODE::quoted_ascii_length(base, length) + 1;
507 result = NEW_RESOURCE_ARRAY(char, result_length);
508 UNICODE::as_quoted_ascii(base, length, result, result_length);
509 }
510 assert(result_length >= length + 1, "must not be shorter");
511 assert(result_length == (int)strlen(result) + 1, "must match");
512 return result;
513 }
514
515 unsigned int java_lang_String::hash_string(oop java_string) {
516 int length = java_lang_String::length(java_string);
517 // Zero length string doesn't necessarily hash to zero.
518 if (length == 0) {
519 return StringTable::hash_string((jchar*) NULL, 0);
520 }
521
522 typeArrayOop value = java_lang_String::value(java_string);
523 bool is_latin1 = java_lang_String::is_latin1(java_string);
524 if (is_latin1) {
525 return StringTable::hash_string(value->byte_at_addr(0), length);
526 } else {
527 return StringTable::hash_string(value->char_at_addr(0), length);
528 }
529 }
530
531 Symbol* java_lang_String::as_symbol(Handle java_string, TRAPS) {
532 oop obj = java_string();
533 typeArrayOop value = java_lang_String::value(obj);
534 int length = java_lang_String::length(obj);
535 bool is_latin1 = java_lang_String::is_latin1(obj);
536 if (!is_latin1) {
537 jchar* base = (length == 0) ? NULL : value->char_at_addr(0);
538 Symbol* sym = SymbolTable::lookup_unicode(base, length, THREAD);
539 return sym;
540 } else {
541 ResourceMark rm;
542 jbyte* position = (length == 0) ? NULL : value->byte_at_addr(0);
543 const char* base = UNICODE::as_utf8(position, length);
544 Symbol* sym = SymbolTable::lookup(base, length, THREAD);
545 return sym;
546 }
547 }
548
549 Symbol* java_lang_String::as_symbol_or_null(oop java_string) {
550 typeArrayOop value = java_lang_String::value(java_string);
551 int length = java_lang_String::length(java_string);
552 bool is_latin1 = java_lang_String::is_latin1(java_string);
553 if (!is_latin1) {
554 jchar* base = (length == 0) ? NULL : value->char_at_addr(0);
555 return SymbolTable::probe_unicode(base, length);
556 } else {
557 ResourceMark rm;
558 jbyte* position = (length == 0) ? NULL : value->byte_at_addr(0);
559 const char* base = UNICODE::as_utf8(position, length);
560 return SymbolTable::probe(base, length);
561 }
562 }
563
564 int java_lang_String::utf8_length(oop java_string) {
565 typeArrayOop value = java_lang_String::value(java_string);
566 int length = java_lang_String::length(java_string);
567 bool is_latin1 = java_lang_String::is_latin1(java_string);
568 if (length == 0) {
569 return 0;
570 }
571 if (!is_latin1) {
572 return UNICODE::utf8_length(value->char_at_addr(0), length);
573 } else {
574 return UNICODE::utf8_length(value->byte_at_addr(0), length);
575 }
576 }
577
578 char* java_lang_String::as_utf8_string(oop java_string) {
579 typeArrayOop value = java_lang_String::value(java_string);
580 int length = java_lang_String::length(java_string);
581 bool is_latin1 = java_lang_String::is_latin1(java_string);
582 if (!is_latin1) {
583 jchar* position = (length == 0) ? NULL : value->char_at_addr(0);
584 return UNICODE::as_utf8(position, length);
585 } else {
586 jbyte* position = (length == 0) ? NULL : value->byte_at_addr(0);
587 return UNICODE::as_utf8(position, length);
588 }
589 }
590
591 char* java_lang_String::as_utf8_string(oop java_string, char* buf, int buflen) {
592 typeArrayOop value = java_lang_String::value(java_string);
593 int length = java_lang_String::length(java_string);
594 bool is_latin1 = java_lang_String::is_latin1(java_string);
595 if (!is_latin1) {
596 jchar* position = (length == 0) ? NULL : value->char_at_addr(0);
597 return UNICODE::as_utf8(position, length, buf, buflen);
598 } else {
599 jbyte* position = (length == 0) ? NULL : value->byte_at_addr(0);
600 return UNICODE::as_utf8(position, length, buf, buflen);
601 }
602 }
603
604 char* java_lang_String::as_utf8_string(oop java_string, int start, int len) {
605 typeArrayOop value = java_lang_String::value(java_string);
606 int length = java_lang_String::length(java_string);
607 assert(start + len <= length, "just checking");
608 bool is_latin1 = java_lang_String::is_latin1(java_string);
609 if (!is_latin1) {
610 jchar* position = value->char_at_addr(start);
611 return UNICODE::as_utf8(position, len);
612 } else {
613 jbyte* position = value->byte_at_addr(start);
614 return UNICODE::as_utf8(position, len);
615 }
616 }
617
618 char* java_lang_String::as_utf8_string(oop java_string, int start, int len, char* buf, int buflen) {
619 typeArrayOop value = java_lang_String::value(java_string);
620 int length = java_lang_String::length(java_string);
621 assert(start + len <= length, "just checking");
622 bool is_latin1 = java_lang_String::is_latin1(java_string);
623 if (!is_latin1) {
624 jchar* position = value->char_at_addr(start);
625 return UNICODE::as_utf8(position, len, buf, buflen);
626 } else {
627 jbyte* position = value->byte_at_addr(start);
628 return UNICODE::as_utf8(position, len, buf, buflen);
629 }
630 }
631
632 bool java_lang_String::equals(oop java_string, jchar* chars, int len) {
633 assert(java_string->klass() == SystemDictionary::String_klass(),
634 "must be java_string");
635 typeArrayOop value = java_lang_String::value(java_string);
636 int length = java_lang_String::length(java_string);
637 if (length != len) {
638 return false;
639 }
640 bool is_latin1 = java_lang_String::is_latin1(java_string);
641 if (!is_latin1) {
642 for (int i = 0; i < len; i++) {
643 if (value->char_at(i) != chars[i]) {
644 return false;
645 }
646 }
647 } else {
648 for (int i = 0; i < len; i++) {
649 if ((((jchar) value->byte_at(i)) & 0xff) != chars[i]) {
650 return false;
651 }
652 }
653 }
654 return true;
655 }
656
657 bool java_lang_String::equals(oop str1, oop str2) {
658 assert(str1->klass() == SystemDictionary::String_klass(),
659 "must be java String");
660 assert(str2->klass() == SystemDictionary::String_klass(),
661 "must be java String");
662 typeArrayOop value1 = java_lang_String::value(str1);
663 int length1 = java_lang_String::length(str1);
664 bool is_latin1 = java_lang_String::is_latin1(str1);
665 typeArrayOop value2 = java_lang_String::value(str2);
666 int length2 = java_lang_String::length(str2);
667 bool is_latin2 = java_lang_String::is_latin1(str2);
668
669 if ((length1 != length2) || (is_latin1 != is_latin2)) {
670 // Strings of different size or with different
671 // coders are never equal.
672 return false;
673 }
674 int blength1 = value1->length();
675 for (int i = 0; i < value1->length(); i++) {
676 if (value1->byte_at(i) != value2->byte_at(i)) {
677 return false;
678 }
679 }
680 return true;
681 }
682
683 void java_lang_String::print(oop java_string, outputStream* st) {
684 assert(java_string->klass() == SystemDictionary::String_klass(), "must be java_string");
685 typeArrayOop value = java_lang_String::value(java_string);
686
687 if (value == NULL) {
688 // This can happen if, e.g., printing a String
689 // object before its initializer has been called
690 st->print("NULL");
691 return;
692 }
693
694 int length = java_lang_String::length(java_string);
695 bool is_latin1 = java_lang_String::is_latin1(java_string);
696
697 st->print("\"");
698 for (int index = 0; index < length; index++) {
699 st->print("%c", (!is_latin1) ? value->char_at(index) :
700 ((jchar) value->byte_at(index)) & 0xff );
701 }
702 st->print("\"");
703 }
704
705
706 static void initialize_static_field(fieldDescriptor* fd, Handle mirror, TRAPS) {
707 assert(mirror.not_null() && fd->is_static(), "just checking");
708 if (fd->has_initial_value()) {
709 BasicType t = fd->field_type();
710 switch (t) {
711 case T_BYTE:
712 mirror()->byte_field_put(fd->offset(), fd->int_initial_value());
713 break;
714 case T_BOOLEAN:
715 mirror()->bool_field_put(fd->offset(), fd->int_initial_value());
716 break;
717 case T_CHAR:
718 mirror()->char_field_put(fd->offset(), fd->int_initial_value());
719 break;
720 case T_SHORT:
1352 };
1353 }
1354 int java_lang_ThreadGroup::_parent_offset = 0;
1355 int java_lang_ThreadGroup::_name_offset = 0;
1356 int java_lang_ThreadGroup::_threads_offset = 0;
1357 int java_lang_ThreadGroup::_groups_offset = 0;
1358 int java_lang_ThreadGroup::_maxPriority_offset = 0;
1359 int java_lang_ThreadGroup::_destroyed_offset = 0;
1360 int java_lang_ThreadGroup::_daemon_offset = 0;
1361 int java_lang_ThreadGroup::_vmAllowSuspension_offset = 0;
1362 int java_lang_ThreadGroup::_nthreads_offset = 0;
1363 int java_lang_ThreadGroup::_ngroups_offset = 0;
1364
1365 oop java_lang_ThreadGroup::parent(oop java_thread_group) {
1366 assert(java_thread_group->is_oop(), "thread group must be oop");
1367 return java_thread_group->obj_field(_parent_offset);
1368 }
1369
1370 // ("name as oop" accessor is not necessary)
1371
1372 const char* java_lang_ThreadGroup::name(oop java_thread_group) {
1373 oop name = java_thread_group->obj_field(_name_offset);
1374 // ThreadGroup.name can be null
1375 if (name != NULL) {
1376 return java_lang_String::as_utf8_string(name);
1377 }
1378 return NULL;
1379 }
1380
1381 int java_lang_ThreadGroup::nthreads(oop java_thread_group) {
1382 assert(java_thread_group->is_oop(), "thread group must be oop");
1383 return java_thread_group->int_field(_nthreads_offset);
1384 }
1385
1386 objArrayOop java_lang_ThreadGroup::threads(oop java_thread_group) {
1387 oop threads = java_thread_group->obj_field(_threads_offset);
1388 assert(threads != NULL, "threadgroups should have threads");
1389 assert(threads->is_objArray(), "just checking"); // Todo: Add better type checking code
1390 return objArrayOop(threads);
1391 }
1392
1393 int java_lang_ThreadGroup::ngroups(oop java_thread_group) {
1394 assert(java_thread_group->is_oop(), "thread group must be oop");
1395 return java_thread_group->int_field(_ngroups_offset);
1396 }
1397
1398 objArrayOop java_lang_ThreadGroup::groups(oop java_thread_group) {
3727 // Check the hard-coded field offsets of all the classes in this file
3728
3729 void JavaClasses::check_offsets() {
3730 bool valid = true;
3731 HandleMark hm;
3732
3733 #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
3734 valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig)
3735
3736 #define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
3737 valid &= check_offset(klass_name, cpp_klass_name :: long_ ## field_name ## _offset, #field_name, field_sig)
3738
3739 #define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
3740 valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig)
3741
3742 #define CHECK_CONSTANT(klass_name, cpp_klass_name, field_name, field_sig) \
3743 valid &= check_constant(klass_name, cpp_klass_name :: field_name, #field_name, field_sig)
3744
3745 // java.lang.String
3746
3747 CHECK_OFFSET("java/lang/String", java_lang_String, value, "[B");
3748 if (java_lang_String::has_hash_field()) {
3749 CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I");
3750 }
3751 if (java_lang_String::has_coder_field()) {
3752 CHECK_OFFSET("java/lang/String", java_lang_String, coder, "B");
3753 }
3754
3755 // java.lang.Class
3756
3757 // Fake fields
3758 // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked
3759 // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked
3760
3761 // java.lang.Throwable
3762
3763 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;");
3764 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;");
3765 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;");
3766 CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;");
3767
3768 // Boxed primitive objects (java_lang_boxing_object)
3769
3770 CHECK_OFFSET("java/lang/Boolean", java_lang_boxing_object, value, "Z");
3771 CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C");
3772 CHECK_OFFSET("java/lang/Float", java_lang_boxing_object, value, "F");
|