/*

 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.

 * Copyright (c) 2019 SAP SE. All rights reserved.

 * 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 "classfile/systemDictionary.hpp"

#include "gc/shared/gcLocker.hpp"

#include "interpreter/bytecodeUtils.hpp"

#include "memory/resourceArea.hpp"

#include "runtime/signature.hpp"

#include "utilities/events.hpp"

/*

 * Returns the name of the klass that is described at constant pool

 * index cp_index in the constant pool of method 'method'.

 */

char const* MethodBytecodePrinter::get_klass_name(Method* method, int cp_index) {

  ConstantPool* cp = method->constants();

  int class_index = cp->klass_ref_index_at(cp_index);

  Symbol* klass = cp->klass_at_noresolve(class_index);

  return klass->as_klass_external_name();

}

/*

 * Returns the name of the method that is described at constant pool

 * index cp_index in the constant pool of method 'method'.

 */

char const* MethodBytecodePrinter::get_method_name(Method* method, int cp_index) {

  ConstantPool* cp = method->constants();

  int class_index = cp->klass_ref_index_at(cp_index);

  Symbol* klass = cp->klass_at_noresolve(class_index);

  int name_and_type_index = cp->name_and_type_ref_index_at(cp_index);

  int name_index = cp->name_ref_index_at(name_and_type_index);

  int type_index = cp->signature_ref_index_at(name_and_type_index);

  Symbol* name = cp->symbol_at(name_index);

  Symbol* signature = cp->symbol_at(type_index);

  stringStream ss;

  ss.print("%s.%s%s", klass->as_klass_external_name(), name->as_C_string(), signature->as_C_string());

  return ss.as_string();

}

/*

 * Returns the name of the field that is described at constant pool

 * index cp_index in the constant pool of method 'method'.

 */

char const* MethodBytecodePrinter::get_field_and_class(Method* method, int cp_index) {

  ConstantPool* cp = method->constants();

  int class_index = cp->klass_ref_index_at(cp_index);

  Symbol* klass = cp->klass_at_noresolve(class_index);

  int name_and_type_index = cp->name_and_type_ref_index_at(cp_index);

  int name_index = cp->name_ref_index_at(name_and_type_index);

  Symbol* name = cp->symbol_at(name_index);

  stringStream ss;

  ss.print("%s.%s", klass->as_klass_external_name(), name->as_C_string());

  return ss.as_string();

}

/*

 * Returns the name of the field that is described at constant pool

 * index cp_index in the constant pool of method 'method'.

 */

char const* MethodBytecodePrinter::get_field_name(Method* method, int cp_index) {

  ConstantPool* cp = method->constants();

  int name_and_type_index = cp->name_and_type_ref_index_at(cp_index);

  int name_index = cp->name_ref_index_at(name_and_type_index);

  Symbol* name = cp->symbol_at(name_index);

  return name->as_C_string();

}

TrackingStackEntry::TrackingStackEntry(BasicType type) : _entry(INVALID + type * SCALE) { }

TrackingStackEntry::TrackingStackEntry(int bci, BasicType type) : _entry(bci + type * SCALE) {

  assert(bci >= 0, "BCI must be >= 0");

  assert(bci < 65536, "BCI must be < 65536");

}

int TrackingStackEntry::get_bci() {

  return _entry % SCALE;

}

BasicType TrackingStackEntry::get_type() {

  return BasicType (_entry / SCALE);

}

TrackingStackEntry TrackingStackEntry::merge(TrackingStackEntry other) {

  if (get_type() != other.get_type()) {

    if (((get_type() == T_OBJECT) || (get_type() == T_ARRAY)) &&

        ((other.get_type() == T_OBJECT) || (other.get_type() == T_ARRAY))) {

      if (get_bci() == other.get_bci()) {

        return TrackingStackEntry(get_bci(), T_OBJECT);

      } else {

        return TrackingStackEntry(T_OBJECT);

      }

    } else {

      return TrackingStackEntry(T_CONFLICT);

    }

  }

  if (get_bci() == other.get_bci()) {

    return *this;

  } else {

    return TrackingStackEntry(get_type());

  }

}

