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 ||
 332            length % instanceKlass::inner_class_next_offset == instanceKlass::enclosing_method_attribute_size),
 333            "just checking");
 334   u2 entry_count = length / instanceKlass::inner_class_next_offset;
 335   u4 size = 2 + entry_count * (2+2+2+2);
 336 
 337   write_attribute_name_index("InnerClasses");
 338   write_u4(size);
 339   write_u2(entry_count);
 340   for (int i = 0; i < length; i += instanceKlass::inner_class_next_offset) {
 341     if (i == length - instanceKlass::enclosing_method_attribute_size) {
 342       break;
 343     }
 344     write_u2(inner_class_list_h->ushort_at(
 345                       i + instanceKlass::inner_class_inner_class_info_offset));
 346     write_u2(inner_class_list_h->ushort_at(
 347                       i + instanceKlass::inner_class_outer_class_info_offset));
 348     write_u2(inner_class_list_h->ushort_at(
 349                       i + instanceKlass::inner_class_inner_name_offset));
 350     write_u2(inner_class_list_h->ushort_at(
 351                       i + instanceKlass::inner_class_access_flags_offset));
 352   }
 353 }
 354 
 355 // Write Synthetic attribute
 356 // JVMSpec|   Synthetic_attribute {
 357 // JVMSpec|     u2 attribute_name_index;
 358 // JVMSpec|     u4 attribute_length;
 359 // JVMSpec|   }
 360 void JvmtiClassFileReconstituter::write_synthetic_attribute() {
 361   write_attribute_name_index("Synthetic");
 362   write_u4(0); //length always zero
 363 }
 364 
 365 // Compute size of LineNumberTable
 366 u2 JvmtiClassFileReconstituter::line_number_table_entries(methodHandle method) {
 367   // The line number table is compressed so we don't know how big it is until decompressed.
 368   // Decompression is really fast so we just do it twice.
 369   u2 num_entries = 0;
 370   CompressedLineNumberReadStream stream(method->compressed_linenumber_table());
 371   while (stream.read_pair()) {
 372     num_entries++;
 373   }
 374   return num_entries;
 375 }
 376 
 377 // Write LineNumberTable attribute
 378 // JVMSpec|   LineNumberTable_attribute {
 379 // JVMSpec|     u2 attribute_name_index;
 380 // JVMSpec|     u4 attribute_length;
 381 // JVMSpec|     u2 line_number_table_length;
 382 // JVMSpec|     {  u2 start_pc;
 383 // JVMSpec|        u2 line_number;
 384 // JVMSpec|     } line_number_table[line_number_table_length];
 385 // JVMSpec|   }
 386 void JvmtiClassFileReconstituter::write_line_number_table_attribute(methodHandle method,
 387                                                                     u2 num_entries) {
 388 
 389   write_attribute_name_index("LineNumberTable");
 390   write_u4(2 + num_entries * (2 + 2));
 391   write_u2(num_entries);
 392 
 393   CompressedLineNumberReadStream stream(method->compressed_linenumber_table());
 394   while (stream.read_pair()) {
 395     write_u2(stream.bci());
 396     write_u2(stream.line());
 397   }
 398 }
 399 
 400 // Write LineNumberTable attribute
 401 // JVMSpec|   LocalVariableTable_attribute {
 402 // JVMSpec|     u2 attribute_name_index;
 403 // JVMSpec|     u4 attribute_length;
 404 // JVMSpec|     u2 local_variable_table_length;
 405 // JVMSpec|     {  u2 start_pc;
 406 // JVMSpec|       u2 length;
 407 // JVMSpec|       u2 name_index;
 408 // JVMSpec|       u2 descriptor_index;
 409 // JVMSpec|       u2 index;
 410 // JVMSpec|     } local_variable_table[local_variable_table_length];
 411 // JVMSpec|   }
 412 void JvmtiClassFileReconstituter::write_local_variable_table_attribute(methodHandle method, u2 num_entries) {
 413     write_attribute_name_index("LocalVariableTable");
 414     write_u4(2 + num_entries * (2 + 2 + 2 + 2 + 2));
 415     write_u2(num_entries);
 416 
 417     assert(method->localvariable_table_length() == num_entries, "just checking");
 418 
 419     LocalVariableTableElement *elem = method->localvariable_table_start();
 420     for (int j=0; j<method->localvariable_table_length(); j++) {
 421       write_u2(elem->start_bci);
 422       write_u2(elem->length);
 423       write_u2(elem->name_cp_index);
 424       write_u2(elem->descriptor_cp_index);
 425       write_u2(elem->slot);
 426       elem++;
 427     }
 428 }
 429 
 430 // Write stack map table attribute
 431 // JSR-202|   StackMapTable_attribute {
 432 // JSR-202|     u2 attribute_name_index;
 433 // JSR-202|     u4 attribute_length;
 434 // JSR-202|     u2 number_of_entries;
 435 // JSR-202|     stack_map_frame_entries[number_of_entries];
 436 // JSR-202|   }
 437 void JvmtiClassFileReconstituter::write_stackmap_table_attribute(methodHandle method,
 438                                                                  int stackmap_len) {
 439 
 440   write_attribute_name_index("StackMapTable");
 441   write_u4(stackmap_len);
 442   memcpy(
 443     writeable_address(stackmap_len),
 444     (void*)(method->stackmap_data()->byte_at_addr(0)),
 445     stackmap_len);
 446 }
 447 
 448 // Write one method_info structure
 449 // JVMSpec|   method_info {
 450 // JVMSpec|     u2 access_flags;
 451 // JVMSpec|     u2 name_index;
 452 // JVMSpec|     u2 descriptor_index;
 453 // JVMSpec|     u2 attributes_count;
 454 // JVMSpec|     attribute_info attributes[attributes_count];
 455 // JVMSpec|   }
 456 void JvmtiClassFileReconstituter::write_method_info(methodHandle method) {
 457   AccessFlags access_flags = method->access_flags();
 458   constMethodHandle const_method(thread(), method->constMethod());
 459   u2 generic_signature_index = const_method->generic_signature_index();
 460   typeArrayHandle anno(thread(), method->annotations());
 461   typeArrayHandle param_anno(thread(), method->parameter_annotations());
 462   typeArrayHandle default_anno(thread(), method->annotation_default());
 463 
 464   write_u2(access_flags.get_flags() & JVM_RECOGNIZED_METHOD_MODIFIERS);
 465   write_u2(const_method->name_index());
 466   write_u2(const_method->signature_index());
 467 
 468   // write attributes in the same order javac does, so we can test with byte for
 469   // byte comparison
 470   int attr_count = 0;
 471   if (const_method->code_size() != 0) {
 472     ++attr_count;     // has Code attribute
 473   }
 474   if (const_method->has_checked_exceptions()) {
 475     ++attr_count;     // has Exceptions attribute
 476   }
 477   if (default_anno.not_null()) {
 478     ++attr_count;     // has AnnotationDefault attribute
 479   }
 480   // Deprecated attribute would go here
 481   if (access_flags.is_synthetic()) { // FIXME
 482     // ++attr_count;
 483   }
 484   if (generic_signature_index != 0) {
 485     ++attr_count;
 486   }
 487   if (anno.not_null()) {
 488     ++attr_count;     // has RuntimeVisibleAnnotations attribute
 489   }
 490   if (param_anno.not_null()) {
 491     ++attr_count;     // has RuntimeVisibleParameterAnnotations attribute
 492   }
 493 
 494   write_u2(attr_count);
 495   if (const_method->code_size() > 0) {
 496     write_code_attribute(method);
 497   }
 498   if (const_method->has_checked_exceptions()) {
 499     write_exceptions_attribute(const_method);
 500   }
 501   if (default_anno.not_null()) {
 502     write_annotations_attribute("AnnotationDefault", default_anno);
 503   }
 504   // Deprecated attribute would go here
 505   if (access_flags.is_synthetic()) {
 506     // write_synthetic_attribute();
 507   }
 508   if (generic_signature_index != 0) {
 509     write_signature_attribute(generic_signature_index);
 510   }
 511   if (anno.not_null()) {
 512     write_annotations_attribute("RuntimeVisibleAnnotations", anno);
 513   }
 514   if (param_anno.not_null()) {
 515     write_annotations_attribute("RuntimeVisibleParameterAnnotations", param_anno);
 516   }
 517 }
 518 
 519 // Write the class attributes portion of ClassFile structure
 520 // JVMSpec|     u2 attributes_count;
 521 // JVMSpec|     attribute_info attributes[attributes_count];
 522 void JvmtiClassFileReconstituter::write_class_attributes() {
 523   u2 inner_classes_length = inner_classes_attribute_length();
 524   Symbol* generic_signature = ikh()->generic_signature();
 525   typeArrayHandle anno(thread(), ikh()->class_annotations());
 526 
 527   int attr_count = 0;
 528   if (generic_signature != NULL) {
 529     ++attr_count;
 530   }
 531   if (ikh()->source_file_name() != NULL) {
 532     ++attr_count;
 533   }
 534   if (ikh()->source_debug_extension() != NULL) {
 535     ++attr_count;
 536   }
 537   if (inner_classes_length > 0) {
 538     ++attr_count;
 539   }
 540   if (anno.not_null()) {
 541     ++attr_count;     // has RuntimeVisibleAnnotations attribute
 542   }
 543 
 544   write_u2(attr_count);
 545 
 546   if (generic_signature != NULL) {
 547     write_signature_attribute(symbol_to_cpool_index(generic_signature));
 548   }
 549   if (ikh()->source_file_name() != NULL) {
 550     write_source_file_attribute();
 551   }
 552   if (ikh()->source_debug_extension() != NULL) {
 553     write_source_debug_extension_attribute();
 554   }
 555   if (inner_classes_length > 0) {
 556     write_inner_classes_attribute(inner_classes_length);
 557   }
 558   if (anno.not_null()) {
 559     write_annotations_attribute("RuntimeVisibleAnnotations", anno);
 560   }
 561 }
 562 
 563 // Write the method information portion of ClassFile structure
 564 // JVMSpec|     u2 methods_count;
 565 // JVMSpec|     method_info methods[methods_count];
 566 void JvmtiClassFileReconstituter::write_method_infos() {
 567   HandleMark hm(thread());
 568   objArrayHandle methods(thread(), ikh()->methods());
 569   int num_methods = methods->length();
 570 
 571   write_u2(num_methods);
 572   if (JvmtiExport::can_maintain_original_method_order()) {
 573     int index;
 574     int original_index;
 575     int* method_order = NEW_RESOURCE_ARRAY(int, num_methods);
 576 
 577     // invert the method order mapping
 578     for (index = 0; index < num_methods; index++) {
 579       original_index = ikh()->method_ordering()->int_at(index);
 580       assert(original_index >= 0 && original_index < num_methods,
 581              "invalid original method index");
 582       method_order[original_index] = index;
 583     }
 584 
 585     // write in original order
 586     for (original_index = 0; original_index < num_methods; original_index++) {
 587       index = method_order[original_index];
 588       methodHandle method(thread(), (methodOop)(ikh()->methods()->obj_at(index)));
 589       write_method_info(method);
 590     }
 591   } else {
 592     // method order not preserved just dump the method infos
 593     for (int index = 0; index < num_methods; index++) {
 594       methodHandle method(thread(), (methodOop)(ikh()->methods()->obj_at(index)));
 595       write_method_info(method);
 596     }
 597   }
 598 }
 599 
 600 void JvmtiClassFileReconstituter::write_class_file_format() {
 601   ReallocMark();
 602 
 603   // JVMSpec|   ClassFile {
 604   // JVMSpec|           u4 magic;
 605   write_u4(0xCAFEBABE);
 606 
 607   // JVMSpec|           u2 minor_version;
 608   // JVMSpec|           u2 major_version;
 609   write_u2(ikh()->minor_version());
 610   u2 major = ikh()->major_version();
 611   write_u2(major);
 612 
 613   // JVMSpec|           u2 constant_pool_count;
 614   // JVMSpec|           cp_info constant_pool[constant_pool_count-1];
 615   write_u2(cpool()->length());
 616   copy_cpool_bytes(writeable_address(cpool_size()));
 617 
 618   // JVMSpec|           u2 access_flags;
 619   write_u2(ikh()->access_flags().get_flags() & JVM_RECOGNIZED_CLASS_MODIFIERS);
 620 
 621   // JVMSpec|           u2 this_class;
 622   // JVMSpec|           u2 super_class;
 623   write_u2(class_symbol_to_cpool_index(ikh()->name()));
 624   klassOop super_class = ikh()->super();
 625   write_u2(super_class == NULL? 0 :  // zero for java.lang.Object
 626                 class_symbol_to_cpool_index(super_class->klass_part()->name()));
 627 
 628   // JVMSpec|           u2 interfaces_count;
 629   // JVMSpec|           u2 interfaces[interfaces_count];
 630   objArrayHandle interfaces(thread(), ikh()->local_interfaces());
 631   int num_interfaces = interfaces->length();
 632   write_u2(num_interfaces);
 633   for (int index = 0; index < num_interfaces; index++) {
 634     HandleMark hm(thread());
 635     instanceKlassHandle iikh(thread(), klassOop(interfaces->obj_at(index)));
 636     write_u2(class_symbol_to_cpool_index(iikh->name()));
 637   }
 638 
 639   // JVMSpec|           u2 fields_count;
 640   // JVMSpec|           field_info fields[fields_count];
 641   write_field_infos();
 642 
 643   // JVMSpec|           u2 methods_count;
 644   // JVMSpec|           method_info methods[methods_count];
 645   write_method_infos();
 646 
 647   // JVMSpec|           u2 attributes_count;
 648   // JVMSpec|           attribute_info attributes[attributes_count];
 649   // JVMSpec|   } /* end ClassFile 8?
 650   write_class_attributes();
 651 }
 652 
 653 address JvmtiClassFileReconstituter::writeable_address(size_t size) {
 654   size_t used_size = _buffer_ptr - _buffer;
 655   if (size + used_size >= _buffer_size) {
 656     // compute the new buffer size: must be at least twice as big as before
 657     // plus whatever new is being used; then convert to nice clean block boundary
 658     size_t new_buffer_size = (size + _buffer_size*2 + 1) / initial_buffer_size
 659                                                          * initial_buffer_size;
 660 
 661     // VM goes belly-up if the memory isn't available, so cannot do OOM processing
 662     _buffer = REALLOC_RESOURCE_ARRAY(u1, _buffer, _buffer_size, new_buffer_size);
 663     _buffer_size = new_buffer_size;
 664     _buffer_ptr = _buffer + used_size;
 665   }
 666   u1* ret_ptr = _buffer_ptr;
 667   _buffer_ptr += size;
 668   return ret_ptr;
 669 }
 670 
 671 void JvmtiClassFileReconstituter::write_attribute_name_index(const char* name) {
 672   TempNewSymbol sym = SymbolTable::probe(name, (int)strlen(name));
 673   assert(sym != NULL, "attribute name symbol not found");
 674   u2 attr_name_index = symbol_to_cpool_index(sym);
 675   assert(attr_name_index != 0, "attribute name symbol not in constant pool");
 676   write_u2(attr_name_index);
 677 }
 678 
 679 void JvmtiClassFileReconstituter::write_u1(u1 x) {
 680   *writeable_address(1) = x;
 681 }
 682 
 683 void JvmtiClassFileReconstituter::write_u2(u2 x) {
 684   Bytes::put_Java_u2(writeable_address(2), x);
 685 }
 686 
 687 void JvmtiClassFileReconstituter::write_u4(u4 x) {
 688   Bytes::put_Java_u4(writeable_address(4), x);
 689 }
 690 
 691 void JvmtiClassFileReconstituter::write_u8(u8 x) {
 692   Bytes::put_Java_u8(writeable_address(8), x);
 693 }
 694 
 695 void JvmtiClassFileReconstituter::copy_bytecodes(methodHandle mh,
 696                                                  unsigned char* bytecodes) {
 697   // use a BytecodeStream to iterate over the bytecodes. JVM/fast bytecodes
 698   // and the breakpoint bytecode are converted to their original bytecodes.
 699 
 700   BytecodeStream bs(mh);
 701 
 702   unsigned char* p = bytecodes;
 703   Bytecodes::Code code;
 704   bool is_rewritten = instanceKlass::cast(mh->method_holder())->is_rewritten();
 705 
 706   while ((code = bs.next()) >= 0) {
 707     assert(Bytecodes::is_java_code(code), "sanity check");
 708     assert(code != Bytecodes::_breakpoint, "sanity check");
 709 
 710     // length of bytecode (mnemonic + operands)
 711     address bcp = bs.bcp();
 712     int     len = bs.instruction_size();
 713     assert(len > 0, "length must be > 0");
 714 
 715     // copy the bytecodes
 716     *p = (unsigned char) (bs.is_wide()? Bytecodes::_wide : code);
 717     if (len > 1) {
 718       memcpy(p+1, bcp+1, len-1);
 719     }
 720 
 721     // During linking the get/put and invoke instructions are rewritten
 722     // with an index into the constant pool cache. The original constant
 723     // pool index must be returned to caller.  Rewrite the index.
 724     if (is_rewritten && len >= 3) {
 725       switch (code) {
 726       case Bytecodes::_getstatic       :  // fall through
 727       case Bytecodes::_putstatic       :  // fall through
 728       case Bytecodes::_getfield        :  // fall through
 729       case Bytecodes::_putfield        :  // fall through
 730       case Bytecodes::_invokevirtual   :  // fall through
 731       case Bytecodes::_invokespecial   :  // fall through
 732       case Bytecodes::_invokestatic    :  // fall through
 733       case Bytecodes::_invokedynamic   :  // fall through
 734       case Bytecodes::_invokeinterface :
 735         assert(len == 3 || (code == Bytecodes::_invokeinterface && len ==5),
 736                "sanity check");
 737         int cpci = Bytes::get_native_u2(bcp+1);
 738         bool is_invokedynamic = (EnableInvokeDynamic && code == Bytecodes::_invokedynamic);
 739         if (is_invokedynamic)
 740           cpci = Bytes::get_native_u4(bcp+1);
 741         // cache cannot be pre-fetched since some classes won't have it yet
 742         ConstantPoolCacheEntry* entry =
 743           mh->constants()->cache()->main_entry_at(cpci);
 744         int i = entry->constant_pool_index();
 745         assert(i < mh->constants()->length(), "sanity check");
 746         Bytes::put_Java_u2((address)(p+1), (u2)i);     // java byte ordering
 747         if (is_invokedynamic)  *(p+3) = *(p+4) = 0;
 748         break;
 749       }
 750     }
 751 
 752     p += len;
 753   }
 754 }