javaClasses.cpp 125.5 KB
Newer Older
D
duke 已提交
1
/*
K
kvn 已提交
2
 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
D
duke 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
19 20 21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
D
duke 已提交
22 23 24
 *
 */

25
#include "precompiled.hpp"
26
#include "classfile/altHashing.hpp"
27 28 29 30 31
#include "classfile/javaClasses.hpp"
#include "classfile/symbolTable.hpp"
#include "classfile/vmSymbols.hpp"
#include "code/debugInfo.hpp"
#include "code/pcDesc.hpp"
32
#include "compiler/compilerOracle.hpp"
33 34 35 36
#include "interpreter/interpreter.hpp"
#include "memory/oopFactory.hpp"
#include "memory/resourceArea.hpp"
#include "memory/universe.inline.hpp"
37
#include "oops/fieldStreams.hpp"
38
#include "oops/instanceKlass.hpp"
39
#include "oops/instanceMirrorKlass.hpp"
40
#include "oops/klass.hpp"
41
#include "oops/method.hpp"
42
#include "oops/symbol.hpp"
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
#include "oops/typeArrayOop.hpp"
#include "runtime/fieldDescriptor.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/interfaceSupport.hpp"
#include "runtime/java.hpp"
#include "runtime/javaCalls.hpp"
#include "runtime/safepoint.hpp"
#include "runtime/vframe.hpp"
#include "utilities/preserveException.hpp"
#ifdef TARGET_OS_FAMILY_linux
# include "thread_linux.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_solaris
# include "thread_solaris.inline.hpp"
#endif
#ifdef TARGET_OS_FAMILY_windows
# include "thread_windows.inline.hpp"
#endif
N
never 已提交
61 62 63
#ifdef TARGET_OS_FAMILY_bsd
# include "thread_bsd.inline.hpp"
#endif
D
duke 已提交
64

65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
#define INJECTED_FIELD_COMPUTE_OFFSET(klass, name, signature, may_be_java)    \
  klass::_##name##_offset = JavaClasses::compute_injected_offset(JavaClasses::klass##_##name##_enum);

#define DECLARE_INJECTED_FIELD(klass, name, signature, may_be_java)           \
  { SystemDictionary::WK_KLASS_ENUM_NAME(klass), vmSymbols::VM_SYMBOL_ENUM_NAME(name##_name), vmSymbols::VM_SYMBOL_ENUM_NAME(signature), may_be_java },

InjectedField JavaClasses::_injected_fields[] = {
  ALL_INJECTED_FIELDS(DECLARE_INJECTED_FIELD)
};

int JavaClasses::compute_injected_offset(InjectedFieldID id) {
  return _injected_fields[id].compute_offset();
}


InjectedField* JavaClasses::get_injected(Symbol* class_name, int* field_count) {
  *field_count = 0;

  vmSymbols::SID sid = vmSymbols::find_sid(class_name);
  if (sid == vmSymbols::NO_SID) {
    // Only well known classes can inject fields
    return NULL;
  }

  int count = 0;
  int start = -1;

#define LOOKUP_INJECTED_FIELD(klass, name, signature, may_be_java) \
  if (sid == vmSymbols::VM_SYMBOL_ENUM_NAME(klass)) {              \
    count++;                                                       \
    if (start == -1) start = klass##_##name##_enum;                \
  }
  ALL_INJECTED_FIELDS(LOOKUP_INJECTED_FIELD);
#undef LOOKUP_INJECTED_FIELD

  if (start != -1) {
    *field_count = count;
    return _injected_fields + start;
  }
  return NULL;
}


108
static bool find_field(InstanceKlass* ik,
109
                       Symbol* name_symbol, Symbol* signature_symbol,
110 111 112 113 114 115 116 117
                       fieldDescriptor* fd,
                       bool allow_super = false) {
  if (allow_super)
    return ik->find_field(name_symbol, signature_symbol, fd) != NULL;
  else
    return ik->find_local_field(name_symbol, signature_symbol, fd);
}

118 119 120
// Helpful routine for computing field offsets at run time rather than hardcoding them
static void
compute_offset(int &dest_offset,
121
               Klass* klass_oop, Symbol* name_symbol, Symbol* signature_symbol,
122
               bool allow_super = false) {
123
  fieldDescriptor fd;
124
  InstanceKlass* ik = InstanceKlass::cast(klass_oop);
125
  if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {
126 127
    ResourceMark rm;
    tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string());
128 129 130
#ifndef PRODUCT
    klass_oop->print();
    tty->print_cr("all fields:");
131
    for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) {
132 133 134
      tty->print_cr("  name: %s, sig: %s, flags: %08x", fs.name()->as_C_string(), fs.signature()->as_C_string(), fs.access_flags().as_int());
    }
#endif //PRODUCT
135 136 137
    fatal("Invalid layout of preloaded class");
  }
  dest_offset = fd.offset();
D
duke 已提交
138 139 140
}

// Same as above but for "optional" offsets that might not be present in certain JDK versions
141 142
static void
compute_optional_offset(int& dest_offset,
143
                        Klass* klass_oop, Symbol* name_symbol, Symbol* signature_symbol,
144
                        bool allow_super = false) {
145
  fieldDescriptor fd;
146
  InstanceKlass* ik = InstanceKlass::cast(klass_oop);
147
  if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {
148 149
    dest_offset = fd.offset();
  }
D
duke 已提交
150 151
}

152

K
kvn 已提交
153 154 155 156 157 158 159 160 161 162
int java_lang_String::value_offset  = 0;
int java_lang_String::offset_offset = 0;
int java_lang_String::count_offset  = 0;
int java_lang_String::hash_offset   = 0;

bool java_lang_String::initialized  = false;

void java_lang_String::compute_offsets() {
  assert(!initialized, "offsets should be initialized only once");

163
  Klass* k = SystemDictionary::String_klass();
K
kvn 已提交
164 165 166 167 168 169 170 171
  compute_offset(value_offset,           k, vmSymbols::value_name(),  vmSymbols::char_array_signature());
  compute_optional_offset(offset_offset, k, vmSymbols::offset_name(), vmSymbols::int_signature());
  compute_optional_offset(count_offset,  k, vmSymbols::count_name(),  vmSymbols::int_signature());
  compute_optional_offset(hash_offset,   k, vmSymbols::hash_name(),   vmSymbols::int_signature());

  initialized = true;
}

172
Handle java_lang_String::basic_create(int length, TRAPS) {
K
kvn 已提交
173
  assert(initialized, "Must be initialized");
D
duke 已提交
174 175 176
  // Create the String object first, so there's a chance that the String
  // and the char array it points to end up in the same cache line.
  oop obj;
177
  obj = InstanceKlass::cast(SystemDictionary::String_klass())->allocate_instance(CHECK_NH);
D
duke 已提交
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195

  // Create the char array.  The String object must be handlized here
  // because GC can happen as a result of the allocation attempt.
  Handle h_obj(THREAD, obj);
  typeArrayOop buffer;
    buffer = oopFactory::new_charArray(length, CHECK_NH);

  // Point the String at the char array
  obj = h_obj();
  set_value(obj, buffer);
  // No need to zero the offset, allocation zero'ed the entire String object
  assert(offset(obj) == 0, "initial String offset should be zero");
//set_offset(obj, 0);
  set_count(obj, length);

  return h_obj;
}

196 197
Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) {
  Handle h_obj = basic_create(length, CHECK_NH);
D
duke 已提交
198 199 200 201 202 203 204 205
  typeArrayOop buffer = value(h_obj());
  for (int index = 0; index < length; index++) {
    buffer->char_at_put(index, unicode[index]);
  }
  return h_obj;
}

oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) {
206
  Handle h_obj = create_from_unicode(unicode, length, CHECK_0);
D
duke 已提交
207 208 209 210 211 212 213 214
  return h_obj();
}

Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) {
  if (utf8_str == NULL) {
    return Handle();
  }
  int length = UTF8::unicode_length(utf8_str);
215
  Handle h_obj = basic_create(length, CHECK_NH);
D
duke 已提交
216 217 218 219 220 221 222 223 224 225 226
  if (length > 0) {
    UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length);
  }
  return h_obj;
}

oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) {
  Handle h_obj = create_from_str(utf8_str, CHECK_0);
  return h_obj();
}

227
Handle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) {
D
duke 已提交
228
  int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length());
229
  Handle h_obj = basic_create(length, CHECK_NH);
D
duke 已提交
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
  if (length > 0) {
    UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length);
  }
  return h_obj;
}

// Converts a C string to a Java String based on current encoding
Handle java_lang_String::create_from_platform_dependent_str(const char* str, TRAPS) {
  assert(str != NULL, "bad arguments");

  typedef jstring (*to_java_string_fn_t)(JNIEnv*, const char *);
  static to_java_string_fn_t _to_java_string_fn = NULL;

  if (_to_java_string_fn == NULL) {
    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"));
D
duke 已提交
246 247 248 249 250 251 252 253 254
    if (_to_java_string_fn == NULL) {
      fatal("NewStringPlatform missing");
    }
  }

  jstring js = NULL;
  { JavaThread* thread = (JavaThread*)THREAD;
    assert(thread->is_Java_thread(), "must be java thread");
    HandleMark hm(thread);
255
    ThreadToNativeFromVM ttn(thread);
D
duke 已提交
256 257 258 259 260
    js = (_to_java_string_fn)(thread->jni_environment(), str);
  }
  return Handle(THREAD, JNIHandles::resolve(js));
}

261 262 263 264 265 266 267 268 269
// Converts a Java String to a native C string that can be used for
// native OS calls.
char* java_lang_String::as_platform_dependent_str(Handle java_string, TRAPS) {

  typedef char* (*to_platform_string_fn_t)(JNIEnv*, jstring, bool*);
  static to_platform_string_fn_t _to_platform_string_fn = NULL;

  if (_to_platform_string_fn == NULL) {
    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 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
    if (_to_platform_string_fn == NULL) {
      fatal("GetStringPlatformChars missing");
    }
  }

  char *native_platform_string;
  { JavaThread* thread = (JavaThread*)THREAD;
    assert(thread->is_Java_thread(), "must be java thread");
    JNIEnv *env = thread->jni_environment();
    jstring js = (jstring) JNIHandles::make_local(env, java_string());
    bool is_copy;
    HandleMark hm(thread);
    ThreadToNativeFromVM ttn(thread);
    native_platform_string = (_to_platform_string_fn)(env, js, &is_copy);
    assert(is_copy == JNI_TRUE, "is_copy value changed");
    JNIHandles::destroy_local(js);
  }
  return native_platform_string;
}

D
duke 已提交
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
Handle java_lang_String::char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS) {
  oop          obj    = java_string();
  // Typical usage is to convert all '/' to '.' in string.
  typeArrayOop value  = java_lang_String::value(obj);
  int          offset = java_lang_String::offset(obj);
  int          length = java_lang_String::length(obj);

  // First check if any from_char exist
  int index; // Declared outside, used later
  for (index = 0; index < length; index++) {
    if (value->char_at(index + offset) == from_char) {
      break;
    }
  }
  if (index == length) {
    // No from_char, so do not copy.
    return java_string;
  }

  // Create new UNICODE buffer. Must handlize value because GC
  // may happen during String and char array creation.
  typeArrayHandle h_value(THREAD, value);
313
  Handle string = basic_create(length, CHECK_NH);
D
duke 已提交
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340

  typeArrayOop from_buffer = h_value();
  typeArrayOop to_buffer   = java_lang_String::value(string());

  // Copy contents
  for (index = 0; index < length; index++) {
    jchar c = from_buffer->char_at(index + offset);
    if (c == from_char) {
      c = to_char;
    }
    to_buffer->char_at_put(index, c);
  }
  return string;
}

jchar* java_lang_String::as_unicode_string(oop java_string, int& length) {
  typeArrayOop value  = java_lang_String::value(java_string);
  int          offset = java_lang_String::offset(java_string);
               length = java_lang_String::length(java_string);

  jchar* result = NEW_RESOURCE_ARRAY(jchar, length);
  for (int index = 0; index < length; index++) {
    result[index] = value->char_at(index + offset);
  }
  return result;
}

341 342 343 344 345
unsigned int java_lang_String::to_hash(oop java_string) {
  int          length = java_lang_String::length(java_string);
  // Zero length string will hash to zero with String.toHash() function.
  if (length == 0) return 0;

346 347
  typeArrayOop value  = java_lang_String::value(java_string);
  int          offset = java_lang_String::offset(java_string);
348 349 350 351
  return java_lang_String::to_hash(value->char_at_addr(offset), length);
}

unsigned int java_lang_String::hash_string(oop java_string) {
352
  int          length = java_lang_String::length(java_string);
353 354 355 356
  // Zero length string doesn't hash necessarily hash to zero.
  if (length == 0) {
    return StringTable::hash_string(NULL, 0);
  }
357

358 359 360
  typeArrayOop value  = java_lang_String::value(java_string);
  int          offset = java_lang_String::offset(java_string);
  return StringTable::hash_string(value->char_at_addr(offset), length);
361 362
}

363
Symbol* java_lang_String::as_symbol(Handle java_string, TRAPS) {
D
duke 已提交
364 365 366 367
  oop          obj    = java_string();
  typeArrayOop value  = java_lang_String::value(obj);
  int          offset = java_lang_String::offset(obj);
  int          length = java_lang_String::length(obj);
368
  jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
369 370
  Symbol* sym = SymbolTable::lookup_unicode(base, length, THREAD);
  return sym;
371
}
D
duke 已提交
372

373
Symbol* java_lang_String::as_symbol_or_null(oop java_string) {
374 375 376
  typeArrayOop value  = java_lang_String::value(java_string);
  int          offset = java_lang_String::offset(java_string);
  int          length = java_lang_String::length(java_string);
377
  jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
378
  return SymbolTable::probe_unicode(base, length);
D
duke 已提交
379 380
}

381

D
duke 已提交
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
int java_lang_String::utf8_length(oop java_string) {
  typeArrayOop value  = java_lang_String::value(java_string);
  int          offset = java_lang_String::offset(java_string);
  int          length = java_lang_String::length(java_string);
  jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
  return UNICODE::utf8_length(position, length);
}

char* java_lang_String::as_utf8_string(oop java_string) {
  typeArrayOop value  = java_lang_String::value(java_string);
  int          offset = java_lang_String::offset(java_string);
  int          length = java_lang_String::length(java_string);
  jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
  return UNICODE::as_utf8(position, length);
}

398 399 400 401 402 403 404 405
char* java_lang_String::as_utf8_string(oop java_string, char* buf, int buflen) {
  typeArrayOop value  = java_lang_String::value(java_string);
  int          offset = java_lang_String::offset(java_string);
  int          length = java_lang_String::length(java_string);
  jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
  return UNICODE::as_utf8(position, length, buf, buflen);
}

D
duke 已提交
406 407 408 409 410 411 412 413 414 415 416
char* java_lang_String::as_utf8_string(oop java_string, int start, int len) {
  typeArrayOop value  = java_lang_String::value(java_string);
  int          offset = java_lang_String::offset(java_string);
  int          length = java_lang_String::length(java_string);
  assert(start + len <= length, "just checking");
  jchar* position = value->char_at_addr(offset + start);
  return UNICODE::as_utf8(position, len);
}

bool java_lang_String::equals(oop java_string, jchar* chars, int len) {
  assert(SharedSkipVerify ||
417
         java_string->klass() == SystemDictionary::String_klass(),
D
duke 已提交
418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434
         "must be java_string");
  typeArrayOop value  = java_lang_String::value(java_string);
  int          offset = java_lang_String::offset(java_string);
  int          length = java_lang_String::length(java_string);
  if (length != len) {
    return false;
  }
  for (int i = 0; i < len; i++) {
    if (value->char_at(i + offset) != chars[i]) {
      return false;
    }
  }
  return true;
}

void java_lang_String::print(Handle java_string, outputStream* st) {
  oop          obj    = java_string();
435
  assert(obj->klass() == SystemDictionary::String_klass(), "must be java_string");
D
duke 已提交
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
  typeArrayOop value  = java_lang_String::value(obj);
  int          offset = java_lang_String::offset(obj);
  int          length = java_lang_String::length(obj);

  int end = MIN2(length, 100);
  if (value == NULL) {
    // This can happen if, e.g., printing a String
    // object before its initializer has been called
    st->print_cr("NULL");
  } else {
    st->print("\"");
    for (int index = 0; index < length; index++) {
      st->print("%c", value->char_at(index + offset));
    }
    st->print("\"");
  }
}

