1268 }
1269 if (sorted) break;
1270 sorted = true;
1271 }
1272 #ifdef ASSERT
1273 uintptr_t prev = 0;
1274 for (int i = 0; i < methods->length(); ++i) {
1275 Method* mh = methods->at(i);
1276 uintptr_t nv = (uintptr_t)mh->name();
1277 assert(nv >= prev, "Incorrect overpass method ordering");
1278 prev = nv;
1279 }
1280 #endif
1281 }
1282
1283 static void merge_in_new_methods(InstanceKlass* klass,
1284 GrowableArray<Method*>* new_methods, TRAPS) {
1285
1286 enum { ANNOTATIONS, PARAMETERS, DEFAULTS, NUM_ARRAYS };
1287
1288 Array<AnnotationArray*>* original_annots[NUM_ARRAYS];
1289
1290 Array<Method*>* original_methods = klass->methods();
1291 Annotations* annots = klass->annotations();
1292 original_annots[ANNOTATIONS] = annots->methods_annotations();
1293 original_annots[PARAMETERS] = annots->methods_parameter_annotations();
1294 original_annots[DEFAULTS] = annots->methods_default_annotations();
1295
1296 Array<int>* original_ordering = klass->method_ordering();
1297 Array<int>* merged_ordering = Universe::the_empty_int_array();
1298
1299 int new_size = klass->methods()->length() + new_methods->length();
1300
1301 Array<AnnotationArray*>* merged_annots[NUM_ARRAYS];
1302
1303 Array<Method*>* merged_methods = MetadataFactory::new_array<Method*>(
1304 klass->class_loader_data(), new_size, NULL, CHECK);
1305 for (int i = 0; i < NUM_ARRAYS; ++i) {
1306 if (original_annots[i] != NULL) {
1307 merged_annots[i] = MetadataFactory::new_array<AnnotationArray*>(
1308 klass->class_loader_data(), new_size, CHECK);
1309 } else {
1310 merged_annots[i] = NULL;
1311 }
1312 }
1313 if (original_ordering != NULL && original_ordering->length() > 0) {
1314 merged_ordering = MetadataFactory::new_array<int>(
1353 }
1354 ++new_idx;
1355 }
1356 // update idnum for new location
1357 merged_methods->at(i)->set_method_idnum(i);
1358 }
1359
1360 // Verify correct order
1361 #ifdef ASSERT
1362 uintptr_t prev = 0;
1363 for (int i = 0; i < merged_methods->length(); ++i) {
1364 Method* mo = merged_methods->at(i);
1365 uintptr_t nv = (uintptr_t)mo->name();
1366 assert(nv >= prev, "Incorrect method ordering");
1367 prev = nv;
1368 }
1369 #endif
1370
1371 // Replace klass methods with new merged lists
1372 klass->set_methods(merged_methods);
1373 annots->set_methods_annotations(merged_annots[ANNOTATIONS]);
1374 annots->set_methods_parameter_annotations(merged_annots[PARAMETERS]);
1375 annots->set_methods_default_annotations(merged_annots[DEFAULTS]);
1376
1377 ClassLoaderData* cld = klass->class_loader_data();
1378 MetadataFactory::free_array(cld, original_methods);
1379 for (int i = 0; i < NUM_ARRAYS; ++i) {
1380 MetadataFactory::free_array(cld, original_annots[i]);
1381 }
1382 if (original_ordering->length() > 0) {
1383 klass->set_method_ordering(merged_ordering);
1384 MetadataFactory::free_array(cld, original_ordering);
1385 }
1386 }
1387
|
1268 }
1269 if (sorted) break;
1270 sorted = true;
1271 }
1272 #ifdef ASSERT
1273 uintptr_t prev = 0;
1274 for (int i = 0; i < methods->length(); ++i) {
1275 Method* mh = methods->at(i);
1276 uintptr_t nv = (uintptr_t)mh->name();
1277 assert(nv >= prev, "Incorrect overpass method ordering");
1278 prev = nv;
1279 }
1280 #endif
1281 }
1282
1283 static void merge_in_new_methods(InstanceKlass* klass,
1284 GrowableArray<Method*>* new_methods, TRAPS) {
1285
1286 enum { ANNOTATIONS, PARAMETERS, DEFAULTS, NUM_ARRAYS };
1287
1288 Array<AnnotationArray*>* original_annots[NUM_ARRAYS] = { NULL };
1289
1290 Array<Method*>* original_methods = klass->methods();
1291 Annotations* annots = klass->annotations();
1292 if (annots != NULL) {
1293 original_annots[ANNOTATIONS] = annots->methods_annotations();
1294 original_annots[PARAMETERS] = annots->methods_parameter_annotations();
1295 original_annots[DEFAULTS] = annots->methods_default_annotations();
1296 }
1297
1298 Array<int>* original_ordering = klass->method_ordering();
1299 Array<int>* merged_ordering = Universe::the_empty_int_array();
1300
1301 int new_size = klass->methods()->length() + new_methods->length();
1302
1303 Array<AnnotationArray*>* merged_annots[NUM_ARRAYS];
1304
1305 Array<Method*>* merged_methods = MetadataFactory::new_array<Method*>(
1306 klass->class_loader_data(), new_size, NULL, CHECK);
1307 for (int i = 0; i < NUM_ARRAYS; ++i) {
1308 if (original_annots[i] != NULL) {
1309 merged_annots[i] = MetadataFactory::new_array<AnnotationArray*>(
1310 klass->class_loader_data(), new_size, CHECK);
1311 } else {
1312 merged_annots[i] = NULL;
1313 }
1314 }
1315 if (original_ordering != NULL && original_ordering->length() > 0) {
1316 merged_ordering = MetadataFactory::new_array<int>(
1355 }
1356 ++new_idx;
1357 }
1358 // update idnum for new location
1359 merged_methods->at(i)->set_method_idnum(i);
1360 }
1361
1362 // Verify correct order
1363 #ifdef ASSERT
1364 uintptr_t prev = 0;
1365 for (int i = 0; i < merged_methods->length(); ++i) {
1366 Method* mo = merged_methods->at(i);
1367 uintptr_t nv = (uintptr_t)mo->name();
1368 assert(nv >= prev, "Incorrect method ordering");
1369 prev = nv;
1370 }
1371 #endif
1372
1373 // Replace klass methods with new merged lists
1374 klass->set_methods(merged_methods);
1375 if (annots != NULL) {
1376 annots->set_methods_annotations(merged_annots[ANNOTATIONS]);
1377 annots->set_methods_parameter_annotations(merged_annots[PARAMETERS]);
1378 annots->set_methods_default_annotations(merged_annots[DEFAULTS]);
1379 } else {
1380 assert(merged_annots[ANNOTATIONS] == NULL, "Must be");
1381 assert(merged_annots[PARAMETERS] == NULL, "Must be");
1382 assert(merged_annots[DEFAULTS] == NULL, "Must be");
1383 }
1384
1385 ClassLoaderData* cld = klass->class_loader_data();
1386 MetadataFactory::free_array(cld, original_methods);
1387 for (int i = 0; i < NUM_ARRAYS; ++i) {
1388 MetadataFactory::free_array(cld, original_annots[i]);
1389 }
1390 if (original_ordering->length() > 0) {
1391 klass->set_method_ordering(merged_ordering);
1392 MetadataFactory::free_array(cld, original_ordering);
1393 }
1394 }
1395
|