/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "jvm.h"

#include "classfile/classFileParser.hpp"

#include "classfile/classFileStream.hpp"

#include "classfile/javaClasses.inline.hpp"

#include "classfile/moduleEntry.hpp"

#include "classfile/modules.hpp"

#include "classfile/stackMapTable.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/verificationType.hpp"

#include "interpreter/bytecodes.hpp"

#include "jfr/instrumentation/jfrEventClassTransformer.hpp"

#include "jfr/jfr.hpp"

#include "jfr/jni/jfrJavaSupport.hpp"

#include "jfr/jni/jfrUpcalls.hpp"

#include "jfr/support/jfrEventClass.hpp"

#include "jfr/utilities/jfrBigEndian.hpp"

#include "jfr/writers/jfrBigEndianWriter.hpp"

#include "logging/log.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/resourceArea.hpp"

#include "oops/array.hpp"

#include "oops/constantPool.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/method.hpp"

#include "prims/jvmtiRedefineClasses.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/os.hpp"

#include "runtime/thread.inline.hpp"

#include "utilities/exceptions.hpp"

#include "utilities/globalDefinitions.hpp"

#include "utilities/macros.hpp"

static const u2 number_of_new_methods = 5;

static const u2 number_of_new_fields = 3;

static const int extra_stream_bytes = 0x280;

static const u2 invalid_cp_index = 0;

static const char* utf8_constants[] = {

  "Code",         // 0

  "J",            // 1

  "commit",       // 2

  "eventHandler", // 3

  "duration",     // 4

  "begin",        // 5

  "()V",          // 6

  "isEnabled",    // 7

  "()Z",          // 8

  "end",          // 9

  "shouldCommit", // 10

  "startTime",    // 11 // LAST_REQUIRED_UTF8

  "Ljdk/jfr/internal/handlers/EventHandler;", // 12

  "Ljava/lang/Object;", // 13

  "<clinit>",     // 14

  "jdk/jfr/FlightRecorder", // 15

  "register",     // 16

  "(Ljava/lang/Class;)V", // 17

  "StackMapTable", // 18

  "Exceptions", // 19

  "LineNumberTable", // 20

  "LocalVariableTable", // 21

  "LocalVariableTypeTable", // 22

  "RuntimeVisibleAnnotation", // 23

};

enum utf8_req_symbols {

  UTF8_REQ_Code,

  UTF8_REQ_J_FIELD_DESC,

  UTF8_REQ_commit,

  UTF8_REQ_eventHandler,

  UTF8_REQ_duration,

  UTF8_REQ_begin,

  UTF8_REQ_EMPTY_VOID_METHOD_DESC,

  UTF8_REQ_isEnabled,

  UTF8_REQ_EMPTY_BOOLEAN_METHOD_DESC,

  UTF8_REQ_end,

  UTF8_REQ_shouldCommit,

  UTF8_REQ_startTime,

  NOF_UTF8_REQ_SYMBOLS

};

enum utf8_opt_symbols {

  UTF8_OPT_eventHandler_FIELD_DESC = NOF_UTF8_REQ_SYMBOLS,

  UTF8_OPT_LjavaLangObject,

  UTF8_OPT_clinit,

  UTF8_OPT_FlightRecorder,

  UTF8_OPT_register,

  UTF8_OPT_CLASS_VOID_METHOD_DESC,

  UTF8_OPT_StackMapTable,

  UTF8_OPT_Exceptions,

  UTF8_OPT_LineNumberTable,

  UTF8_OPT_LocalVariableTable,

  UTF8_OPT_LocalVariableTypeTable,

  UTF8_OPT_RuntimeVisibleAnnotation,

  NOF_UTF8_SYMBOLS

};

static u1 empty_void_method_code_attribute[] = {

  0x0,

  0x0,

  0x0,

  0xd, // attribute len

  0x0,

  0x0, // max stack

  0x0,

  0x1, // max locals

  0x0,

  0x0,

  0x0,

  0x1, // code length

  Bytecodes::_return,

  0x0,

  0x0, // ex table len

  0x0,

  0x0  // attributes_count

};

