/*
 * Copyright (c) 2023, 2024, Oracle and/or its affiliates. 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.
 *
 */

#ifndef SHARE_OOPS_RESOLVEDINDYENTRY_HPP
#define SHARE_OOPS_RESOLVEDINDYENTRY_HPP

// ResolvedIndyEntry contains the resolution information for invokedynamic bytecodes.
// A member of this class can be initialized with the resolved references index and
// constant pool index before any resolution is done, where "resolution" refers to finding the target
// method and its relevant information, like number of parameters and return type. These entries are contained
// within the ConstantPoolCache and are accessed with indices added to the invokedynamic bytecode after
// rewriting.

// The invokedynamic bytecode starts with an Constant Pool index as its operand which is then rewritten
// to become an "indy index", an index into the array of ResolvedIndyEntry. The method here is an adapter method
// which will be something like linkToTargetMethod. When an indy call is resolved, we no longer need to invoke
// the bootstrap method (BSM) and we can get the target method (the method actually doing stuff, i.e. a string concat)
// from the CallSite. The CallSite is generated when the BSM is invoked and it simply contains a MethodHandle for
// the target method. The adapter will propagate information to and from the target method and the JVM.


class Method;
class ResolvedIndyEntry {
  friend class VMStructs;

  Method* _method;               // Adapter method for indy call
  u2 _resolved_references_index; // Index of resolved references array that holds the appendix oop
  u2 _cpool_index;               // Constant pool index
  u2 _number_of_parameters;      // Number of arguments for adapter method
  u1 _return_type;               // Adapter method return type
  u1 _flags;                     // Flags: [0000|00|has_appendix|resolution_failed]

public:
  ResolvedIndyEntry() :
    _method(nullptr),
    _resolved_references_index(0),
    _cpool_index(0),
    _number_of_parameters(0),
    _return_type(0),
    _flags(0) {}
  ResolvedIndyEntry(u2 resolved_references_index, u2 cpool_index) :
    _method(nullptr),
    _resolved_references_index(resolved_references_index),
    _cpool_index(cpool_index),
    _number_of_parameters(0),
    _return_type(0),
    _flags(0) {}

  // Bit shift to get flags
  enum {
    resolution_failed_shift = 0,
    has_appendix_shift      = 1,
  };

  // Getters
  Method* method()               const { return Atomic::load_acquire(&_method); }
  u2 resolved_references_index() const { return _resolved_references_index;     }
  u2 constant_pool_index()       const { return _cpool_index;                   }
  u2 num_parameters()            const { return _number_of_parameters;          }
  u1 return_type()               const { return _return_type;                   }
  bool is_resolved()             const { return method() != nullptr;            }
  bool has_appendix()            const { return (_flags & (1 << has_appendix_shift)) != 0; }
  bool resolution_failed()       const { return (_flags & 1) != 0; }
  bool is_vfinal()               const { return false; }
  bool is_final()                const { return false; }
  bool has_local_signature()     const { return true;  }

  // Printing
  void print_on(outputStream* st) const;

  // Initialize with fields available before resolution
  void init(u2 resolved_references_index, u2 cpool_index) {
    _resolved_references_index = resolved_references_index;
    _cpool_index = cpool_index;
  }

  void set_num_parameters(int value) {
    assert(_number_of_parameters == 0 || _number_of_parameters == value,
      "size must not change: parameter_size=%d, value=%d", _number_of_parameters, value);
    Atomic::store(&_number_of_parameters, (u2)value);
    guarantee(_number_of_parameters == value,
      "size must not change: parameter_size=%d, value=%d", _number_of_parameters, value);
  }

  // Populate structure with resolution information
  void fill_in(Method* m, u2 num_params, u1 return_type, bool has_appendix) {
    set_num_parameters(num_params);
    _return_type = return_type;
    set_has_appendix(has_appendix);
    // Set the method last since it is read lock free.
    // Resolution is indicated by whether or not the method is set.
    Atomic::release_store(&_method, m);
  }

  void set_has_appendix(bool has_appendix) {
    u1 new_flags = (has_appendix ? 1 : 0) << has_appendix_shift;
    u1 old_flags = _flags & ~(1 << has_appendix_shift);
    // Preserve the unaffected bits
    _flags = old_flags | new_flags;
  }


  void set_resolution_failed() {
    _flags = _flags | (1 << resolution_failed_shift);
  }

  void adjust_method_entry(Method* new_method) { _method = new_method; }
  bool check_no_old_or_obsolete_entry();

  // CDS
#if INCLUDE_CDS
  void remove_unshareable_info();
  void mark_and_relocate();
#endif

  // Offsets
  static ByteSize method_offset()                    { return byte_offset_of(ResolvedIndyEntry, _method);                    }
  static ByteSize resolved_references_index_offset() { return byte_offset_of(ResolvedIndyEntry, _resolved_references_index); }
  static ByteSize result_type_offset()               { return byte_offset_of(ResolvedIndyEntry, _return_type);               }
  static ByteSize num_parameters_offset()            { return byte_offset_of(ResolvedIndyEntry, _number_of_parameters);      }
  static ByteSize flags_offset()                     { return byte_offset_of(ResolvedIndyEntry, _flags);                     }
};

#endif // SHARE_OOPS_RESOLVEDINDYENTRY_HPP