TrackingStack::TrackingStack(const TrackingStack &copy) {

  for (int i = 0; i < copy.get_size(); i++) {

    push_raw(copy._stack.at(i));

  }

}

void TrackingStack::push_raw(TrackingStackEntry entry) {

  if (entry.get_type() == T_VOID) {

    return;

  }

  _stack.push(entry);

}

void TrackingStack::push(TrackingStackEntry entry) {

  if (type2size[entry.get_type()] == 2) {

    push_raw(entry);

    push_raw(entry);

  } else {

    push_raw(entry);

  }

}

void TrackingStack::push(int bci, BasicType type) {

  push(TrackingStackEntry(bci, type));

}

void TrackingStack::pop(int slots) {

  for (int i = 0; i < slots; ++i) {

    _stack.pop();

  }

  assert(get_size() >= 0, "Popped too many slots");

}

void TrackingStack::merge(TrackingStack const& other) {

  assert(get_size() == other.get_size(), "Stacks not of same size");

  for (int i = get_size() - 1; i >= 0; --i) {

    _stack.at_put(i, _stack.at(i).merge(other._stack.at(i)));

  }

}

int TrackingStack::get_size() const {

  return _stack.length();

}

TrackingStackEntry TrackingStack::get_entry(int slot) {

  assert(slot >= 0, "Slot < 0");

  assert(slot < get_size(), "Slot >= size");

  return _stack.at(get_size() - slot - 1);

}

static TrackingStackSource createInvalidSource(int bci) {

  return TrackingStackSource(TrackingStackSource::INVALID, bci, "invalid");

}

static TrackingStackSource createLocalVarSource(int bci, Method* method, int slot) {

  // We assume outermost caller has ResourceMark.

  stringStream reason;

  if (method->has_localvariable_table()) {

    for (int i = 0; i < method->localvariable_table_length(); i++) {

      LocalVariableTableElement* elem = method->localvariable_table_start() + i;

      int start = elem->start_bci;

      int end = start + elem->length;

      if ((bci >= start) && (bci < end) && (elem->slot == slot)) {

        ConstantPool* cp = method->constants();

        char *var =  cp->symbol_at(elem->name_cp_index)->as_C_string();

        if (strlen(var) == 4 && strcmp(var, "this") == 0) {

        } else {

        }

        return TrackingStackSource(TrackingStackSource::LOCAL_VAR, bci, reason.as_string());

      }

    }

  }

  // Handle at least some cases we know.

  if (!method->is_static() && (slot == 0)) {

  } else {

    int curr = method->is_static() ? 0 : 1;

    SignatureStream ss(method->signature());

    int param_index = 0;

    bool found = false;

    for (SignatureStream ss(method->signature()); !ss.is_done(); ss.next()) {

      if (ss.at_return_type()) {

        continue;

      }

      int size = type2size[ss.type()];

      if ((slot >= curr) && (slot < curr + size)) {

        found = true;

        break;

      }

      param_index += 1;

      curr += size;

    }

    if (found) {

    } else {

      // This is the best we can do.

    }

  }

  return TrackingStackSource(TrackingStackSource::LOCAL_VAR, bci, reason.as_string());

}

}

static TrackingStackSource createArraySource(int bci, TrackingStackSource const& array_source,

                                             TrackingStackSource const& index_source) {

  // We assume outermost caller has ResourceMark.

  stringStream reason;

  if (array_source.get_type() != TrackingStackSource::INVALID) {

  } else {

  }

  return TrackingStackSource(TrackingStackSource::ARRAY_ELEM, bci, reason.as_string());

}

static TrackingStackSource createFieldSource(int bci, Method* method, int cp_index,

                                             TrackingStackSource const& object_source) {

  // We assume outermost caller has ResourceMark.

  stringStream reason;

  if (object_source.get_type() != TrackingStackSource::INVALID) {

  }

  return TrackingStackSource(TrackingStackSource::FIELD_ELEM, bci, reason.as_string());

}

