3277 InstanceKlass* k2, TRAPS) {
3278 if (signature->utf8_length() == 1) return; // Primitive signature
3279 if (!(k1->has_value_types_attribute() || k2->has_value_types_attribute())) return;
3280 ResourceMark rm(THREAD);
3281 for (SignatureStream sstream(signature); !sstream.is_done(); sstream.next()) {
3282 if (sstream.is_object()) {
3283 Symbol* sym = sstream.as_symbol(THREAD);
3284 Symbol* name = sym;
3285 if (sstream.is_array()) {
3286 int i=0;
3287 while (sym->byte_at(i) == '[') i++;
3288 if (i == sym->utf8_length() - 1 ) continue; // primitive array
3289 assert(sym->byte_at(i) == 'L', "Must be a L-type");
3290 name = SymbolTable::lookup(sym->as_C_string() + i + 1,
3291 sym->utf8_length() - 2 - i, CHECK);
3292 }
3293 bool opinion1 = k1->is_declared_value_type(name);
3294 bool opinion2 = k2->is_declared_value_type(name);
3295 if (sym != name) name->decrement_refcount();
3296 if (opinion1 != opinion2) {
3297 THROW(vmSymbols::java_lang_IncompatibleClassChangeError());
3298 }
3299 }
3300 }
3301 }
3302
3303 void InstanceKlass::check_symbol_for_value_types_consistency(Symbol* sym,
3304 InstanceKlass* k1,
3305 InstanceKlass* k2, TRAPS) {
3306 if (sym->utf8_length() == 1) return; // Primitive signature
3307 if (!(k1->has_value_types_attribute() || k2->has_value_types_attribute())) return;
3308 assert(sym->byte_at(0) == 'L' || sym->byte_at(0) == '[', "Sanity check");
3309 ResourceMark rm(THREAD);
3310 Symbol* name;
3311 if (sym->byte_at(0) == 'L') {
3312 name = SymbolTable::lookup(sym->as_C_string() + 1,
3313 sym->utf8_length() - 2, CHECK);
3314 } else {
3315 int i=0;
3316 while (sym->byte_at(i) == '[') i++;
3317 if (i == sym->utf8_length() - 1 ) return; // primitive array
3318 assert(sym->byte_at(i) == 'L', "Must be a L-type");
3319 name = SymbolTable::lookup(sym->as_C_string() + i + 1,
3320 sym->utf8_length() - 2 - i, CHECK);
3321 }
3322 bool opinion1 = k1->is_declared_value_type(name);
3323 bool opinion2 = k2->is_declared_value_type(name);
3324 name->decrement_refcount();
3325 if (opinion1 != opinion2) {
3326 THROW(vmSymbols::java_lang_IncompatibleClassChangeError());
3327 }
3328 }
3329
3330 void InstanceKlass::print_class_load_logging(ClassLoaderData* loader_data,
3331 const char* module_name,
3332 const ClassFileStream* cfs) const {
3333 if (!log_is_enabled(Info, class, load)) {
3334 return;
3335 }
3336
3337 ResourceMark rm;
3338 LogMessage(class, load) msg;
3339 stringStream info_stream;
3340
3341 // Name and class hierarchy info
3342 info_stream.print("%s", external_name());
3343
3344 // Source
3345 if (cfs != NULL) {
3346 if (cfs->source() != NULL) {
|
3277 InstanceKlass* k2, TRAPS) {
3278 if (signature->utf8_length() == 1) return; // Primitive signature
3279 if (!(k1->has_value_types_attribute() || k2->has_value_types_attribute())) return;
3280 ResourceMark rm(THREAD);
3281 for (SignatureStream sstream(signature); !sstream.is_done(); sstream.next()) {
3282 if (sstream.is_object()) {
3283 Symbol* sym = sstream.as_symbol(THREAD);
3284 Symbol* name = sym;
3285 if (sstream.is_array()) {
3286 int i=0;
3287 while (sym->byte_at(i) == '[') i++;
3288 if (i == sym->utf8_length() - 1 ) continue; // primitive array
3289 assert(sym->byte_at(i) == 'L', "Must be a L-type");
3290 name = SymbolTable::lookup(sym->as_C_string() + i + 1,
3291 sym->utf8_length() - 2 - i, CHECK);
3292 }
3293 bool opinion1 = k1->is_declared_value_type(name);
3294 bool opinion2 = k2->is_declared_value_type(name);
3295 if (sym != name) name->decrement_refcount();
3296 if (opinion1 != opinion2) {
3297 stringStream ss;
3298 ss.print("signature %s inconsistent value type: %s %s",
3299 signature->as_C_string(), k1->external_name(), k2->external_name());
3300 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), ss.as_string());
3301 }
3302 }
3303 }
3304 }
3305
3306 void InstanceKlass::check_symbol_for_value_types_consistency(Symbol* sym,
3307 InstanceKlass* k1,
3308 InstanceKlass* k2, TRAPS) {
3309 if (sym->utf8_length() == 1) return; // Primitive signature
3310 if (!(k1->has_value_types_attribute() || k2->has_value_types_attribute())) return;
3311 assert(sym->byte_at(0) == 'L' || sym->byte_at(0) == '[', "Sanity check");
3312 ResourceMark rm(THREAD);
3313 Symbol* name;
3314 if (sym->byte_at(0) == 'L') {
3315 name = SymbolTable::lookup(sym->as_C_string() + 1,
3316 sym->utf8_length() - 2, CHECK);
3317 } else {
3318 int i=0;
3319 while (sym->byte_at(i) == '[') i++;
3320 if (i == sym->utf8_length() - 1 ) return; // primitive array
3321 assert(sym->byte_at(i) == 'L', "Must be a L-type");
3322 name = SymbolTable::lookup(sym->as_C_string() + i + 1,
3323 sym->utf8_length() - 2 - i, CHECK);
3324 }
3325 bool opinion1 = k1->is_declared_value_type(name);
3326 bool opinion2 = k2->is_declared_value_type(name);
3327 name->decrement_refcount();
3328 if (opinion1 != opinion2) {
3329 stringStream ss;
3330 ss.print("symbol %s inconsistent value type: %s %s",
3331 sym->as_C_string(), k1->external_name(), k2->external_name());
3332 THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), ss.as_string());
3333 }
3334 }
3335
3336 void InstanceKlass::print_class_load_logging(ClassLoaderData* loader_data,
3337 const char* module_name,
3338 const ClassFileStream* cfs) const {
3339 if (!log_is_enabled(Info, class, load)) {
3340 return;
3341 }
3342
3343 ResourceMark rm;
3344 LogMessage(class, load) msg;
3345 stringStream info_stream;
3346
3347 // Name and class hierarchy info
3348 info_stream.print("%s", external_name());
3349
3350 // Source
3351 if (cfs != NULL) {
3352 if (cfs->source() != NULL) {
|