1 /*
   2  * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "classfile/symbolTable.hpp"
  27 #include "interpreter/bytecodeStream.hpp"
  28 #include "oops/fieldStreams.hpp"
  29 #include "prims/jvmtiClassFileReconstituter.hpp"
  30 #include "runtime/signature.hpp"
  31 #ifdef TARGET_ARCH_x86
  32 # include "bytes_x86.hpp"
  33 #endif
  34 #ifdef TARGET_ARCH_sparc
  35 # include "bytes_sparc.hpp"
  36 #endif
  37 #ifdef TARGET_ARCH_zero
  38 # include "bytes_zero.hpp"
  39 #endif
  40 #ifdef TARGET_ARCH_arm
  41 # include "bytes_arm.hpp"
  42 #endif
  43 #ifdef TARGET_ARCH_ppc
  44 # include "bytes_ppc.hpp"
  45 #endif
  46 // FIXME: add Deprecated, LVTT attributes
  47 // FIXME: fix Synthetic attribute
  48 // FIXME: per Serguei, add error return handling for constantPoolOopDesc::copy_cpool_bytes()
  49 
  50 
  51 // Write the field information portion of ClassFile structure
  52 // JVMSpec|     u2 fields_count;
  53 // JVMSpec|     field_info fields[fields_count];
  54 void JvmtiClassFileReconstituter::write_field_infos() {
  55   HandleMark hm(thread());
  56   objArrayHandle fields_anno(thread(), ikh()->fields_annotations());
  57 
  58   // Compute the real number of Java fields
  59   int java_fields = ikh()->java_fields_count();
  60 
  61   write_u2(java_fields);
  62   for (JavaFieldStream fs(ikh()); !fs.done(); fs.next()) {
  63     AccessFlags access_flags = fs.access_flags();
  64     int name_index = fs.name_index();
  65     int signature_index = fs.signature_index();
  66     int initial_value_index = fs.initval_index();
  67     guarantee(name_index != 0 && signature_index != 0, "bad constant pool index for field");
  68     // int offset = ikh()->field_offset( index );
  69     int generic_signature_index = fs.generic_signature_index();
  70     typeArrayHandle anno(thread(), fields_anno.not_null() ?
  71                                  (typeArrayOop)(fields_anno->obj_at(fs.index())) :
  72                                  (typeArrayOop)NULL);
  73 
  74     // JVMSpec|   field_info {
  75     // JVMSpec|         u2 access_flags;
  76     // JVMSpec|         u2 name_index;
  77     // JVMSpec|         u2 descriptor_index;
  78     // JVMSpec|         u2 attributes_count;
  79     // JVMSpec|         attribute_info attributes[attributes_count];
  80     // JVMSpec|   }
  81 
  82     write_u2(access_flags.as_int() & JVM_RECOGNIZED_FIELD_MODIFIERS);
  83     write_u2(name_index);
  84     write_u2(signature_index);
  85     int attr_count = 0;
  86     if (initial_value_index != 0) {
  87       ++attr_count;
  88     }
  89     if (access_flags.is_synthetic()) {
  90       // ++attr_count;
  91     }
  92     if (generic_signature_index != 0) {
  93       ++attr_count;
  94     }
  95     if (anno.not_null()) {
  96       ++attr_count;     // has RuntimeVisibleAnnotations attribute
  97     }
  98 
  99     write_u2(attr_count);
 100 
 101     if (initial_value_index != 0) {
 102       write_attribute_name_index("ConstantValue");
 103       write_u4(2); //length always 2
 104       write_u2(initial_value_index);
 105     }
 106     if (access_flags.is_synthetic()) {
 107       // write_synthetic_attribute();
 108     }
 109     if (generic_signature_index != 0) {
 110       write_signature_attribute(generic_signature_index);
 111     }
 112     if (anno.not_null()) {
 113       write_annotations_attribute("RuntimeVisibleAnnotations", anno);
 114     }
 115   }
 116 }
 117 
 118 // Write Code attribute
 119 // JVMSpec|   Code_attribute {
 120 // JVMSpec|     u2 attribute_name_index;
 121 // JVMSpec|     u4 attribute_length;
 122 // JVMSpec|     u2 max_stack;
 123 // JVMSpec|     u2 max_locals;
 124 // JVMSpec|     u4 code_length;
 125 // JVMSpec|     u1 code[code_length];
 126 // JVMSpec|     u2 exception_table_length;
 127 // JVMSpec|     {       u2 start_pc;
 128 // JVMSpec|             u2 end_pc;
 129 // JVMSpec|             u2  handler_pc;
 130 // JVMSpec|             u2  catch_type;
 131 // JVMSpec|     }       exception_table[exception_table_length];
 132 // JVMSpec|     u2 attributes_count;
 133 // JVMSpec|     attribute_info attributes[attributes_count];
 134 // JVMSpec|   }
 135 void JvmtiClassFileReconstituter::write_code_attribute(methodHandle method) {
 136   constMethodHandle const_method(thread(), method->constMethod());
 137   u2 line_num_cnt = 0;
 138   int stackmap_len = 0;
 139   int local_variable_table_length = 0;
 140 
 141   // compute number and length of attributes
 142   int attr_count = 0;
 143   int attr_size = 0;
 144   if (const_method->has_linenumber_table()) {
 145     line_num_cnt = line_number_table_entries(method);
 146     if (line_num_cnt != 0) {
 147       ++attr_count;
 148       // Compute the complete size of the line number table attribute:
 149       //      LineNumberTable_attribute {
 150       //        u2 attribute_name_index;
 151       //        u4 attribute_length;
 152       //        u2 line_number_table_length;
 153       //        {  u2 start_pc;
 154       //           u2 line_number;
 155       //        } line_number_table[line_number_table_length];
 156       //      }
 157       attr_size += 2 + 4 + 2 + line_num_cnt * (2 + 2);
 158     }
 159   }
 160   if (method->has_stackmap_table()) {
 161     stackmap_len = method->stackmap_data()->length();
 162     if (stackmap_len != 0) {
 163       ++attr_count;
 164       // Compute the  size of the stack map table attribute (VM stores raw):
 165       //      StackMapTable_attribute {
 166       //        u2 attribute_name_index;
 167       //        u4 attribute_length;
 168       //        u2 number_of_entries;
 169       //        stack_map_frame_entries[number_of_entries];
 170       //      }
 171       attr_size += 2 + 4 + stackmap_len;
 172     }
 173   }
 174   if (method->has_localvariable_table()) {
 175     local_variable_table_length = method->localvariable_table_length();
 176     ++attr_count;
 177     if (local_variable_table_length != 0) {
 178       // Compute the size of the local variable table attribute (VM stores raw):
 179       // LocalVariableTable_attribute {
 180       //   u2 attribute_name_index;
 181       //   u4 attribute_length;
 182       //   u2 local_variable_table_length;
 183       //   {
 184       //     u2 start_pc;
 185       //     u2 length;
 186       //     u2 name_index;
 187       //     u2 descriptor_index;
 188       //     u2 index;
 189       //   }
 190       attr_size += 2 + 4 + 2 + local_variable_table_length * (2 + 2 + 2 + 2 + 2);
 191     }
 192   }
 193 
 194   typeArrayHandle exception_table(thread(), const_method->exception_table());
 195   int exception_table_length = exception_table->length();
 196   int exception_table_entries = exception_table_length / 4;
 197   int code_size = const_method->code_size();
 198   int size =
 199     2+2+4 +                                // max_stack, max_locals, code_length
 200     code_size +                            // code
 201     2 +                                    // exception_table_length
 202     (2+2+2+2) * exception_table_entries +  // exception_table
 203     2 +                                    // attributes_count
 204     attr_size;                             // attributes
 205 
 206   write_attribute_name_index("Code");
 207   write_u4(size);
 208   write_u2(method->max_stack());
 209   write_u2(method->max_locals());
 210   write_u4(code_size);
 211   copy_bytecodes(method, (unsigned char*)writeable_address(code_size));
 212   write_u2(exception_table_entries);
 213   for (int index = 0; index < exception_table_length; ) {
 214     write_u2(exception_table->int_at(index++));
 215     write_u2(exception_table->int_at(index++));
 216     write_u2(exception_table->int_at(index++));
 217     write_u2(exception_table->int_at(index++));
 218   }
 219   write_u2(attr_count);
 220   if (line_num_cnt != 0) {
 221     write_line_number_table_attribute(method, line_num_cnt);
 222   }
 223   if (stackmap_len != 0) {
 224     write_stackmap_table_attribute(method, stackmap_len);
 225   }
 226   if (local_variable_table_length != 0) {
 227     write_local_variable_table_attribute(method, local_variable_table_length);
 228   }
 229 }
 230 
 231 // Write Exceptions attribute
 232 // JVMSpec|   Exceptions_attribute {
 233 // JVMSpec|     u2 attribute_name_index;
 234 // JVMSpec|     u4 attribute_length;
 235 // JVMSpec|     u2 number_of_exceptions;
 236 // JVMSpec|     u2 exception_index_table[number_of_exceptions];
 237 // JVMSpec|   }
 238 void JvmtiClassFileReconstituter::write_exceptions_attribute(constMethodHandle const_method) {
 239   CheckedExceptionElement* checked_exceptions = const_method->checked_exceptions_start();
 240   int checked_exceptions_length = const_method->checked_exceptions_length();
 241   int size =
 242     2 +                                    // number_of_exceptions
 243     2 * checked_exceptions_length;         // exception_index_table
 244 
 245   write_attribute_name_index("Exceptions");
 246   write_u4(size);
 247   write_u2(checked_exceptions_length);
 248   for (int index = 0; index < checked_exceptions_length; index++) {
 249     write_u2(checked_exceptions[index].class_cp_index);
 250   }
 251 }
 252 
 253 // Write SourceFile attribute
 254 // JVMSpec|   SourceFile_attribute {
 255 // JVMSpec|     u2 attribute_name_index;
 256 // JVMSpec|     u4 attribute_length;
 257 // JVMSpec|     u2 sourcefile_index;
 258 // JVMSpec|   }
 259 void JvmtiClassFileReconstituter::write_source_file_attribute() {
 260   assert(ikh()->source_file_name() != NULL, "caller must check");
 261 
 262   write_attribute_name_index("SourceFile");
 263   write_u4(2);  // always length 2
 264   write_u2(symbol_to_cpool_index(ikh()->source_file_name()));
 265 }
 266 
 267 // Write SourceDebugExtension attribute
 268 // JSR45|   SourceDebugExtension_attribute {
 269 // JSR45|       u2 attribute_name_index;
 270 // JSR45|       u4 attribute_length;
 271 // JSR45|       u2 sourcefile_index;
 272 // JSR45|   }
 273 void JvmtiClassFileReconstituter::write_source_debug_extension_attribute() {
 274   assert(ikh()->source_debug_extension() != NULL, "caller must check");
 275 
 276   write_attribute_name_index("SourceDebugExtension");
 277   write_u4(2);  // always length 2
 278   write_u2(symbol_to_cpool_index(ikh()->source_debug_extension()));
 279 }
 280 
 281 // Write (generic) Signature attribute
 282 // JVMSpec|   Signature_attribute {
 283 // JVMSpec|     u2 attribute_name_index;
 284 // JVMSpec|     u4 attribute_length;
 285 // JVMSpec|     u2 signature_index;
 286 // JVMSpec|   }
 287 void JvmtiClassFileReconstituter::write_signature_attribute(u2 generic_signature_index) {
 288   write_attribute_name_index("Signature");
 289   write_u4(2);  // always length 2
 290   write_u2(generic_signature_index);
 291 }
 292 
 293 // Compute the number of entries in the InnerClasses attribute
 294 u2 JvmtiClassFileReconstituter::inner_classes_attribute_length() {
 295   typeArrayOop inner_class_list = ikh()->inner_classes();
 296   return (inner_class_list == NULL) ? 0 : inner_class_list->length();
 297 }
 298 
 299 // Write an annotation attribute.  The VM stores them in raw form, so all we need
 300 // to do is add the attrubute name and fill in the length.
 301 // JSR202|   *Annotations_attribute {
 302 // JSR202|     u2 attribute_name_index;
 303 // JSR202|     u4 attribute_length;
 304 // JSR202|     ...
 305 // JSR202|   }
 306 void JvmtiClassFileReconstituter::write_annotations_attribute(const char* attr_name,
 307                                                               typeArrayHandle annos) {
 308   u4 length = annos->length();
 309   write_attribute_name_index(attr_name);
 310   write_u4(length);
 311   memcpy(writeable_address(length), annos->byte_at_addr(0), length);
 312 }
 313 
 314 
 315 // Write InnerClasses attribute
 316 // JVMSpec|   InnerClasses_attribute {
 317 // JVMSpec|     u2 attribute_name_index;
 318 // JVMSpec|     u4 attribute_length;
 319 // JVMSpec|     u2 number_of_classes;
 320 // JVMSpec|     {  u2 inner_class_info_index;
 321 // JVMSpec|        u2 outer_class_info_index;
 322 // JVMSpec|        u2 inner_name_index;
 323 // JVMSpec|        u2 inner_class_access_flags;
 324 // JVMSpec|     } classes[number_of_classes];
 325 // JVMSpec|   }
 326 void JvmtiClassFileReconstituter::write_inner_classes_attribute(int length) {
 327   typeArrayOop inner_class_list = ikh()->inner_classes();
 328   guarantee(inner_class_list != NULL && inner_class_list->length() == length,
 329             "caller must check");
 330   typeArrayHandle inner_class_list_h(thread(), inner_class_list);
 331   assert (length % instanceKlass::inner_class_next_offset == 0, "just checking");
 332   u2 entry_count = length / instanceKlass::inner_class_next_offset;
 333   u4 size = 2 + entry_count * (2+2+2+2);
 334 
 335   write_attribute_name_index("InnerClasses");
 336   write_u4(size);
 337   write_u2(entry_count);
 338   for (int i = 0; i < length; i += instanceKlass::inner_class_next_offset) {
 339     write_u2(inner_class_list_h->ushort_at(
 340                       i + instanceKlass::inner_class_inner_class_info_offset));
 341     write_u2(inner_class_list_h->ushort_at(
 342                       i + instanceKlass::inner_class_outer_class_info_offset));
 343     write_u2(inner_class_list_h->ushort_at(
 344                       i + instanceKlass::inner_class_inner_name_offset));
 345     write_u2(inner_class_list_h->ushort_at(
 346                       i + instanceKlass::inner_class_access_flags_offset));
 347   }
 348 }
 349 
 350 // Write Synthetic attribute
 351 // JVMSpec|   Synthetic_attribute {
 352 // JVMSpec|     u2 attribute_name_index;
 353 // JVMSpec|     u4 attribute_length;
 354 // JVMSpec|   }
 355 void JvmtiClassFileReconstituter::write_synthetic_attribute() {
 356   write_attribute_name_index("Synthetic");
 357   write_u4(0); //length always zero
 358 }
 359 
 360 // Compute size of LineNumberTable
 361 u2 JvmtiClassFileReconstituter::line_number_table_entries(methodHandle method) {
 362   // The line number table is compressed so we don't know how big it is until decompressed.
 363   // Decompression is really fast so we just do it twice.
 364   u2 num_entries = 0;
 365   CompressedLineNumberReadStream stream(method->compressed_linenumber_table());
 366   while (stream.read_pair()) {
 367     num_entries++;
 368   }
 369   return num_entries;
 370 }
 371 
 372 // Write LineNumberTable attribute
 373 // JVMSpec|   LineNumberTable_attribute {
 374 // JVMSpec|     u2 attribute_name_index;
 375 // JVMSpec|     u4 attribute_length;
 376 // JVMSpec|     u2 line_number_table_length;
 377 // JVMSpec|     {  u2 start_pc;
 378 // JVMSpec|        u2 line_number;
 379 // JVMSpec|     } line_number_table[line_number_table_length];
 380 // JVMSpec|   }
 381 void JvmtiClassFileReconstituter::write_line_number_table_attribute(methodHandle method,
 382                                                                     u2 num_entries) {
 383 
 384   write_attribute_name_index("LineNumberTable");
 385   write_u4(2 + num_entries * (2 + 2));
 386   write_u2(num_entries);
 387 
 388   CompressedLineNumberReadStream stream(method->compressed_linenumber_table());
 389   while (stream.read_pair()) {
 390     write_u2(stream.bci());
 391     write_u2(stream.line());
 392   }
 393 }
 394 
 395 // Write LineNumberTable attribute
 396 // JVMSpec|   LocalVariableTable_attribute {
 397 // JVMSpec|     u2 attribute_name_index;
 398 // JVMSpec|     u4 attribute_length;
 399 // JVMSpec|     u2 local_variable_table_length;
 400 // JVMSpec|     {  u2 start_pc;
 401 // JVMSpec|       u2 length;
 402 // JVMSpec|       u2 name_index;
 403 // JVMSpec|       u2 descriptor_index;
 404 // JVMSpec|       u2 index;
 405 // JVMSpec|     } local_variable_table[local_variable_table_length];
 406 // JVMSpec|   }
 407 void JvmtiClassFileReconstituter::write_local_variable_table_attribute(methodHandle method, u2 num_entries) {
 408     write_attribute_name_index("LocalVariableTable");
 409     write_u4(2 + num_entries * (2 + 2 + 2 + 2 + 2));
 410     write_u2(num_entries);
 411 
 412     assert(method->localvariable_table_length() == num_entries, "just checking");
 413 
 414     LocalVariableTableElement *elem = method->localvariable_table_start();
 415     for (int j=0; j<method->localvariable_table_length(); j++) {
 416       write_u2(elem->start_bci);
 417       write_u2(elem->length);
 418       write_u2(elem->name_cp_index);
 419       write_u2(elem->descriptor_cp_index);
 420       write_u2(elem->slot);
 421       elem++;
 422     }
 423 }
 424 
 425 // Write stack map table attribute
 426 // JSR-202|   StackMapTable_attribute {
 427 // JSR-202|     u2 attribute_name_index;
 428 // JSR-202|     u4 attribute_length;
 429 // JSR-202|     u2 number_of_entries;
 430 // JSR-202|     stack_map_frame_entries[number_of_entries];
 431 // JSR-202|   }
 432 void JvmtiClassFileReconstituter::write_stackmap_table_attribute(methodHandle method,
 433                                                                  int stackmap_len) {
 434 
 435   write_attribute_name_index("StackMapTable");
 436   write_u4(stackmap_len);
 437   memcpy(
 438     writeable_address(stackmap_len),
 439     (void*)(method->stackmap_data()->byte_at_addr(0)),
 440     stackmap_len);
 441 }
 442 
 443 // Write one method_info structure
 444 // JVMSpec|   method_info {
 445 // JVMSpec|     u2 access_flags;
 446 // JVMSpec|     u2 name_index;
 447 // JVMSpec|     u2 descriptor_index;
 448 // JVMSpec|     u2 attributes_count;
 449 // JVMSpec|     attribute_info attributes[attributes_count];
 450 // JVMSpec|   }
 451 void JvmtiClassFileReconstituter::write_method_info(methodHandle method) {
 452   AccessFlags access_flags = method->access_flags();
 453   constMethodHandle const_method(thread(), method->constMethod());
 454   u2 generic_signature_index = const_method->generic_signature_index();
 455   typeArrayHandle anno(thread(), method->annotations());
 456   typeArrayHandle param_anno(thread(), method->parameter_annotations());
 457   typeArrayHandle default_anno(thread(), method->annotation_default());
 458 
 459   write_u2(access_flags.get_flags() & JVM_RECOGNIZED_METHOD_MODIFIERS);
 460   write_u2(const_method->name_index());
 461   write_u2(const_method->signature_index());
 462 
 463   // write attributes in the same order javac does, so we can test with byte for
 464   // byte comparison
 465   int attr_count = 0;
 466   if (const_method->code_size() != 0) {
 467     ++attr_count;     // has Code attribute
 468   }
 469   if (const_method->has_checked_exceptions()) {
 470     ++attr_count;     // has Exceptions attribute
 471   }
 472   if (default_anno.not_null()) {
 473     ++attr_count;     // has AnnotationDefault attribute
 474   }
 475   // Deprecated attribute would go here
 476   if (access_flags.is_synthetic()) { // FIXME
 477     // ++attr_count;
 478   }
 479   if (generic_signature_index != 0) {
 480     ++attr_count;
 481   }
 482   if (anno.not_null()) {
 483     ++attr_count;     // has RuntimeVisibleAnnotations attribute
 484   }
 485   if (param_anno.not_null()) {
 486     ++attr_count;     // has RuntimeVisibleParameterAnnotations attribute
 487   }
 488 
 489   write_u2(attr_count);
 490   if (const_method->code_size() > 0) {
 491     write_code_attribute(method);
 492   }
 493   if (const_method->has_checked_exceptions()) {
 494     write_exceptions_attribute(const_method);
 495   }
 496   if (default_anno.not_null()) {
 497     write_annotations_attribute("AnnotationDefault", default_anno);
 498   }
 499   // Deprecated attribute would go here
 500   if (access_flags.is_synthetic()) {
 501     // write_synthetic_attribute();
 502   }
 503   if (generic_signature_index != 0) {
 504     write_signature_attribute(generic_signature_index);
 505   }
 506   if (anno.not_null()) {
 507     write_annotations_attribute("RuntimeVisibleAnnotations", anno);
 508   }
 509   if (param_anno.not_null()) {
 510     write_annotations_attribute("RuntimeVisibleParameterAnnotations", param_anno);
 511   }
 512 }
 513 
 514 // Write the class attributes portion of ClassFile structure
 515 // JVMSpec|     u2 attributes_count;
 516 // JVMSpec|     attribute_info attributes[attributes_count];
 517 void JvmtiClassFileReconstituter::write_class_attributes() {
 518   u2 inner_classes_length = inner_classes_attribute_length();
 519   Symbol* generic_signature = ikh()->generic_signature();
 520   typeArrayHandle anno(thread(), ikh()->class_annotations());
 521 
 522   int attr_count = 0;
 523   if (generic_signature != NULL) {
 524     ++attr_count;
 525   }
 526   if (ikh()->source_file_name() != NULL) {
 527     ++attr_count;
 528   }
 529   if (ikh()->source_debug_extension() != NULL) {
 530     ++attr_count;
 531   }
 532   if (inner_classes_length > 0) {
 533     ++attr_count;
 534   }
 535   if (anno.not_null()) {
 536     ++attr_count;     // has RuntimeVisibleAnnotations attribute
 537   }
 538 
 539   write_u2(attr_count);
 540 
 541   if (generic_signature != NULL) {
 542     write_signature_attribute(symbol_to_cpool_index(generic_signature));
 543   }
 544   if (ikh()->source_file_name() != NULL) {
 545     write_source_file_attribute();
 546   }
 547   if (ikh()->source_debug_extension() != NULL) {
 548     write_source_debug_extension_attribute();
 549   }
 550   if (inner_classes_length > 0) {
 551     write_inner_classes_attribute(inner_classes_length);
 552   }
 553   if (anno.not_null()) {
 554     write_annotations_attribute("RuntimeVisibleAnnotations", anno);
 555   }
 556 }
 557 
 558 // Write the method information portion of ClassFile structure
 559 // JVMSpec|     u2 methods_count;
 560 // JVMSpec|     method_info methods[methods_count];
 561 void JvmtiClassFileReconstituter::write_method_infos() {
 562   HandleMark hm(thread());
 563   objArrayHandle methods(thread(), ikh()->methods());
 564   int num_methods = methods->length();
 565 
 566   write_u2(num_methods);
 567   if (JvmtiExport::can_maintain_original_method_order()) {
 568     int index;
 569     int original_index;
 570     int* method_order = NEW_RESOURCE_ARRAY(int, num_methods);
 571 
 572     // invert the method order mapping
 573     for (index = 0; index < num_methods; index++) {
 574       original_index = ikh()->method_ordering()->int_at(index);
 575       assert(original_index >= 0 && original_index < num_methods,
 576              "invalid original method index");
 577       method_order[original_index] = index;
 578     }
 579 
 580     // write in original order
 581     for (original_index = 0; original_index < num_methods; original_index++) {
 582       index = method_order[original_index];
 583       methodHandle method(thread(), (methodOop)(ikh()->methods()->obj_at(index)));
 584       write_method_info(method);
 585     }
 586   } else {
 587     // method order not preserved just dump the method infos
 588     for (int index = 0; index < num_methods; index++) {
 589       methodHandle method(thread(), (methodOop)(ikh()->methods()->obj_at(index)));
 590       write_method_info(method);
 591     }
 592   }
 593 }
 594 
 595 void JvmtiClassFileReconstituter::write_class_file_format() {
 596   ReallocMark();
 597 
 598   // JVMSpec|   ClassFile {
 599   // JVMSpec|           u4 magic;
 600   write_u4(0xCAFEBABE);
 601 
 602   // JVMSpec|           u2 minor_version;
 603   // JVMSpec|           u2 major_version;
 604   write_u2(ikh()->minor_version());
 605   u2 major = ikh()->major_version();
 606   write_u2(major);
 607 
 608   // JVMSpec|           u2 constant_pool_count;
 609   // JVMSpec|           cp_info constant_pool[constant_pool_count-1];
 610   write_u2(cpool()->length());
 611   copy_cpool_bytes(writeable_address(cpool_size()));
 612 
 613   // JVMSpec|           u2 access_flags;
 614   write_u2(ikh()->access_flags().get_flags() & JVM_RECOGNIZED_CLASS_MODIFIERS);
 615 
 616   // JVMSpec|           u2 this_class;
 617   // JVMSpec|           u2 super_class;
 618   write_u2(class_symbol_to_cpool_index(ikh()->name()));
 619   klassOop super_class = ikh()->super();
 620   write_u2(super_class == NULL? 0 :  // zero for java.lang.Object
 621                 class_symbol_to_cpool_index(super_class->klass_part()->name()));
 622 
 623   // JVMSpec|           u2 interfaces_count;
 624   // JVMSpec|           u2 interfaces[interfaces_count];
 625   objArrayHandle interfaces(thread(), ikh()->local_interfaces());
 626   int num_interfaces = interfaces->length();
 627   write_u2(num_interfaces);
 628   for (int index = 0; index < num_interfaces; index++) {
 629     HandleMark hm(thread());
 630     instanceKlassHandle iikh(thread(), klassOop(interfaces->obj_at(index)));
 631     write_u2(class_symbol_to_cpool_index(iikh->name()));
 632   }
 633 
 634   // JVMSpec|           u2 fields_count;
 635   // JVMSpec|           field_info fields[fields_count];
 636   write_field_infos();
 637 
 638   // JVMSpec|           u2 methods_count;
 639   // JVMSpec|           method_info methods[methods_count];
 640   write_method_infos();
 641 
 642   // JVMSpec|           u2 attributes_count;
 643   // JVMSpec|           attribute_info attributes[attributes_count];
 644   // JVMSpec|   } /* end ClassFile 8?
 645   write_class_attributes();
 646 }
 647 
 648 address JvmtiClassFileReconstituter::writeable_address(size_t size) {
 649   size_t used_size = _buffer_ptr - _buffer;
 650   if (size + used_size >= _buffer_size) {
 651     // compute the new buffer size: must be at least twice as big as before
 652     // plus whatever new is being used; then convert to nice clean block boundary
 653     size_t new_buffer_size = (size + _buffer_size*2 + 1) / initial_buffer_size
 654                                                          * initial_buffer_size;
 655 
 656     // VM goes belly-up if the memory isn't available, so cannot do OOM processing
 657     _buffer = REALLOC_RESOURCE_ARRAY(u1, _buffer, _buffer_size, new_buffer_size);
 658     _buffer_size = new_buffer_size;
 659     _buffer_ptr = _buffer + used_size;
 660   }
 661   u1* ret_ptr = _buffer_ptr;
 662   _buffer_ptr += size;
 663   return ret_ptr;
 664 }
 665 
 666 void JvmtiClassFileReconstituter::write_attribute_name_index(const char* name) {
 667   TempNewSymbol sym = SymbolTable::probe(name, (int)strlen(name));
 668   assert(sym != NULL, "attribute name symbol not found");
 669   u2 attr_name_index = symbol_to_cpool_index(sym);
 670   assert(attr_name_index != 0, "attribute name symbol not in constant pool");
 671   write_u2(attr_name_index);
 672 }
 673 
 674 void JvmtiClassFileReconstituter::write_u1(u1 x) {
 675   *writeable_address(1) = x;
 676 }
 677 
 678 void JvmtiClassFileReconstituter::write_u2(u2 x) {
 679   Bytes::put_Java_u2(writeable_address(2), x);
 680 }
 681 
 682 void JvmtiClassFileReconstituter::write_u4(u4 x) {
 683   Bytes::put_Java_u4(writeable_address(4), x);
 684 }
 685 
 686 void JvmtiClassFileReconstituter::write_u8(u8 x) {
 687   Bytes::put_Java_u8(writeable_address(8), x);
 688 }
 689 
 690 void JvmtiClassFileReconstituter::copy_bytecodes(methodHandle mh,
 691                                                  unsigned char* bytecodes) {
 692   // use a BytecodeStream to iterate over the bytecodes. JVM/fast bytecodes
 693   // and the breakpoint bytecode are converted to their original bytecodes.
 694 
 695   BytecodeStream bs(mh);
 696 
 697   unsigned char* p = bytecodes;
 698   Bytecodes::Code code;
 699   bool is_rewritten = instanceKlass::cast(mh->method_holder())->is_rewritten();
 700 
 701   while ((code = bs.next()) >= 0) {
 702     assert(Bytecodes::is_java_code(code), "sanity check");
 703     assert(code != Bytecodes::_breakpoint, "sanity check");
 704 
 705     // length of bytecode (mnemonic + operands)
 706     address bcp = bs.bcp();
 707     int     len = bs.instruction_size();
 708     assert(len > 0, "length must be > 0");
 709 
 710     // copy the bytecodes
 711     *p = (unsigned char) (bs.is_wide()? Bytecodes::_wide : code);
 712     if (len > 1) {
 713       memcpy(p+1, bcp+1, len-1);
 714     }
 715 
 716     // During linking the get/put and invoke instructions are rewritten
 717     // with an index into the constant pool cache. The original constant
 718     // pool index must be returned to caller.  Rewrite the index.
 719     if (is_rewritten && len >= 3) {
 720       switch (code) {
 721       case Bytecodes::_getstatic       :  // fall through
 722       case Bytecodes::_putstatic       :  // fall through
 723       case Bytecodes::_getfield        :  // fall through
 724       case Bytecodes::_putfield        :  // fall through
 725       case Bytecodes::_invokevirtual   :  // fall through
 726       case Bytecodes::_invokespecial   :  // fall through
 727       case Bytecodes::_invokestatic    :  // fall through
 728       case Bytecodes::_invokedynamic   :  // fall through
 729       case Bytecodes::_invokeinterface :
 730         assert(len == 3 || (code == Bytecodes::_invokeinterface && len ==5),
 731                "sanity check");
 732         int cpci = Bytes::get_native_u2(bcp+1);
 733         bool is_invokedynamic = (EnableInvokeDynamic && code == Bytecodes::_invokedynamic);
 734         if (is_invokedynamic)
 735           cpci = Bytes::get_native_u4(bcp+1);
 736         // cache cannot be pre-fetched since some classes won't have it yet
 737         ConstantPoolCacheEntry* entry =
 738           mh->constants()->cache()->main_entry_at(cpci);
 739         int i = entry->constant_pool_index();
 740         assert(i < mh->constants()->length(), "sanity check");
 741         Bytes::put_Java_u2((address)(p+1), (u2)i);     // java byte ordering
 742         if (is_invokedynamic)  *(p+3) = *(p+4) = 0;
 743         break;
 744       }
 745     }
 746 
 747     p += len;
 748   }
 749 }