static TrackingStackSource createStaticFieldSource(int bci, Method* method, int cp_index) {

  // We assume outermost caller has ResourceMark.

  stringStream reason;

               MethodBytecodePrinter::get_field_and_class(method, cp_index));

  return TrackingStackSource(TrackingStackSource::FIELD_ELEM, bci, reason.as_string());

}

TrackingStackCreator::TrackingStackCreator(Method* method, int bci) : _method(method) {

  ConstMethod* const_method = method->constMethod();

  int len = const_method->code_size();

  _nr_of_entries = 0;

  _max_entries = 1000000;

  _stacks = new GrowableArray<TrackingStack*> (len+1);

  for (int i = 0; i <= len; ++i) {

    _stacks->push(NULL);

  }

  // Initialize stack a bci 0.

  _stacks->at_put(0, new TrackingStack());

  // And initialize the start of all exception handlers.

  if (const_method->has_exception_handler()) {

    ExceptionTableElement *et = const_method->exception_table_start();

    for (int i = 0; i < const_method->exception_table_length(); ++i) {

      u2 index = et[i].handler_pc;

      if (_stacks->at(index) == NULL) {

        _stacks->at_put(index, new TrackingStack());

        _stacks->at(index)->push(index, T_OBJECT);

      }

    }

  }

  _all_processed = false;

  _added_one = true;

  // Do this until each bytecode hash a stack or we haven't

  // added a new stack in one iteration.

  while (!_all_processed && _added_one) {

    _all_processed = true;

    _added_one = false;

    for (int i = 0; i < len; ) {

      // Analyse bytecode i. Step by size of the analyzed bytecode to next bytecode.

      i += do_instruction(i);

      // If we want the data only for a certain bci, we can possibly end early.

      if ((bci == i) && (_stacks->at(i) != NULL)) {

        _all_processed = true;

        break;

      }

      if (_nr_of_entries > _max_entries) {

        return;

      }

    }

  }

}

TrackingStackCreator::~TrackingStackCreator() {

  for (int i = 0; i < _stacks->length(); ++i) {

    delete _stacks->at(i);

  }

}

void TrackingStackCreator::merge(int bci, TrackingStack* stack) {

  assert(stack != _stacks->at(bci), "Cannot merge itself");

  if (_stacks->at(bci) != NULL) {

    stack->merge(*_stacks->at(bci));

  } else {

    // Got a new stack, so count the entries.

    _nr_of_entries += stack->get_size();

  }

  delete _stacks->at(bci);

  _stacks->at_put(bci, new TrackingStack(*stack));

}

