1 /*

     2  * Copyright (c) 2016, 2018, 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 "jvm.h"

    27 #include "classfile/classFileParser.hpp"

    28 #include "classfile/classFileStream.hpp"

    29 #include "classfile/javaClasses.inline.hpp"

    30 #include "classfile/stackMapTable.hpp"

    31 #include "classfile/verificationType.hpp"

    32 #include "interpreter/bytecodes.hpp"

    33 #include "jfr/instrumentation/jfrEventClassTransformer.hpp"

    34 #include "jfr/jfr.hpp"

    35 #include "jfr/jni/jfrJavaSupport.hpp"

    36 #include "jfr/jni/jfrUpcalls.hpp"

    37 #include "jfr/support/jfrEventClass.hpp"

    38 #include "jfr/utilities/jfrBigEndian.hpp"

    39 #include "jfr/writers/jfrBigEndianWriter.hpp"

    40 #include "logging/log.hpp"

    41 #include "memory/allocation.inline.hpp"

    42 #include "memory/resourceArea.hpp"

    43 #include "oops/array.hpp"

    44 #include "oops/instanceKlass.hpp"

    45 #include "oops/method.hpp"

    46 #include "prims/jvmtiRedefineClasses.hpp"

    47 #include "runtime/handles.inline.hpp"

    48 #include "runtime/os.hpp"

    49 #include "runtime/thread.inline.hpp"

    50 #include "utilities/exceptions.hpp"

    51 #include "utilities/globalDefinitions.hpp"

    52 #include "utilities/macros.hpp"

    53 

    54 static const u2 number_of_new_methods = 5;

    55 static const u2 number_of_new_fields = 3;

    56 static const int extra_stream_bytes = 0x280;

    57 static const u2 invalid_cp_index = 0;

    58 

    59 static const char* utf8_constants[] = {

    60   "Code",         // 0

    61   "J",            // 1

    62   "commit",       // 2

    63   "eventHandler", // 3

    64   "Ljdk/jfr/internal/handlers/EventHandler;", // 4

    65   "duration",     // 5

    66   "begin",        // 6

    67   "()V",          // 7

    68   "isEnabled",    // 8

    69   "()Z",          // 9

    70   "end",          // 10

    71   "shouldCommit", // 11

    72   "startTime",    // 12

    73   "<clinit>",     // 13

    74   "jdk/jfr/FlightRecorder", // 14

    75   "register", // 15

    76   "(Ljava/lang/Class;)V", // 16 // LAST_REQUIRED_UTF8

    77   "StackMapTable", // 17

    78   "Exceptions", // 18

    79   "LineNumberTable", // 20

    80   "LocalVariableTable", // 21

    81   "LocalVariableTypeTable", // 22

    82   "RuntimeVisibleAnnotation" // 23

    83 };

    84 

    85 enum utf8_req_symbols {

    86   UTF8_REQ_Code,

    87   UTF8_REQ_J_FIELD_DESC,

    88   UTF8_REQ_commit,

    89   UTF8_REQ_eventHandler,

    90   UTF8_REQ_eventHandler_FIELD_DESC,

    91   UTF8_REQ_duration,

    92   UTF8_REQ_begin,

    93   UTF8_REQ_EMPTY_VOID_METHOD_DESC,

    94   UTF8_REQ_isEnabled,

    95   UTF8_REQ_EMPTY_BOOLEAN_METHOD_DESC,

    96   UTF8_REQ_end,

    97   UTF8_REQ_shouldCommit,

    98   UTF8_REQ_startTime,

    99   UTF8_REQ_clinit,

   100   UTF8_REQ_FlightRecorder,

   101   UTF8_REQ_register,

   102   UTF8_REQ_CLASS_VOID_METHOD_DESC,

   103   NOF_UTF8_REQ_SYMBOLS

   104 };

   105 

   106 enum utf8_opt_symbols {

   107   UTF8_OPT_StackMapTable = NOF_UTF8_REQ_SYMBOLS,

   108   UTF8_OPT_Exceptions,

   109   UTF8_OPT_LineNumberTable,

   110   UTF8_OPT_LocalVariableTable,

   111   UTF8_OPT_LocalVariableTypeTable,

   112   UTF8_OPT_RuntimeVisibleAnnotation,

   113   NOF_UTF8_SYMBOLS

   114 };

   115 

   116 static u1 empty_void_method_code_attribute[] = {

   117   0x0,

   118   0x0,

   119   0x0,

   120   0xd, // attribute len

   121   0x0,

   122   0x0, // max stack

   123   0x0,

   124   0x1, // max locals

   125   0x0,

   126   0x0,

   127   0x0,

   128   0x1, // code length

   129   Bytecodes::_return,

   130   0x0,

   131   0x0, // ex table len

   132   0x0,

   133   0x0  // attributes_count

   134 };

   135 

   136 static u1 boolean_method_code_attribute[] = {

   137   0x0,

   138   0x0,

   139   0x0,

   140   0xe,

   141   0x0,

   142   0x1, // max stack

   143   0x0,

   144   0x1, // max locals

   145   0x0,

   146   0x0,

   147   0x0,

   148   0x2,

   149   Bytecodes::_iconst_0,

   150   Bytecodes::_ireturn,

   151   0x0,

   152   0x0, // ex table len

   153   0x0,

   154   0x0, // attributes_count

   155 };

   156 

   157 // annotation processing support

   158 

   159 enum {  // initial annotation layout

   160   atype_off = 0,      // utf8 such as 'Ljava/lang/annotation/Retention;'

   161   count_off = 2,      // u2   such as 1 (one value)

   162   member_off = 4,     // utf8 such as 'value'

   163   tag_off = 6,        // u1   such as 'c' (type) or 'e' (enum)

   164   e_tag_val = 'e',

   165   e_type_off = 7,   // utf8 such as 'Ljava/lang/annotation/RetentionPolicy;'

   166   e_con_off = 9,    // utf8 payload, such as 'SOURCE', 'CLASS', 'RUNTIME'

   167   e_size = 11,     // end of 'e' annotation

   168   c_tag_val = 'c',    // payload is type

   169   c_con_off = 7,    // utf8 payload, such as 'I'

   170   c_size = 9,       // end of 'c' annotation

   171   s_tag_val = 's',    // payload is String

   172   s_con_off = 7,    // utf8 payload, such as 'Ljava/lang/String;'

   173   s_size = 9,

   174   min_size = 6        // smallest possible size (zero members)

   175 };

   176 

   177 static int skip_annotation_value(const address, int, int); // fwd decl

   178 

   179 // Skip an annotation.  Return >=limit if there is any problem.

   180 static int next_annotation_index(const address buffer, int limit, int index) {

   181   assert(buffer != NULL, "invariant");

   182   index += 2;  // skip atype

   183   if ((index += 2) >= limit) {

   184     return limit;

   185   }

   186   int nof_members = JfrBigEndian::read<u2>(buffer + index - 2);

   187   while (--nof_members >= 0 && index < limit) {

   188     index += 2; // skip member

   189     index = skip_annotation_value(buffer, limit, index);

   190   }

   191   return index;

   192 }

   193 

   194 // Skip an annotation value.  Return >=limit if there is any problem.

   195 static int skip_annotation_value(const address buffer, int limit, int index) {

   196   assert(buffer != NULL, "invariant");

   197   // value := switch (tag:u1) {

   198   //   case B, C, I, S, Z, D, F, J, c: con:u2;

   199   //   case e: e_class:u2 e_name:u2;

   200   //   case s: s_con:u2;

   201   //   case [: do(nval:u2) {value};

   202   //   case @: annotation;

   203   //   case s: s_con:u2;

   204   // }

   205   if ((index += 1) >= limit) {

   206     return limit;

   207   }

   208   const u1 tag = buffer[index - 1];

   209   switch (tag) {

   210     case 'B':

   211     case 'C':

   212     case 'I':

   213     case 'S':

   214     case 'Z':

   215     case 'D':

   216     case 'F':

   217     case 'J':

   218     case 'c':

   219     case 's':

   220       index += 2;  // skip con or s_con

   221       break;

   222     case 'e':

   223       index += 4;  // skip e_class, e_name

   224       break;

   225     case '[':

   226       {

   227         if ((index += 2) >= limit) {

   228           return limit;

   229         }

   230         int nof_values = JfrBigEndian::read<u2>(buffer + index - 2);

   231         while (--nof_values >= 0 && index < limit) {

   232           index = skip_annotation_value(buffer, limit, index);

   233         }

   234       }

   235       break;

   236     case '@':

   237       index = next_annotation_index(buffer, limit, index);

   238       break;

   239     default:

   240       return limit;  //  bad tag byte

   241   }

   242   return index;

   243 }

   244 

   245 static const u2 number_of_elements_offset = (u2)2;

   246 static const u2 element_name_offset = (u2)(number_of_elements_offset + 2);

   247 static const u2 element_name_size = (u2)2;

   248 static const u2 value_type_relative_offset = (u2)2;

   249 static const u2 value_relative_offset = (u2)(value_type_relative_offset + 1);

   250 

   251 // see JVMS - 4.7.16. The RuntimeVisibleAnnotations Attribute

   252 

   253 class AnnotationElementIterator : public StackObj {

   254  private:

   255   const InstanceKlass* _ik;

   256   const address _buffer;

   257   const u2 _limit; // length of annotation

   258   mutable u2 _current; // element

   259   mutable u2 _next; // element

   260   u2 value_index() const {

   261     return JfrBigEndian::read<u2>(_buffer + _current + value_relative_offset);

   262   }

   263 

   264  public:

   265   AnnotationElementIterator(const InstanceKlass* ik, address buffer, u2 limit) : _ik(ik),

   266                                                                                  _buffer(buffer),

   267                                                                                  _limit(limit),

   268                                                                                  _next(element_name_offset),

   269                                                                                  _current(element_name_offset) {

   270     assert(_buffer != NULL, "invariant");

   271     assert(_next == element_name_offset, "invariant");

   272     assert(_current == element_name_offset, "invariant");

   273   }

   274 

   275   bool has_next() const {

   276     return _next < _limit;

   277   }

   278 

   279   void move_to_next() const {

   280     assert(has_next(), "invariant");

   281     _current = _next;

   282     if (_next < _limit) {

   283       _next = skip_annotation_value(_buffer, _limit, _next + element_name_size);

   284     }

   285     assert(_next <= _limit, "invariant");

   286     assert(_current <= _limit, "invariant");

   287   }

   288 

   289   u2 number_of_elements() const {

   290     return JfrBigEndian::read<u2>(_buffer + number_of_elements_offset);

   291   }

   292 

   293   const Symbol* name() const {

   294     assert(_current < _next, "invariant");

   295     return _ik->constants()->symbol_at(JfrBigEndian::read<u2>(_buffer + _current));

   296   }

   297 

   298   char value_type() const {

   299     return JfrBigEndian::read<u1>(_buffer + _current + value_type_relative_offset);

   300   }

   301 

   302   jint read_int() const {

   303     return _ik->constants()->int_at(value_index());

   304   }

   305 

   306   bool read_bool() const {

   307     return read_int() != 0;

   308   }

   309 };

   310 

   311 class AnnotationIterator : public StackObj {

   312  private:

   313   const InstanceKlass* _ik;

   314   // ensure _limit field is declared before _buffer

   315   u2 _limit; // length of annotations array

   316   const address _buffer;

   317   mutable u2 _current; // annotation

   318   mutable u2 _next; // annotation

   319 

   320  public:

   321   AnnotationIterator(const InstanceKlass* ik, AnnotationArray* ar) : _ik(ik),

   322                                                                      _current(0),

   323                                                                      _next(0),

   324                                                                      _limit(ar != NULL ? ar->length() : 0),

   325                                                                      _buffer(_limit > 2 ? ar->adr_at(2) : NULL) {

   326     if (_buffer != NULL) {

   327       _limit -= 2; // subtract sizeof(u2) number of annotations field

   328     }

   329   }

   330   bool has_next() const {

   331     return _next < _limit;

   332   }

   333 

   334   void move_to_next() const {

   335     assert(has_next(), "invariant");

   336     _current = _next;

   337     if (_next < _limit) {

   338       _next = next_annotation_index(_buffer, _limit, _next);

   339     }

   340     assert(_next <= _limit, "invariant");

   341     assert(_current <= _limit, "invariant");

   342   }

   343   const AnnotationElementIterator elements() const {

   344     assert(_current < _next, "invariant");

   345     return AnnotationElementIterator(_ik, _buffer + _current, _next - _current);

   346   }

   347   const Symbol* type() const {

   348     assert(_buffer != NULL, "invariant");

   349     assert(_current < _limit, "invariant");

   350     return _ik->constants()->symbol_at(JfrBigEndian::read<u2>(_buffer + _current));

   351   }

   352 };

   353 

   354 static unsigned int unused_hash = 0;

   355 static const char value_name[] = "value";

   356 static bool has_registered_annotation(const InstanceKlass* ik, const Symbol* annotation_type, bool& value) {

   357   assert(annotation_type != NULL, "invariant");

   358   AnnotationArray* class_annotations = ik->class_annotations();

   359   if (class_annotations == NULL) {

   360     return false;

   361   }

   362 

   363   const AnnotationIterator annotation_iterator(ik, class_annotations);

   364   while (annotation_iterator.has_next()) {

   365     annotation_iterator.move_to_next();

   366     if (annotation_iterator.type() == annotation_type) {

   367       // target annotation found

   368       static const Symbol* value_symbol =

   369         SymbolTable::lookup_only(value_name, sizeof value_name - 1, unused_hash);

   370       assert(value_symbol != NULL, "invariant");

   371       const AnnotationElementIterator element_iterator = annotation_iterator.elements();

   372       while (element_iterator.has_next()) {

   373         element_iterator.move_to_next();

   374         if (value_symbol == element_iterator.name()) {

   375           // "value" element

   376           assert('Z' == element_iterator.value_type(), "invariant");

   377           value = element_iterator.read_bool();

   378           return true;

   379         }

   380       }

   381     }

   382   }

   383   return false;

   384 }

   385 

   386 static bool registered_annotation_value(const InstanceKlass* ik, const Symbol* const registered_symbol) {

   387   assert(registered_symbol != NULL, "invariant");

   388   assert(ik != NULL, "invariant");

   389   assert(JdkJfrEvent::is_a(ik), "invariant");

   390   bool registered_value = false;

   391   if (has_registered_annotation(ik, registered_symbol, registered_value)) {

   392     return registered_value;

   393   }

   394   InstanceKlass* super = InstanceKlass::cast(ik->super());

   395   return registered_annotation_value(super, registered_symbol);

   396 }

   397 

   398 static const char registered_constant[] = "Ljdk/jfr/Registered;";

   399 

   400 // Evaluate to the value of the first found "Ljdk/jfr/Registered;" annotation.

   401 // Searching moves upwards in the klass hierarchy in order to support

   402 // inherited annotations in addition to the ability to override.

   403 static bool should_register_klass(const InstanceKlass* ik) {

   404   static const Symbol* const registered_symbol = SymbolTable::lookup_only(registered_constant,

   405                                                                           sizeof registered_constant - 1,

   406                                                                           unused_hash);

   407   assert(registered_symbol != NULL, "invariant");

   408   return registered_annotation_value(ik, registered_symbol);

   409 }

   410 /*

   411  * Map an utf8 constant back to its CONSTANT_UTF8_INFO

   412  */

   413 static u2 utf8_info_index(const InstanceKlass* ik, const Symbol* const target, TRAPS) {

   414   assert(target != NULL, "invariant");

   415   const ConstantPool* cp = ik->constants();

   416   const int cp_len = cp->length();

   417   for (u2 index = 1; index < cp_len; ++index) {

   418     const constantTag tag = cp->tag_at(index);

   419     if (tag.is_utf8()) {

   420       const Symbol* const utf8_sym = cp->symbol_at(index);

   421       assert(utf8_sym != NULL, "invariant");

   422       if (utf8_sym == target) {

   423         return index;

   424       }

   425     }

   426   }

   427   // not in constant pool

   428   return invalid_cp_index;

   429 }

   430 

   431 #ifdef ASSERT

   432 static bool is_index_within_range(u2 index, u2 orig_cp_len, u2 new_cp_entries_len) {

   433   return index > 0 && index < orig_cp_len + new_cp_entries_len;

   434 }

   435 #endif

   436 

   437 static u2 add_utf8_info(JfrBigEndianWriter& writer, const char* utf8_constant, u2 orig_cp_len, u2& new_cp_entries_len) {

   438   assert(utf8_constant != NULL, "invariant");

   439   writer.write<u1>(JVM_CONSTANT_Utf8);

   440   writer.write_utf8_u2_len(utf8_constant);

   441   assert(writer.is_valid(), "invariant");

   442   // return index for the added utf8 info

   443   return orig_cp_len + new_cp_entries_len++;

   444 }

   445 

   446 static u2 add_method_ref_info(JfrBigEndianWriter& writer,

   447                               u2 cls_name_index,

   448                               u2 method_index,

   449                               u2 desc_index,

   450                               u2 orig_cp_len,

   451                               u2& number_of_new_constants,

   452                               TRAPS) {

   453   assert(is_index_within_range(cls_name_index, orig_cp_len, number_of_new_constants), "invariant");

   454   assert(is_index_within_range(method_index, orig_cp_len, number_of_new_constants), "invariant");

   455   assert(is_index_within_range(desc_index, orig_cp_len, number_of_new_constants), "invariant");

   456   writer.write<u1>(JVM_CONSTANT_Class);

   457   writer.write<u2>(cls_name_index);

   458   const u2 cls_entry_index = orig_cp_len + number_of_new_constants;

   459   ++number_of_new_constants;

   460   writer.write<u1>(JVM_CONSTANT_NameAndType);

   461   writer.write<u2>(method_index);

   462   writer.write<u2>(desc_index);

   463   const u2 nat_entry_index = orig_cp_len + number_of_new_constants;

   464   ++number_of_new_constants;

   465   writer.write<u1>(JVM_CONSTANT_Methodref);

   466   writer.write<u2>(cls_entry_index);

   467   writer.write<u2>(nat_entry_index);

   468   // post-increment number_of_new_constants

   469   // value returned is the index to the added method_ref

   470   return orig_cp_len + number_of_new_constants++;

   471 }

   472 

   473 static u2 add_flr_register_method_constants(JfrBigEndianWriter& writer,

   474                                             const u2* utf8_indexes,

   475                                             u2 orig_cp_len,

   476                                             u2& number_of_new_constants,

   477                                             TRAPS) {

   478   assert(utf8_indexes != NULL, "invariant");

   479   return add_method_ref_info(writer,

   480                              utf8_indexes[UTF8_REQ_FlightRecorder],

   481                              utf8_indexes[UTF8_REQ_register],

   482                              utf8_indexes[UTF8_REQ_CLASS_VOID_METHOD_DESC],

   483                              orig_cp_len,

   484                              number_of_new_constants,

   485                              THREAD);

   486 }

   487 

   488 /*

   489  * field_info {

   490  *   u2             access_flags;

   491  *   u2             name_index;

   492  *   u2             descriptor_index;

   493  *   u2             attributes_count;

   494  *   attribute_info attributes[attributes_count];

   495  * }

   496  */

   497 static jlong add_field_info(JfrBigEndianWriter& writer, u2 name_index, u2 desc_index, bool is_static = false) {

   498   assert(name_index > 0, "invariant");

   499   assert(desc_index > 0, "invariant");

   500   DEBUG_ONLY(const jlong start_offset = writer.current_offset();)

   501   writer.write<u2>(JVM_ACC_SYNTHETIC | JVM_ACC_PRIVATE | (is_static ? JVM_ACC_STATIC : JVM_ACC_TRANSIENT)); // flags

   502   writer.write(name_index);

   503   writer.write(desc_index);

   504   writer.write((u2)0x0); // attributes_count

   505   assert(writer.is_valid(), "invariant");

   506   DEBUG_ONLY(assert(start_offset + 8 == writer.current_offset(), "invariant");)

   507   return writer.current_offset();

   508 }

   509 

   510 static u2 add_field_infos(JfrBigEndianWriter& writer, const u2* utf8_indexes) {

   511   assert(utf8_indexes != NULL, "invariant");

   512   add_field_info(writer,

   513                  utf8_indexes[UTF8_REQ_eventHandler],

   514                  utf8_indexes[UTF8_REQ_eventHandler_FIELD_DESC],

   515                  true); // static

   516 

   517   add_field_info(writer,

   518                  utf8_indexes[UTF8_REQ_startTime],

   519                  utf8_indexes[UTF8_REQ_J_FIELD_DESC]);

   520 

   521   add_field_info(writer,

   522                  utf8_indexes[UTF8_REQ_duration],

   523                  utf8_indexes[UTF8_REQ_J_FIELD_DESC]);

   524 

   525   return number_of_new_fields;

   526 }

   527 

   528 /*

   529  * method_info {

   530  *  u2             access_flags;

   531  *  u2             name_index;

   532  *  u2             descriptor_index;

   533  *  u2             attributes_count;

   534  *  attribute_info attributes[attributes_count];

   535  * }

   536  *

   537  * Code_attribute {

   538  *   u2 attribute_name_index;

   539  *   u4 attribute_length;

   540  *   u2 max_stack;

   541  *   u2 max_locals;

   542  *   u4 code_length;

   543  *   u1 code[code_length];

   544  *   u2 exception_table_length;

   545  *   {   u2 start_pc;

   546  *       u2 end_pc;

   547  *       u2 handler_pc;

   548  *       u2 catch_type;

   549  *   } exception_table[exception_table_length];

   550  *   u2 attributes_count;

   551  *   attribute_info attributes[attributes_count];

   552  * }

   553  */

   554 

   555 static jlong add_method_info(JfrBigEndianWriter& writer,

   556                              u2 name_index,

   557                              u2 desc_index,

   558                              u2 code_index,

   559                              const u1* const code,

   560                              const size_t code_len) {

   561   assert(name_index > 0, "invariant");

   562   assert(desc_index > 0, "invariant");

   563   assert(code_index > 0, "invariant");

   564   DEBUG_ONLY(const jlong start_offset = writer.current_offset();)

   565   writer.write<u2>(JVM_ACC_SYNTHETIC | JVM_ACC_PUBLIC); // flags

   566   writer.write(name_index);

   567   writer.write(desc_index);

   568   writer.write<u2>(0x1); // attributes_count ; 1 for "Code" attribute

   569   assert(writer.is_valid(), "invariant");

   570   DEBUG_ONLY(assert(start_offset + 8 == writer.current_offset(), "invariant");)

   571   // Code attribute

   572   writer.write(code_index); // "Code"

   573   writer.bytes(code, code_len);

   574   DEBUG_ONLY(assert((start_offset + 8 + 2 + (jlong)code_len) == writer.current_offset(), "invariant");)

   575   return writer.current_offset();

   576 }

   577 

   578 /*

   579  * On return, the passed stream will be positioned

   580  * just after the constant pool section in the classfile

   581  * and the cp length is returned.

   582  *

   583  * Stream should come in at the start position.

   584  */

   585 static u2 position_stream_after_cp(const ClassFileStream* stream) {

   586   assert(stream != NULL, "invariant");

   587   assert(stream->current_offset() == 0, "invariant");

   588   stream->skip_u4_fast(2);  // 8 bytes skipped

   589   const u2 cp_len = stream->get_u2_fast();

   590   assert(cp_len > 0, "invariant");

   591   // now spin the stream position to just after the constant pool

   592   for (u2 index = 1; index < cp_len; ++index) {

   593     const u1 tag = stream->get_u1_fast(); // cp tag

   594     switch (tag) {

   595       case JVM_CONSTANT_Class:

   596       case JVM_CONSTANT_String: {

   597         stream->skip_u2_fast(1); // skip 2 bytes

   598         continue;

   599       }

   600       case JVM_CONSTANT_Fieldref:

   601       case JVM_CONSTANT_Methodref:

   602       case JVM_CONSTANT_InterfaceMethodref:

   603       case JVM_CONSTANT_Integer:

   604       case JVM_CONSTANT_Float:

   605       case JVM_CONSTANT_NameAndType:

   606       case JVM_CONSTANT_InvokeDynamic: {

   607         stream->skip_u4_fast(1); // skip 4 bytes

   608         continue;

   609       }

   610       case JVM_CONSTANT_Long:

   611       case JVM_CONSTANT_Double: {

   612         stream->skip_u4_fast(2); // skip 8 bytes

   613         // Skip entry following eigth-byte constant, see JVM book p. 98

   614         ++index;

   615         continue;

   616       }

   617       case JVM_CONSTANT_Utf8: {

   618         u2 utf8_length = stream->get_u2_fast();

   619         stream->skip_u1_fast(utf8_length); // skip 2 + len bytes

   620         continue;

   621       }

   622       case JVM_CONSTANT_MethodHandle:

   623       case JVM_CONSTANT_MethodType: {

   624         if (tag == JVM_CONSTANT_MethodHandle) {

   625           stream->skip_u1_fast(1);

   626           stream->skip_u2_fast(1); // skip 3 bytes

   627         }

   628         else if (tag == JVM_CONSTANT_MethodType) {

   629           stream->skip_u2_fast(1); // skip 3 bytes

   630         }

   631       }

   632       continue;

   633       default:

   634         assert(false, "error in skip logic!");

   635         break;

   636     } // end switch(tag)

   637   }

   638   return cp_len;

   639 }

   640 

   641 /*

   642 * On return, the passed stream will be positioned

   643 * just after the fields section in the classfile

   644 * and the number of fields will be returned.

   645 *

   646 * Stream should come in positioned just before fields_count

   647 */

   648 static u2 position_stream_after_fields(const ClassFileStream* stream) {

   649   assert(stream != NULL, "invariant");

   650   assert(stream->current_offset() > 0, "invariant");

   651   // fields len

   652   const u2 orig_fields_len = stream->get_u2_fast();

   653   // fields

   654   for (u2 i = 0; i < orig_fields_len; ++i) {

   655     stream->skip_u2_fast(3);

   656     const u2 attrib_info_len = stream->get_u2_fast();

   657     for (u2 j = 0; j < attrib_info_len; ++j) {

   658       stream->skip_u2_fast(1);

   659       const u4 attrib_len = stream->get_u4_fast();

   660       stream->skip_u1_fast(attrib_len);

   661     }

   662   }

   663   return orig_fields_len;

   664 }

   665 

   666 /*

   667 * On return, the passed stream will be positioned

   668 * just after the methods section in the classfile

   669 * and the number of methods will be returned.

   670 *

   671 * Stream should come in positioned just before methods_count

   672 */

   673 static u2 position_stream_after_methods(JfrBigEndianWriter& writer,

   674                                         const ClassFileStream* stream,

   675                                         const u2* utf8_indexes,

   676                                         bool register_klass,

   677                                         const Method* clinit_method,

   678                                         u4& orig_method_len_offset) {

   679   assert(stream != NULL, "invariant");

   680   assert(stream->current_offset() > 0, "invariant");

   681   assert(utf8_indexes != NULL, "invariant");

   682   // We will come back to this location when we

   683   // know how many methods there will be.

   684   writer.reserve(sizeof(u2));

   685   const u2 orig_methods_len = stream->get_u2_fast();

   686   // Move copy position past original method_count

   687   // in order to not copy the original count

   688   orig_method_len_offset += sizeof(u2);

   689   for (u2 i = 0; i < orig_methods_len; ++i) {

   690     const u4 method_offset = stream->current_offset();

   691     stream->skip_u2_fast(1); // Access Flags

   692     const u2 name_index = stream->get_u2_fast(); // Name index

   693     stream->skip_u2_fast(1); // Descriptor index

   694     const u2 attributes_count = stream->get_u2_fast();

   695     for (u2 j = 0; j < attributes_count; ++j) {

   696       stream->skip_u2_fast(1);

   697       const u4 attrib_len = stream->get_u4_fast();

   698       stream->skip_u1_fast(attrib_len);

   699     }

   700     if (clinit_method != NULL && name_index == clinit_method->name_index()) {

   701       // The method just parsed is an existing <clinit> method.

   702       // If the class has the @Registered(false) annotation, i.e. marking a class

   703       // for opting out from automatic registration, then we do not need to do anything.

   704       if (!register_klass) {

   705         continue;

   706       }

   707       // Automatic registration with the jfr system is acccomplished

   708       // by pre-pending code to the <clinit> method of the class.

   709       // We will need to re-create a new <clinit> in a later step.

   710       // For now, ensure that this method is excluded from the methods

   711       // being copied.

   712       writer.bytes(stream->buffer() + orig_method_len_offset,

   713                    method_offset - orig_method_len_offset);

   714       assert(writer.is_valid(), "invariant");

   715 

   716       // Update copy position to skip copy of <clinit> method

   717       orig_method_len_offset = stream->current_offset();

   718     }

   719   }

   720   return orig_methods_len;

   721 }

   722 

   723 static u2 add_method_infos(JfrBigEndianWriter& writer, const u2* utf8_indexes) {

   724   assert(utf8_indexes != NULL, "invariant");

   725   add_method_info(writer,

   726                   utf8_indexes[UTF8_REQ_begin],

   727                   utf8_indexes[UTF8_REQ_EMPTY_VOID_METHOD_DESC],

   728                   utf8_indexes[UTF8_REQ_Code],

   729                   empty_void_method_code_attribute,

   730                   sizeof(empty_void_method_code_attribute));

   731 

   732   assert(writer.is_valid(), "invariant");

   733 

   734   add_method_info(writer,

   735                   utf8_indexes[UTF8_REQ_end],

   736                   utf8_indexes[UTF8_REQ_EMPTY_VOID_METHOD_DESC],

   737                   utf8_indexes[UTF8_REQ_Code],

   738                   empty_void_method_code_attribute,

   739                   sizeof(empty_void_method_code_attribute));

   740 

   741   assert(writer.is_valid(), "invariant");

   742 

   743   add_method_info(writer,

   744                   utf8_indexes[UTF8_REQ_commit],

   745                   utf8_indexes[UTF8_REQ_EMPTY_VOID_METHOD_DESC],

   746                   utf8_indexes[UTF8_REQ_Code],

   747                   empty_void_method_code_attribute,

   748                   sizeof(empty_void_method_code_attribute));

   749 

   750   assert(writer.is_valid(), "invariant");

   751 

   752   add_method_info(writer,

   753                   utf8_indexes[UTF8_REQ_isEnabled],

   754                   utf8_indexes[UTF8_REQ_EMPTY_BOOLEAN_METHOD_DESC],

   755                   utf8_indexes[UTF8_REQ_Code],

   756                   boolean_method_code_attribute,

   757                   sizeof(boolean_method_code_attribute));

   758 

   759   assert(writer.is_valid(), "invariant");

   760 

   761   add_method_info(writer,

   762                   utf8_indexes[UTF8_REQ_shouldCommit],

   763                   utf8_indexes[UTF8_REQ_EMPTY_BOOLEAN_METHOD_DESC],

   764                   utf8_indexes[UTF8_REQ_Code],

   765                   boolean_method_code_attribute,

   766                   sizeof(boolean_method_code_attribute));

   767   assert(writer.is_valid(), "invariant");

   768   return number_of_new_methods;

   769 }

   770 

   771 static void adjust_exception_table(JfrBigEndianWriter& writer, u2 bci_adjustment_offset, const Method* method, TRAPS) {

   772   const u2 ex_table_length = method != NULL ? (u2)method->exception_table_length() : 0;

   773   writer.write<u2>(ex_table_length); // Exception table length

   774   if (ex_table_length > 0) {

   775     assert(method != NULL, "invariant");

   776     const ExceptionTableElement* const ex_elements = method->exception_table_start();

   777     for (int i = 0; i < ex_table_length; ++i) {

   778       assert(ex_elements != NULL, "invariant");

   779       writer.write<u2>(ex_elements[i].start_pc + bci_adjustment_offset);

   780       writer.write<u2>(ex_elements[i].end_pc + bci_adjustment_offset);

   781       writer.write<u2>(ex_elements[i].handler_pc + bci_adjustment_offset);

   782       writer.write<u2>(ex_elements[i].catch_type_index); // no adjustment

   783     }

   784   }

   785 }

   786 

   787 enum StackMapFrameTypes {

   788   SAME_FRAME_BEGIN = 0,

   789   SAME_FRAME_END = 63,

   790   SAME_LOCALS_1_STACK_ITEM_FRAME_BEGIN = 64,

   791   SAME_LOCALS_1_STACK_ITEM_FRAME_END = 127,

   792   SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED = 247,

   793   CHOP_FRAME_BEGIN = 248,

   794   CHOP_FRAME_END = 250,

   795   SAME_FRAME_EXTENDED = 251,

   796   APPEND_FRAME_BEGIN = 252,

   797   APPEND_FRAME_END = 254,

   798   FULL_FRAME = 255

   799 };

   800 

   801 static void adjust_stack_map(JfrBigEndianWriter& writer,

   802                              Array<u1>* stack_map,

   803                              const u2* utf8_indexes,

   804                              u2 bci_adjustment_offset,

   805                              TRAPS) {

   806   assert(stack_map != NULL, "invariant");

   807   assert(utf8_indexes != NULL, "invariant");

   808   writer.write<u2>(utf8_indexes[UTF8_OPT_StackMapTable]);

   809   const jlong stack_map_attrib_len_offset = writer.current_offset();

   810   writer.reserve(sizeof(u4));

   811   StackMapStream stream(stack_map);

   812   const u2 stack_map_entries = stream.get_u2(THREAD);

   813   // number of entries

   814   writer.write<u2>(stack_map_entries); // new stack map entry added

   815   const u1 frame_type = stream.get_u1(THREAD);

   816   // SAME_FRAME and SAME_LOCALS_1_STACK_ITEM_FRAME encode

   817   // their offset_delta into the actual frame type itself.

   818   // If such a frame type is the first frame, then we transform

   819   // it to a SAME_FRAME_EXTENDED or a SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED frame.

   820   // This is done in order to not overflow frame types accidentally

   821   // when adjusting the offset_delta. In changing the frame types,

   822   // we can work with an explicit u2 offset_delta field (like the other frame types)

   823   if (frame_type <= SAME_FRAME_END) {

   824     writer.write<u1>(SAME_FRAME_EXTENDED);

   825     writer.write<u2>(frame_type + bci_adjustment_offset);

   826   } else if (frame_type >= SAME_LOCALS_1_STACK_ITEM_FRAME_BEGIN &&

   827              frame_type <= SAME_LOCALS_1_STACK_ITEM_FRAME_END) {

   828     writer.write<u1>(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED);

   829     writer.write<u2>((frame_type - SAME_LOCALS_1_STACK_ITEM_FRAME_BEGIN) + bci_adjustment_offset);

   830   } else if (frame_type >= SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED) {

   831       // SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED to FULL_FRAME

   832       // has a u2 offset_delta field

   833       writer.write<u1>(frame_type);

   834       writer.write<u2>(stream.get_u2(THREAD) + bci_adjustment_offset);

   835   } else {

   836     assert(false, "stackMapFrame type is invalid");

   837   }

   838 

   839   while (!stream.at_end()) {

   840     writer.write<u1>(stream.get_u1(THREAD));

   841   }

   842 

   843   u4 stack_map_attrib_len = writer.current_offset() - stack_map_attrib_len_offset;

   844   // the stack_map_table_attributes_length value is exclusive

   845   stack_map_attrib_len -= sizeof(u4);

   846   writer.write_at_offset(stack_map_attrib_len, stack_map_attrib_len_offset);

   847 }

   848 

   849 static void adjust_line_number_table(JfrBigEndianWriter& writer,

   850                                      const u2* utf8_indexes,

   851                                      u4 bci_adjustement_offset,

   852                                      const Method* method,

   853                                      TRAPS) {

   854   assert(utf8_indexes != NULL, "invariant");

   855   assert(method != NULL, "invariant");

   856   assert(method->has_linenumber_table(), "invariant");

   857   writer.write(utf8_indexes[UTF8_OPT_LineNumberTable]);

   858   const jlong lnt_attributes_length_offset = writer.current_offset();

   859   writer.reserve(sizeof(u4));

   860   const jlong lnt_attributes_entries_offset = writer.current_offset();

   861   writer.reserve(sizeof(u2));

   862   u1* lnt = method->compressed_linenumber_table();

   863   CompressedLineNumberReadStream lnt_stream(lnt);

   864   u2 line_number_table_entries = 0;

   865   while (lnt_stream.read_pair()) {

   866     ++line_number_table_entries;

   867     const u2 bci = (u2)lnt_stream.bci();

   868     writer.write<u2>(bci + (u2)bci_adjustement_offset);

   869     writer.write<u2>((u2)lnt_stream.line());

   870   }

   871   writer.write_at_offset(line_number_table_entries, lnt_attributes_entries_offset);

   872   u4 lnt_table_attributes_len = writer.current_offset() - lnt_attributes_length_offset;

   873   // the line_number_table_attributes_length value is exclusive

   874   lnt_table_attributes_len -= sizeof(u4);

   875   writer.write_at_offset(lnt_table_attributes_len, lnt_attributes_length_offset);

   876 }

   877 

   878 // returns the number of lvtt entries

   879 static u2 adjust_local_variable_table(JfrBigEndianWriter& writer,

   880                                       const u2* utf8_indexes,

   881                                       u2 bci_adjustment_offset,

   882                                       const Method* method,

   883                                       TRAPS) {

   884   assert(utf8_indexes != NULL, "invariant");

   885   assert(method != NULL, "invariant");

   886   assert(method->has_localvariable_table(), "invariant");

   887   writer.write<u2>(utf8_indexes[UTF8_OPT_LocalVariableTable]);

   888   const jlong lvt_attributes_length_offset = writer.current_offset();

   889   writer.reserve(sizeof(u4));

   890   const int lvt_len = method->localvariable_table_length();

   891   writer.write<u2>((u2)lvt_len);

   892   const LocalVariableTableElement* table = method->localvariable_table_start();

   893   assert(table != NULL, "invariant");

   894   u2 num_lvtt_entries = 0;

   895   for (int i = 0; i < lvt_len; ++i) {

   896     writer.write<u2>(table[i].start_bci + bci_adjustment_offset);

   897     writer.write<u2>(table[i].length);

   898     writer.write<u2>(table[i].name_cp_index);

   899     writer.write<u2>(table[i].descriptor_cp_index);

   900     writer.write<u2>(table[i].slot);

   901     if (table[i].signature_cp_index > 0) {

   902       ++num_lvtt_entries;

   903     }

   904   }

   905   u4 lvt_table_attributes_len = writer.current_offset() - lvt_attributes_length_offset;

   906   // the lvt_table_attributes_length value is exclusive

   907   lvt_table_attributes_len -= sizeof(u4);

   908   writer.write_at_offset(lvt_table_attributes_len, lvt_attributes_length_offset);

   909   return num_lvtt_entries;

   910 }

   911 

   912 static void adjust_local_variable_type_table(JfrBigEndianWriter& writer,

   913                                             const u2* utf8_indexes,

   914                                             u2 bci_adjustment_offset,

   915                                             u2 num_lvtt_entries,

   916                                             const Method* method,

   917                                             TRAPS) {

   918   assert(num_lvtt_entries > 0, "invariant");

   919   writer.write<u2>(utf8_indexes[UTF8_OPT_LocalVariableTypeTable]);

   920   const jlong lvtt_attributes_length_offset = writer.current_offset();

   921   writer.reserve(sizeof(u4));

   922   writer.write<u2>(num_lvtt_entries);

   923   const LocalVariableTableElement* table = method->localvariable_table_start();

   924   assert(table != NULL, "invariant");

   925   const int lvt_len = method->localvariable_table_length();

   926   for (int i = 0; i < lvt_len; ++i) {

   927     if (table[i].signature_cp_index > 0) {

   928       writer.write<u2>(table[i].start_bci + bci_adjustment_offset);

   929       writer.write<u2>(table[i].length);

   930       writer.write<u2>(table[i].name_cp_index);

   931       writer.write<u2>(table[i].signature_cp_index);

   932       writer.write<u2>(table[i].slot);

   933     }

   934   }

   935   u4 lvtt_table_attributes_len = writer.current_offset() - lvtt_attributes_length_offset;

   936   // the lvtt_table_attributes_length value is exclusive

   937   lvtt_table_attributes_len -= sizeof(u4);

   938   writer.write_at_offset(lvtt_table_attributes_len, lvtt_attributes_length_offset);

   939 }

   940 

   941 static void adjust_code_attributes(JfrBigEndianWriter& writer,

   942                                    const u2* utf8_indexes,

   943                                    u2 bci_adjustment_offset,

   944                                    const Method* clinit_method,

   945                                    TRAPS) {

   946   // "Code" attributes

   947   assert(utf8_indexes != NULL, "invariant");

   948   const jlong code_attributes_offset = writer.current_offset();

   949   writer.reserve(sizeof(u2));

   950   u2 number_of_code_attributes = 0;

   951   if (clinit_method != NULL) {

   952     Array<u1>* stack_map = clinit_method->stackmap_data();

   953     if (stack_map != NULL) {

   954       ++number_of_code_attributes;

   955       adjust_stack_map(writer, stack_map, utf8_indexes, bci_adjustment_offset, THREAD);

   956       assert(writer.is_valid(), "invariant");

   957     }

   958     if (clinit_method != NULL && clinit_method->has_linenumber_table()) {

   959       ++number_of_code_attributes;

   960       adjust_line_number_table(writer, utf8_indexes, bci_adjustment_offset, clinit_method, THREAD);

   961       assert(writer.is_valid(), "invariant");

   962     }

   963     if (clinit_method != NULL && clinit_method->has_localvariable_table()) {

   964       ++number_of_code_attributes;

   965       const u2 num_of_lvtt_entries = adjust_local_variable_table(writer, utf8_indexes, bci_adjustment_offset, clinit_method, THREAD);

   966       assert(writer.is_valid(), "invariant");

   967       if (num_of_lvtt_entries > 0) {

   968         ++number_of_code_attributes;

   969         adjust_local_variable_type_table(writer, utf8_indexes, bci_adjustment_offset, num_of_lvtt_entries, clinit_method, THREAD);

   970         assert(writer.is_valid(), "invariant");

   971       }

   972     }

   973   }

   974 

   975   // Store the number of code_attributes

   976   writer.write_at_offset(number_of_code_attributes, code_attributes_offset);

   977 }

   978 

   979 static jlong insert_clinit_method(const InstanceKlass* ik,

   980                                   const ClassFileParser& parser,

   981                                   JfrBigEndianWriter& writer,

   982                                   u2 orig_constant_pool_len,

   983                                   const u2* utf8_indexes,

   984                                   const u2 register_method_ref_index,

   985                                   const Method* clinit_method,

   986                                   TRAPS) {

   987   assert(utf8_indexes != NULL, "invariant");

   988   // The injected code length is always this value.

   989   // This is to ensure that padding can be done

   990   // where needed and to simplify size calculations.

   991   static const u2 injected_code_length = 8;

   992   const u2 name_index = utf8_indexes[UTF8_REQ_clinit];

   993   const u2 desc_index = utf8_indexes[UTF8_REQ_EMPTY_VOID_METHOD_DESC];

   994   const u2 max_stack = MAX2(clinit_method != NULL ? clinit_method->verifier_max_stack() : 1, 1);

   995   const u2 max_locals = MAX2(clinit_method != NULL ? clinit_method->max_locals() : 0, 0);

   996   const u2 orig_bytecodes_length = clinit_method != NULL ? (u2)clinit_method->code_size() : 0;

   997   const address orig_bytecodes = clinit_method != NULL ? clinit_method->code_base() : NULL;

   998   const u2 new_code_length = injected_code_length + orig_bytecodes_length;

   999   DEBUG_ONLY(const jlong start_offset = writer.current_offset();)

  1000   writer.write<u2>(JVM_ACC_STATIC); // flags

  1001   writer.write<u2>(name_index);

  1002   writer.write<u2>(desc_index);

  1003   writer.write<u2>((u2)0x1); // attributes_count // "Code"

  1004   assert(writer.is_valid(), "invariant");

  1005   DEBUG_ONLY(assert(start_offset + 8 == writer.current_offset(), "invariant");)

  1006   // "Code" attribute

  1007   writer.write<u2>(utf8_indexes[UTF8_REQ_Code]); // "Code"

  1008   const jlong code_attribute_length_offset = writer.current_offset();

  1009   writer.reserve(sizeof(u4));

  1010   writer.write<u2>(max_stack); // max stack

  1011   writer.write<u2>(max_locals); // max locals

  1012   writer.write<u4>((u4)new_code_length); // code length

  1013 

  1014   /* BEGIN CLINIT CODE */

  1015 

  1016   // Note the use of ldc_w here instead of ldc.

  1017   // This is to handle all values of "this_class_index"

  1018   writer.write<u1>((u1)Bytecodes::_ldc_w);

  1019   writer.write<u2>((u2)parser.this_class_index()); // load constant "this class"

  1020   writer.write<u1>((u1)Bytecodes::_invokestatic);

  1021   // invoke "FlightRecorder.register(Ljava/lang/Class;")

  1022   writer.write<u2>(register_method_ref_index);

  1023   if (clinit_method == NULL) {

  1024     writer.write<u1>((u1)Bytecodes::_nop);

  1025     writer.write<u1>((u1)Bytecodes::_return);

  1026   } else {

  1027     // If we are pre-pending to original code,

  1028     // do padding to minimize disruption to the original.

  1029     // It might have dependencies on 4-byte boundaries

  1030     // i.e. lookupswitch and tableswitch instructions

  1031     writer.write<u1>((u1)Bytecodes::_nop);

  1032     writer.write<u1>((u1)Bytecodes::_nop);

  1033     // insert original clinit code

  1034     writer.bytes(orig_bytecodes, orig_bytecodes_length);

  1035   }

  1036 

  1037   /* END CLINIT CODE */

  1038 

  1039   assert(writer.is_valid(), "invariant");

  1040   adjust_exception_table(writer, injected_code_length, clinit_method, THREAD);

  1041   assert(writer.is_valid(), "invariant");

  1042   adjust_code_attributes(writer, utf8_indexes, injected_code_length, clinit_method, THREAD);

  1043   assert(writer.is_valid(), "invariant");

  1044   u4 code_attribute_len = writer.current_offset() - code_attribute_length_offset;

  1045   // the code_attribute_length value is exclusive

  1046   code_attribute_len -= sizeof(u4);

  1047   writer.write_at_offset(code_attribute_len, code_attribute_length_offset);

  1048   return writer.current_offset();

  1049 }

  1050 

  1051 // Caller needs ResourceMark

  1052 static ClassFileStream* create_new_bytes_for_event_klass(const InstanceKlass* ik, const ClassFileParser& parser, TRAPS) {

  1053   DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));

  1054   static const u2 public_final_flag_mask = JVM_ACC_PUBLIC | JVM_ACC_FINAL;

  1055   const ClassFileStream* const orig_stream = parser.clone_stream();

  1056   const int orig_stream_length = orig_stream->length();

  1057   // allocate an identically sized buffer

  1058   u1* const new_buffer = NEW_RESOURCE_ARRAY_IN_THREAD_RETURN_NULL(THREAD, u1, orig_stream_length);

  1059   if (new_buffer == NULL) {

  1060     return NULL;

  1061   }

  1062   assert(new_buffer != NULL, "invariant");

  1063   // memcpy the entire [B

  1064   memcpy(new_buffer, orig_stream->buffer(), orig_stream_length);

  1065   const u2 orig_cp_len = position_stream_after_cp(orig_stream);

  1066   assert(orig_cp_len > 0, "invariant");

  1067   assert(orig_stream->current_offset() > 0, "invariant");

  1068   orig_stream->skip_u2_fast(3); // access_flags, this_class_index, super_class_index

  1069   const u2 iface_len = orig_stream->get_u2_fast();

  1070   orig_stream->skip_u2_fast(iface_len);

  1071   // fields len

  1072   const u2 orig_fields_len = orig_stream->get_u2_fast();

  1073   // fields

  1074   for (u2 i = 0; i < orig_fields_len; ++i) {

  1075     orig_stream->skip_u2_fast(3);

  1076     const u2 attrib_info_len = orig_stream->get_u2_fast();

  1077     for (u2 j = 0; j < attrib_info_len; ++j) {

  1078       orig_stream->skip_u2_fast(1);

  1079       const u4 attrib_len = orig_stream->get_u4_fast();

  1080       orig_stream->skip_u1_fast(attrib_len);

  1081     }

  1082   }

  1083   // methods

  1084   const u2 orig_methods_len = orig_stream->get_u2_fast();

  1085   for (u2 i = 0; i < orig_methods_len; ++i) {

  1086     const u4 access_flag_offset = orig_stream->current_offset();

  1087     const u2 flags = orig_stream->get_u2_fast();

  1088     // Rewrite JVM_ACC_FINAL -> JVM_ACC_PUBLIC

  1089     if (public_final_flag_mask == flags) {

  1090       JfrBigEndianWriter accessflagsrewriter(new_buffer + access_flag_offset, sizeof(u2));

  1091       accessflagsrewriter.write<u2>(JVM_ACC_PUBLIC);

  1092       assert(accessflagsrewriter.is_valid(), "invariant");

  1093     }

  1094     orig_stream->skip_u2_fast(2);

  1095     const u2 attributes_count = orig_stream->get_u2_fast();

  1096     for (u2 j = 0; j < attributes_count; ++j) {

  1097       orig_stream->skip_u2_fast(1);

  1098       const u4 attrib_len = orig_stream->get_u4_fast();

  1099       orig_stream->skip_u1_fast(attrib_len);

  1100     }

  1101   }

  1102   return new ClassFileStream(new_buffer, orig_stream_length, NULL, ClassFileStream::verify);

  1103 }

  1104 

  1105 // Attempt to locate an existing UTF8_INFO mapping the utf8_constant.

  1106 // If no UTF8_INFO exists, add (append) a new one to the constant pool.

  1107 static u2 find_or_add_utf8_info(JfrBigEndianWriter& writer,

  1108                                 const InstanceKlass* ik,

  1109                                 const char* const utf8_constant,

  1110                                 u2 orig_cp_len,

  1111                                 u2& added_cp_entries,

  1112                                 TRAPS) {

  1113   assert(utf8_constant != NULL, "invariant");

  1114   TempNewSymbol utf8_sym = SymbolTable::new_symbol(utf8_constant, THREAD);

  1115   // lookup existing

  1116   const int utf8_orig_idx = utf8_info_index(ik, utf8_sym, THREAD);

  1117   if (utf8_orig_idx != invalid_cp_index) {

  1118     // existing constant pool entry found

  1119     return utf8_orig_idx;

  1120   }

  1121   // no existing match, need to add a new utf8 cp entry

  1122   assert(invalid_cp_index == utf8_orig_idx, "invariant");

  1123   // add / append new

  1124   return add_utf8_info(writer, utf8_constant, orig_cp_len, added_cp_entries);

  1125 }

  1126 

  1127 /*

  1128  * This routine will resolve the required utf8_constants array

  1129  * to their constant pool indexes (mapping to their UTF8_INFO's)

  1130  * Only if a constant is actually needed and does not already exist

  1131  * will it be added.

  1132  *

  1133  * The passed in indexes array will be populated with the resolved indexes.

  1134  * The number of newly added constant pool entries is returned.

  1135  */