/*

 * 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 "memory/allocation.hpp"

#include "oops/method.hpp"

#include "utilities/growableArray.hpp"

class TrackingStack;

class TrackingStackCreator;

// The entry of TrackingStack.

class TrackingStackEntry {

 private:

  friend class TrackingStack;

  friend class TrackingStackCreator;

  // The raw entry composed of the type and the bci.

  int _entry;

  enum {

    SCALE = 1024 * 1024

  };

  // Merges this entry with the given one and returns the result. If

  // the bcis of the entry are different, the bci of the result will be

  // undefined. If the types are different, the result type is T_CONFLICT.

  // (an exception is if one type is an array and the other is object, then

  // the result type will be T_OBJECT).

  TrackingStackEntry merge(TrackingStackEntry other);

public:

  // Creates a new entry with an invalid bci and the given type.

  TrackingStackEntry(BasicType type = T_CONFLICT);

  // Creates a new entry with the given bci and type.

  TrackingStackEntry(int bci, BasicType type);

 public:

  enum {

    INVALID = SCALE - 1

  };

  // Returns the bci. If the bci is invalid, INVALID is returned.

  int get_bci();

  // Returns true, if the bci is not invalid.

  bool has_bci() { return get_bci() != INVALID; }

  // Returns the type of the entry.

  BasicType get_type();

};

// A stack consisting of TrackingStackEntries.

class TrackingStack: CHeapObj<mtInternal> {

 private:

  friend class TrackingStackCreator;

  friend class TrackingStackEntry;

  // The stack.

  GrowableArray<TrackingStackEntry> _stack;

  TrackingStack() { };

  TrackingStack(const TrackingStack &copy);

  // Pushes the given entry.

  void push_raw(TrackingStackEntry entry);

  // Like push_raw, but if the entry is long or double, we push two.

  void push(TrackingStackEntry entry);

  // Like push(entry), but using bci/type instead of entry.

  void push(int bci, BasicType type);

  // Pops the given number of entries.

  void pop(int slots);

  // Merges this with the given stack by merging all entries. The

  // size of the stacks must be the same.

  void merge(TrackingStack const& other);

 public:

  // Returns the size of the stack.

  int get_size() const;

  // Returns the entry with the given index. Top of stack is at index 0.

  TrackingStackEntry get_entry(int slot);

};

// Analyses the bytecodes of a method and tries to create a tracking

// stack for each bci. The tracking stack holds the bci and type of

// instruction, which put the entry on the stack.

class TrackingStackCreator {

  // The stacks.

  GrowableArray<TrackingStack*>* _stacks;

  // The method.

  Method* _method;

  // The maximum number of entries we want to use. This is used to

  // limit the amount of memory we waste for insane methods (as they

  // appear in JCK tests).

  int _max_entries;

  // The number of entries used (the sum of all entries of all stacks).

  int _nr_of_entries;

  // If true, we have added at least one new stack.

  bool _added_one;

  // If true, we have processed all bytecodes.

  bool _all_processed;

  // Merges the stack the the given bci with the given stack. If there

  // is no stack at the bci, we just put the given stack there. This

  // method doesn't takes ownership of the stack.

  void merge(int bci, TrackingStack* stack);

  // Processes the instruction at the given bci in the method. Returns

  // the size of the instruction.

  int do_instruction(int bci);

 public:

  // Creates tracking stacks for the given method (the method must be

  // rewritten already). Note that you're not allowed to use this object

  // when crossing a safepoint! If the bci is != -1, we only create the

  // stacks as far as needed to get a stack for the bci.

  TrackingStackCreator(Method* method, int bci = -1);

  // Releases the resources.

  ~TrackingStackCreator();

  // Returns the number of stacks (this is the size of the method).

  int get_size() { return _stacks->length() - 1; }

  // Assuming that a NullPointerException was thrown at the given bci,

  // we return the nr of the slot holding the null reference. If this

  // NPE is created by hand, we return -2 as the slot. If there

};