454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
static void initialize_static_field(fieldDescriptor* fd, TRAPS) {
  Handle mirror (THREAD, fd->field_holder()->java_mirror());
  assert(mirror.not_null() && fd->is_static(), "just checking");
  if (fd->has_initial_value()) {
    BasicType t = fd->field_type();
    switch (t) {
      case T_BYTE:
        mirror()->byte_field_put(fd->offset(), fd->int_initial_value());
              break;
      case T_BOOLEAN:
        mirror()->bool_field_put(fd->offset(), fd->int_initial_value());
              break;
      case T_CHAR:
        mirror()->char_field_put(fd->offset(), fd->int_initial_value());
              break;
      case T_SHORT:
        mirror()->short_field_put(fd->offset(), fd->int_initial_value());
              break;
      case T_INT:
        mirror()->int_field_put(fd->offset(), fd->int_initial_value());
        break;
      case T_FLOAT:
        mirror()->float_field_put(fd->offset(), fd->float_initial_value());
        break;
      case T_DOUBLE:
        mirror()->double_field_put(fd->offset(), fd->double_initial_value());
        break;
      case T_LONG:
        mirror()->long_field_put(fd->offset(), fd->long_initial_value());
        break;
      case T_OBJECT:
        {
          #ifdef ASSERT
          TempNewSymbol sym = SymbolTable::new_symbol("Ljava/lang/String;", CHECK);
          assert(fd->signature() == sym, "just checking");
          #endif
          oop string = fd->string_initial_value(CHECK);
          mirror()->obj_field_put(fd->offset(), string);
        }
        break;
      default:
        THROW_MSG(vmSymbols::java_lang_ClassFormatError(),
                  "Illegal ConstantValue attribute in class file");
    }
  }
}


void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) {
  assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already");

505 506
  // If the offset was read from the shared archive, it was fixed up already
  if (!k->is_shared()) {
507
  if (k->oop_is_instance()) {
508 509 510
    // During bootstrap, java.lang.Class wasn't loaded so static field
    // offsets were computed without the size added it.  Go back and
    // update all the static field offsets to included the size.
511
      for (JavaFieldStream fs(InstanceKlass::cast(k())); !fs.done(); fs.next()) {
512 513 514 515 516
      if (fs.access_flags().is_static()) {
        int real_offset = fs.offset() + instanceMirrorKlass::offset_of_static_fields();
        fs.set_offset(real_offset);
      }
    }
517
  }
518
  }
519 520
  create_mirror(k, CHECK);
}
D
duke 已提交
521 522 523 524 525 526 527 528 529

oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
  assert(k->java_mirror() == NULL, "should only assign mirror once");
  // Use this moment of initialization to cache modifier_flags also,
  // to support Class.getModifiers().  Instance classes recalculate
  // the cached flags after the class file is parsed, but before the
  // class is put into the system dictionary.
  int computed_modifiers = k->compute_modifier_flags(CHECK_0);
  k->set_modifier_flags(computed_modifiers);
530 531 532
  // Class_klass has to be loaded because it is used to allocate
  // the mirror.
  if (SystemDictionary::Class_klass_loaded()) {
D
duke 已提交
533
    // Allocate mirror (java.lang.Class instance)
534 535 536 537 538
    Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0);

    instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass());
    java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror()));

D
duke 已提交
539
    // It might also have a component mirror.  This mirror must already exist.
540
    if (k->oop_is_array()) {
D
duke 已提交
541 542
      Handle comp_mirror;
      if (k->oop_is_typeArray()) {
543
        BasicType type = typeArrayKlass::cast(k())->element_type();
D
duke 已提交
544
        comp_mirror = Universe::java_mirror(type);
545 546 547 548
      } else {
        assert(k->oop_is_objArray(), "Must be");
        Klass* element_klass = objArrayKlass::cast(k())->element_klass();
        assert(element_klass != NULL, "Must have an element klass");
D
duke 已提交
549 550
          comp_mirror = Klass::cast(element_klass)->java_mirror();
      }
551 552
      assert(comp_mirror.not_null(), "must have a mirror");

D
duke 已提交
553
        // Two-way link between the array klass and its component mirror:
554 555 556 557
      arrayKlass::cast(k())->set_component_mirror(comp_mirror());
      set_array_klass(comp_mirror(), k());
    } else {
      assert(k->oop_is_instance(), "Must be");
558
      // Initialize static fields
559
      InstanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL);
D
duke 已提交
560 561 562
    }
    return mirror();
  } else {
563 564 565 566 567 568
    if (fixup_mirror_list() == NULL) {
      GrowableArray<Klass*>* list =
       new (ResourceObj::C_HEAP, mtClass) GrowableArray<Klass*>(40, true);
      set_fixup_mirror_list(list);
    }
    fixup_mirror_list()->push(k());
D
duke 已提交
569 570 571 572 573
    return NULL;
  }
}


574 575

int  java_lang_Class::oop_size(oop java_class) {
576 577
  assert(_oop_size_offset != 0, "must be set");
  return java_class->int_field(_oop_size_offset);
578 579
}
void java_lang_Class::set_oop_size(oop java_class, int size) {
580 581
  assert(_oop_size_offset != 0, "must be set");
  java_class->int_field_put(_oop_size_offset, size);
582 583
}
int  java_lang_Class::static_oop_field_count(oop java_class) {
584 585
  assert(_static_oop_field_count_offset != 0, "must be set");
  return java_class->int_field(_static_oop_field_count_offset);
586 587
}
void java_lang_Class::set_static_oop_field_count(oop java_class, int size) {
588 589
  assert(_static_oop_field_count_offset != 0, "must be set");
  java_class->int_field_put(_static_oop_field_count_offset, size);
590 591
}

D
duke 已提交
592 593 594
oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {
  // This should be improved by adding a field at the Java level or by
  // introducing a new VM klass (see comment in ClassFileParser)
595
  oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(NULL, CHECK_0);
D
duke 已提交
596
  if (type != T_VOID) {
597
    Klass* aklass = Universe::typeArrayKlassObj(type);
D
duke 已提交
598 599 600
    assert(aklass != NULL, "correct bootstrap");
    set_array_klass(java_class, aklass);
  }
601
#ifdef ASSERT
602
  instanceMirrorKlass* mk = instanceMirrorKlass::cast(SystemDictionary::Class_klass());
603 604
  assert(java_lang_Class::static_oop_field_count(java_class) == 0, "should have been zeroed by allocation");
#endif
D
duke 已提交
605 606 607 608
  return java_class;
}


609
Klass* java_lang_Class::as_Klass(oop java_class) {
D
duke 已提交
610
  //%note memory_2
611
  assert(java_lang_Class::is_instance(java_class), "must be a Class object");
612
  Klass* k = ((Klass*)java_class->metadata_field(_klass_offset));
D
duke 已提交
613 614 615 616 617
  assert(k == NULL || k->is_klass(), "type check");
  return k;
}


618
void java_lang_Class::set_klass(oop java_class, Klass* klass) {
619
  assert(java_lang_Class::is_instance(java_class), "must be a Class object");
620
  java_class->metadata_field_put(_klass_offset, klass);
621 622 623
}


624 625
void java_lang_Class::print_signature(oop java_class, outputStream* st) {
  assert(java_lang_Class::is_instance(java_class), "must be a Class object");
626
  Symbol* name = NULL;
627 628 629 630
  bool is_instance = false;
  if (is_primitive(java_class)) {
    name = vmSymbols::type_signature(primitive_type(java_class));
  } else {
631
    Klass* k = as_Klass(java_class);
632 633 634 635 636 637 638 639 640 641 642 643
    is_instance = Klass::cast(k)->oop_is_instance();
    name = Klass::cast(k)->name();
  }
  if (name == NULL) {
    st->print("<null>");
    return;
  }
  if (is_instance)  st->print("L");
  st->write((char*) name->base(), (int) name->utf8_length());
  if (is_instance)  st->print(";");
}

644
Symbol* java_lang_Class::as_signature(oop java_class, bool intern_if_not_found, TRAPS) {
645
  assert(java_lang_Class::is_instance(java_class), "must be a Class object");
646
  Symbol* name;
647
  if (is_primitive(java_class)) {
648 649 650 651 652
    name = vmSymbols::type_signature(primitive_type(java_class));
    // Because this can create a new symbol, the caller has to decrement
    // the refcount, so make adjustment here and below for symbols returned
    // that are not created or incremented due to a successful lookup.
    name->increment_refcount();
653
  } else {
654
    Klass* k = as_Klass(java_class);
655
    if (!Klass::cast(k)->oop_is_instance()) {
656 657
      name = Klass::cast(k)->name();
      name->increment_refcount();
658 659 660 661
    } else {
      ResourceMark rm;
      const char* sigstr = Klass::cast(k)->signature_name();
      int         siglen = (int) strlen(sigstr);
662 663 664 665 666
      if (!intern_if_not_found) {
        name = SymbolTable::probe(sigstr, siglen);
      } else {
        name = SymbolTable::new_symbol(sigstr, siglen, THREAD);
      }
667 668
    }
  }
669
  return name;
670 671 672
}


673 674 675
Klass* java_lang_Class::array_klass(oop java_class) {
  Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
  assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_array(), "should be array klass");
D
duke 已提交
676 677 678 679
  return k;
}


680 681 682
void java_lang_Class::set_array_klass(oop java_class, Klass* klass) {
  assert(klass->is_klass() && Klass::cast(klass)->oop_is_array(), "should be array klass");
  java_class->metadata_field_put(_array_klass_offset, klass);
D
duke 已提交
683 684 685
}


686 687
Method* java_lang_Class::resolved_constructor(oop java_class) {
  Metadata* constructor = java_class->metadata_field(_resolved_constructor_offset);
D
duke 已提交
688
  assert(constructor == NULL || constructor->is_method(), "should be method");
689
  return ((Method*)constructor);
D
duke 已提交
690 691 692
}


693
void java_lang_Class::set_resolved_constructor(oop java_class, Method* constructor) {
D
duke 已提交
694
  assert(constructor->is_method(), "should be method");
695
  java_class->metadata_field_put(_resolved_constructor_offset, constructor);
D
duke 已提交
696 697 698 699
}


bool java_lang_Class::is_primitive(oop java_class) {
700 701
  // should assert:
  //assert(java_lang_Class::is_instance(java_class), "must be a Class object");
702 703 704 705 706 707 708 709 710 711 712
  bool is_primitive = (java_class->metadata_field(_klass_offset) == NULL);

#ifdef ASSERT
  if (is_primitive) {
    Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
    assert(k == NULL || is_java_primitive(arrayKlass::cast(k)->element_type()),
        "Should be either the T_VOID primitive or a java primitive");
  }
#endif

  return is_primitive;
D
duke 已提交
713 714 715 716 717
}


BasicType java_lang_Class::primitive_type(oop java_class) {
  assert(java_lang_Class::is_primitive(java_class), "just checking");
718
  Klass* ak = ((Klass*)java_class->metadata_field(_array_klass_offset));
D
duke 已提交
719 720 721 722 723 724 725 726 727 728 729
  BasicType type = T_VOID;
  if (ak != NULL) {
    // Note: create_basic_type_mirror above initializes ak to a non-null value.
    type = arrayKlass::cast(ak)->element_type();
  } else {
    assert(java_class == Universe::void_mirror(), "only valid non-array primitive");
  }
  assert(Universe::java_mirror(type) == java_class, "must be consistent");
  return type;
}

730
BasicType java_lang_Class::as_BasicType(oop java_class, Klass** reference_klass) {
731 732 733 734 735 736 737
  assert(java_lang_Class::is_instance(java_class), "must be a Class object");
  if (is_primitive(java_class)) {
    if (reference_klass != NULL)
      (*reference_klass) = NULL;
    return primitive_type(java_class);
  } else {
    if (reference_klass != NULL)
738
      (*reference_klass) = as_Klass(java_class);
739 740 741 742
    return T_OBJECT;
  }
}

D
duke 已提交
743 744 745

oop java_lang_Class::primitive_mirror(BasicType t) {
  oop mirror = Universe::java_mirror(t);
746
  assert(mirror != NULL && mirror->is_a(SystemDictionary::Class_klass()), "must be a Class");
D
duke 已提交
747 748 749 750 751 752 753 754 755 756 757
  assert(java_lang_Class::is_primitive(mirror), "must be primitive");
  return mirror;
}

bool java_lang_Class::offsets_computed = false;
int  java_lang_Class::classRedefinedCount_offset = -1;

void java_lang_Class::compute_offsets() {
  assert(!offsets_computed, "offsets should be initialized only once");
  offsets_computed = true;

758
  Klass* klass_oop = SystemDictionary::Class_klass();
D
duke 已提交
759 760
  // The classRedefinedCount field is only present starting in 1.5,
  // so don't go fatal.
761
  compute_optional_offset(classRedefinedCount_offset,
762
                          klass_oop, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());
763

764
  CLASS_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
D
duke 已提交
765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
}

int java_lang_Class::classRedefinedCount(oop the_class_mirror) {
  if (!JDK_Version::is_gte_jdk15x_version()
      || classRedefinedCount_offset == -1) {
    // The classRedefinedCount field is only present starting in 1.5.
    // If we don't have an offset for it then just return -1 as a marker.
    return -1;
  }

  return the_class_mirror->int_field(classRedefinedCount_offset);
}

void java_lang_Class::set_classRedefinedCount(oop the_class_mirror, int value) {
  if (!JDK_Version::is_gte_jdk15x_version()
      || classRedefinedCount_offset == -1) {
    // The classRedefinedCount field is only present starting in 1.5.
    // If we don't have an offset for it then nothing to set.
    return;
  }

  the_class_mirror->int_field_put(classRedefinedCount_offset, value);
}


// Note: JDK1.1 and before had a privateInfo_offset field which was used for the
//       platform thread structure, and a eetop offset which was used for thread
//       local storage (and unused by the HotSpot VM). In JDK1.2 the two structures
//       merged, so in the HotSpot VM we just use the eetop field for the thread
//       instead of the privateInfo_offset.
//
// Note: The stackSize field is only present starting in 1.4.

int java_lang_Thread::_name_offset = 0;
int java_lang_Thread::_group_offset = 0;
int java_lang_Thread::_contextClassLoader_offset = 0;
int java_lang_Thread::_inheritedAccessControlContext_offset = 0;
int java_lang_Thread::_priority_offset = 0;
int java_lang_Thread::_eetop_offset = 0;
int java_lang_Thread::_daemon_offset = 0;
int java_lang_Thread::_stillborn_offset = 0;
int java_lang_Thread::_stackSize_offset = 0;
int java_lang_Thread::_tid_offset = 0;
int java_lang_Thread::_thread_status_offset = 0;
int java_lang_Thread::_park_blocker_offset = 0;
int java_lang_Thread::_park_event_offset = 0 ;


void java_lang_Thread::compute_offsets() {
  assert(_group_offset == 0, "offsets should be initialized only once");

816
  Klass* k = SystemDictionary::Thread_klass();
817 818 819 820 821 822 823 824
  compute_offset(_name_offset,      k, vmSymbols::name_name(),      vmSymbols::char_array_signature());
  compute_offset(_group_offset,     k, vmSymbols::group_name(),     vmSymbols::threadgroup_signature());
  compute_offset(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature());
  compute_offset(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature());
  compute_offset(_priority_offset,  k, vmSymbols::priority_name(),  vmSymbols::int_signature());
  compute_offset(_daemon_offset,    k, vmSymbols::daemon_name(),    vmSymbols::bool_signature());
  compute_offset(_eetop_offset,     k, vmSymbols::eetop_name(),     vmSymbols::long_signature());
  compute_offset(_stillborn_offset, k, vmSymbols::stillborn_name(), vmSymbols::bool_signature());
D
duke 已提交
825
  // The stackSize field is only present starting in 1.4, so don't go fatal.
826
  compute_optional_offset(_stackSize_offset, k, vmSymbols::stackSize_name(), vmSymbols::long_signature());
D
duke 已提交
827
  // The tid and thread_status fields are only present starting in 1.5, so don't go fatal.
828 829
  compute_optional_offset(_tid_offset, k, vmSymbols::thread_id_name(), vmSymbols::long_signature());
  compute_optional_offset(_thread_status_offset, k, vmSymbols::thread_status_name(), vmSymbols::int_signature());
D
duke 已提交
830
  // The parkBlocker field is only present starting in 1.6, so don't go fatal.
831 832
  compute_optional_offset(_park_blocker_offset, k, vmSymbols::park_blocker_name(), vmSymbols::object_signature());
  compute_optional_offset(_park_event_offset, k, vmSymbols::park_event_name(),
D
duke 已提交
833 834 835 836 837
 vmSymbols::long_signature());
}


JavaThread* java_lang_Thread::thread(oop java_thread) {
838
  return (JavaThread*)java_thread->address_field(_eetop_offset);
D
duke 已提交
839 840 841 842
}


void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) {
843
  java_thread->address_field_put(_eetop_offset, (address)thread);
D
duke 已提交
844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
}