static u1 boolean_method_code_attribute[] = {

  0x0,

  0x0,

  0x0,

  0xe,

  0x0,

  0x1, // max stack

  0x0,

  0x1, // max locals

  0x0,

  0x0,

  0x0,

  0x2,

  Bytecodes::_iconst_0,

  Bytecodes::_ireturn,

  0x0,

  0x0, // ex table len

  0x0,

  0x0, // attributes_count

};

// annotation processing support

enum {  // initial annotation layout

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

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

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

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

  e_tag_val = 'e',

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

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

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

  c_tag_val = 'c',    // payload is type

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

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

  s_tag_val = 's',    // payload is String

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

  s_size = 9,

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

};

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

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

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

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

  index += 2;  // skip atype

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

    return limit;

  }

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

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

    index += 2; // skip member

    index = skip_annotation_value(buffer, limit, index);

  }

  return index;

}

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

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

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

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

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

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

  //   case s: s_con:u2;

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

  //   case @: annotation;

  //   case s: s_con:u2;

  // }

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

    return limit;

  }

  const u1 tag = buffer[index - 1];

  switch (tag) {

    case 'B':

    case 'C':

    case 'I':

    case 'S':

    case 'Z':

    case 'D':

    case 'F':

    case 'J':

    case 'c':

    case 's':

      index += 2;  // skip con or s_con

      break;

    case 'e':

      index += 4;  // skip e_class, e_name

      break;

    case '[':

      {

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

          return limit;

        }

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

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

          index = skip_annotation_value(buffer, limit, index);

        }

      }

      break;

    case '@':

      index = next_annotation_index(buffer, limit, index);

      break;

    default:

      return limit;  //  bad tag byte

  }

  return index;

}

static const u2 number_of_elements_offset = (u2)2;

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

static const u2 element_name_size = (u2)2;

static const u2 value_type_relative_offset = (u2)2;

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

// see JVMS - 4.7.16. The RuntimeVisibleAnnotations Attribute

class AnnotationElementIterator : public StackObj {

 private:

  const InstanceKlass* _ik;

  const address _buffer;

  const u2 _limit; // length of annotation

  mutable u2 _current; // element

  mutable u2 _next; // element

  u2 value_index() const {

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

  }

 public:

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

                                                                                 _buffer(buffer),

                                                                                 _limit(limit),

                                                                                 _current(element_name_offset),

                                                                                 _next(element_name_offset) {

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

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

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

  }

  bool has_next() const {

    return _next < _limit;

  }

  void move_to_next() const {

    assert(has_next(), "invariant");

    _current = _next;

    if (_next < _limit) {

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

    }

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

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

  }

  u2 number_of_elements() const {

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

  }

  const Symbol* name() const {

    assert(_current < _next, "invariant");

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

  }

  char value_type() const {

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

  }

  jint read_int() const {

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

  }

  bool read_bool() const {

    return read_int() != 0;

  }

};

class AnnotationIterator : public StackObj {

 private:

  const InstanceKlass* _ik;

  // ensure _limit field is declared before _buffer

  u2 _limit; // length of annotations array

  const address _buffer;

  mutable u2 _current; // annotation

  mutable u2 _next; // annotation

 public:

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

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

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

                                                                     _current(0),

                                                                     _next(0) {

    if (_buffer != NULL) {

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

    }

  }

  bool has_next() const {

    return _next < _limit;

  }

  void move_to_next() const {

    assert(has_next(), "invariant");

    _current = _next;

    if (_next < _limit) {

      _next = next_annotation_index(_buffer, _limit, _next);

    }

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

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

  }

  const AnnotationElementIterator elements() const {

    assert(_current < _next, "invariant");

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

  }

  const Symbol* type() const {

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

    assert(_current < _limit, "invariant");

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

  }

};

