2577 // Fill in class name
2578 Handle java_class(THREAD, holder->java_mirror());
2579 oop classname = java_lang_Class::name(java_class, CHECK);
2580 java_lang_StackTraceElement::set_declaringClass(element(), classname);
2581 java_lang_StackTraceElement::set_declaringClassObject(element(), java_class());
2582
2583 oop loader = holder->class_loader();
2584 if (loader != NULL) {
2585 oop loader_name = java_lang_ClassLoader::name(loader);
2586 if (loader_name != NULL)
2587 java_lang_StackTraceElement::set_classLoaderName(element(), loader_name);
2588 }
2589
2590 // Fill in method name
2591 oop methodname = StringTable::intern(name, CHECK);
2592 java_lang_StackTraceElement::set_methodName(element(), methodname);
2593
2594 // Fill in module name and version
2595 ModuleEntry* module = holder->module();
2596 if (module->is_named()) {
2597 oop module_name = StringTable::intern(module->name(), CHECK);
2598 java_lang_StackTraceElement::set_moduleName(element(), module_name);
2599 oop module_version;
2600 if (module->version() != NULL) {
2601 module_version = StringTable::intern(module->version(), CHECK);
2602 } else {
2603 module_version = NULL;
2604 }
2605 java_lang_StackTraceElement::set_moduleVersion(element(), module_version);
2606 }
2607
2608 if (method() == NULL || !version_matches(method(), version)) {
2609 // The method was redefined, accurate line number information isn't available
2610 java_lang_StackTraceElement::set_fileName(element(), NULL);
2611 java_lang_StackTraceElement::set_lineNumber(element(), -1);
2612 } else {
2613 // Fill in source file name and line number.
2614 Symbol* source = Backtrace::get_source_file_name(holder, version);
2615 oop source_file = java_lang_Class::source_file(java_class());
2616 if (source != NULL) {
2617 // Class was not redefined. We can trust its cache if set,
2618 // else we have to initialize it.
2619 if (source_file == NULL) {
2620 source_file = StringTable::intern(source, CHECK);
2621 java_lang_Class::set_source_file(java_class(), source_file);
3086 }
3087
3088 void java_lang_reflect_Parameter::set_index(oop param, int value) {
3089 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3090 param->int_field_put(index_offset, value);
3091 }
3092
3093 oop java_lang_reflect_Parameter::executable(oop param) {
3094 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3095 return param->obj_field(executable_offset);
3096 }
3097
3098 void java_lang_reflect_Parameter::set_executable(oop param, oop value) {
3099 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3100 param->obj_field_put(executable_offset, value);
3101 }
3102
3103
3104 int java_lang_Module::loader_offset;
3105 int java_lang_Module::name_offset;
3106 int java_lang_Module::_module_entry_offset = -1;
3107
3108 Handle java_lang_Module::create(Handle loader, Handle module_name, TRAPS) {
3109 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3110 return JavaCalls::construct_new_instance(SystemDictionary::Module_klass(),
3111 vmSymbols::java_lang_module_init_signature(),
3112 loader, module_name, CHECK_NH);
3113 }
3114
3115 #define MODULE_FIELDS_DO(macro) \
3116 macro(loader_offset, k, vmSymbols::loader_name(), classloader_signature, false); \
3117 macro(name_offset, k, vmSymbols::name_name(), string_signature, false)
3118
3119 void java_lang_Module::compute_offsets() {
3120 InstanceKlass* k = SystemDictionary::Module_klass();
3121 MODULE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3122 MODULE_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3123 }
3124
3125 #if INCLUDE_CDS
3126 void java_lang_Module::serialize_offsets(SerializeClosure* f) {
3127 MODULE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3128 MODULE_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
3129 }
3130 #endif
3131
3132 oop java_lang_Module::loader(oop module) {
3133 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3134 return module->obj_field(loader_offset);
3135 }
3136
3137 void java_lang_Module::set_loader(oop module, oop value) {
3138 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3139 module->obj_field_put(loader_offset, value);
3140 }
3141
3142 oop java_lang_Module::name(oop module) {
3143 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3144 return module->obj_field(name_offset);
3145 }
3146
3147 void java_lang_Module::set_name(oop module, oop value) {
3148 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3149 module->obj_field_put(name_offset, value);
3150 }
3151
3152 ModuleEntry* java_lang_Module::module_entry(oop module) {
3153 assert(_module_entry_offset != -1, "Uninitialized module_entry_offset");
3154 assert(module != NULL, "module can't be null");
3155 assert(oopDesc::is_oop(module), "module must be oop");
3156
3157 ModuleEntry* module_entry = (ModuleEntry*)module->address_field(_module_entry_offset);
3158 if (module_entry == NULL) {
3159 // If the inject field containing the ModuleEntry* is null then return the
3160 // class loader's unnamed module.
3161 oop loader = java_lang_Module::loader(module);
3162 Handle h_loader = Handle(Thread::current(), loader);
3163 ClassLoaderData* loader_cld = SystemDictionary::register_loader(h_loader);
3164 return loader_cld->unnamed_module();
3165 }
3166 return module_entry;
3167 }
3168
3169 void java_lang_Module::set_module_entry(oop module, ModuleEntry* module_entry) {
3170 assert(_module_entry_offset != -1, "Uninitialized module_entry_offset");
3171 assert(module != NULL, "module can't be null");
3172 assert(oopDesc::is_oop(module), "module must be oop");
3173 module->address_field_put(_module_entry_offset, (address)module_entry);
3174 }
3175
3176 Handle reflect_ConstantPool::create(TRAPS) {
3177 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3178 InstanceKlass* k = SystemDictionary::reflect_ConstantPool_klass();
3179 // Ensure it is initialized
3180 k->initialize(CHECK_NH);
3181 return k->allocate_instance_handle(THREAD);
3182 }
3183
3184
3185 void reflect_ConstantPool::set_cp(oop reflect, ConstantPool* value) {
3186 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3187 oop mirror = value->pool_holder()->java_mirror();
3188 // Save the mirror to get back the constant pool.
3189 reflect->obj_field_put(_oop_offset, mirror);
3190 }
3191
3192 ConstantPool* reflect_ConstantPool::get_cp(oop reflect) {
3193 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
|
2577 // Fill in class name
2578 Handle java_class(THREAD, holder->java_mirror());
2579 oop classname = java_lang_Class::name(java_class, CHECK);
2580 java_lang_StackTraceElement::set_declaringClass(element(), classname);
2581 java_lang_StackTraceElement::set_declaringClassObject(element(), java_class());
2582
2583 oop loader = holder->class_loader();
2584 if (loader != NULL) {
2585 oop loader_name = java_lang_ClassLoader::name(loader);
2586 if (loader_name != NULL)
2587 java_lang_StackTraceElement::set_classLoaderName(element(), loader_name);
2588 }
2589
2590 // Fill in method name
2591 oop methodname = StringTable::intern(name, CHECK);
2592 java_lang_StackTraceElement::set_methodName(element(), methodname);
2593
2594 // Fill in module name and version
2595 ModuleEntry* module = holder->module();
2596 if (module->is_named()) {
2597 oop module_name = java_lang_Module::name(module->module());
2598 assert(module_name != NULL, "module name is set");
2599 java_lang_StackTraceElement::set_moduleName(element(), module_name);
2600 oop module_version;
2601 if (module->version() != NULL) {
2602 oop md = java_lang_Module::module_descriptor(module->module());
2603 assert(md != NULL, "module descriptor is set");
2604 oop mdv = java_lang_module_ModuleDescriptor::version(md);
2605 if (mdv != NULL) {
2606 module_version = java_lang_module_ModuleDescriptor_Version::version(mdv);
2607 } else {
2608 module_version = java_lang_module_ModuleDescriptor::raw_version(md);
2609 }
2610 assert(module_version != NULL, "module version string is set");
2611 } else {
2612 module_version = NULL;
2613 }
2614 java_lang_StackTraceElement::set_moduleVersion(element(), module_version);
2615 }
2616
2617 if (method() == NULL || !version_matches(method(), version)) {
2618 // The method was redefined, accurate line number information isn't available
2619 java_lang_StackTraceElement::set_fileName(element(), NULL);
2620 java_lang_StackTraceElement::set_lineNumber(element(), -1);
2621 } else {
2622 // Fill in source file name and line number.
2623 Symbol* source = Backtrace::get_source_file_name(holder, version);
2624 oop source_file = java_lang_Class::source_file(java_class());
2625 if (source != NULL) {
2626 // Class was not redefined. We can trust its cache if set,
2627 // else we have to initialize it.
2628 if (source_file == NULL) {
2629 source_file = StringTable::intern(source, CHECK);
2630 java_lang_Class::set_source_file(java_class(), source_file);
3095 }
3096
3097 void java_lang_reflect_Parameter::set_index(oop param, int value) {
3098 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3099 param->int_field_put(index_offset, value);
3100 }
3101
3102 oop java_lang_reflect_Parameter::executable(oop param) {
3103 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3104 return param->obj_field(executable_offset);
3105 }
3106
3107 void java_lang_reflect_Parameter::set_executable(oop param, oop value) {
3108 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3109 param->obj_field_put(executable_offset, value);
3110 }
3111
3112
3113 int java_lang_Module::loader_offset;
3114 int java_lang_Module::name_offset;
3115 int java_lang_Module::module_descriptor_offset;
3116 int java_lang_Module::_module_entry_offset = -1;
3117
3118 Handle java_lang_Module::create(Handle loader, Handle module_name, TRAPS) {
3119 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3120 return JavaCalls::construct_new_instance(SystemDictionary::Module_klass(),
3121 vmSymbols::java_lang_module_init_signature(),
3122 loader, module_name, CHECK_NH);
3123 }
3124
3125 #define MODULE_FIELDS_DO(macro) \
3126 macro(loader_offset, k, vmSymbols::loader_name(), classloader_signature, false); \
3127 macro(name_offset, k, vmSymbols::name_name(), string_signature, false); \
3128 macro(module_descriptor_offset, k, vmSymbols::descriptor_name(), module_descriptor_signature, false); \
3129
3130 void java_lang_Module::compute_offsets() {
3131 InstanceKlass* k = SystemDictionary::Module_klass();
3132 MODULE_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3133 MODULE_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3134 }
3135
3136 #if INCLUDE_CDS
3137 void java_lang_Module::serialize_offsets(SerializeClosure* f) {
3138 MODULE_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3139 MODULE_INJECTED_FIELDS(INJECTED_FIELD_SERIALIZE_OFFSET);
3140 }
3141 #endif
3142
3143 oop java_lang_Module::loader(oop module) {
3144 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3145 return module->obj_field(loader_offset);
3146 }
3147
3148 void java_lang_Module::set_loader(oop module, oop value) {
3149 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3150 module->obj_field_put(loader_offset, value);
3151 }
3152
3153 oop java_lang_Module::name(oop module) {
3154 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3155 return module->obj_field(name_offset);
3156 }
3157
3158 void java_lang_Module::set_name(oop module, oop value) {
3159 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3160 module->obj_field_put(name_offset, value);
3161 }
3162
3163 oop java_lang_Module::module_descriptor(oop module) {
3164 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3165 assert(java_lang_Module::is_instance(module), "sanity");
3166 return module->obj_field(module_descriptor_offset);
3167 }
3168
3169 ModuleEntry* java_lang_Module::module_entry(oop module) {
3170 assert(_module_entry_offset != -1, "Uninitialized module_entry_offset");
3171 assert(module != NULL, "module can't be null");
3172 assert(oopDesc::is_oop(module), "module must be oop");
3173
3174 ModuleEntry* module_entry = (ModuleEntry*)module->address_field(_module_entry_offset);
3175 if (module_entry == NULL) {
3176 // If the inject field containing the ModuleEntry* is null then return the
3177 // class loader's unnamed module.
3178 oop loader = java_lang_Module::loader(module);
3179 Handle h_loader = Handle(Thread::current(), loader);
3180 ClassLoaderData* loader_cld = SystemDictionary::register_loader(h_loader);
3181 return loader_cld->unnamed_module();
3182 }
3183 return module_entry;
3184 }
3185
3186 void java_lang_Module::set_module_entry(oop module, ModuleEntry* module_entry) {
3187 assert(_module_entry_offset != -1, "Uninitialized module_entry_offset");
3188 assert(module != NULL, "module can't be null");
3189 assert(oopDesc::is_oop(module), "module must be oop");
3190 module->address_field_put(_module_entry_offset, (address)module_entry);
3191 }
3192
3193 int java_lang_module_ModuleDescriptor::version_offset;
3194 int java_lang_module_ModuleDescriptor::raw_version_offset;
3195
3196 #define MODULE_DESCRIPTOR_FIELDS_DO(macro) \
3197 macro(version_offset, k, vmSymbols::version_name(), module_descriptor_version_signature, false); \
3198 macro(raw_version_offset, k, vmSymbols::raw_version_string_name(), string_signature, false); \
3199
3200 void java_lang_module_ModuleDescriptor::compute_offsets() {
3201 InstanceKlass* k = SystemDictionary::ModuleDescriptor_klass();
3202 MODULE_DESCRIPTOR_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3203 }
3204
3205 #if INCLUDE_CDS
3206 void java_lang_module_ModuleDescriptor::serialize_offsets(SerializeClosure* f) {
3207 MODULE_DESCRIPTOR_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3208 }
3209 #endif
3210
3211 inline bool java_lang_module_ModuleDescriptor::is_instance(oop obj) {
3212 return obj != NULL && obj->klass() == SystemDictionary::ModuleDescriptor_klass();
3213 }
3214
3215 oop java_lang_module_ModuleDescriptor::version(oop module_descriptor) {
3216 assert(java_lang_module_ModuleDescriptor::is_instance(module_descriptor), "sanity");
3217 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3218 return module_descriptor->obj_field(version_offset);
3219 }
3220
3221 oop java_lang_module_ModuleDescriptor::raw_version(oop module_descriptor) {
3222 assert(java_lang_module_ModuleDescriptor::is_instance(module_descriptor), "sanity");
3223 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3224 return module_descriptor->obj_field(raw_version_offset);
3225 }
3226
3227 int java_lang_module_ModuleDescriptor_Version::version_offset;
3228
3229 #define MODULE_DESCRIPTOR_VERSION_FIELDS_DO(macro) \
3230 macro(version_offset, k, vmSymbols::version_name(), string_signature, false); \
3231
3232 void java_lang_module_ModuleDescriptor_Version::compute_offsets() {
3233 InstanceKlass* k = SystemDictionary::ModuleDescriptor_Version_klass();
3234 MODULE_DESCRIPTOR_VERSION_FIELDS_DO(FIELD_COMPUTE_OFFSET);
3235 }
3236
3237 #if INCLUDE_CDS
3238 void java_lang_module_ModuleDescriptor_Version::serialize_offsets(SerializeClosure* f) {
3239 MODULE_DESCRIPTOR_VERSION_FIELDS_DO(FIELD_SERIALIZE_OFFSET);
3240 }
3241 #endif
3242
3243 inline bool java_lang_module_ModuleDescriptor_Version::is_instance(oop obj) {
3244 return obj != NULL && obj->klass() == SystemDictionary::ModuleDescriptor_Version_klass();
3245 }
3246
3247 oop java_lang_module_ModuleDescriptor_Version::version(oop module_descriptor_version) {
3248 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3249 assert(java_lang_module_ModuleDescriptor_Version::is_instance(module_descriptor_version), "sanity");
3250 return module_descriptor_version->obj_field(version_offset);
3251 }
3252
3253 Handle reflect_ConstantPool::create(TRAPS) {
3254 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3255 InstanceKlass* k = SystemDictionary::reflect_ConstantPool_klass();
3256 // Ensure it is initialized
3257 k->initialize(CHECK_NH);
3258 return k->allocate_instance_handle(THREAD);
3259 }
3260
3261
3262 void reflect_ConstantPool::set_cp(oop reflect, ConstantPool* value) {
3263 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
3264 oop mirror = value->pool_holder()->java_mirror();
3265 // Save the mirror to get back the constant pool.
3266 reflect->obj_field_put(_oop_offset, mirror);
3267 }
3268
3269 ConstantPool* reflect_ConstantPool::get_cp(oop reflect) {
3270 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
|