typeArrayOop java_lang_Thread::name(oop java_thread) {
  oop name = java_thread->obj_field(_name_offset);
  assert(name == NULL || (name->is_typeArray() && typeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking");
  return typeArrayOop(name);
}


void java_lang_Thread::set_name(oop java_thread, typeArrayOop name) {
  assert(java_thread->obj_field(_name_offset) == NULL, "name should be NULL");
  java_thread->obj_field_put(_name_offset, name);
}


ThreadPriority java_lang_Thread::priority(oop java_thread) {
  return (ThreadPriority)java_thread->int_field(_priority_offset);
}


void java_lang_Thread::set_priority(oop java_thread, ThreadPriority priority) {
  java_thread->int_field_put(_priority_offset, priority);
}


oop java_lang_Thread::threadGroup(oop java_thread) {
  return java_thread->obj_field(_group_offset);
}


bool java_lang_Thread::is_stillborn(oop java_thread) {
  return java_thread->bool_field(_stillborn_offset) != 0;
}


// We never have reason to turn the stillborn bit off
void java_lang_Thread::set_stillborn(oop java_thread) {
  java_thread->bool_field_put(_stillborn_offset, true);
}


bool java_lang_Thread::is_alive(oop java_thread) {
  JavaThread* thr = java_lang_Thread::thread(java_thread);
  return (thr != NULL);
}


bool java_lang_Thread::is_daemon(oop java_thread) {
  return java_thread->bool_field(_daemon_offset) != 0;
}


void java_lang_Thread::set_daemon(oop java_thread) {
  java_thread->bool_field_put(_daemon_offset, true);
}

oop java_lang_Thread::context_class_loader(oop java_thread) {
  return java_thread->obj_field(_contextClassLoader_offset);
}

oop java_lang_Thread::inherited_access_control_context(oop java_thread) {
  return java_thread->obj_field(_inheritedAccessControlContext_offset);
}


jlong java_lang_Thread::stackSize(oop java_thread) {
  // The stackSize field is only present starting in 1.4
  if (_stackSize_offset > 0) {
    assert(JDK_Version::is_gte_jdk14x_version(), "sanity check");
    return java_thread->long_field(_stackSize_offset);
  } else {
    return 0;
  }
}

// Write the thread status value to threadStatus field in java.lang.Thread java class.
void java_lang_Thread::set_thread_status(oop java_thread,
                                         java_lang_Thread::ThreadStatus status) {
  assert(JavaThread::current()->thread_state() == _thread_in_vm, "Java Thread is not running in vm");
  // The threadStatus is only present starting in 1.5
  if (_thread_status_offset > 0) {
    java_thread->int_field_put(_thread_status_offset, status);
  }
}

// Read thread status value from threadStatus field in java.lang.Thread java class.
java_lang_Thread::ThreadStatus java_lang_Thread::get_thread_status(oop java_thread) {
  assert(Thread::current()->is_VM_thread() ||
         JavaThread::current()->thread_state() == _thread_in_vm,
         "Java Thread is not running in vm");
  // The threadStatus is only present starting in 1.5
  if (_thread_status_offset > 0) {
    return (java_lang_Thread::ThreadStatus)java_thread->int_field(_thread_status_offset);
  } else {
    // All we can easily figure out is if it is alive, but that is
    // enough info for a valid unknown status.
    // These aren't restricted to valid set ThreadStatus values, so
    // use JVMTI values and cast.
    JavaThread* thr = java_lang_Thread::thread(java_thread);
    if (thr == NULL) {
      // the thread hasn't run yet or is in the process of exiting
      return NEW;
    }
    return (java_lang_Thread::ThreadStatus)JVMTI_THREAD_STATE_ALIVE;
  }
}


jlong java_lang_Thread::thread_id(oop java_thread) {
  // The thread ID field is only present starting in 1.5
  if (_tid_offset > 0) {
    return java_thread->long_field(_tid_offset);
  } else {
    return 0;
  }
}

oop java_lang_Thread::park_blocker(oop java_thread) {
K
kamg 已提交
963 964
  assert(JDK_Version::current().supports_thread_park_blocker() &&
         _park_blocker_offset != 0, "Must support parkBlocker field");
D
duke 已提交
965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074

  if (_park_blocker_offset > 0) {
    return java_thread->obj_field(_park_blocker_offset);
  }

  return NULL;
}

jlong java_lang_Thread::park_event(oop java_thread) {
  if (_park_event_offset > 0) {
    return java_thread->long_field(_park_event_offset);
  }
  return 0;
}

bool java_lang_Thread::set_park_event(oop java_thread, jlong ptr) {
  if (_park_event_offset > 0) {
    java_thread->long_field_put(_park_event_offset, ptr);
    return true;
  }
  return false;
}


const char* java_lang_Thread::thread_status_name(oop java_thread) {
  assert(JDK_Version::is_gte_jdk15x_version() && _thread_status_offset != 0, "Must have thread status");
  ThreadStatus status = (java_lang_Thread::ThreadStatus)java_thread->int_field(_thread_status_offset);
  switch (status) {
    case NEW                      : return "NEW";
    case RUNNABLE                 : return "RUNNABLE";
    case SLEEPING                 : return "TIMED_WAITING (sleeping)";
    case IN_OBJECT_WAIT           : return "WAITING (on object monitor)";
    case IN_OBJECT_WAIT_TIMED     : return "TIMED_WAITING (on object monitor)";
    case PARKED                   : return "WAITING (parking)";
    case PARKED_TIMED             : return "TIMED_WAITING (parking)";
    case BLOCKED_ON_MONITOR_ENTER : return "BLOCKED (on object monitor)";
    case TERMINATED               : return "TERMINATED";
    default                       : return "UNKNOWN";
  };
}
int java_lang_ThreadGroup::_parent_offset = 0;
int java_lang_ThreadGroup::_name_offset = 0;
int java_lang_ThreadGroup::_threads_offset = 0;
int java_lang_ThreadGroup::_groups_offset = 0;
int java_lang_ThreadGroup::_maxPriority_offset = 0;
int java_lang_ThreadGroup::_destroyed_offset = 0;
int java_lang_ThreadGroup::_daemon_offset = 0;
int java_lang_ThreadGroup::_vmAllowSuspension_offset = 0;
int java_lang_ThreadGroup::_nthreads_offset = 0;
int java_lang_ThreadGroup::_ngroups_offset = 0;

oop  java_lang_ThreadGroup::parent(oop java_thread_group) {
  assert(java_thread_group->is_oop(), "thread group must be oop");
  return java_thread_group->obj_field(_parent_offset);
}

// ("name as oop" accessor is not necessary)

typeArrayOop java_lang_ThreadGroup::name(oop java_thread_group) {
  oop name = java_thread_group->obj_field(_name_offset);
  // ThreadGroup.name can be null
  return name == NULL ? (typeArrayOop)NULL : java_lang_String::value(name);
}

int java_lang_ThreadGroup::nthreads(oop java_thread_group) {
  assert(java_thread_group->is_oop(), "thread group must be oop");
  return java_thread_group->int_field(_nthreads_offset);
}

objArrayOop java_lang_ThreadGroup::threads(oop java_thread_group) {
  oop threads = java_thread_group->obj_field(_threads_offset);
  assert(threads != NULL, "threadgroups should have threads");
  assert(threads->is_objArray(), "just checking"); // Todo: Add better type checking code
  return objArrayOop(threads);
}

int java_lang_ThreadGroup::ngroups(oop java_thread_group) {
  assert(java_thread_group->is_oop(), "thread group must be oop");
  return java_thread_group->int_field(_ngroups_offset);
}

objArrayOop java_lang_ThreadGroup::groups(oop java_thread_group) {
  oop groups = java_thread_group->obj_field(_groups_offset);
  assert(groups == NULL || groups->is_objArray(), "just checking"); // Todo: Add better type checking code
  return objArrayOop(groups);
}

ThreadPriority java_lang_ThreadGroup::maxPriority(oop java_thread_group) {
  assert(java_thread_group->is_oop(), "thread group must be oop");
  return (ThreadPriority) java_thread_group->int_field(_maxPriority_offset);
}

bool java_lang_ThreadGroup::is_destroyed(oop java_thread_group) {
  assert(java_thread_group->is_oop(), "thread group must be oop");
  return java_thread_group->bool_field(_destroyed_offset) != 0;
}

bool java_lang_ThreadGroup::is_daemon(oop java_thread_group) {
  assert(java_thread_group->is_oop(), "thread group must be oop");
  return java_thread_group->bool_field(_daemon_offset) != 0;
}

bool java_lang_ThreadGroup::is_vmAllowSuspension(oop java_thread_group) {
  assert(java_thread_group->is_oop(), "thread group must be oop");
  return java_thread_group->bool_field(_vmAllowSuspension_offset) != 0;
}

void java_lang_ThreadGroup::compute_offsets() {
  assert(_parent_offset == 0, "offsets should be initialized only once");

1075
  Klass* k = SystemDictionary::ThreadGroup_klass();
D
duke 已提交
1076

1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
  compute_offset(_parent_offset,      k, vmSymbols::parent_name(),      vmSymbols::threadgroup_signature());
  compute_offset(_name_offset,        k, vmSymbols::name_name(),        vmSymbols::string_signature());
  compute_offset(_threads_offset,     k, vmSymbols::threads_name(),     vmSymbols::thread_array_signature());
  compute_offset(_groups_offset,      k, vmSymbols::groups_name(),      vmSymbols::threadgroup_array_signature());
  compute_offset(_maxPriority_offset, k, vmSymbols::maxPriority_name(), vmSymbols::int_signature());
  compute_offset(_destroyed_offset,   k, vmSymbols::destroyed_name(),   vmSymbols::bool_signature());
  compute_offset(_daemon_offset,      k, vmSymbols::daemon_name(),      vmSymbols::bool_signature());
  compute_offset(_vmAllowSuspension_offset, k, vmSymbols::vmAllowSuspension_name(), vmSymbols::bool_signature());
  compute_offset(_nthreads_offset,    k, vmSymbols::nthreads_name(),    vmSymbols::int_signature());
  compute_offset(_ngroups_offset,     k, vmSymbols::ngroups_name(),     vmSymbols::int_signature());
D
duke 已提交
1087 1088
}

1089
oop java_lang_Throwable::unassigned_stacktrace() {
1090
  InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Throwable_klass());
1091 1092 1093 1094 1095 1096 1097 1098
  address addr = ik->static_field_addr(static_unassigned_stacktrace_offset);
  if (UseCompressedOops) {
    return oopDesc::load_decode_heap_oop((narrowOop *)addr);
  } else {
    return oopDesc::load_decode_heap_oop((oop*)addr);
  }
}

D
duke 已提交
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
oop java_lang_Throwable::backtrace(oop throwable) {
  return throwable->obj_field_acquire(backtrace_offset);
}


void java_lang_Throwable::set_backtrace(oop throwable, oop value) {
  throwable->release_obj_field_put(backtrace_offset, value);
}


oop java_lang_Throwable::message(oop throwable) {
  return throwable->obj_field(detailMessage_offset);
}


oop java_lang_Throwable::message(Handle throwable) {
  return throwable->obj_field(detailMessage_offset);
}


void java_lang_Throwable::set_message(oop throwable, oop value) {
  throwable->obj_field_put(detailMessage_offset, value);
}


1124 1125 1126 1127
void java_lang_Throwable::set_stacktrace(oop throwable, oop st_element_array) {
  throwable->obj_field_put(stackTrace_offset, st_element_array);
}

D
duke 已提交
1128 1129
void java_lang_Throwable::clear_stacktrace(oop throwable) {
  assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4");
1130
  set_stacktrace(throwable, NULL);
D
duke 已提交
1131 1132 1133 1134 1135
}


void java_lang_Throwable::print(oop throwable, outputStream* st) {
  ResourceMark rm;
1136
  Klass* k = throwable->klass();
D
duke 已提交
1137
  assert(k != NULL, "just checking");
1138
  st->print("%s", InstanceKlass::cast(k)->external_name());
D
duke 已提交
1139 1140 1141 1142 1143 1144 1145 1146 1147
  oop msg = message(throwable);
  if (msg != NULL) {
    st->print(": %s", java_lang_String::as_utf8_string(msg));
  }
}


void java_lang_Throwable::print(Handle throwable, outputStream* st) {
  ResourceMark rm;
1148
  Klass* k = throwable->klass();
D
duke 已提交
1149
  assert(k != NULL, "just checking");
1150
  st->print("%s", InstanceKlass::cast(k)->external_name());
D
duke 已提交
1151 1152 1153 1154 1155 1156 1157
  oop msg = message(throwable);
  if (msg != NULL) {
    st->print(": %s", java_lang_String::as_utf8_string(msg));
  }
}

// Print stack trace element to resource allocated buffer
1158
char* java_lang_Throwable::print_stack_element_to_buffer(Method* method, int bci) {
D
duke 已提交
1159
  // Get strings and string lengths
1160
  InstanceKlass* klass = InstanceKlass::cast(method->method_holder());
D
duke 已提交
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
  const char* klass_name  = klass->external_name();
  int buf_len = (int)strlen(klass_name);
  char* source_file_name;
  if (klass->source_file_name() == NULL) {
    source_file_name = NULL;
  } else {
    source_file_name = klass->source_file_name()->as_C_string();
    buf_len += (int)strlen(source_file_name);
  }
  char* method_name = method->name()->as_C_string();
  buf_len += (int)strlen(method_name);

  // Allocate temporary buffer with extra space for formatting and line number
  char* buf = NEW_RESOURCE_ARRAY(char, buf_len + 64);

  // Print stack trace line in buffer
  sprintf(buf, "\tat %s.%s", klass_name, method_name);
  if (method->is_native()) {
    strcat(buf, "(Native Method)");
  } else {
    int line_number = method->line_number_from_bci(bci);
    if (source_file_name != NULL && (line_number != -1)) {
      // Sourcename and linenumber
      sprintf(buf + (int)strlen(buf), "(%s:%d)", source_file_name, line_number);
    } else if (source_file_name != NULL) {
      // Just sourcename
      sprintf(buf + (int)strlen(buf), "(%s)", source_file_name);
    } else {
      // Neither soucename and linenumber
      sprintf(buf + (int)strlen(buf), "(Unknown Source)");
    }
    nmethod* nm = method->code();
    if (WizardMode && nm != NULL) {
N
never 已提交
1194
      sprintf(buf + (int)strlen(buf), "(nmethod " INTPTR_FORMAT ")", (intptr_t)nm);
D
duke 已提交
1195 1196 1197 1198 1199 1200 1201
    }
  }

  return buf;
}


1202
void java_lang_Throwable::print_stack_element(Handle stream, Method* method, int bci) {
D
duke 已提交
1203 1204 1205 1206 1207
  ResourceMark rm;
  char* buf = print_stack_element_to_buffer(method, bci);
  print_to_stream(stream, buf);
}

1208
void java_lang_Throwable::print_stack_element(outputStream *st, Method* method, int bci) {
D
duke 已提交
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
  ResourceMark rm;
  char* buf = print_stack_element_to_buffer(method, bci);
  st->print_cr("%s", buf);
}

void java_lang_Throwable::print_to_stream(Handle stream, const char* str) {
  if (stream.is_null()) {
    tty->print_cr("%s", str);
  } else {
    EXCEPTION_MARK;
    JavaValue result(T_VOID);
    Handle arg (THREAD, oopFactory::new_charArray(str, THREAD));
    if (!HAS_PENDING_EXCEPTION) {
      JavaCalls::call_virtual(&result,
                              stream,
                              KlassHandle(THREAD, stream->klass()),
1225 1226
                              vmSymbols::println_name(),
                              vmSymbols::char_array_void_signature(),
D
duke 已提交
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
                              arg,
                              THREAD);
    }
    // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
    if (HAS_PENDING_EXCEPTION) CLEAR_PENDING_EXCEPTION;
  }

}


const char* java_lang_Throwable::no_stack_trace_message() {
  return "\t<<no stack trace available>>";
}


// Currently used only for exceptions occurring during startup
void java_lang_Throwable::print_stack_trace(oop throwable, outputStream* st) {
  Thread *THREAD = Thread::current();
  Handle h_throwable(THREAD, throwable);
  while (h_throwable.not_null()) {
    objArrayHandle result (THREAD, objArrayOop(backtrace(h_throwable())));
    if (result.is_null()) {
      st->print_cr(no_stack_trace_message());
      return;
    }

    while (result.not_null()) {
1254 1255
      typeArrayHandle methods (THREAD,
                               typeArrayOop(result->obj_at(trace_methods_offset)));
D
duke 已提交
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
      typeArrayHandle bcis (THREAD,
                            typeArrayOop(result->obj_at(trace_bcis_offset)));

      if (methods.is_null() || bcis.is_null()) {
        st->print_cr(no_stack_trace_message());
        return;
      }

      int length = methods()->length();
      for (int index = 0; index < length; index++) {
1266
        Method* method = ((Method*)methods()->metadata_at(index));
D
duke 已提交
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279
        if (method == NULL) goto handle_cause;
        int bci = bcis->ushort_at(index);
        print_stack_element(st, method, bci);
      }
      result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));
    }
  handle_cause:
    {
      EXCEPTION_MARK;
      JavaValue result(T_OBJECT);
      JavaCalls::call_virtual(&result,
                              h_throwable,
                              KlassHandle(THREAD, h_throwable->klass()),
1280 1281
                              vmSymbols::getCause_name(),
                              vmSymbols::void_throwable_signature(),
D
duke 已提交
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
                              THREAD);
      // Ignore any exceptions. we are in the middle of exception handling. Same as classic VM.
      if (HAS_PENDING_EXCEPTION) {
        CLEAR_PENDING_EXCEPTION;
        h_throwable = Handle();
      } else {
        h_throwable = Handle(THREAD, (oop) result.get_jobject());
        if (h_throwable.not_null()) {
          st->print("Caused by: ");
          print(h_throwable, st);
          st->cr();
        }
      }
    }
  }
}


void java_lang_Throwable::print_stack_trace(oop throwable, oop print_stream) {
  // Note: this is no longer used in Merlin, but we support it for compatibility.
  Thread *thread = Thread::current();
  Handle stream(thread, print_stream);
  objArrayHandle result (thread, objArrayOop(backtrace(throwable)));
  if (result.is_null()) {
    print_to_stream(stream, no_stack_trace_message());
    return;
  }

  while (result.not_null()) {
1311 1312
    typeArrayHandle methods(thread,
                            typeArrayOop(result->obj_at(trace_methods_offset)));
D
duke 已提交
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
    typeArrayHandle bcis (thread,
                          typeArrayOop(result->obj_at(trace_bcis_offset)));

    if (methods.is_null() || bcis.is_null()) {
      print_to_stream(stream, no_stack_trace_message());
      return;
    }

    int length = methods()->length();
    for (int index = 0; index < length; index++) {
1323
      Method* method = ((Method*)methods()->metadata_at(index));
D
duke 已提交
1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338
      if (method == NULL) return;
      int bci = bcis->ushort_at(index);
      print_stack_element(stream, method, bci);
    }
    result = objArrayHandle(thread, objArrayOop(result->obj_at(trace_next_offset)));
  }
}

// This class provides a simple wrapper over the internal structure of
// exception backtrace to insulate users of the backtrace from needing
// to know what it looks like.
class BacktraceBuilder: public StackObj {
 private:
  Handle          _backtrace;
  objArrayOop     _head;
1339
  typeArrayOop    _methods;
D
duke 已提交
1340
  typeArrayOop    _bcis;
1341
  objArrayOop     _mirrors;
D
duke 已提交
1342 1343 1344 1345 1346 1347 1348 1349
  int             _index;
  No_Safepoint_Verifier _nsv;

 public:

  enum {
    trace_methods_offset = java_lang_Throwable::trace_methods_offset,
    trace_bcis_offset    = java_lang_Throwable::trace_bcis_offset,
1350
    trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset,
D
duke 已提交
1351 1352 1353 1354 1355 1356
    trace_next_offset    = java_lang_Throwable::trace_next_offset,
    trace_size           = java_lang_Throwable::trace_size,
    trace_chunk_size     = java_lang_Throwable::trace_chunk_size
  };

  // constructor for new backtrace
1357
  BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL) {
D
duke 已提交
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
    expand(CHECK);
    _backtrace = _head;
    _index = 0;
  }

  void expand(TRAPS) {
    objArrayHandle old_head(THREAD, _head);
    Pause_No_Safepoint_Verifier pnsv(&_nsv);

    objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK);
    objArrayHandle new_head(THREAD, head);

1370 1371
    typeArrayOop methods = oopFactory::new_metaDataArray(trace_chunk_size, CHECK);
    typeArrayHandle new_methods(THREAD, methods);
D
duke 已提交
1372 1373 1374 1375

    typeArrayOop bcis = oopFactory::new_shortArray(trace_chunk_size, CHECK);
    typeArrayHandle new_bcis(THREAD, bcis);

1376 1377 1378
    objArrayOop mirrors = oopFactory::new_objectArray(trace_chunk_size, CHECK);
    objArrayHandle new_mirrors(THREAD, mirrors);

D
duke 已提交
1379 1380 1381 1382 1383
    if (!old_head.is_null()) {
      old_head->obj_at_put(trace_next_offset, new_head());
    }
    new_head->obj_at_put(trace_methods_offset, new_methods());
    new_head->obj_at_put(trace_bcis_offset, new_bcis());
1384
    new_head->obj_at_put(trace_mirrors_offset, new_mirrors());
D
duke 已提交
1385 1386 1387 1388

    _head    = new_head();
    _methods = new_methods();
    _bcis    = new_bcis();
1389
    _mirrors = new_mirrors();
D
duke 已提交
1390 1391 1392 1393 1394 1395 1396
    _index = 0;
  }

  oop backtrace() {
    return _backtrace();
  }

1397
  inline void push(Method* method, int bci, TRAPS) {
1398 1399 1400 1401 1402 1403
    // Smear the -1 bci to 0 since the array only holds unsigned
    // shorts.  The later line number lookup would just smear the -1
    // to a 0 even if it could be recorded.
    if (bci == SynchronizationEntryBCI) bci = 0;
    assert(bci == (jushort)bci, "doesn't fit");

D
duke 已提交
1404 1405 1406 1407 1408 1409
    if (_index >= trace_chunk_size) {
      methodHandle mhandle(THREAD, method);
      expand(CHECK);
      method = mhandle();
    }

1410
    _methods->metadata_at_put(_index, method);
D
duke 已提交
1411
    _bcis->ushort_at_put(_index, bci);
1412 1413 1414 1415
    // we need to save the mirrors in the backtrace to keep the methods from
    // being unloaded if their class loader is unloaded while we still have
    // this stack trace.
    _mirrors->obj_at_put(_index, method->method_holder()->java_mirror());
D
duke 已提交
1416 1417 1418
    _index++;
  }

1419
  Method* current_method() {
D
duke 已提交
1420
    assert(_index >= 0 && _index < trace_chunk_size, "out of range");
1421
    return ((Method*)_methods->metadata_at(_index));
D
duke 已提交
1422 1423 1424 1425 1426 1427 1428 1429 1430
  }

  jushort current_bci() {
    assert(_index >= 0 && _index < trace_chunk_size, "out of range");
    return _bcis->ushort_at(_index);
  }
};


1431
void java_lang_Throwable::fill_in_stack_trace(Handle throwable, methodHandle method, TRAPS) {
D
duke 已提交
1432 1433 1434 1435 1436 1437 1438 1439 1440
  if (!StackTraceInThrowable) return;
  ResourceMark rm(THREAD);

  // Start out by clearing the backtrace for this object, in case the VM
  // runs out of memory while allocating the stack trace
  set_backtrace(throwable(), NULL);
  if (JDK_Version::is_gte_jdk14x_version()) {
    // New since 1.4, clear lazily constructed Java level stacktrace if
    // refilling occurs
1441
    // This is unnecessary in 1.7+ but harmless
D
duke 已提交
1442 1443 1444 1445 1446 1447 1448
    clear_stacktrace(throwable());
  }

  int max_depth = MaxJavaStackTraceDepth;
  JavaThread* thread = (JavaThread*)THREAD;
  BacktraceBuilder bt(CHECK);

1449 1450 1451 1452 1453 1454 1455 1456 1457 1458
  // If there is no Java frame just return the method that was being called
  // with bci 0
  if (!thread->has_last_Java_frame()) {
    if (max_depth >= 1 && method() != NULL) {
      bt.push(method(), 0, CHECK);
      set_backtrace(throwable(), bt.backtrace());
    }
    return;
  }

D
duke 已提交
1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
  // Instead of using vframe directly, this version of fill_in_stack_trace
  // basically handles everything by hand. This significantly improved the
  // speed of this method call up to 28.5% on Solaris sparc. 27.1% on Windows.
  // See bug 6333838 for  more details.
  // The "ASSERT" here is to verify this method generates the exactly same stack
  // trace as utilizing vframe.
#ifdef ASSERT
  vframeStream st(thread);
  methodHandle st_method(THREAD, st.method());
#endif
  int total_count = 0;
  RegisterMap map(thread, false);
  int decode_offset = 0;
  nmethod* nm = NULL;
  bool skip_fillInStackTrace_check = false;
  bool skip_throwableInit_check = false;
1475
  bool skip_hidden = !ShowHiddenFrames;
D
duke 已提交
1476 1477

  for (frame fr = thread->last_frame(); max_depth != total_count;) {
1478
    Method* method = NULL;
D
duke 已提交
1479 1480 1481 1482 1483 1484
    int bci = 0;

    // Compiled java method case.
    if (decode_offset != 0) {
      DebugInfoReadStream stream(nm, decode_offset);
      decode_offset = stream.read_int();
1485
      method = (Method*)nm->metadata_at(stream.read_int());
1486
      bci = stream.read_bci();
D
duke 已提交
1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516
    } else {
      if (fr.is_first_frame()) break;
      address pc = fr.pc();
      if (fr.is_interpreted_frame()) {
        intptr_t bcx = fr.interpreter_frame_bcx();
        method = fr.interpreter_frame_method();
        bci =  fr.is_bci(bcx) ? bcx : method->bci_from((address)bcx);
        fr = fr.sender(&map);
      } else {
        CodeBlob* cb = fr.cb();
        // HMMM QQQ might be nice to have frame return nm as NULL if cb is non-NULL
        // but non nmethod
        fr = fr.sender(&map);
        if (cb == NULL || !cb->is_nmethod()) {
          continue;
        }
        nm = (nmethod*)cb;
        if (nm->method()->is_native()) {
          method = nm->method();
          bci = 0;
        } else {
          PcDesc* pd = nm->pc_desc_at(pc);
          decode_offset = pd->scope_decode_offset();
          // if decode_offset is not equal to 0, it will execute the
          // "compiled java method case" at the beginning of the loop.
          continue;
        }
      }
    }
#ifdef ASSERT
1517 1518 1519 1520
    assert(st_method() == method && st.bci() == bci,
           "Wrong stack trace");
    st.next();
    // vframeStream::method isn't GC-safe so store off a copy
1521
    // of the Method* in case we GC.
1522 1523 1524
    if (!st.at_end()) {
      st_method = st.method();
    }
D
duke 已提交
1525
#endif
1526 1527 1528 1529 1530 1531

    // the format of the stacktrace will be:
    // - 1 or more fillInStackTrace frames for the exception class (skipped)
    // - 0 or more <init> methods for the exception class (skipped)
    // - rest of the stack

D
duke 已提交
1532
    if (!skip_fillInStackTrace_check) {
1533 1534 1535
      if ((method->name() == vmSymbols::fillInStackTrace_name() ||
           method->name() == vmSymbols::fillInStackTrace0_name()) &&
          throwable->is_a(method->method_holder())) {
D
duke 已提交
1536 1537
        continue;
      }
1538 1539 1540
      else {
        skip_fillInStackTrace_check = true; // gone past them all
      }
D
duke 已提交
1541 1542
    }
    if (!skip_throwableInit_check) {
1543 1544 1545 1546
      assert(skip_fillInStackTrace_check, "logic error in backtrace filtering");

      // skip <init> methods of the exception class and superclasses
      // This is simlar to classic VM.
D
duke 已提交
1547 1548 1549 1550
      if (method->name() == vmSymbols::object_initializer_name() &&
          throwable->is_a(method->method_holder())) {
        continue;
      } else {
1551
        // there are none or we've seen them all - either way stop checking
D
duke 已提交
1552 1553 1554
        skip_throwableInit_check = true;
      }
    }
1555 1556 1557
    if (method->is_hidden()) {
      if (skip_hidden)  continue;
    }
D
duke 已提交
1558 1559 1560 1561 1562 1563 1564 1565
    bt.push(method, bci, CHECK);
    total_count++;
  }

  // Put completed stack trace into throwable object
  set_backtrace(throwable(), bt.backtrace());
}

1566
void java_lang_Throwable::fill_in_stack_trace(Handle throwable, methodHandle method) {
D
duke 已提交
1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579
  // No-op if stack trace is disabled
  if (!StackTraceInThrowable) {
    return;
  }

  // Disable stack traces for some preallocated out of memory errors
  if (!Universe::should_fill_in_stack_trace(throwable)) {
    return;
  }

  PRESERVE_EXCEPTION_MARK;

  JavaThread* thread = JavaThread::active();
1580
  fill_in_stack_trace(throwable, method, thread);
D
duke 已提交
1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592
  // ignore exceptions thrown during stack trace filling
  CLEAR_PENDING_EXCEPTION;
}

void java_lang_Throwable::allocate_backtrace(Handle throwable, TRAPS) {
  // Allocate stack trace - backtrace is created but not filled in

  // No-op if stack trace is disabled
  if (!StackTraceInThrowable) return;

  objArrayOop h_oop = oopFactory::new_objectArray(trace_size, CHECK);
  objArrayHandle backtrace  (THREAD, h_oop);
1593 1594
  typeArrayOop m_oop = oopFactory::new_metaDataArray(trace_chunk_size, CHECK);
  typeArrayHandle methods (THREAD, m_oop);
D
duke 已提交
1595 1596
  typeArrayOop b = oopFactory::new_shortArray(trace_chunk_size, CHECK);
  typeArrayHandle bcis(THREAD, b);
1597 1598
  objArrayOop mirror_oop = oopFactory::new_objectArray(trace_chunk_size, CHECK);
  objArrayHandle mirrors (THREAD, mirror_oop);
D
duke 已提交
1599 1600 1601 1602

  // backtrace has space for one chunk (next is NULL)
  backtrace->obj_at_put(trace_methods_offset, methods());
  backtrace->obj_at_put(trace_bcis_offset, bcis());
1603
  backtrace->obj_at_put(trace_mirrors_offset, mirrors());
D
duke 已提交
1604 1605 1606 1607 1608 1609 1610 1611 1612 1613
  set_backtrace(throwable(), backtrace());
}


void java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(Handle throwable) {
  // Fill in stack trace into preallocated backtrace (no GC)

  // No-op if stack trace is disabled
  if (!StackTraceInThrowable) return;

1614
  assert(throwable->is_a(SystemDictionary::Throwable_klass()), "sanity check");
D
duke 已提交
1615

1616
  objArrayOop backtrace = (objArrayOop)java_lang_Throwable::backtrace(throwable());
D
duke 已提交
1617 1618
  assert(backtrace != NULL, "backtrace not preallocated");

1619 1620
  oop m = backtrace->obj_at(trace_methods_offset);
  typeArrayOop methods = typeArrayOop(m);
D
duke 已提交
1621 1622
  assert(methods != NULL && methods->length() > 0, "method array not preallocated");

1623
  oop b = backtrace->obj_at(trace_bcis_offset);
D
duke 已提交
1624 1625 1626
  typeArrayOop bcis = typeArrayOop(b);
  assert(bcis != NULL, "bci array not preallocated");

1627 1628 1629 1630 1631 1632 1633
  oop mr = backtrace->obj_at(trace_mirrors_offset);
  objArrayOop mirrors = objArrayOop(mr);
  assert(mirrors != NULL, "bci array not preallocated");

  assert(methods->length() == bcis->length() &&
         methods->length() == mirrors->length(),
         "method and bci arrays should match");
D
duke 已提交
1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646

  JavaThread* thread = JavaThread::current();
  ResourceMark rm(thread);
  vframeStream st(thread);

  // Unlike fill_in_stack_trace we do not skip fillInStackTrace or throwable init
  // methods as preallocated errors aren't created by "java" code.

  // fill in as much stack trace as possible
  int max_chunks = MIN2(methods->length(), (int)MaxJavaStackTraceDepth);
  int chunk_count = 0;

  for (;!st.at_end(); st.next()) {
1647 1648 1649 1650 1651 1652 1653
    // Add entry and smear the -1 bci to 0 since the array only holds
    // unsigned shorts.  The later line number lookup would just smear
    // the -1 to a 0 even if it could be recorded.
    int bci = st.bci();
    if (bci == SynchronizationEntryBCI) bci = 0;
    assert(bci == (jushort)bci, "doesn't fit");
    bcis->ushort_at_put(chunk_count, bci);
1654 1655 1656
    methods->metadata_at_put(chunk_count, st.method());
    mirrors->obj_at_put(chunk_count,
                   st.method()->method_holder()->java_mirror());
D
duke 已提交
1657 1658 1659 1660 1661 1662

    chunk_count++;

    // Bail-out for deep stacks
    if (chunk_count >= max_chunks) break;
  }
1663 1664 1665 1666 1667 1668 1669 1670 1671

  // For Java 7+ we support the Throwable immutability protocol defined for Java 7. This support
  // was missing in 7u0 so in 7u0 there is a workaround in the Throwable class. That workaround
  // can be removed in a JDK using this JVM version
  if (JDK_Version::is_gte_jdk17x_version()) {
      java_lang_Throwable::set_stacktrace(throwable(), java_lang_Throwable::unassigned_stacktrace());
      assert(java_lang_Throwable::unassigned_stacktrace() != NULL, "not initialized");
  }

D
duke 已提交
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690
}