int TrackingStackCreator::do_instruction(int bci) {

  ConstMethod* const_method = _method->constMethod();

  address code_base = _method->constMethod()->code_base();

  // We use the java code, since we don't want to cope with all the fast variants.

  int len = Bytecodes::java_length_at(_method, code_base + bci);

  // If we have no stack for this bci, we cannot process the bytecode now.

  if (_stacks->at(bci) == NULL) {

    _all_processed = false;

    return len;

  }

  TrackingStack* stack = new TrackingStack(*_stacks->at(bci));

  // dest_bci is != -1 if we branch.

  int dest_bci = -1;

  // This is for table and lookup switch.

  static const int initial_length = 2;

  GrowableArray<int> dests(initial_length);

  bool flow_ended = false;

  // Get the bytecode.

  bool is_wide = false;

  Bytecodes::Code raw_code = Bytecodes::code_at(_method, code_base + bci);

  Bytecodes::Code code = Bytecodes::java_code_at(_method, code_base + bci);

  int pos = bci + 1;

  if (code == Bytecodes::_wide) {

    is_wide = true;

    code = Bytecodes::java_code_at(_method, code_base + bci + 1);

    pos += 1;

  }

  // Now simulate the action of each bytecode.

  switch (code) {

    case Bytecodes::_nop:

    case Bytecodes::_aconst_null:

    case Bytecodes::_iconst_m1:

    case Bytecodes::_iconst_0:

    case Bytecodes::_iconst_1:

    case Bytecodes::_iconst_2:

    case Bytecodes::_iconst_3:

    case Bytecodes::_iconst_4:

    case Bytecodes::_iconst_5:

    case Bytecodes::_lconst_0:

    case Bytecodes::_lconst_1:

    case Bytecodes::_fconst_0:

    case Bytecodes::_fconst_1:

    case Bytecodes::_fconst_2:

    case Bytecodes::_dconst_0:

    case Bytecodes::_dconst_1:

    case Bytecodes::_bipush:

    case Bytecodes::_sipush:

    case Bytecodes::_iload:

    case Bytecodes::_lload:

    case Bytecodes::_fload:

    case Bytecodes::_dload:

    case Bytecodes::_aload:

    case Bytecodes::_iload_0:

    case Bytecodes::_iload_1:

    case Bytecodes::_iload_2:

    case Bytecodes::_iload_3:

    case Bytecodes::_lload_0:

    case Bytecodes::_lload_1:

    case Bytecodes::_lload_2:

    case Bytecodes::_lload_3:

    case Bytecodes::_fload_0:

    case Bytecodes::_fload_1:

    case Bytecodes::_fload_2:

    case Bytecodes::_fload_3:

    case Bytecodes::_dload_0:

    case Bytecodes::_dload_1:

    case Bytecodes::_dload_2:

    case Bytecodes::_dload_3:

    case Bytecodes::_aload_0:

    case Bytecodes::_aload_1:

    case Bytecodes::_aload_2:

    case Bytecodes::_aload_3:

    case Bytecodes::_iinc:

    case Bytecodes::_new:

      stack->push(bci, Bytecodes::result_type(code));

      break;

    case Bytecodes::_ldc:

    case Bytecodes::_ldc_w:

    case Bytecodes::_ldc2_w: {

      int cp_index;

      ConstantPool* cp = _method->constants();

      if (code == Bytecodes::_ldc) {

        cp_index = *(uint8_t*) (code_base + pos);

        if (raw_code == Bytecodes::_fast_aldc) {

          cp_index = cp->object_to_cp_index(cp_index);

        }

      } else {

        if (raw_code == Bytecodes::_fast_aldc_w) {

          cp_index = Bytes::get_native_u2(code_base + pos);

          cp_index = cp->object_to_cp_index(cp_index);

        }

        else {

          cp_index = Bytes::get_Java_u2(code_base + pos);

        }

      }

      constantTag tag = cp->tag_at(cp_index);

      if (tag.is_klass()  || tag.is_unresolved_klass() ||

          tag.is_method() || tag.is_interface_method() ||

          tag.is_field()  || tag.is_string()) {

        stack->push(bci, T_OBJECT);

      } else if (tag.is_int()) {

        stack->push(bci, T_INT);

      } else if (tag.is_long()) {

        stack->push(bci, T_LONG);

      } else if (tag.is_float()) {

        stack->push(bci, T_FLOAT);

      } else if (tag.is_double()) {

        stack->push(bci, T_DOUBLE);

      } else {

        assert(false, "Unexpected tag");

      }

      break;

    }

    case Bytecodes::_iaload:

    case Bytecodes::_faload:

    case Bytecodes::_aaload:

    case Bytecodes::_baload:

    case Bytecodes::_caload:

    case Bytecodes::_saload:

    case Bytecodes::_laload:

    case Bytecodes::_daload:

      stack->pop(2);

      stack->push(bci, Bytecodes::result_type(code));

      break;

    case Bytecodes::_istore:

    case Bytecodes::_lstore:

    case Bytecodes::_fstore:

    case Bytecodes::_dstore:

    case Bytecodes::_astore:

    case Bytecodes::_istore_0:

    case Bytecodes::_istore_1:

    case Bytecodes::_istore_2:

    case Bytecodes::_istore_3:

    case Bytecodes::_lstore_0:

    case Bytecodes::_lstore_1:

    case Bytecodes::_lstore_2: