/*

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

/*

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

 */

  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);

}

/*

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

 */

  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);

}

/*

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

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

 */

  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() {

}

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);

}

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:

    case Bytecodes::_lstore_3:

    case Bytecodes::_fstore_0:

    case Bytecodes::_fstore_1:

    case Bytecodes::_fstore_2:

    case Bytecodes::_fstore_3:

    case Bytecodes::_dstore_0:

    case Bytecodes::_dstore_1:

    case Bytecodes::_dstore_2:

    case Bytecodes::_dstore_3:

    case Bytecodes::_astore_0:

    case Bytecodes::_astore_1:

    case Bytecodes::_astore_2:

    case Bytecodes::_astore_3:

    case Bytecodes::_iastore:

    case Bytecodes::_lastore:

    case Bytecodes::_fastore:

    case Bytecodes::_dastore:

    case Bytecodes::_aastore:

    case Bytecodes::_bastore:

    case Bytecodes::_castore:

    case Bytecodes::_sastore:

    case Bytecodes::_pop:

    case Bytecodes::_pop2:

    case Bytecodes::_monitorenter:

    case Bytecodes::_monitorexit:

    case Bytecodes::_breakpoint:

      stack->pop(-Bytecodes::depth(code));

      break;

    case Bytecodes::_dup:

      stack->push_raw(stack->get_entry(0));

      break;

    case Bytecodes::_dup_x1: {

      TrackingStackEntry top1 = stack->get_entry(0);

      TrackingStackEntry top2 = stack->get_entry(1);

      stack->pop(2);

      stack->push_raw(top1);

      stack->push_raw(top2);

      stack->push_raw(top1);

      break;

    }

    case Bytecodes::_dup_x2: {

      TrackingStackEntry top1 = stack->get_entry(0);

      TrackingStackEntry top2 = stack->get_entry(1);

      TrackingStackEntry top3 = stack->get_entry(2);

      stack->pop(3);

      stack->push_raw(top1);

      stack->push_raw(top3);

      stack->push_raw(top2);

      stack->push_raw(top1);

      break;

    }

    case Bytecodes::_dup2:

      stack->push_raw(stack->get_entry(1));

      stack->push_raw(stack->get_entry(1));

      break;

    case Bytecodes::_dup2_x1: {

      TrackingStackEntry top1 = stack->get_entry(0);

      TrackingStackEntry top2 = stack->get_entry(1);

      TrackingStackEntry top3 = stack->get_entry(2);

      stack->pop(3);

      stack->push_raw(top2);

      stack->push_raw(top1);

      stack->push_raw(top3);

      stack->push_raw(top2);

      stack->push_raw(top1);

      break;

    }

    case Bytecodes::_dup2_x2: {

      TrackingStackEntry top1 = stack->get_entry(0);

      TrackingStackEntry top2 = stack->get_entry(1);

      TrackingStackEntry top3 = stack->get_entry(2);