int java_lang_Throwable::get_stack_trace_depth(oop throwable, TRAPS) {
  if (throwable == NULL) {
    THROW_0(vmSymbols::java_lang_NullPointerException());
  }
  objArrayOop chunk = objArrayOop(backtrace(throwable));
  int depth = 0;
  if (chunk != NULL) {
    // Iterate over chunks and count full ones
    while (true) {
      objArrayOop next = objArrayOop(chunk->obj_at(trace_next_offset));
      if (next == NULL) break;
      depth += trace_chunk_size;
      chunk = next;
    }
    assert(chunk != NULL && chunk->obj_at(trace_next_offset) == NULL, "sanity check");
    // Count element in remaining partial chunk
1691
    typeArrayOop methods = typeArrayOop(chunk->obj_at(trace_methods_offset));
D
duke 已提交
1692 1693 1694
    typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset));
    assert(methods != NULL && bcis != NULL, "sanity check");
    for (int i = 0; i < methods->length(); i++) {
1695
      if (methods->metadata_at(i) == NULL) break;
D
duke 已提交
1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
      depth++;
    }
  }
  return depth;
}


oop java_lang_Throwable::get_stack_trace_element(oop throwable, int index, TRAPS) {
  if (throwable == NULL) {
    THROW_0(vmSymbols::java_lang_NullPointerException());
  }
  if (index < 0) {
    THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
  }
  // Compute how many chunks to skip and index into actual chunk
  objArrayOop chunk = objArrayOop(backtrace(throwable));
  int skip_chunks = index / trace_chunk_size;
  int chunk_index = index % trace_chunk_size;
  while (chunk != NULL && skip_chunks > 0) {
    chunk = objArrayOop(chunk->obj_at(trace_next_offset));
        skip_chunks--;
  }
  if (chunk == NULL) {
    THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
  }
  // Get method,bci from chunk
1722
  typeArrayOop methods = typeArrayOop(chunk->obj_at(trace_methods_offset));
D
duke 已提交
1723 1724
  typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset));
  assert(methods != NULL && bcis != NULL, "sanity check");
1725
  methodHandle method(THREAD, ((Method*)methods->metadata_at(chunk_index)));
D
duke 已提交
1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
  int bci = bcis->ushort_at(chunk_index);
  // Chunk can be partial full
  if (method.is_null()) {
    THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
  }

  oop element = java_lang_StackTraceElement::create(method, bci, CHECK_0);
  return element;
}

oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) {
  // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs
  assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4");

  // Allocate java.lang.StackTraceElement instance
1741
  Klass* k = SystemDictionary::StackTraceElement_klass();
1742
  assert(k != NULL, "must be loaded in 1.4+");
D
duke 已提交
1743 1744 1745 1746 1747 1748 1749 1750
  instanceKlassHandle ik (THREAD, k);
  if (ik->should_be_initialized()) {
    ik->initialize(CHECK_0);
  }

  Handle element = ik->allocate_instance_handle(CHECK_0);
  // Fill in class name
  ResourceMark rm(THREAD);
1751
  const char* str = InstanceKlass::cast(method->method_holder())->external_name();
D
duke 已提交
1752 1753 1754 1755 1756 1757
  oop classname = StringTable::intern((char*) str, CHECK_0);
  java_lang_StackTraceElement::set_declaringClass(element(), classname);
  // Fill in method name
  oop methodname = StringTable::intern(method->name(), CHECK_0);
  java_lang_StackTraceElement::set_methodName(element(), methodname);
  // Fill in source file name
1758
  Symbol* source = InstanceKlass::cast(method->method_holder())->source_file_name();
1759 1760
  if (ShowHiddenFrames && source == NULL)
    source = vmSymbols::unknown_class_name();
D
duke 已提交
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772
  oop filename = StringTable::intern(source, CHECK_0);
  java_lang_StackTraceElement::set_fileName(element(), filename);
  // File in source line number
  int line_number;
  if (method->is_native()) {
    // Negative value different from -1 below, enabling Java code in
    // class java.lang.StackTraceElement to distinguish "native" from
    // "no LineNumberTable".
    line_number = -2;
  } else {
    // Returns -1 if no LineNumberTable, and otherwise actual line number
    line_number = method->line_number_from_bci(bci);
1773 1774 1775
    if (line_number == -1 && ShowHiddenFrames) {
      line_number = bci + 1000000;
    }
D
duke 已提交
1776 1777 1778 1779 1780 1781 1782 1783
  }
  java_lang_StackTraceElement::set_lineNumber(element(), line_number);

  return element();
}


void java_lang_reflect_AccessibleObject::compute_offsets() {
1784
  Klass* k = SystemDictionary::reflect_AccessibleObject_klass();
1785
  compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
D
duke 已提交
1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798
}

jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return (jboolean) reflect->bool_field(override_offset);
}

void java_lang_reflect_AccessibleObject::set_override(oop reflect, jboolean value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  reflect->bool_field_put(override_offset, (int) value);
}

void java_lang_reflect_Method::compute_offsets() {
1799
  Klass* k = SystemDictionary::reflect_Method_klass();
1800 1801 1802 1803 1804 1805 1806
  compute_offset(clazz_offset,          k, vmSymbols::clazz_name(),          vmSymbols::class_signature());
  compute_offset(name_offset,           k, vmSymbols::name_name(),           vmSymbols::string_signature());
  compute_offset(returnType_offset,     k, vmSymbols::returnType_name(),     vmSymbols::class_signature());
  compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
  compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
  compute_offset(slot_offset,           k, vmSymbols::slot_name(),           vmSymbols::int_signature());
  compute_offset(modifiers_offset,      k, vmSymbols::modifiers_name(),      vmSymbols::int_signature());
D
duke 已提交
1807 1808 1809 1810 1811
  // The generic signature and annotations fields are only present in 1.5
  signature_offset = -1;
  annotations_offset = -1;
  parameter_annotations_offset = -1;
  annotation_default_offset = -1;
1812 1813 1814 1815
  compute_optional_offset(signature_offset,             k, vmSymbols::signature_name(),             vmSymbols::string_signature());
  compute_optional_offset(annotations_offset,           k, vmSymbols::annotations_name(),           vmSymbols::byte_array_signature());
  compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature());
  compute_optional_offset(annotation_default_offset,    k, vmSymbols::annotation_default_name(),    vmSymbols::byte_array_signature());
D
duke 已提交
1816 1817 1818 1819
}

Handle java_lang_reflect_Method::create(TRAPS) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1820
  Klass* klass = SystemDictionary::reflect_Method_klass();
D
duke 已提交
1821 1822
  // This class is eagerly initialized during VM initialization, since we keep a refence
  // to one of the methods
1823 1824
  assert(InstanceKlass::cast(klass)->is_initialized(), "must be initialized");
  return InstanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH);
D
duke 已提交
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961
}

oop java_lang_reflect_Method::clazz(oop reflect) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return reflect->obj_field(clazz_offset);
}

void java_lang_reflect_Method::set_clazz(oop reflect, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   reflect->obj_field_put(clazz_offset, value);
}

int java_lang_reflect_Method::slot(oop reflect) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return reflect->int_field(slot_offset);
}

void java_lang_reflect_Method::set_slot(oop reflect, int value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  reflect->int_field_put(slot_offset, value);
}

oop java_lang_reflect_Method::name(oop method) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return method->obj_field(name_offset);
}

void java_lang_reflect_Method::set_name(oop method, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  method->obj_field_put(name_offset, value);
}

oop java_lang_reflect_Method::return_type(oop method) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return method->obj_field(returnType_offset);
}

void java_lang_reflect_Method::set_return_type(oop method, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  method->obj_field_put(returnType_offset, value);
}

oop java_lang_reflect_Method::parameter_types(oop method) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return method->obj_field(parameterTypes_offset);
}

void java_lang_reflect_Method::set_parameter_types(oop method, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  method->obj_field_put(parameterTypes_offset, value);
}

oop java_lang_reflect_Method::exception_types(oop method) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return method->obj_field(exceptionTypes_offset);
}

void java_lang_reflect_Method::set_exception_types(oop method, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  method->obj_field_put(exceptionTypes_offset, value);
}

int java_lang_reflect_Method::modifiers(oop method) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return method->int_field(modifiers_offset);
}

void java_lang_reflect_Method::set_modifiers(oop method, int value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  method->int_field_put(modifiers_offset, value);
}

bool java_lang_reflect_Method::has_signature_field() {
  return (signature_offset >= 0);
}

oop java_lang_reflect_Method::signature(oop method) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_signature_field(), "signature field must be present");
  return method->obj_field(signature_offset);
}

void java_lang_reflect_Method::set_signature(oop method, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_signature_field(), "signature field must be present");
  method->obj_field_put(signature_offset, value);
}

bool java_lang_reflect_Method::has_annotations_field() {
  return (annotations_offset >= 0);
}

oop java_lang_reflect_Method::annotations(oop method) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_annotations_field(), "annotations field must be present");
  return method->obj_field(annotations_offset);
}

void java_lang_reflect_Method::set_annotations(oop method, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_annotations_field(), "annotations field must be present");
  method->obj_field_put(annotations_offset, value);
}

bool java_lang_reflect_Method::has_parameter_annotations_field() {
  return (parameter_annotations_offset >= 0);
}

oop java_lang_reflect_Method::parameter_annotations(oop method) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_parameter_annotations_field(), "parameter annotations field must be present");
  return method->obj_field(parameter_annotations_offset);
}

void java_lang_reflect_Method::set_parameter_annotations(oop method, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_parameter_annotations_field(), "parameter annotations field must be present");
  method->obj_field_put(parameter_annotations_offset, value);
}

bool java_lang_reflect_Method::has_annotation_default_field() {
  return (annotation_default_offset >= 0);
}

oop java_lang_reflect_Method::annotation_default(oop method) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_annotation_default_field(), "annotation default field must be present");
  return method->obj_field(annotation_default_offset);
}

void java_lang_reflect_Method::set_annotation_default(oop method, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_annotation_default_field(), "annotation default field must be present");
  method->obj_field_put(annotation_default_offset, value);
}

void java_lang_reflect_Constructor::compute_offsets() {
1962
  Klass* k = SystemDictionary::reflect_Constructor_klass();
1963 1964 1965 1966 1967
  compute_offset(clazz_offset,          k, vmSymbols::clazz_name(),          vmSymbols::class_signature());
  compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
  compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
  compute_offset(slot_offset,           k, vmSymbols::slot_name(),           vmSymbols::int_signature());
  compute_offset(modifiers_offset,      k, vmSymbols::modifiers_name(),      vmSymbols::int_signature());
D
duke 已提交
1968 1969 1970 1971
  // The generic signature and annotations fields are only present in 1.5
  signature_offset = -1;
  annotations_offset = -1;
  parameter_annotations_offset = -1;
1972 1973 1974
  compute_optional_offset(signature_offset,             k, vmSymbols::signature_name(),             vmSymbols::string_signature());
  compute_optional_offset(annotations_offset,           k, vmSymbols::annotations_name(),           vmSymbols::byte_array_signature());
  compute_optional_offset(parameter_annotations_offset, k, vmSymbols::parameter_annotations_name(), vmSymbols::byte_array_signature());
D
duke 已提交
1975 1976 1977 1978
}

Handle java_lang_reflect_Constructor::create(TRAPS) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
1979
  Symbol* name = vmSymbols::java_lang_reflect_Constructor();
1980
  Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
D
duke 已提交
1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085
  instanceKlassHandle klass (THREAD, k);
  // Ensure it is initialized
  klass->initialize(CHECK_NH);
  return klass->allocate_instance_handle(CHECK_NH);
}

oop java_lang_reflect_Constructor::clazz(oop reflect) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return reflect->obj_field(clazz_offset);
}

void java_lang_reflect_Constructor::set_clazz(oop reflect, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   reflect->obj_field_put(clazz_offset, value);
}

oop java_lang_reflect_Constructor::parameter_types(oop constructor) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return constructor->obj_field(parameterTypes_offset);
}

void java_lang_reflect_Constructor::set_parameter_types(oop constructor, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  constructor->obj_field_put(parameterTypes_offset, value);
}

oop java_lang_reflect_Constructor::exception_types(oop constructor) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return constructor->obj_field(exceptionTypes_offset);
}

void java_lang_reflect_Constructor::set_exception_types(oop constructor, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  constructor->obj_field_put(exceptionTypes_offset, value);
}

int java_lang_reflect_Constructor::slot(oop reflect) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return reflect->int_field(slot_offset);
}

void java_lang_reflect_Constructor::set_slot(oop reflect, int value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  reflect->int_field_put(slot_offset, value);
}

int java_lang_reflect_Constructor::modifiers(oop constructor) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return constructor->int_field(modifiers_offset);
}

void java_lang_reflect_Constructor::set_modifiers(oop constructor, int value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  constructor->int_field_put(modifiers_offset, value);
}

bool java_lang_reflect_Constructor::has_signature_field() {
  return (signature_offset >= 0);
}

oop java_lang_reflect_Constructor::signature(oop constructor) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_signature_field(), "signature field must be present");
  return constructor->obj_field(signature_offset);
}

void java_lang_reflect_Constructor::set_signature(oop constructor, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_signature_field(), "signature field must be present");
  constructor->obj_field_put(signature_offset, value);
}

bool java_lang_reflect_Constructor::has_annotations_field() {
  return (annotations_offset >= 0);
}

oop java_lang_reflect_Constructor::annotations(oop constructor) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_annotations_field(), "annotations field must be present");
  return constructor->obj_field(annotations_offset);
}

void java_lang_reflect_Constructor::set_annotations(oop constructor, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_annotations_field(), "annotations field must be present");
  constructor->obj_field_put(annotations_offset, value);
}

bool java_lang_reflect_Constructor::has_parameter_annotations_field() {
  return (parameter_annotations_offset >= 0);
}

oop java_lang_reflect_Constructor::parameter_annotations(oop method) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_parameter_annotations_field(), "parameter annotations field must be present");
  return method->obj_field(parameter_annotations_offset);
}

void java_lang_reflect_Constructor::set_parameter_annotations(oop method, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_parameter_annotations_field(), "parameter annotations field must be present");
  method->obj_field_put(parameter_annotations_offset, value);
}

void java_lang_reflect_Field::compute_offsets() {
2086
  Klass* k = SystemDictionary::reflect_Field_klass();
2087 2088 2089 2090 2091
  compute_offset(clazz_offset,     k, vmSymbols::clazz_name(),     vmSymbols::class_signature());
  compute_offset(name_offset,      k, vmSymbols::name_name(),      vmSymbols::string_signature());
  compute_offset(type_offset,      k, vmSymbols::type_name(),      vmSymbols::class_signature());
  compute_offset(slot_offset,      k, vmSymbols::slot_name(),      vmSymbols::int_signature());
  compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
D
duke 已提交
2092 2093 2094
  // The generic signature and annotations fields are only present in 1.5
  signature_offset = -1;
  annotations_offset = -1;
2095 2096
  compute_optional_offset(signature_offset, k, vmSymbols::signature_name(), vmSymbols::string_signature());
  compute_optional_offset(annotations_offset,  k, vmSymbols::annotations_name(),  vmSymbols::byte_array_signature());
D
duke 已提交
2097 2098 2099 2100
}

Handle java_lang_reflect_Field::create(TRAPS) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2101
  Symbol* name = vmSymbols::java_lang_reflect_Field();
2102
  Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH);
D
duke 已提交
2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192
  instanceKlassHandle klass (THREAD, k);
  // Ensure it is initialized
  klass->initialize(CHECK_NH);
  return klass->allocate_instance_handle(CHECK_NH);
}

oop java_lang_reflect_Field::clazz(oop reflect) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return reflect->obj_field(clazz_offset);
}

void java_lang_reflect_Field::set_clazz(oop reflect, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
   reflect->obj_field_put(clazz_offset, value);
}

oop java_lang_reflect_Field::name(oop field) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return field->obj_field(name_offset);
}

void java_lang_reflect_Field::set_name(oop field, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  field->obj_field_put(name_offset, value);
}

oop java_lang_reflect_Field::type(oop field) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return field->obj_field(type_offset);
}

void java_lang_reflect_Field::set_type(oop field, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  field->obj_field_put(type_offset, value);
}

int java_lang_reflect_Field::slot(oop reflect) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return reflect->int_field(slot_offset);
}

void java_lang_reflect_Field::set_slot(oop reflect, int value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  reflect->int_field_put(slot_offset, value);
}

int java_lang_reflect_Field::modifiers(oop field) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  return field->int_field(modifiers_offset);
}

void java_lang_reflect_Field::set_modifiers(oop field, int value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  field->int_field_put(modifiers_offset, value);
}

bool java_lang_reflect_Field::has_signature_field() {
  return (signature_offset >= 0);
}

oop java_lang_reflect_Field::signature(oop field) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_signature_field(), "signature field must be present");
  return field->obj_field(signature_offset);
}

void java_lang_reflect_Field::set_signature(oop field, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_signature_field(), "signature field must be present");
  field->obj_field_put(signature_offset, value);
}

bool java_lang_reflect_Field::has_annotations_field() {
  return (annotations_offset >= 0);
}

oop java_lang_reflect_Field::annotations(oop field) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_annotations_field(), "annotations field must be present");
  return field->obj_field(annotations_offset);
}

void java_lang_reflect_Field::set_annotations(oop field, oop value) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
  assert(has_annotations_field(), "annotations field must be present");
  field->obj_field_put(annotations_offset, value);
}


void sun_reflect_ConstantPool::compute_offsets() {
2193
  Klass* k = SystemDictionary::reflect_ConstantPool_klass();
D
duke 已提交
2194 2195
  // This null test can be removed post beta
  if (k != NULL) {
2196 2197
    // The field is called ConstantPool* in the sun.reflect.ConstantPool class.
    compute_offset(_oop_offset, k, vmSymbols::ConstantPool_name(), vmSymbols::object_signature());
D
duke 已提交
2198 2199 2200 2201 2202 2203
  }
}


Handle sun_reflect_ConstantPool::create(TRAPS) {
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2204
  Klass* k = SystemDictionary::reflect_ConstantPool_klass();
D
duke 已提交
2205 2206 2207 2208 2209 2210 2211
  instanceKlassHandle klass (THREAD, k);
  // Ensure it is initialized
  klass->initialize(CHECK_NH);
  return klass->allocate_instance_handle(CHECK_NH);
}


2212
void sun_reflect_ConstantPool::set_cp(oop reflect, ConstantPool* value) {
D
duke 已提交
2213
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2214 2215 2216
  oop mirror = value->pool_holder()->java_mirror();
  // Save the mirror to get back the constant pool.
  reflect->obj_field_put(_oop_offset, mirror);
D
duke 已提交
2217 2218
}

2219
ConstantPool* sun_reflect_ConstantPool::get_cp(oop reflect) {
D
duke 已提交
2220
  assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231

  oop mirror = reflect->obj_field(_oop_offset);
  Klass* k = java_lang_Class::as_Klass(mirror);
  assert(k->oop_is_instance(), "Must be");

  // Get the constant pool back from the klass.  Since class redefinition
  // merges the new constant pool into the old, this is essentially the
  // same constant pool as the original.  If constant pool merging is
  // no longer done in the future, this will have to change to save
  // the original.
  return InstanceKlass::cast(k)->constants();
D
duke 已提交
2232 2233 2234
}

void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() {
2235
  Klass* k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass();
D
duke 已提交
2236 2237
  // This null test can be removed post beta
  if (k != NULL) {
2238
    compute_offset(_base_offset, k,
D
duke 已提交
2239 2240 2241 2242
                   vmSymbols::base_name(), vmSymbols::object_signature());
  }
}

2243
oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) {
2244
  Klass* k = SystemDictionary::box_klass(type);
2245 2246 2247 2248
  if (k == NULL)  return NULL;
  instanceKlassHandle h (THREAD, k);
  if (!h->is_initialized())  h->initialize(CHECK_0);
  return h->allocate_instance(THREAD);
D
duke 已提交
2249 2250 2251 2252
}


oop java_lang_boxing_object::create(BasicType type, jvalue* value, TRAPS) {
2253 2254
  oop box = initialize_and_allocate(type, CHECK_0);
  if (box == NULL)  return NULL;
D
duke 已提交
2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265
  switch (type) {
    case T_BOOLEAN:
      box->bool_field_put(value_offset, value->z);
      break;
    case T_CHAR:
      box->char_field_put(value_offset, value->c);
      break;
    case T_FLOAT:
      box->float_field_put(value_offset, value->f);
      break;
    case T_DOUBLE:
2266
      box->double_field_put(long_value_offset, value->d);
D
duke 已提交
2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277
      break;
    case T_BYTE:
      box->byte_field_put(value_offset, value->b);
      break;
    case T_SHORT:
      box->short_field_put(value_offset, value->s);
      break;
    case T_INT:
      box->int_field_put(value_offset, value->i);
      break;
    case T_LONG:
2278
      box->long_field_put(long_value_offset, value->j);
D
duke 已提交
2279 2280 2281 2282 2283 2284 2285 2286
      break;
    default:
      return NULL;
  }
  return box;
}


2287 2288 2289 2290 2291 2292 2293 2294 2295
BasicType java_lang_boxing_object::basic_type(oop box) {
  if (box == NULL)  return T_ILLEGAL;
  BasicType type = SystemDictionary::box_klass_type(box->klass());
  if (type == T_OBJECT)         // 'unknown' value returned by SD::bkt
    return T_ILLEGAL;
  return type;
}


D
duke 已提交
2296
BasicType java_lang_boxing_object::get_value(oop box, jvalue* value) {
2297 2298 2299
  BasicType type = SystemDictionary::box_klass_type(box->klass());
  switch (type) {
  case T_BOOLEAN:
D
duke 已提交
2300
    value->z = box->bool_field(value_offset);
2301 2302
    break;
  case T_CHAR:
D
duke 已提交
2303
    value->c = box->char_field(value_offset);
2304 2305
    break;
  case T_FLOAT:
D
duke 已提交
2306
    value->f = box->float_field(value_offset);
2307 2308
    break;
  case T_DOUBLE:
2309
    value->d = box->double_field(long_value_offset);
2310 2311
    break;
  case T_BYTE:
D
duke 已提交
2312
    value->b = box->byte_field(value_offset);
2313 2314
    break;
  case T_SHORT:
D
duke 已提交
2315
    value->s = box->short_field(value_offset);
2316 2317
    break;
  case T_INT:
D
duke 已提交
2318
    value->i = box->int_field(value_offset);
2319 2320
    break;
  case T_LONG:
2321
    value->j = box->long_field(long_value_offset);
2322 2323 2324 2325 2326
    break;
  default:
    return T_ILLEGAL;
  } // end switch
  return type;
D
duke 已提交
2327 2328 2329 2330
}


BasicType java_lang_boxing_object::set_value(oop box, jvalue* value) {
2331 2332 2333
  BasicType type = SystemDictionary::box_klass_type(box->klass());
  switch (type) {
  case T_BOOLEAN:
D
duke 已提交
2334
    box->bool_field_put(value_offset, value->z);
2335 2336
    break;
  case T_CHAR:
D
duke 已提交
2337
    box->char_field_put(value_offset, value->c);
2338 2339
    break;
  case T_FLOAT:
D
duke 已提交
2340
    box->float_field_put(value_offset, value->f);
2341 2342
    break;
  case T_DOUBLE:
2343
    box->double_field_put(long_value_offset, value->d);
2344 2345
    break;
  case T_BYTE:
D
duke 已提交
2346
    box->byte_field_put(value_offset, value->b);
2347 2348
    break;
  case T_SHORT:
D
duke 已提交
2349
    box->short_field_put(value_offset, value->s);
2350 2351
    break;
  case T_INT:
D
duke 已提交
2352
    box->int_field_put(value_offset, value->i);
2353 2354
    break;
  case T_LONG:
2355
    box->long_field_put(long_value_offset, value->j);
2356 2357 2358 2359 2360
    break;
  default:
    return T_ILLEGAL;
  } // end switch
  return type;
D
duke 已提交
2361 2362 2363
}


2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378
void java_lang_boxing_object::print(BasicType type, jvalue* value, outputStream* st) {
  switch (type) {
  case T_BOOLEAN:   st->print("%s", value->z ? "true" : "false");   break;
  case T_CHAR:      st->print("%d", value->c);                      break;
  case T_BYTE:      st->print("%d", value->b);                      break;
  case T_SHORT:     st->print("%d", value->s);                      break;
  case T_INT:       st->print("%d", value->i);                      break;
  case T_LONG:      st->print(INT64_FORMAT, value->j);              break;
  case T_FLOAT:     st->print("%f", value->f);                      break;
  case T_DOUBLE:    st->print("%lf", value->d);                     break;
  default:          st->print("type %d?", type);                    break;
  }
}


D
duke 已提交
2379
// Support for java_lang_ref_Reference
2380 2381 2382 2383 2384 2385
HeapWord *java_lang_ref_Reference::pending_list_lock_addr() {
  InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass());
  address addr = ik->static_field_addr(static_lock_offset);
  return (HeapWord*) addr;
}

2386
oop java_lang_ref_Reference::pending_list_lock() {
2387
  InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass());
2388
  address addr = ik->static_field_addr(static_lock_offset);
2389 2390 2391 2392 2393
  if (UseCompressedOops) {
    return oopDesc::load_decode_heap_oop((narrowOop *)addr);
  } else {
    return oopDesc::load_decode_heap_oop((oop*)addr);
  }
D
duke 已提交
2394 2395
}

2396
HeapWord *java_lang_ref_Reference::pending_list_addr() {
2397
  InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass());
2398
  address addr = ik->static_field_addr(static_pending_offset);
2399 2400
  // XXX This might not be HeapWord aligned, almost rather be char *.
  return (HeapWord*)addr;
D
duke 已提交
2401 2402
}

2403 2404 2405 2406 2407 2408 2409
oop java_lang_ref_Reference::pending_list() {
  char *addr = (char *)pending_list_addr();
  if (UseCompressedOops) {
    return oopDesc::load_decode_heap_oop((narrowOop *)addr);
  } else {
    return oopDesc::load_decode_heap_oop((oop*)addr);
  }
D
duke 已提交
2410 2411 2412 2413 2414 2415 2416 2417 2418 2419
}


// Support for java_lang_ref_SoftReference

jlong java_lang_ref_SoftReference::timestamp(oop ref) {
  return ref->long_field(timestamp_offset);
}

jlong java_lang_ref_SoftReference::clock() {
2420
  InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass());
2421 2422
  jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset);
  return *offset;
D
duke 已提交
2423 2424 2425
}

void java_lang_ref_SoftReference::set_clock(jlong value) {
2426
  InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass());
2427 2428
  jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset);
  *offset = value;
D
duke 已提交
2429 2430 2431
}


2432
// Support for java_lang_invoke_MethodHandle
2433

2434
int java_lang_invoke_MethodHandle::_type_offset;
2435
int java_lang_invoke_MethodHandle::_form_offset;
2436

2437 2438 2439 2440 2441
int java_lang_invoke_MemberName::_clazz_offset;
int java_lang_invoke_MemberName::_name_offset;
int java_lang_invoke_MemberName::_type_offset;
int java_lang_invoke_MemberName::_flags_offset;
int java_lang_invoke_MemberName::_vmtarget_offset;
2442
int java_lang_invoke_MemberName::_vmloader_offset;
2443
int java_lang_invoke_MemberName::_vmindex_offset;
2444

2445
int java_lang_invoke_LambdaForm::_vmentry_offset;
2446

2447
void java_lang_invoke_MethodHandle::compute_offsets() {
2448
  Klass* klass_oop = SystemDictionary::MethodHandle_klass();
2449
  if (klass_oop != NULL && EnableInvokeDynamic) {
2450 2451 2452 2453 2454
    compute_offset(_type_offset, klass_oop, vmSymbols::type_name(), vmSymbols::java_lang_invoke_MethodType_signature());
    compute_optional_offset(_form_offset, klass_oop, vmSymbols::form_name(), vmSymbols::java_lang_invoke_LambdaForm_signature());
    if (_form_offset == 0) {
      EnableInvokeDynamic = false;
    }
2455 2456 2457
  }
}

2458
void java_lang_invoke_MemberName::compute_offsets() {
2459
  Klass* klass_oop = SystemDictionary::MemberName_klass();
2460 2461 2462 2463 2464 2465
  if (klass_oop != NULL && EnableInvokeDynamic) {
    compute_offset(_clazz_offset,     klass_oop, vmSymbols::clazz_name(),     vmSymbols::class_signature());
    compute_offset(_name_offset,      klass_oop, vmSymbols::name_name(),      vmSymbols::string_signature());
    compute_offset(_type_offset,      klass_oop, vmSymbols::type_name(),      vmSymbols::object_signature());
    compute_offset(_flags_offset,     klass_oop, vmSymbols::flags_name(),     vmSymbols::int_signature());
    MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
2466 2467 2468
  }
}

2469
void java_lang_invoke_LambdaForm::compute_offsets() {
2470
  Klass* klass_oop = SystemDictionary::LambdaForm_klass();
2471 2472
  if (klass_oop != NULL && EnableInvokeDynamic) {
    compute_offset(_vmentry_offset, klass_oop, vmSymbols::vmentry_name(), vmSymbols::java_lang_invoke_MemberName_signature());
2473 2474 2475
  }
}

2476
oop java_lang_invoke_MethodHandle::type(oop mh) {
2477 2478 2479
  return mh->obj_field(_type_offset);
}

2480
void java_lang_invoke_MethodHandle::set_type(oop mh, oop mtype) {
2481 2482 2483
  mh->obj_field_put(_type_offset, mtype);
}

2484 2485 2486
oop java_lang_invoke_MethodHandle::form(oop mh) {
  assert(_form_offset != 0, "");
  return mh->obj_field(_form_offset);
2487 2488
}

2489 2490 2491
void java_lang_invoke_MethodHandle::set_form(oop mh, oop lform) {
  assert(_form_offset != 0, "");
  mh->obj_field_put(_form_offset, lform);
2492 2493 2494 2495
}

/// MemberName accessors

2496
oop java_lang_invoke_MemberName::clazz(oop mname) {
2497 2498 2499 2500
  assert(is_instance(mname), "wrong type");
  return mname->obj_field(_clazz_offset);
}

2501
void java_lang_invoke_MemberName::set_clazz(oop mname, oop clazz) {
2502 2503 2504 2505
  assert(is_instance(mname), "wrong type");
  mname->obj_field_put(_clazz_offset, clazz);
}

2506
oop java_lang_invoke_MemberName::name(oop mname) {
2507 2508 2509 2510
  assert(is_instance(mname), "wrong type");
  return mname->obj_field(_name_offset);
}

2511
void java_lang_invoke_MemberName::set_name(oop mname, oop name) {
2512 2513 2514 2515
  assert(is_instance(mname), "wrong type");
  mname->obj_field_put(_name_offset, name);
}

2516
oop java_lang_invoke_MemberName::type(oop mname) {
2517 2518 2519 2520
  assert(is_instance(mname), "wrong type");
  return mname->obj_field(_type_offset);
}

2521
void java_lang_invoke_MemberName::set_type(oop mname, oop type) {
2522 2523 2524 2525
  assert(is_instance(mname), "wrong type");
  mname->obj_field_put(_type_offset, type);
}

2526
int java_lang_invoke_MemberName::flags(oop mname) {
2527 2528 2529 2530
  assert(is_instance(mname), "wrong type");
  return mname->int_field(_flags_offset);
}

2531
void java_lang_invoke_MemberName::set_flags(oop mname, int flags) {
2532 2533 2534 2535
  assert(is_instance(mname), "wrong type");
  mname->int_field_put(_flags_offset, flags);
}

2536
Metadata* java_lang_invoke_MemberName::vmtarget(oop mname) {
2537
  assert(is_instance(mname), "wrong type");
2538
  return (Metadata*)mname->address_field(_vmtarget_offset);
2539 2540
}

2541
void java_lang_invoke_MemberName::set_vmtarget(oop mname, Metadata* ref) {
2542
  assert(is_instance(mname), "wrong type");
2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
#ifdef ASSERT
  // check the type of the vmtarget
  if (ref != NULL) {
    switch (flags(mname) & (MN_IS_METHOD |
                            MN_IS_CONSTRUCTOR |
                            MN_IS_FIELD)) {
    case MN_IS_METHOD:
    case MN_IS_CONSTRUCTOR:
      assert(ref->is_method(), "should be a method");
      break;
    case MN_IS_FIELD:
      assert(ref->is_klass(), "should be a class");
      break;
    default:
      ShouldNotReachHere();
    }
  }
#endif //ASSERT
2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573
  mname->address_field_put(_vmtarget_offset, (address)ref);
  oop loader = NULL;
  if (ref != NULL) {
    if (ref->is_klass()) {
      loader = ((Klass*)ref)->class_loader();
    } else if (ref->is_method()) {
      loader = ((Method*)ref)->method_holder()->class_loader();
    } else {
      ShouldNotReachHere();
    }
  }
  // Add a reference to the loader to ensure the metadata is kept alive
  mname->obj_field_put(_vmloader_offset, loader);
2574 2575
}

2576
intptr_t java_lang_invoke_MemberName::vmindex(oop mname) {
2577
  assert(is_instance(mname), "wrong type");
2578
  return (intptr_t) mname->address_field(_vmindex_offset);
2579 2580
}

2581
void java_lang_invoke_MemberName::set_vmindex(oop mname, intptr_t index) {
2582
  assert(is_instance(mname), "wrong type");
2583
  mname->address_field_put(_vmindex_offset, (address) index);
2584 2585
}

2586 2587 2588
oop java_lang_invoke_LambdaForm::vmentry(oop lform) {
  assert(is_instance(lform), "wrong type");
  return lform->obj_field(_vmentry_offset);
2589 2590 2591
}


2592
// Support for java_lang_invoke_MethodType
2593

2594 2595
int java_lang_invoke_MethodType::_rtype_offset;
int java_lang_invoke_MethodType::_ptypes_offset;
2596

2597
void java_lang_invoke_MethodType::compute_offsets() {
2598
  Klass* k = SystemDictionary::MethodType_klass();
2599 2600 2601 2602 2603 2604
  if (k != NULL) {
    compute_offset(_rtype_offset,  k, vmSymbols::rtype_name(),  vmSymbols::class_signature());
    compute_offset(_ptypes_offset, k, vmSymbols::ptypes_name(), vmSymbols::class_array_signature());
  }
}

2605
void java_lang_invoke_MethodType::print_signature(oop mt, outputStream* st) {
2606 2607 2608 2609 2610 2611 2612 2613 2614
  st->print("(");
  objArrayOop pts = ptypes(mt);
  for (int i = 0, limit = pts->length(); i < limit; i++) {
    java_lang_Class::print_signature(pts->obj_at(i), st);
  }
  st->print(")");
  java_lang_Class::print_signature(rtype(mt), st);
}

2615
Symbol* java_lang_invoke_MethodType::as_signature(oop mt, bool intern_if_not_found, TRAPS) {
2616 2617 2618 2619 2620
  ResourceMark rm;
  stringStream buffer(128);
  print_signature(mt, &buffer);
  const char* sigstr =       buffer.base();
  int         siglen = (int) buffer.size();
2621 2622 2623 2624 2625 2626 2627
  Symbol *name;
  if (!intern_if_not_found) {
    name = SymbolTable::probe(sigstr, siglen);
  } else {
    name = SymbolTable::new_symbol(sigstr, siglen, THREAD);
  }
  return name;
2628 2629
}

2630
bool java_lang_invoke_MethodType::equals(oop mt1, oop mt2) {
2631 2632
  if (mt1 == mt2)
    return true;
2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643
  if (rtype(mt1) != rtype(mt2))
    return false;
  if (ptype_count(mt1) != ptype_count(mt2))
    return false;
  for (int i = ptype_count(mt1) - 1; i >= 0; i--) {
    if (ptype(mt1, i) != ptype(mt2, i))
      return false;
  }
  return true;
}

2644
oop java_lang_invoke_MethodType::rtype(oop mt) {
2645 2646 2647 2648
  assert(is_instance(mt), "must be a MethodType");
  return mt->obj_field(_rtype_offset);
}

2649
objArrayOop java_lang_invoke_MethodType::ptypes(oop mt) {
2650 2651 2652 2653
  assert(is_instance(mt), "must be a MethodType");
  return (objArrayOop) mt->obj_field(_ptypes_offset);
}

2654
oop java_lang_invoke_MethodType::ptype(oop mt, int idx) {
2655 2656 2657
  return ptypes(mt)->obj_at(idx);
}

2658
int java_lang_invoke_MethodType::ptype_count(oop mt) {
2659 2660 2661
  return ptypes(mt)->length();
}

2662 2663 2664 2665 2666 2667 2668
int java_lang_invoke_MethodType::ptype_slot_count(oop mt) {
  objArrayOop pts = ptypes(mt);
  int count = pts->length();
  int slots = 0;
  for (int i = 0; i < count; i++) {
    BasicType bt = java_lang_Class::as_BasicType(pts->obj_at(i));
    slots += type2size[bt];
2669
  }
2670
  return slots;
2671 2672
}

2673 2674 2675
int java_lang_invoke_MethodType::rtype_slot_count(oop mt) {
  BasicType bt = java_lang_Class::as_BasicType(rtype(mt));
  return type2size[bt];
2676 2677
}

2678

2679
// Support for java_lang_invoke_CallSite
2680

2681
int java_lang_invoke_CallSite::_target_offset;
2682

2683
void java_lang_invoke_CallSite::compute_offsets() {
2684
  if (!EnableInvokeDynamic)  return;
2685
  Klass* k = SystemDictionary::CallSite_klass();
2686
  if (k != NULL) {
2687
    compute_offset(_target_offset, k, vmSymbols::target_name(), vmSymbols::java_lang_invoke_MethodHandle_signature());
2688 2689 2690
  }
}

2691

D
duke 已提交
2692 2693 2694 2695 2696 2697 2698 2699 2700
// Support for java_security_AccessControlContext

int java_security_AccessControlContext::_context_offset = 0;
int java_security_AccessControlContext::_privilegedContext_offset = 0;
int java_security_AccessControlContext::_isPrivileged_offset = 0;

void java_security_AccessControlContext::compute_offsets() {
  assert(_isPrivileged_offset == 0, "offsets should be initialized only once");
  fieldDescriptor fd;
2701
  InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::AccessControlContext_klass());
D
duke 已提交
2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722

  if (!ik->find_local_field(vmSymbols::context_name(), vmSymbols::protectiondomain_signature(), &fd)) {
    fatal("Invalid layout of java.security.AccessControlContext");
  }
  _context_offset = fd.offset();

  if (!ik->find_local_field(vmSymbols::privilegedContext_name(), vmSymbols::accesscontrolcontext_signature(), &fd)) {
    fatal("Invalid layout of java.security.AccessControlContext");
  }
  _privilegedContext_offset = fd.offset();

  if (!ik->find_local_field(vmSymbols::isPrivileged_name(), vmSymbols::bool_signature(), &fd)) {
    fatal("Invalid layout of java.security.AccessControlContext");
  }
  _isPrivileged_offset = fd.offset();
}


oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) {
  assert(_isPrivileged_offset != 0, "offsets should have been initialized");
  // Ensure klass is initialized
2723
  InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0);
D
duke 已提交
2724
  // Allocate result
2725
  oop result = InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0);
D
duke 已提交
2726 2727 2728 2729 2730 2731 2732 2733 2734
  // Fill in values
  result->obj_field_put(_context_offset, context());
  result->obj_field_put(_privilegedContext_offset, privileged_context());
  result->bool_field_put(_isPrivileged_offset, isPrivileged);
  return result;
}


// Support for java_lang_ClassLoader
2735

2736
bool java_lang_ClassLoader::offsets_computed = false;
2737 2738
int  java_lang_ClassLoader::_loader_data_offset = -1;
int  java_lang_ClassLoader::_dependencies_offset = -1;
2739 2740
int  java_lang_ClassLoader::parallelCapable_offset = -1;

2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761
ClassLoaderData** java_lang_ClassLoader::loader_data_addr(oop loader) {
    assert(loader != NULL && loader->is_oop(), "loader must be oop");
    return (ClassLoaderData**) loader->address_field_addr(_loader_data_offset);
}

ClassLoaderData* java_lang_ClassLoader::loader_data(oop loader) {
  return *java_lang_ClassLoader::loader_data_addr(loader);
}

oop java_lang_ClassLoader::dependencies(oop loader) {
  return loader->obj_field(_dependencies_offset);
}

HeapWord* java_lang_ClassLoader::dependencies_addr(oop loader) {
  if (UseCompressedOops) {
    return (HeapWord*)loader->obj_field_addr<narrowOop>(_dependencies_offset);
  } else {
    return (HeapWord*)loader->obj_field_addr<oop>(_dependencies_offset);
  }
}

2762 2763 2764 2765 2766
void java_lang_ClassLoader::compute_offsets() {
  assert(!offsets_computed, "offsets should be initialized only once");
  offsets_computed = true;

  // The field indicating parallelCapable (parallelLockMap) is only present starting in 7,
2767
  Klass* k1 = SystemDictionary::ClassLoader_klass();
2768 2769
  compute_optional_offset(parallelCapable_offset,
    k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature());
2770 2771

  CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
2772
}
D
duke 已提交
2773 2774

oop java_lang_ClassLoader::parent(oop loader) {
2775
  assert(is_instance(loader), "loader must be oop");
D
duke 已提交
2776 2777 2778
  return loader->obj_field(parent_offset);
}

2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794
bool java_lang_ClassLoader::isAncestor(oop loader, oop cl) {
  assert(is_instance(loader), "loader must be oop");
  assert(cl == NULL || is_instance(cl), "cl argument must be oop");
  oop acl = loader;
  debug_only(jint loop_count = 0);
  // This loop taken verbatim from ClassLoader.java:
  do {
    acl = parent(acl);
    if (cl == acl) {
      return true;
    }
    assert(++loop_count > 0, "loop_count overflow");
  } while (acl != NULL);
  return false;
}

D
duke 已提交
2795

2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807
// For class loader classes, parallelCapable defined
// based on non-null field
// Written to by java.lang.ClassLoader, vm only reads this field, doesn't set it
bool java_lang_ClassLoader::parallelCapable(oop class_loader) {
  if (!JDK_Version::is_gte_jdk17x_version()
     || parallelCapable_offset == -1) {
     // Default for backward compatibility is false
     return false;
  }
  return (class_loader->obj_field(parallelCapable_offset) != NULL);
}

D
duke 已提交
2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825
bool java_lang_ClassLoader::is_trusted_loader(oop loader) {
  // Fix for 4474172; see evaluation for more details
  loader = non_reflection_class_loader(loader);

  oop cl = SystemDictionary::java_system_loader();
  while(cl != NULL) {
    if (cl == loader) return true;
    cl = parent(cl);
  }
  return false;
}

oop java_lang_ClassLoader::non_reflection_class_loader(oop loader) {
  if (loader != NULL) {
    // See whether this is one of the class loaders associated with
    // the generated bytecodes for reflection, and if so, "magically"
    // delegate to its parent to prevent class loading from occurring
    // in places where applications using reflection didn't expect it.
2826
    Klass* delegating_cl_class = SystemDictionary::reflect_DelegatingClassLoader_klass();
D
duke 已提交
2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837
    // This might be null in non-1.4 JDKs
    if (delegating_cl_class != NULL && loader->is_a(delegating_cl_class)) {
      return parent(loader);
    }
  }
  return loader;
}


// Support for java_lang_System
int java_lang_System::in_offset_in_bytes() {
2838
  return (instanceMirrorKlass::offset_of_static_fields() + static_in_offset);
D
duke 已提交
2839 2840 2841 2842
}


int java_lang_System::out_offset_in_bytes() {
2843
  return (instanceMirrorKlass::offset_of_static_fields() + static_out_offset);
D
duke 已提交
2844 2845 2846 2847
}


int java_lang_System::err_offset_in_bytes() {
2848
  return (instanceMirrorKlass::offset_of_static_fields() + static_err_offset);
D
duke 已提交
2849 2850 2851 2852
}



2853 2854 2855 2856 2857
int java_lang_Class::_klass_offset;
int java_lang_Class::_array_klass_offset;
int java_lang_Class::_resolved_constructor_offset;
int java_lang_Class::_oop_size_offset;
int java_lang_Class::_static_oop_field_count_offset;
2858
GrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = NULL;
D
duke 已提交
2859 2860 2861 2862
int java_lang_Throwable::backtrace_offset;
int java_lang_Throwable::detailMessage_offset;
int java_lang_Throwable::cause_offset;
int java_lang_Throwable::stackTrace_offset;
2863
int java_lang_Throwable::static_unassigned_stacktrace_offset;
D
duke 已提交
2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891
int java_lang_reflect_AccessibleObject::override_offset;
int java_lang_reflect_Method::clazz_offset;
int java_lang_reflect_Method::name_offset;
int java_lang_reflect_Method::returnType_offset;
int java_lang_reflect_Method::parameterTypes_offset;
int java_lang_reflect_Method::exceptionTypes_offset;
int java_lang_reflect_Method::slot_offset;
int java_lang_reflect_Method::modifiers_offset;
int java_lang_reflect_Method::signature_offset;
int java_lang_reflect_Method::annotations_offset;
int java_lang_reflect_Method::parameter_annotations_offset;
int java_lang_reflect_Method::annotation_default_offset;
int java_lang_reflect_Constructor::clazz_offset;
int java_lang_reflect_Constructor::parameterTypes_offset;
int java_lang_reflect_Constructor::exceptionTypes_offset;
int java_lang_reflect_Constructor::slot_offset;
int java_lang_reflect_Constructor::modifiers_offset;
int java_lang_reflect_Constructor::signature_offset;
int java_lang_reflect_Constructor::annotations_offset;
int java_lang_reflect_Constructor::parameter_annotations_offset;
int java_lang_reflect_Field::clazz_offset;
int java_lang_reflect_Field::name_offset;
int java_lang_reflect_Field::type_offset;
int java_lang_reflect_Field::slot_offset;
int java_lang_reflect_Field::modifiers_offset;
int java_lang_reflect_Field::signature_offset;
int java_lang_reflect_Field::annotations_offset;
int java_lang_boxing_object::value_offset;
2892
int java_lang_boxing_object::long_value_offset;
D
duke 已提交
2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916
int java_lang_ref_Reference::referent_offset;
int java_lang_ref_Reference::queue_offset;
int java_lang_ref_Reference::next_offset;
int java_lang_ref_Reference::discovered_offset;
int java_lang_ref_Reference::static_lock_offset;
int java_lang_ref_Reference::static_pending_offset;
int java_lang_ref_Reference::number_of_fake_oop_fields;
int java_lang_ref_SoftReference::timestamp_offset;
int java_lang_ref_SoftReference::static_clock_offset;
int java_lang_ClassLoader::parent_offset;
int java_lang_System::static_in_offset;
int java_lang_System::static_out_offset;
int java_lang_System::static_err_offset;
int java_lang_StackTraceElement::declaringClass_offset;
int java_lang_StackTraceElement::methodName_offset;
int java_lang_StackTraceElement::fileName_offset;
int java_lang_StackTraceElement::lineNumber_offset;
int java_lang_AssertionStatusDirectives::classes_offset;
int java_lang_AssertionStatusDirectives::classEnabled_offset;
int java_lang_AssertionStatusDirectives::packages_offset;
int java_lang_AssertionStatusDirectives::packageEnabled_offset;
int java_lang_AssertionStatusDirectives::deflt_offset;
int java_nio_Buffer::_limit_offset;
int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset = 0;
2917
int sun_reflect_ConstantPool::_oop_offset;
D
duke 已提交
2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969
int sun_reflect_UnsafeStaticFieldAccessorImpl::_base_offset;


// Support for java_lang_StackTraceElement

void java_lang_StackTraceElement::set_fileName(oop element, oop value) {
  element->obj_field_put(fileName_offset, value);
}

void java_lang_StackTraceElement::set_declaringClass(oop element, oop value) {
  element->obj_field_put(declaringClass_offset, value);
}

void java_lang_StackTraceElement::set_methodName(oop element, oop value) {
  element->obj_field_put(methodName_offset, value);
}

void java_lang_StackTraceElement::set_lineNumber(oop element, int value) {
  element->int_field_put(lineNumber_offset, value);
}


// Support for java Assertions - java_lang_AssertionStatusDirectives.

void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) {
  o->obj_field_put(classes_offset, val);
}

void java_lang_AssertionStatusDirectives::set_classEnabled(oop o, oop val) {
  o->obj_field_put(classEnabled_offset, val);
}

void java_lang_AssertionStatusDirectives::set_packages(oop o, oop val) {
  o->obj_field_put(packages_offset, val);
}

void java_lang_AssertionStatusDirectives::set_packageEnabled(oop o, oop val) {
  o->obj_field_put(packageEnabled_offset, val);
}

void java_lang_AssertionStatusDirectives::set_deflt(oop o, bool val) {
  o->bool_field_put(deflt_offset, val);
}