static const char value_name[] = "value";

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

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

  AnnotationArray* class_annotations = ik->class_annotations();

  if (class_annotations == NULL) {

    return false;

  }

  const AnnotationIterator annotation_iterator(ik, class_annotations);

  while (annotation_iterator.has_next()) {

    annotation_iterator.move_to_next();

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

      // target annotation found

      static const Symbol* value_symbol =

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

      const AnnotationElementIterator element_iterator = annotation_iterator.elements();

      while (element_iterator.has_next()) {

        element_iterator.move_to_next();

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

          // "value" element

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

          value = element_iterator.read_bool();

          return true;

        }

      }

    }

  }

  return false;

}

// Evaluate to the value of the first found Symbol* annotation type.

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

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

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

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

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

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

  if (has_annotation(ik, annotation_type, value)) {

    return true;

  }

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

  return super != NULL && JdkJfrEvent::is_a(super) ? annotation_value(super, annotation_type, value) : false;

}

static const char jdk_jfr_module_name[] = "jdk.jfr";

static bool java_base_can_read_jdk_jfr() {

  static bool can_read = false;

  if (can_read) {

    return true;

  }

  static Symbol* jdk_jfr_module_symbol = NULL;

  if (jdk_jfr_module_symbol == NULL) {

    if (jdk_jfr_module_symbol == NULL) {

      return false;

    }

  }

  assert(jdk_jfr_module_symbol != NULL, "invariant");

  ModuleEntryTable* const table = Modules::get_module_entry_table(Handle());

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

  const ModuleEntry* const java_base_module = table->javabase_moduleEntry();

  if (java_base_module == NULL) {

    return false;

  }

  assert(java_base_module != NULL, "invariant");

  ModuleEntry* const jdk_jfr_module = table->lookup_only(jdk_jfr_module_symbol);

  if (jdk_jfr_module == NULL) {

    return false;

  }

  assert(jdk_jfr_module != NULL, "invariant");

  if (java_base_module->can_read(jdk_jfr_module)) {

    can_read = true;

  }

  return can_read;

}

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

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

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

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

static bool should_register_klass(const InstanceKlass* ik, bool& untypedEventHandler) {

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

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

  assert(!untypedEventHandler, "invariant");

  static const Symbol* registered_symbol = NULL;

  if (registered_symbol == NULL) {

    if (registered_symbol == NULL) {

      untypedEventHandler = true;

      return false;

    }

  }

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

  bool value = false; // to be set by annotation_value

  untypedEventHandler = !(annotation_value(ik, registered_symbol, value) || java_base_can_read_jdk_jfr());

  return value;

}

/*

 * Map an utf8 constant back to its CONSTANT_UTF8_INFO

 */

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

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

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

  const int cp_len = cp->length();

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

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

    if (tag.is_utf8()) {

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

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

      if (utf8_sym == target) {

        return index;

      }

    }

  }

  // not in constant pool

  return invalid_cp_index;

}

#ifdef ASSERT

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

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

}

#endif

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

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

  writer.write<u1>(JVM_CONSTANT_Utf8);

  writer.write_utf8_u2_len(utf8_constant);

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

  // return index for the added utf8 info

  return orig_cp_len + new_cp_entries_len++;

}

static u2 add_method_ref_info(JfrBigEndianWriter& writer,

                              u2 cls_name_index,

                              u2 method_index,

                              u2 desc_index,

                              u2 orig_cp_len,

                              u2& number_of_new_constants,

                              TRAPS) {

  assert(cls_name_index != invalid_cp_index, "invariant");

  assert(method_index != invalid_cp_index, "invariant");

  assert(desc_index != invalid_cp_index, "invariant");

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

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

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

  writer.write<u1>(JVM_CONSTANT_Class);

  writer.write<u2>(cls_name_index);

  const u2 cls_entry_index = orig_cp_len + number_of_new_constants;

  ++number_of_new_constants;

  writer.write<u1>(JVM_CONSTANT_NameAndType);

  writer.write<u2>(method_index);

  writer.write<u2>(desc_index);

  const u2 nat_entry_index = orig_cp_len + number_of_new_constants;

  ++number_of_new_constants;

  writer.write<u1>(JVM_CONSTANT_Methodref);