jdk8-mips64-public/hotspot: src/share/vm/prims/jvmtiClassFileReconstituter.cpp@1d1603768966

7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
Summary: Update the copyright to be 2010 on all changed files in OpenJDK
Reviewed-by: ohair

     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  */

    25 #include "precompiled.hpp"

    26 #include "classfile/symbolTable.hpp"

    27 #include "interpreter/bytecodeStream.hpp"

    28 #include "prims/jvmtiClassFileReconstituter.hpp"

    29 #include "runtime/signature.hpp"

    30 #ifdef TARGET_ARCH_x86

    31 # include "bytes_x86.hpp"

    32 #endif

    33 #ifdef TARGET_ARCH_sparc

    34 # include "bytes_sparc.hpp"

    35 #endif

    36 #ifdef TARGET_ARCH_zero

    37 # include "bytes_zero.hpp"

    38 #endif

    39 #ifdef TARGET_ARCH_arm

    40 # include "bytes_arm.hpp"

    41 #endif

    42 #ifdef TARGET_ARCH_ppc

    43 # include "bytes_ppc.hpp"

    44 #endif

    45 // FIXME: add Deprecated, LVT, LVTT attributes

    46 // FIXME: fix Synthetic attribute

    47 // FIXME: per Serguei, add error return handling for constantPoolOopDesc::copy_cpool_bytes()

    50 // Write the field information portion of ClassFile structure

    51 // JVMSpec|     u2 fields_count;

    52 // JVMSpec|     field_info fields[fields_count];

    53 void JvmtiClassFileReconstituter::write_field_infos() {

    54   HandleMark hm(thread());

    55   typeArrayHandle fields(thread(), ikh()->fields());

    56   int fields_length = fields->length();

    57   int num_fields = fields_length / instanceKlass::next_offset;

    58   objArrayHandle fields_anno(thread(), ikh()->fields_annotations());

    60   write_u2(num_fields);

    61   for (int index = 0; index < fields_length; index += instanceKlass::next_offset) {

    62     AccessFlags access_flags;

    63     int flags = fields->ushort_at(index + instanceKlass::access_flags_offset);

    64     access_flags.set_flags(flags);

    65     int name_index = fields->ushort_at(index + instanceKlass::name_index_offset);

    66     int signature_index = fields->ushort_at(index + instanceKlass::signature_index_offset);

    67     int initial_value_index = fields->ushort_at(index + instanceKlass::initval_index_offset);

    68     guarantee(name_index != 0 && signature_index != 0, "bad constant pool index for field");

    69     int offset = ikh()->offset_from_fields( index );

    70     int generic_signature_index =

    71                         fields->ushort_at(index + instanceKlass::generic_signature_offset);

    72     typeArrayHandle anno(thread(), fields_anno.not_null() ?

    73                                  (typeArrayOop)(fields_anno->obj_at(index / instanceKlass::next_offset)) :

    74                                  (typeArrayOop)NULL);

    76     // JVMSpec|   field_info {

    77     // JVMSpec|         u2 access_flags;

    78     // JVMSpec|         u2 name_index;

    79     // JVMSpec|         u2 descriptor_index;

    80     // JVMSpec|         u2 attributes_count;

    81     // JVMSpec|         attribute_info attributes[attributes_count];

    82     // JVMSpec|   }

    84     write_u2(flags & JVM_RECOGNIZED_FIELD_MODIFIERS);

    85     write_u2(name_index);

    86     write_u2(signature_index);

    87     int attr_count = 0;

    88     if (initial_value_index != 0) {

    89       ++attr_count;

    90     }

    91     if (access_flags.is_synthetic()) {

    92       // ++attr_count;

    93     }

    94     if (generic_signature_index != 0) {

    95       ++attr_count;

    96     }

    97     if (anno.not_null()) {

    98       ++attr_count;     // has RuntimeVisibleAnnotations attribute

    99     }

   101     write_u2(attr_count);

   103     if (initial_value_index != 0) {

   104       write_attribute_name_index("ConstantValue");

   105       write_u4(2); //length always 2

   106       write_u2(initial_value_index);

   107     }

   108     if (access_flags.is_synthetic()) {

   109       // write_synthetic_attribute();

   110     }

   111     if (generic_signature_index != 0) {

   112       write_signature_attribute(generic_signature_index);

   113     }

   114     if (anno.not_null()) {

   115       write_annotations_attribute("RuntimeVisibleAnnotations", anno);

   116     }

   117   }

   118 }

   120 // Write Code attribute

   121 // JVMSpec|   Code_attribute {

   122 // JVMSpec|     u2 attribute_name_index;

   123 // JVMSpec|     u4 attribute_length;

   124 // JVMSpec|     u2 max_stack;

   125 // JVMSpec|     u2 max_locals;

   126 // JVMSpec|     u4 code_length;

   127 // JVMSpec|     u1 code[code_length];

   128 // JVMSpec|     u2 exception_table_length;

   129 // JVMSpec|     {       u2 start_pc;

   130 // JVMSpec|             u2 end_pc;

   131 // JVMSpec|             u2  handler_pc;

   132 // JVMSpec|             u2  catch_type;

   133 // JVMSpec|     }       exception_table[exception_table_length];

   134 // JVMSpec|     u2 attributes_count;

   135 // JVMSpec|     attribute_info attributes[attributes_count];

   136 // JVMSpec|   }

   137 void JvmtiClassFileReconstituter::write_code_attribute(methodHandle method) {

   138   constMethodHandle const_method(thread(), method->constMethod());

   139   u2 line_num_cnt = 0;

   140   int stackmap_len = 0;

   142   // compute number and length of attributes -- FIXME: for now no LVT

   143   int attr_count = 0;

   144   int attr_size = 0;

   145   if (const_method->has_linenumber_table()) {

   146     line_num_cnt = line_number_table_entries(method);

   147     if (line_num_cnt != 0) {

   148       ++attr_count;

   149       // Compute the complete size of the line number table attribute:

   150       //      LineNumberTable_attribute {

   151       //        u2 attribute_name_index;

   152       //        u4 attribute_length;

   153       //        u2 line_number_table_length;

   154       //        {  u2 start_pc;

   155       //           u2 line_number;

   156       //        } line_number_table[line_number_table_length];

   157       //      }

   158       attr_size += 2 + 4 + 2 + line_num_cnt * (2 + 2);

   159     }

   160   }

   161   if (method->has_stackmap_table()) {

   162     stackmap_len = method->stackmap_data()->length();

   163     if (stackmap_len != 0) {

   164       ++attr_count;

   165       // Compute the  size of the stack map table attribute (VM stores raw):

   166       //      StackMapTable_attribute {

   167       //        u2 attribute_name_index;

   168       //        u4 attribute_length;

   169       //        u2 number_of_entries;

   170       //        stack_map_frame_entries[number_of_entries];

   171       //      }

   172       attr_size += 2 + 4 + stackmap_len;

   173     }

   174   }

   176   typeArrayHandle exception_table(thread(), const_method->exception_table());

   177   int exception_table_length = exception_table->length();

   178   int exception_table_entries = exception_table_length / 4;

   179   int code_size = const_method->code_size();

   180   int size =

   181     2+2+4 +                                // max_stack, max_locals, code_length

   182     code_size +                            // code

   183     2 +                                    // exception_table_length

   184     (2+2+2+2) * exception_table_entries +  // exception_table

   185     2 +                                    // attributes_count

   186     attr_size;                             // attributes

   188   write_attribute_name_index("Code");

   189   write_u4(size);

   190   write_u2(method->max_stack());

   191   write_u2(method->max_locals());

   192   write_u4(code_size);

   193   copy_bytecodes(method, (unsigned char*)writeable_address(code_size));

   194   write_u2(exception_table_entries);

   195   for (int index = 0; index < exception_table_length; ) {

   196     write_u2(exception_table->int_at(index++));

   197     write_u2(exception_table->int_at(index++));

   198     write_u2(exception_table->int_at(index++));

   199     write_u2(exception_table->int_at(index++));

   200   }

   201   write_u2(attr_count);

   202   if (line_num_cnt != 0) {

   203     write_line_number_table_attribute(method, line_num_cnt);

   204   }

   205   if (stackmap_len != 0) {

   206     write_stackmap_table_attribute(method, stackmap_len);

   207   }

   209   // FIXME: write LVT attribute

   210 }

   212 // Write Exceptions attribute

   213 // JVMSpec|   Exceptions_attribute {

   214 // JVMSpec|     u2 attribute_name_index;

   215 // JVMSpec|     u4 attribute_length;

   216 // JVMSpec|     u2 number_of_exceptions;

   217 // JVMSpec|     u2 exception_index_table[number_of_exceptions];

   218 // JVMSpec|   }

   219 void JvmtiClassFileReconstituter::write_exceptions_attribute(constMethodHandle const_method) {

   220   CheckedExceptionElement* checked_exceptions = const_method->checked_exceptions_start();

   221   int checked_exceptions_length = const_method->checked_exceptions_length();

   222   int size =

   223     2 +                                    // number_of_exceptions

   224     2 * checked_exceptions_length;         // exception_index_table

   226   write_attribute_name_index("Exceptions");

   227   write_u4(size);

   228   write_u2(checked_exceptions_length);

   229   for (int index = 0; index < checked_exceptions_length; index++) {

   230     write_u2(checked_exceptions[index].class_cp_index);

   231   }

   232 }

   234 // Write SourceFile attribute

   235 // JVMSpec|   SourceFile_attribute {

   236 // JVMSpec|     u2 attribute_name_index;

   237 // JVMSpec|     u4 attribute_length;

   238 // JVMSpec|     u2 sourcefile_index;

   239 // JVMSpec|   }

   240 void JvmtiClassFileReconstituter::write_source_file_attribute() {

   241   assert(ikh()->source_file_name() != NULL, "caller must check");

   243   write_attribute_name_index("SourceFile");

   244   write_u4(2);  // always length 2

   245   write_u2(symbol_to_cpool_index(ikh()->source_file_name()));

   246 }

   248 // Write SourceDebugExtension attribute

   249 // JSR45|   SourceDebugExtension_attribute {

   250 // JSR45|       u2 attribute_name_index;

   251 // JSR45|       u4 attribute_length;

   252 // JSR45|       u2 sourcefile_index;

   253 // JSR45|   }

   254 void JvmtiClassFileReconstituter::write_source_debug_extension_attribute() {

   255   assert(ikh()->source_debug_extension() != NULL, "caller must check");

   257   write_attribute_name_index("SourceDebugExtension");

   258   write_u4(2);  // always length 2

   259   write_u2(symbol_to_cpool_index(ikh()->source_debug_extension()));

   260 }

   262 // Write (generic) Signature attribute

   263 // JVMSpec|   Signature_attribute {

   264 // JVMSpec|     u2 attribute_name_index;

   265 // JVMSpec|     u4 attribute_length;

   266 // JVMSpec|     u2 signature_index;

   267 // JVMSpec|   }

   268 void JvmtiClassFileReconstituter::write_signature_attribute(u2 generic_signature_index) {

   269   write_attribute_name_index("Signature");

   270   write_u4(2);  // always length 2

   271   write_u2(generic_signature_index);

   272 }

   274 // Compute the number of entries in the InnerClasses attribute

   275 u2 JvmtiClassFileReconstituter::inner_classes_attribute_length() {

   276   typeArrayOop inner_class_list = ikh()->inner_classes();

   277   return (inner_class_list == NULL) ? 0 : inner_class_list->length();

   278 }

   280 // Write an annotation attribute.  The VM stores them in raw form, so all we need

   281 // to do is add the attrubute name and fill in the length.

   282 // JSR202|   *Annotations_attribute {

   283 // JSR202|     u2 attribute_name_index;

   284 // JSR202|     u4 attribute_length;

   285 // JSR202|     ...

   286 // JSR202|   }

   287 void JvmtiClassFileReconstituter::write_annotations_attribute(const char* attr_name,

   288                                                               typeArrayHandle annos) {

   289   u4 length = annos->length();

   290   write_attribute_name_index(attr_name);

   291   write_u4(length);

   292   memcpy(writeable_address(length), annos->byte_at_addr(0), length);

   293 }

   296 // Write InnerClasses attribute

   297 // JVMSpec|   InnerClasses_attribute {

   298 // JVMSpec|     u2 attribute_name_index;

   299 // JVMSpec|     u4 attribute_length;

   300 // JVMSpec|     u2 number_of_classes;

   301 // JVMSpec|     {  u2 inner_class_info_index;

   302 // JVMSpec|        u2 outer_class_info_index;

   303 // JVMSpec|        u2 inner_name_index;

   304 // JVMSpec|        u2 inner_class_access_flags;

   305 // JVMSpec|     } classes[number_of_classes];

   306 // JVMSpec|   }

   307 void JvmtiClassFileReconstituter::write_inner_classes_attribute(int length) {

   308   typeArrayOop inner_class_list = ikh()->inner_classes();

   309   guarantee(inner_class_list != NULL && inner_class_list->length() == length,

   310             "caller must check");

   311   typeArrayHandle inner_class_list_h(thread(), inner_class_list);

   312   assert (length % instanceKlass::inner_class_next_offset == 0, "just checking");

   313   u2 entry_count = length / instanceKlass::inner_class_next_offset;

   314   u4 size = 2 + entry_count * (2+2+2+2);

   316   write_attribute_name_index("InnerClasses");

   317   write_u4(size);

   318   write_u2(entry_count);

   319   for (int i = 0; i < length; i += instanceKlass::inner_class_next_offset) {

   320     write_u2(inner_class_list_h->ushort_at(

   321                       i + instanceKlass::inner_class_inner_class_info_offset));

   322     write_u2(inner_class_list_h->ushort_at(

   323                       i + instanceKlass::inner_class_outer_class_info_offset));

   324     write_u2(inner_class_list_h->ushort_at(

   325                       i + instanceKlass::inner_class_inner_name_offset));

   326     write_u2(inner_class_list_h->ushort_at(

   327                       i + instanceKlass::inner_class_access_flags_offset));

   328   }

   329 }

   331 // Write Synthetic attribute

   332 // JVMSpec|   Synthetic_attribute {

   333 // JVMSpec|     u2 attribute_name_index;

   334 // JVMSpec|     u4 attribute_length;

   335 // JVMSpec|   }

   336 void JvmtiClassFileReconstituter::write_synthetic_attribute() {

   337   write_attribute_name_index("Synthetic");

   338   write_u4(0); //length always zero

   339 }

   341 // Compute size of LineNumberTable

   342 u2 JvmtiClassFileReconstituter::line_number_table_entries(methodHandle method) {

   343   // The line number table is compressed so we don't know how big it is until decompressed.

   344   // Decompression is really fast so we just do it twice.

   345   u2 num_entries = 0;

   346   CompressedLineNumberReadStream stream(method->compressed_linenumber_table());

   347   while (stream.read_pair()) {

   348     num_entries++;

   349   }

   350   return num_entries;

   351 }

   353 // Write LineNumberTable attribute

   354 // JVMSpec|   LineNumberTable_attribute {

   355 // JVMSpec|     u2 attribute_name_index;

   356 // JVMSpec|     u4 attribute_length;

   357 // JVMSpec|     u2 line_number_table_length;

   358 // JVMSpec|     {  u2 start_pc;

   359 // JVMSpec|        u2 line_number;

   360 // JVMSpec|     } line_number_table[line_number_table_length];

   361 // JVMSpec|   }

   362 void JvmtiClassFileReconstituter::write_line_number_table_attribute(methodHandle method,

   363                                                                     u2 num_entries) {

   365   write_attribute_name_index("LineNumberTable");

   366   write_u4(2 + num_entries * (2 + 2));

   367   write_u2(num_entries);

   369   CompressedLineNumberReadStream stream(method->compressed_linenumber_table());

   370   while (stream.read_pair()) {

   371     write_u2(stream.bci());

   372     write_u2(stream.line());

   373   }

   374 }

   376 // Write stack map table attribute

   377 // JSR-202|   StackMapTable_attribute {

   378 // JSR-202|     u2 attribute_name_index;

   379 // JSR-202|     u4 attribute_length;

   380 // JSR-202|     u2 number_of_entries;

   381 // JSR-202|     stack_map_frame_entries[number_of_entries];

   382 // JSR-202|   }

   383 void JvmtiClassFileReconstituter::write_stackmap_table_attribute(methodHandle method,

   384                                                                  int stackmap_len) {

   386   write_attribute_name_index("StackMapTable");

   387   write_u4(stackmap_len);

   388   memcpy(

   389     writeable_address(stackmap_len),

   390     (void*)(method->stackmap_data()->byte_at_addr(0)),

   391     stackmap_len);

   392 }

   394 // Write one method_info structure

   395 // JVMSpec|   method_info {

   396 // JVMSpec|     u2 access_flags;

   397 // JVMSpec|     u2 name_index;

   398 // JVMSpec|     u2 descriptor_index;

   399 // JVMSpec|     u2 attributes_count;

   400 // JVMSpec|     attribute_info attributes[attributes_count];

   401 // JVMSpec|   }

   402 void JvmtiClassFileReconstituter::write_method_info(methodHandle method) {

   403   AccessFlags access_flags = method->access_flags();

   404   constMethodHandle const_method(thread(), method->constMethod());

   405   u2 generic_signature_index = const_method->generic_signature_index();

   406   typeArrayHandle anno(thread(), method->annotations());

   407   typeArrayHandle param_anno(thread(), method->parameter_annotations());

   408   typeArrayHandle default_anno(thread(), method->annotation_default());

   410   write_u2(access_flags.get_flags() & JVM_RECOGNIZED_METHOD_MODIFIERS);

   411   write_u2(const_method->name_index());

   412   write_u2(const_method->signature_index());

   414   // write attributes in the same order javac does, so we can test with byte for

   415   // byte comparison

   416   int attr_count = 0;

   417   if (const_method->code_size() != 0) {

   418     ++attr_count;     // has Code attribute

   419   }

   420   if (const_method->has_checked_exceptions()) {

   421     ++attr_count;     // has Exceptions attribute

   422   }

   423   if (default_anno.not_null()) {

   424     ++attr_count;     // has AnnotationDefault attribute

   425   }

   426   // Deprecated attribute would go here

   427   if (access_flags.is_synthetic()) { // FIXME

   428     // ++attr_count;

   429   }

   430   if (generic_signature_index != 0) {

   431     ++attr_count;

   432   }

   433   if (anno.not_null()) {

   434     ++attr_count;     // has RuntimeVisibleAnnotations attribute

   435   }

   436   if (param_anno.not_null()) {

   437     ++attr_count;     // has RuntimeVisibleParameterAnnotations attribute

   438   }

   440   write_u2(attr_count);

   441   if (const_method->code_size() > 0) {

   442     write_code_attribute(method);

   443   }

   444   if (const_method->has_checked_exceptions()) {

   445     write_exceptions_attribute(const_method);

   446   }

   447   if (default_anno.not_null()) {

   448     write_annotations_attribute("AnnotationDefault", default_anno);

   449   }

   450   // Deprecated attribute would go here

   451   if (access_flags.is_synthetic()) {

   452     // write_synthetic_attribute();

   453   }

   454   if (generic_signature_index != 0) {

   455     write_signature_attribute(generic_signature_index);

   456   }

   457   if (anno.not_null()) {

   458     write_annotations_attribute("RuntimeVisibleAnnotations", anno);

   459   }

   460   if (param_anno.not_null()) {

   461     write_annotations_attribute("RuntimeVisibleParameterAnnotations", param_anno);

   462   }

   463 }

   465 // Write the class attributes portion of ClassFile structure

   466 // JVMSpec|     u2 attributes_count;

   467 // JVMSpec|     attribute_info attributes[attributes_count];

   468 void JvmtiClassFileReconstituter::write_class_attributes() {

   469   u2 inner_classes_length = inner_classes_attribute_length();

   470   Symbol* generic_signature = ikh()->generic_signature();

   471   typeArrayHandle anno(thread(), ikh()->class_annotations());

   473   int attr_count = 0;

   474   if (generic_signature != NULL) {

   475     ++attr_count;

   476   }

   477   if (ikh()->source_file_name() != NULL) {

   478     ++attr_count;

   479   }

   480   if (ikh()->source_debug_extension() != NULL) {

   481     ++attr_count;

   482   }

   483   if (inner_classes_length > 0) {

   484     ++attr_count;

   485   }

   486   if (anno.not_null()) {

   487     ++attr_count;     // has RuntimeVisibleAnnotations attribute

   488   }

   490   write_u2(attr_count);

   492   if (generic_signature != NULL) {

   493     write_signature_attribute(symbol_to_cpool_index(generic_signature));

   494   }

   495   if (ikh()->source_file_name() != NULL) {

   496     write_source_file_attribute();

   497   }

   498   if (ikh()->source_debug_extension() != NULL) {

   499     write_source_debug_extension_attribute();

   500   }

   501   if (inner_classes_length > 0) {

   502     write_inner_classes_attribute(inner_classes_length);

   503   }

   504   if (anno.not_null()) {

   505     write_annotations_attribute("RuntimeVisibleAnnotations", anno);

   506   }

   507 }

   509 // Write the method information portion of ClassFile structure

   510 // JVMSpec|     u2 methods_count;

   511 // JVMSpec|     method_info methods[methods_count];

   512 void JvmtiClassFileReconstituter::write_method_infos() {

   513   HandleMark hm(thread());

   514   objArrayHandle methods(thread(), ikh()->methods());

   515   int num_methods = methods->length();

   517   write_u2(num_methods);

   518   if (JvmtiExport::can_maintain_original_method_order()) {

   519     int index;

   520     int original_index;

   521     int* method_order = NEW_RESOURCE_ARRAY(int, num_methods);

   523     // invert the method order mapping

   524     for (index = 0; index < num_methods; index++) {

   525       original_index = ikh()->method_ordering()->int_at(index);

   526       assert(original_index >= 0 && original_index < num_methods,

   527              "invalid original method index");

   528       method_order[original_index] = index;

   529     }

   531     // write in original order

   532     for (original_index = 0; original_index < num_methods; original_index++) {

   533       index = method_order[original_index];

   534       methodHandle method(thread(), (methodOop)(ikh()->methods()->obj_at(index)));

   535       write_method_info(method);

   536     }

   537   } else {

   538     // method order not preserved just dump the method infos

   539     for (int index = 0; index < num_methods; index++) {

   540       methodHandle method(thread(), (methodOop)(ikh()->methods()->obj_at(index)));

   541       write_method_info(method);

   542     }

   543   }

   544 }

   546 void JvmtiClassFileReconstituter::write_class_file_format() {

   547   ReallocMark();

   549   // JVMSpec|   ClassFile {

   550   // JVMSpec|           u4 magic;

   551   write_u4(0xCAFEBABE);

   553   // JVMSpec|           u2 minor_version;

   554   // JVMSpec|           u2 major_version;

   555   write_u2(ikh()->minor_version());

   556   u2 major = ikh()->major_version();

   557   write_u2(major);

   559   // JVMSpec|           u2 constant_pool_count;

   560   // JVMSpec|           cp_info constant_pool[constant_pool_count-1];

   561   write_u2(cpool()->length());

   562   copy_cpool_bytes(writeable_address(cpool_size()));

   564   // JVMSpec|           u2 access_flags;

   565   write_u2(ikh()->access_flags().get_flags() & JVM_RECOGNIZED_CLASS_MODIFIERS);

   567   // JVMSpec|           u2 this_class;

   568   // JVMSpec|           u2 super_class;

   569   write_u2(class_symbol_to_cpool_index(ikh()->name()));

   570   klassOop super_class = ikh()->super();

   571   write_u2(super_class == NULL? 0 :  // zero for java.lang.Object

   572                 class_symbol_to_cpool_index(super_class->klass_part()->name()));

   574   // JVMSpec|           u2 interfaces_count;

   575   // JVMSpec|           u2 interfaces[interfaces_count];

   576   objArrayHandle interfaces(thread(), ikh()->local_interfaces());

   577   int num_interfaces = interfaces->length();

   578   write_u2(num_interfaces);

   579   for (int index = 0; index < num_interfaces; index++) {

   580     HandleMark hm(thread());

   581     instanceKlassHandle iikh(thread(), klassOop(interfaces->obj_at(index)));

   582     write_u2(class_symbol_to_cpool_index(iikh->name()));

   583   }

   585   // JVMSpec|           u2 fields_count;

   586   // JVMSpec|           field_info fields[fields_count];

   587   write_field_infos();

   589   // JVMSpec|           u2 methods_count;

   590   // JVMSpec|           method_info methods[methods_count];

   591   write_method_infos();

   593   // JVMSpec|           u2 attributes_count;

   594   // JVMSpec|           attribute_info attributes[attributes_count];

   595   // JVMSpec|   } /* end ClassFile 8?

   596   write_class_attributes();

   597 }

   599 address JvmtiClassFileReconstituter::writeable_address(size_t size) {

   600   size_t used_size = _buffer_ptr - _buffer;

   601   if (size + used_size >= _buffer_size) {

   602     // compute the new buffer size: must be at least twice as big as before

   603     // plus whatever new is being used; then convert to nice clean block boundary

   604     size_t new_buffer_size = (size + _buffer_size*2 + 1) / initial_buffer_size

   605                                                          * initial_buffer_size;

   607     // VM goes belly-up if the memory isn't available, so cannot do OOM processing

   608     _buffer = REALLOC_RESOURCE_ARRAY(u1, _buffer, _buffer_size, new_buffer_size);

   609     _buffer_size = new_buffer_size;

   610     _buffer_ptr = _buffer + used_size;

   611   }

   612   u1* ret_ptr = _buffer_ptr;

   613   _buffer_ptr += size;

   614   return ret_ptr;

   615 }

   617 void JvmtiClassFileReconstituter::write_attribute_name_index(const char* name) {

   618   TempNewSymbol sym = SymbolTable::probe(name, (int)strlen(name));

   619   assert(sym != NULL, "attribute name symbol not found");

   620   u2 attr_name_index = symbol_to_cpool_index(sym);

   621   assert(attr_name_index != 0, "attribute name symbol not in constant pool");

   622   write_u2(attr_name_index);

   623 }

   625 void JvmtiClassFileReconstituter::write_u1(u1 x) {

   626   *writeable_address(1) = x;

   627 }

   629 void JvmtiClassFileReconstituter::write_u2(u2 x) {

   630   Bytes::put_Java_u2(writeable_address(2), x);

   631 }

   633 void JvmtiClassFileReconstituter::write_u4(u4 x) {

   634   Bytes::put_Java_u4(writeable_address(4), x);

   635 }

   637 void JvmtiClassFileReconstituter::write_u8(u8 x) {

   638   Bytes::put_Java_u8(writeable_address(8), x);

   639 }

   641 void JvmtiClassFileReconstituter::copy_bytecodes(methodHandle mh,

   642                                                  unsigned char* bytecodes) {

   643   // use a BytecodeStream to iterate over the bytecodes. JVM/fast bytecodes

   644   // and the breakpoint bytecode are converted to their original bytecodes.

   646   BytecodeStream bs(mh);

   648   unsigned char* p = bytecodes;

   649   Bytecodes::Code code;

   650   bool is_rewritten = instanceKlass::cast(mh->method_holder())->is_rewritten();

   652   while ((code = bs.next()) >= 0) {

   653     assert(Bytecodes::is_java_code(code), "sanity check");

   654     assert(code != Bytecodes::_breakpoint, "sanity check");

   656     // length of bytecode (mnemonic + operands)

   657     address bcp = bs.bcp();

   658     int     len = bs.instruction_size();

   659     assert(len > 0, "length must be > 0");

   661     // copy the bytecodes

   662     *p = (unsigned char) (bs.is_wide()? Bytecodes::_wide : code);

   663     if (len > 1) {

   664       memcpy(p+1, bcp+1, len-1);

   665     }

   667     // During linking the get/put and invoke instructions are rewritten

   668     // with an index into the constant pool cache. The original constant

   669     // pool index must be returned to caller.  Rewrite the index.

   670     if (is_rewritten && len >= 3) {

   671       switch (code) {

   672       case Bytecodes::_getstatic       :  // fall through

   673       case Bytecodes::_putstatic       :  // fall through

   674       case Bytecodes::_getfield        :  // fall through

   675       case Bytecodes::_putfield        :  // fall through

   676       case Bytecodes::_invokevirtual   :  // fall through

   677       case Bytecodes::_invokespecial   :  // fall through

   678       case Bytecodes::_invokestatic    :  // fall through

   679       case Bytecodes::_invokedynamic   :  // fall through

   680       case Bytecodes::_invokeinterface :

   681         assert(len == 3 || (code == Bytecodes::_invokeinterface && len ==5),

   682                "sanity check");

   683         int cpci = Bytes::get_native_u2(bcp+1);

   684         bool is_invokedynamic = (EnableInvokeDynamic && code == Bytecodes::_invokedynamic);

   685         if (is_invokedynamic)

   686           cpci = Bytes::get_native_u4(bcp+1);

   687         // cache cannot be pre-fetched since some classes won't have it yet

   688         ConstantPoolCacheEntry* entry =

   689           mh->constants()->cache()->main_entry_at(cpci);

   690         int i = entry->constant_pool_index();

   691         assert(i < mh->constants()->length(), "sanity check");

   692         Bytes::put_Java_u2((address)(p+1), (u2)i);     // java byte ordering

   693         if (is_invokedynamic)  *(p+3) = *(p+4) = 0;

   694         break;

   695       }

   696     }

   698     p += len;

   699   }

   700 }

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/prims/jvmtiClassFileReconstituter.cpp@1d1603768966

src/share/vm/prims/jvmtiClassFileReconstituter.cpp