// Support for intrinsification of java.nio.Buffer.checkIndex
int java_nio_Buffer::limit_offset() {
  return _limit_offset;
}


void java_nio_Buffer::compute_offsets() {
2970
  Klass* k = SystemDictionary::nio_Buffer_klass();
2971 2972
  assert(k != NULL, "must be loaded in 1.4+");
  compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature());
D
duke 已提交
2973 2974 2975 2976 2977 2978 2979
}

void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) {
  if (_owner_offset != 0) return;

  assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later");
  SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK);
2980
  Klass* k = SystemDictionary::abstract_ownable_synchronizer_klass();
2981
  compute_offset(_owner_offset, k,
D
duke 已提交
2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993
                 vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature());
}

oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
  assert(_owner_offset != 0, "Must be initialized");
  return obj->obj_field(_owner_offset);
}

// Compute hard-coded offsets
// Invoked before SystemDictionary::initialize, so pre-loaded classes
// are not available to determine the offset_of_static_fields.
void JavaClasses::compute_hard_coded_offsets() {
2994
  const int x = heapOopSize;
2995
  const int header = instanceOopDesc::base_offset_in_bytes();
D
duke 已提交
2996 2997 2998 2999 3000 3001

  // Throwable Class
  java_lang_Throwable::backtrace_offset  = java_lang_Throwable::hc_backtrace_offset  * x + header;
  java_lang_Throwable::detailMessage_offset = java_lang_Throwable::hc_detailMessage_offset * x + header;
  java_lang_Throwable::cause_offset      = java_lang_Throwable::hc_cause_offset      * x + header;
  java_lang_Throwable::stackTrace_offset = java_lang_Throwable::hc_stackTrace_offset * x + header;
3002
  java_lang_Throwable::static_unassigned_stacktrace_offset = java_lang_Throwable::hc_static_unassigned_stacktrace_offset *  x;
D
duke 已提交
3003 3004

  // java_lang_boxing_object
3005 3006
  java_lang_boxing_object::value_offset = java_lang_boxing_object::hc_value_offset + header;
  java_lang_boxing_object::long_value_offset = align_size_up((java_lang_boxing_object::hc_value_offset + header), BytesPerLong);
D
duke 已提交
3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019

  // java_lang_ref_Reference:
  java_lang_ref_Reference::referent_offset = java_lang_ref_Reference::hc_referent_offset * x + header;
  java_lang_ref_Reference::queue_offset = java_lang_ref_Reference::hc_queue_offset * x + header;
  java_lang_ref_Reference::next_offset  = java_lang_ref_Reference::hc_next_offset * x + header;
  java_lang_ref_Reference::discovered_offset  = java_lang_ref_Reference::hc_discovered_offset * x + header;
  java_lang_ref_Reference::static_lock_offset = java_lang_ref_Reference::hc_static_lock_offset *  x;
  java_lang_ref_Reference::static_pending_offset = java_lang_ref_Reference::hc_static_pending_offset * x;
  // Artificial fields for java_lang_ref_Reference
  // The first field is for the discovered field added in 1.4
  java_lang_ref_Reference::number_of_fake_oop_fields = 1;

  // java_lang_ref_SoftReference Class
3020
  java_lang_ref_SoftReference::timestamp_offset = align_size_up((java_lang_ref_SoftReference::hc_timestamp_offset * x + header), BytesPerLong);
D
duke 已提交
3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047
  // Don't multiply static fields because they are always in wordSize units
  java_lang_ref_SoftReference::static_clock_offset = java_lang_ref_SoftReference::hc_static_clock_offset * x;

  // java_lang_ClassLoader
  java_lang_ClassLoader::parent_offset = java_lang_ClassLoader::hc_parent_offset * x + header;

  // java_lang_System
  java_lang_System::static_in_offset  = java_lang_System::hc_static_in_offset  * x;
  java_lang_System::static_out_offset = java_lang_System::hc_static_out_offset * x;
  java_lang_System::static_err_offset = java_lang_System::hc_static_err_offset * x;

  // java_lang_StackTraceElement
  java_lang_StackTraceElement::declaringClass_offset = java_lang_StackTraceElement::hc_declaringClass_offset  * x + header;
  java_lang_StackTraceElement::methodName_offset = java_lang_StackTraceElement::hc_methodName_offset * x + header;
  java_lang_StackTraceElement::fileName_offset   = java_lang_StackTraceElement::hc_fileName_offset   * x + header;
  java_lang_StackTraceElement::lineNumber_offset = java_lang_StackTraceElement::hc_lineNumber_offset * x + header;
  java_lang_AssertionStatusDirectives::classes_offset = java_lang_AssertionStatusDirectives::hc_classes_offset * x + header;
  java_lang_AssertionStatusDirectives::classEnabled_offset = java_lang_AssertionStatusDirectives::hc_classEnabled_offset * x + header;
  java_lang_AssertionStatusDirectives::packages_offset = java_lang_AssertionStatusDirectives::hc_packages_offset * x + header;
  java_lang_AssertionStatusDirectives::packageEnabled_offset = java_lang_AssertionStatusDirectives::hc_packageEnabled_offset * x + header;
  java_lang_AssertionStatusDirectives::deflt_offset = java_lang_AssertionStatusDirectives::hc_deflt_offset * x + header;

}


// Compute non-hard-coded field offsets of all the classes in this file
void JavaClasses::compute_offsets() {
3048 3049
  // java_lang_Class::compute_offsets was called earlier in bootstrap
  java_lang_ClassLoader::compute_offsets();
D
duke 已提交
3050 3051
  java_lang_Thread::compute_offsets();
  java_lang_ThreadGroup::compute_offsets();
3052
  if (EnableInvokeDynamic) {
3053 3054
    java_lang_invoke_MethodHandle::compute_offsets();
    java_lang_invoke_MemberName::compute_offsets();
3055
    java_lang_invoke_LambdaForm::compute_offsets();
3056 3057
    java_lang_invoke_MethodType::compute_offsets();
    java_lang_invoke_CallSite::compute_offsets();
3058
  }
D
duke 已提交
3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074
  java_security_AccessControlContext::compute_offsets();
  // Initialize reflection classes. The layouts of these classes
  // changed with the new reflection implementation in JDK 1.4, and
  // since the Universe doesn't know what JDK version it is until this
  // point we defer computation of these offsets until now.
  java_lang_reflect_AccessibleObject::compute_offsets();
  java_lang_reflect_Method::compute_offsets();
  java_lang_reflect_Constructor::compute_offsets();
  java_lang_reflect_Field::compute_offsets();
  if (JDK_Version::is_gte_jdk14x_version()) {
    java_nio_Buffer::compute_offsets();
  }
  if (JDK_Version::is_gte_jdk15x_version()) {
    sun_reflect_ConstantPool::compute_offsets();
    sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets();
  }
3075 3076 3077

  // generated interpreter code wants to know about the offsets we just computed:
  AbstractAssembler::update_delayed_values();
D
duke 已提交
3078 3079 3080 3081 3082 3083 3084 3085 3086 3087
}

#ifndef PRODUCT

// These functions exist to assert the validity of hard-coded field offsets to guard
// against changes in the class files

bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
  EXCEPTION_MARK;
  fieldDescriptor fd;
3088
  TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
3089
  Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
D
duke 已提交
3090
  instanceKlassHandle h_klass (THREAD, k);
3091 3092 3093
  TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
  TempNewSymbol f_sig  = SymbolTable::new_symbol(field_sig, CATCH);
  if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
D
duke 已提交
3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113
    tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
    return false;
  }
  if (fd.is_static()) {
    tty->print_cr("Nonstatic field %s.%s appears to be static", klass_name, field_name);
    return false;
  }
  if (fd.offset() == hardcoded_offset ) {
    return true;
  } else {
    tty->print_cr("Offset of nonstatic field %s.%s is hardcoded as %d but should really be %d.",
                  klass_name, field_name, hardcoded_offset, fd.offset());
    return false;
  }
}


bool JavaClasses::check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
  EXCEPTION_MARK;
  fieldDescriptor fd;
3114
  TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
3115
  Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
D
duke 已提交
3116
  instanceKlassHandle h_klass (THREAD, k);
3117 3118 3119
  TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
  TempNewSymbol f_sig  = SymbolTable::new_symbol(field_sig, CATCH);
  if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
D
duke 已提交
3120 3121 3122 3123 3124 3125 3126
    tty->print_cr("Static field %s.%s not found", klass_name, field_name);
    return false;
  }
  if (!fd.is_static()) {
    tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name);
    return false;
  }
3127
  if (fd.offset() == hardcoded_offset + instanceMirrorKlass::offset_of_static_fields()) {
D
duke 已提交
3128 3129
    return true;
  } else {
3130
    tty->print_cr("Offset of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_offset, fd.offset() - instanceMirrorKlass::offset_of_static_fields());
D
duke 已提交
3131 3132 3133 3134 3135
    return false;
  }
}


3136 3137 3138
bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) {
  EXCEPTION_MARK;
  fieldDescriptor fd;
3139
  TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH);
3140
  Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH);
3141
  instanceKlassHandle h_klass (THREAD, k);
3142 3143 3144
  TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH);
  TempNewSymbol f_sig  = SymbolTable::new_symbol(field_sig, CATCH);
  if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165
    tty->print_cr("Static field %s.%s not found", klass_name, field_name);
    return false;
  }
  if (!fd.is_static() || !fd.has_initial_value()) {
    tty->print_cr("Static field %s.%s appears to be non-constant", klass_name, field_name);
    return false;
  }
  if (!fd.initial_value_tag().is_int()) {
    tty->print_cr("Static field %s.%s is not an int", klass_name, field_name);
    return false;
  }
  jint field_value = fd.int_initial_value();
  if (field_value == hardcoded_constant) {
    return true;
  } else {
    tty->print_cr("Constant value of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_constant, field_value);
    return false;
  }
}


D
duke 已提交
3166 3167 3168 3169
// Check the hard-coded field offsets of all the classes in this file

void JavaClasses::check_offsets() {
  bool valid = true;
3170
  HandleMark hm;
D
duke 已提交
3171 3172 3173 3174

#define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
  valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig)

3175 3176 3177
#define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
  valid &= check_offset(klass_name, cpp_klass_name :: long_ ## field_name ## _offset, #field_name, field_sig)

D
duke 已提交
3178 3179 3180
#define CHECK_STATIC_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
  valid &= check_static_offset(klass_name, cpp_klass_name :: static_ ## field_name ## _offset, #field_name, field_sig)

3181 3182 3183
#define CHECK_CONSTANT(klass_name, cpp_klass_name, field_name, field_sig) \
  valid &= check_constant(klass_name, cpp_klass_name :: field_name, #field_name, field_sig)

D
duke 已提交
3184 3185 3186
  // java.lang.String

  CHECK_OFFSET("java/lang/String", java_lang_String, value, "[C");
K
kvn 已提交
3187 3188 3189 3190 3191 3192 3193
  if (java_lang_String::has_offset_field()) {
    CHECK_OFFSET("java/lang/String", java_lang_String, offset, "I");
    CHECK_OFFSET("java/lang/String", java_lang_String, count, "I");
  }
  if (java_lang_String::has_hash_field()) {
    CHECK_OFFSET("java/lang/String", java_lang_String, hash, "I");
  }
D
duke 已提交
3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213

  // java.lang.Class

  // Fake fields
  // CHECK_OFFSET("java/lang/Class", java_lang_Class, klass); // %%% this needs to be checked
  // CHECK_OFFSET("java/lang/Class", java_lang_Class, array_klass); // %%% this needs to be checked
  // CHECK_OFFSET("java/lang/Class", java_lang_Class, resolved_constructor); // %%% this needs to be checked

  // java.lang.Throwable

  CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, backtrace, "Ljava/lang/Object;");
  CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, detailMessage, "Ljava/lang/String;");
  CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, cause, "Ljava/lang/Throwable;");
  CHECK_OFFSET("java/lang/Throwable", java_lang_Throwable, stackTrace, "[Ljava/lang/StackTraceElement;");

  // Boxed primitive objects (java_lang_boxing_object)

  CHECK_OFFSET("java/lang/Boolean",   java_lang_boxing_object, value, "Z");
  CHECK_OFFSET("java/lang/Character", java_lang_boxing_object, value, "C");
  CHECK_OFFSET("java/lang/Float",     java_lang_boxing_object, value, "F");
3214
  CHECK_LONG_OFFSET("java/lang/Double", java_lang_boxing_object, value, "D");
D
duke 已提交
3215 3216 3217
  CHECK_OFFSET("java/lang/Byte",      java_lang_boxing_object, value, "B");
  CHECK_OFFSET("java/lang/Short",     java_lang_boxing_object, value, "S");
  CHECK_OFFSET("java/lang/Integer",   java_lang_boxing_object, value, "I");
3218
  CHECK_LONG_OFFSET("java/lang/Long", java_lang_boxing_object, value, "J");
D
duke 已提交
3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273

  // java.lang.ClassLoader

  CHECK_OFFSET("java/lang/ClassLoader", java_lang_ClassLoader, parent,      "Ljava/lang/ClassLoader;");

  // java.lang.System

  CHECK_STATIC_OFFSET("java/lang/System", java_lang_System,  in, "Ljava/io/InputStream;");
  CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, out, "Ljava/io/PrintStream;");
  CHECK_STATIC_OFFSET("java/lang/System", java_lang_System, err, "Ljava/io/PrintStream;");

  // java.lang.StackTraceElement

  CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, declaringClass, "Ljava/lang/String;");
  CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, methodName, "Ljava/lang/String;");
  CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement,   fileName, "Ljava/lang/String;");
  CHECK_OFFSET("java/lang/StackTraceElement", java_lang_StackTraceElement, lineNumber, "I");

  // java.lang.ref.Reference

  CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, referent, "Ljava/lang/Object;");
  CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, queue, "Ljava/lang/ref/ReferenceQueue;");
  CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, next, "Ljava/lang/ref/Reference;");
  // Fake field
  //CHECK_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, discovered, "Ljava/lang/ref/Reference;");
  CHECK_STATIC_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, lock, "Ljava/lang/ref/Reference$Lock;");
  CHECK_STATIC_OFFSET("java/lang/ref/Reference", java_lang_ref_Reference, pending, "Ljava/lang/ref/Reference;");

  // java.lang.ref.SoftReference

  CHECK_OFFSET("java/lang/ref/SoftReference", java_lang_ref_SoftReference, timestamp, "J");
  CHECK_STATIC_OFFSET("java/lang/ref/SoftReference", java_lang_ref_SoftReference, clock, "J");

  // java.lang.AssertionStatusDirectives
  //
  // The CheckAssertionStatusDirectives boolean can be removed from here and
  // globals.hpp after the AssertionStatusDirectives class has been integrated
  // into merlin "for some time."  Without it, the vm will fail with early
  // merlin builds.

  if (CheckAssertionStatusDirectives && JDK_Version::is_gte_jdk14x_version()) {
    const char* nm = "java/lang/AssertionStatusDirectives";
    const char* sig = "[Ljava/lang/String;";
    CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classes, sig);
    CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, classEnabled, "[Z");
    CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packages, sig);
    CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, packageEnabled, "[Z");
    CHECK_OFFSET(nm, java_lang_AssertionStatusDirectives, deflt, "Z");
  }

  if (!valid) vm_exit_during_initialization("Hard-coded field offset verification failed");
}

#endif // PRODUCT

3274
int InjectedField::compute_offset() {
3275 3276
  Klass* klass_oop = klass();
  for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) {
3277 3278 3279 3280 3281 3282 3283 3284 3285
    if (!may_be_java && !fs.access_flags().is_internal()) {
      // Only look at injected fields
      continue;
    }
    if (fs.name() == name() && fs.signature() == signature()) {
      return fs.offset();
    }
  }
  ResourceMark rm;
3286
  tty->print_cr("Invalid layout of %s at %s/%s%s", InstanceKlass::cast(klass_oop)->external_name(), name()->as_C_string(), signature()->as_C_string(), may_be_java ? " (may_be_java)" : "");
3287 3288 3289
#ifndef PRODUCT
  klass_oop->print();
  tty->print_cr("all fields:");
3290
  for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) {
3291 3292 3293
    tty->print_cr("  name: %s, sig: %s, flags: %08x", fs.name()->as_C_string(), fs.signature()->as_C_string(), fs.access_flags().as_int());
  }
#endif //PRODUCT
3294 3295 3296 3297
  fatal("Invalid layout of preloaded class");
  return -1;
}

D
duke 已提交
3298 3299 3300 3301 3302
void javaClasses_init() {
  JavaClasses::compute_offsets();
  JavaClasses::check_offsets();
  FilteredFieldsMap::initialize();  // must be done after computing offsets.
}