/*

 * Copyright (c) 1997, 2019, 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.

 *

 */

#include "precompiled.hpp"

#include "code/codeCache.hpp"

#include "code/vmreg.inline.hpp"

#include "compiler/abstractCompiler.hpp"

#include "compiler/disassembler.hpp"

#include "gc/shared/collectedHeap.inline.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/oopMapCache.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/markOop.hpp"

#include "oops/method.hpp"

#include "oops/methodData.hpp"

#include "oops/oop.inline.hpp"

#include "oops/verifyOopClosure.hpp"

#include "prims/methodHandles.hpp"

#include "runtime/frame.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/monitorChunk.hpp"

#include "runtime/os.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/signature.hpp"

#include "runtime/stubCodeGenerator.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/thread.inline.hpp"

#include "utilities/debug.hpp"

#include "utilities/decoder.hpp"

#include "utilities/formatBuffer.hpp"

RegisterMap::RegisterMap(JavaThread *thread, bool update_map) {

  _thread         = thread;

  _update_map     = update_map;

  clear();

  debug_only(_update_for_id = NULL;)

#ifndef PRODUCT

  for (int i = 0; i < reg_count ; i++ ) _location[i] = NULL;

#endif /* PRODUCT */

}

RegisterMap::RegisterMap(const RegisterMap* map) {

  assert(map != this, "bad initialization parameter");

  assert(map != NULL, "RegisterMap must be present");

  _thread                = map->thread();

  _update_map            = map->update_map();

  _include_argument_oops = map->include_argument_oops();

  debug_only(_update_for_id = map->_update_for_id;)

  pd_initialize_from(map);

  if (update_map()) {

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

      LocationValidType bits = !update_map() ? 0 : map->_location_valid[i];

      _location_valid[i] = bits;

      // for whichever bits are set, pull in the corresponding map->_location

      int j = i*location_valid_type_size;

      while (bits != 0) {

        if ((bits & 1) != 0) {

          assert(0 <= j && j < reg_count, "range check");

          _location[j] = map->_location[j];

        }

        bits >>= 1;

        j += 1;

      }

    }

  }

}

void RegisterMap::clear() {

  set_include_argument_oops(true);

  if (_update_map) {

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

      _location_valid[i] = 0;

    }

    pd_clear();

  } else {

    pd_initialize();

  }

}

#ifndef PRODUCT

void RegisterMap::print_on(outputStream* st) const {

  st->print_cr("Register map");

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

    VMReg r = VMRegImpl::as_VMReg(i);

    intptr_t* src = (intptr_t*) location(r);

    if (src != NULL) {

      r->print_on(st);

      st->print(" [" INTPTR_FORMAT "] = ", p2i(src));

      if (((uintptr_t)src & (sizeof(*src)-1)) != 0) {

        st->print_cr("<misaligned>");

      } else {

        st->print_cr(INTPTR_FORMAT, *src);

      }

    }

  }

}

void RegisterMap::print() const {

  print_on(tty);

}

#endif

// This returns the pc that if you were in the debugger you'd see. Not

// the idealized value in the frame object. This undoes the magic conversion

// that happens for deoptimized frames. In addition it makes the value the

// hardware would want to see in the native frame. The only user (at this point)

// is deoptimization. It likely no one else should ever use it.

address frame::raw_pc() const {

  if (is_deoptimized_frame()) {

    CompiledMethod* cm = cb()->as_compiled_method_or_null();

    if (cm->is_method_handle_return(pc()))

      return cm->deopt_mh_handler_begin() - pc_return_offset;

    else

      return cm->deopt_handler_begin() - pc_return_offset;

  } else {

    return (pc() - pc_return_offset);

  }

}

// Change the pc in a frame object. This does not change the actual pc in

// actual frame. To do that use patch_pc.

//

void frame::set_pc(address   newpc ) {

#ifdef ASSERT

  if (_cb != NULL && _cb->is_nmethod()) {

    assert(!((nmethod*)_cb)->is_deopt_pc(_pc), "invariant violation");

  }

#endif // ASSERT

  // Unsafe to use the is_deoptimzed tester after changing pc

  _deopt_state = unknown;

  _pc = newpc;

  _cb = CodeCache::find_blob_unsafe(_pc);

}

// type testers

bool frame::is_ignored_frame() const {

  return false;  // FIXME: some LambdaForm frames should be ignored

}

bool frame::is_deoptimized_frame() const {

  assert(_deopt_state != unknown, "not answerable");

  return _deopt_state == is_deoptimized;

}

bool frame::is_native_frame() const {

  return (_cb != NULL &&

          _cb->is_nmethod() &&

          ((nmethod*)_cb)->is_native_method());

}

bool frame::is_java_frame() const {

  if (is_interpreted_frame()) return true;

  if (is_compiled_frame())    return true;

  return false;

}

bool frame::is_compiled_frame() const {

  if (_cb != NULL &&

      _cb->is_compiled() &&

      ((CompiledMethod*)_cb)->is_java_method()) {

    return true;

  }

  return false;

}

bool frame::is_runtime_frame() const {

  return (_cb != NULL && _cb->is_runtime_stub());

}

bool frame::is_safepoint_blob_frame() const {

  return (_cb != NULL && _cb->is_safepoint_stub());

}

// testers

bool frame::is_first_java_frame() const {

  RegisterMap map(JavaThread::current(), false); // No update

  frame s;

  for (s = sender(&map); !(s.is_java_frame() || s.is_first_frame()); s = s.sender(&map));

  return s.is_first_frame();

}

bool frame::entry_frame_is_first() const {

  return entry_frame_call_wrapper()->is_first_frame();

}

JavaCallWrapper* frame::entry_frame_call_wrapper_if_safe(JavaThread* thread) const {

  JavaCallWrapper** jcw = entry_frame_call_wrapper_addr();

  address addr = (address) jcw;

  // addr must be within the usable part of the stack

  if (thread->is_in_usable_stack(addr)) {

    return *jcw;

  }

  return NULL;

}

bool frame::is_entry_frame_valid(JavaThread* thread) const {

  // Validate the JavaCallWrapper an entry frame must have

  address jcw = (address)entry_frame_call_wrapper();

  bool jcw_safe = (jcw < thread->stack_base()) && (jcw > (address)fp()); // less than stack base

  if (!jcw_safe) {

    return false;

  }

  // Validate sp saved in the java frame anchor

  JavaFrameAnchor* jfa = entry_frame_call_wrapper()->anchor();

  return (jfa->last_Java_sp() > sp());

}

bool frame::should_be_deoptimized() const {

  if (_deopt_state == is_deoptimized ||

      !is_compiled_frame() ) return false;

  assert(_cb != NULL && _cb->is_compiled(), "must be an nmethod");

  CompiledMethod* nm = (CompiledMethod *)_cb;

  if (TraceDependencies) {

    tty->print("checking (%s) ", nm->is_marked_for_deoptimization() ? "true" : "false");

    nm->print_value_on(tty);

    tty->cr();

  }

  if( !nm->is_marked_for_deoptimization() )

    return false;

  // If at the return point, then the frame has already been popped, and

  // only the return needs to be executed. Don't deoptimize here.

  return !nm->is_at_poll_return(pc());

}

bool frame::can_be_deoptimized() const {

  if (!is_compiled_frame()) return false;

  CompiledMethod* nm = (CompiledMethod*)_cb;

  if( !nm->can_be_deoptimized() )

    return false;

  return !nm->is_at_poll_return(pc());

}

void frame::deoptimize(JavaThread* thread) {

  // Schedule deoptimization of an nmethod activation with this frame.

  assert(_cb != NULL && _cb->is_compiled(), "must be");

  // This is a fix for register window patching race

  if (NeedsDeoptSuspend && Thread::current() != thread) {

    assert(SafepointSynchronize::is_at_safepoint(),

           "patching other threads for deopt may only occur at a safepoint");

    // It is possible especially with DeoptimizeALot/DeoptimizeRandom that

    // we could see the frame again and ask for it to be deoptimized since

    // it might move for a long time. That is harmless and we just ignore it.

    if (id() == thread->must_deopt_id()) {

      assert(thread->is_deopt_suspend(), "lost suspension");

      return;

    }

    // We are at a safepoint so the target thread can only be

    // in 4 states:

    //     blocked - no problem

    //     blocked_trans - no problem (i.e. could have woken up from blocked

    //                                 during a safepoint).

    //     native - register window pc patching race

    //     native_trans - momentary state

    //

    // We could just wait out a thread in native_trans to block.

    // Then we'd have all the issues that the safepoint code has as to

    // whether to spin or block. It isn't worth it. Just treat it like

    // native and be done with it.

    //

    // Examine the state of the thread at the start of safepoint since

    // threads that were in native at the start of the safepoint could

    // come to a halt during the safepoint, changing the current value

    // of the safepoint_state.

    JavaThreadState state = thread->safepoint_state()->orig_thread_state();

    if (state == _thread_in_native || state == _thread_in_native_trans) {

      // Since we are at a safepoint the target thread will stop itself

      // before it can return to java as long as we remain at the safepoint.

      // Therefore we can put an additional request for the thread to stop

      // no matter what no (like a suspend). This will cause the thread

      // to notice it needs to do the deopt on its own once it leaves native.

      //

      // The only reason we must do this is because on machine with register

      // windows we have a race with patching the return address and the

      // window coming live as the thread returns to the Java code (but still

      // in native mode) and then blocks. It is only this top most frame

      // that is at risk. So in truth we could add an additional check to

      // see if this frame is one that is at risk.

      RegisterMap map(thread, false);

      frame at_risk =  thread->last_frame().sender(&map);

      if (id() == at_risk.id()) {

        thread->set_must_deopt_id(id());

        thread->set_deopt_suspend();

        return;

      }

    }

  } // NeedsDeoptSuspend

  // If the call site is a MethodHandle call site use the MH deopt

  // handler.

  CompiledMethod* cm = (CompiledMethod*) _cb;

  address deopt = cm->is_method_handle_return(pc()) ?

                        cm->deopt_mh_handler_begin() :

                        cm->deopt_handler_begin();

  // Save the original pc before we patch in the new one

  cm->set_original_pc(this, pc());

  patch_pc(thread, deopt);

#ifdef ASSERT

  {

    RegisterMap map(thread, false);

    frame check = thread->last_frame();

    while (id() != check.id()) {

      check = check.sender(&map);

    }

    assert(check.is_deoptimized_frame(), "missed deopt");

  }

#endif // ASSERT

}

frame frame::java_sender() const {

  RegisterMap map(JavaThread::current(), false);

  frame s;

  for (s = sender(&map); !(s.is_java_frame() || s.is_first_frame()); s = s.sender(&map)) ;

  guarantee(s.is_java_frame(), "tried to get caller of first java frame");

  return s;

}

frame frame::real_sender(RegisterMap* map) const {

  frame result = sender(map);

  while (result.is_runtime_frame() ||

         result.is_ignored_frame()) {

    result = result.sender(map);

  }

  return result;

}

// Interpreter frames

void frame::interpreter_frame_set_locals(intptr_t* locs)  {

  assert(is_interpreted_frame(), "Not an interpreted frame");

  *interpreter_frame_locals_addr() = locs;

}

Method* frame::interpreter_frame_method() const {

  assert(is_interpreted_frame(), "interpreted frame expected");

  Method* m = *interpreter_frame_method_addr();

  assert(m->is_method(), "not a Method*");

  return m;

}

void frame::interpreter_frame_set_method(Method* method) {

  assert(is_interpreted_frame(), "interpreted frame expected");

  *interpreter_frame_method_addr() = method;

}

void frame::interpreter_frame_set_mirror(oop mirror) {

  assert(is_interpreted_frame(), "interpreted frame expected");

  *interpreter_frame_mirror_addr() = mirror;

}

jint frame::interpreter_frame_bci() const {

  assert(is_interpreted_frame(), "interpreted frame expected");

  address bcp = interpreter_frame_bcp();

  return interpreter_frame_method()->bci_from(bcp);

}

address frame::interpreter_frame_bcp() const {

  assert(is_interpreted_frame(), "interpreted frame expected");

  address bcp = (address)*interpreter_frame_bcp_addr();

  return interpreter_frame_method()->bcp_from(bcp);

}

void frame::interpreter_frame_set_bcp(address bcp) {

  assert(is_interpreted_frame(), "interpreted frame expected");

  *interpreter_frame_bcp_addr() = (intptr_t)bcp;

}

address frame::interpreter_frame_mdp() const {

  assert(ProfileInterpreter, "must be profiling interpreter");

  assert(is_interpreted_frame(), "interpreted frame expected");

  return (address)*interpreter_frame_mdp_addr();

}

void frame::interpreter_frame_set_mdp(address mdp) {

  assert(is_interpreted_frame(), "interpreted frame expected");

  assert(ProfileInterpreter, "must be profiling interpreter");

  *interpreter_frame_mdp_addr() = (intptr_t)mdp;

}

BasicObjectLock* frame::next_monitor_in_interpreter_frame(BasicObjectLock* current) const {

  assert(is_interpreted_frame(), "Not an interpreted frame");

#ifdef ASSERT

  interpreter_frame_verify_monitor(current);

#endif

  BasicObjectLock* next = (BasicObjectLock*) (((intptr_t*) current) + interpreter_frame_monitor_size());

  return next;

}

BasicObjectLock* frame::previous_monitor_in_interpreter_frame(BasicObjectLock* current) const {

  assert(is_interpreted_frame(), "Not an interpreted frame");

#ifdef ASSERT

//   // This verification needs to be checked before being enabled

//   interpreter_frame_verify_monitor(current);

#endif

  BasicObjectLock* previous = (BasicObjectLock*) (((intptr_t*) current) - interpreter_frame_monitor_size());

  return previous;

}

// Interpreter locals and expression stack locations.

intptr_t* frame::interpreter_frame_local_at(int index) const {

  const int n = Interpreter::local_offset_in_bytes(index)/wordSize;

  return &((*interpreter_frame_locals_addr())[n]);

}

intptr_t* frame::interpreter_frame_expression_stack_at(jint offset) const {

  const int i = offset * interpreter_frame_expression_stack_direction();

  const int n = i * Interpreter::stackElementWords;

  return &(interpreter_frame_expression_stack()[n]);

}

jint frame::interpreter_frame_expression_stack_size() const {

  // Number of elements on the interpreter expression stack

  // Callers should span by stackElementWords

  int element_size = Interpreter::stackElementWords;

  size_t stack_size = 0;

  if (frame::interpreter_frame_expression_stack_direction() < 0) {

    stack_size = (interpreter_frame_expression_stack() -

                  interpreter_frame_tos_address() + 1)/element_size;

  } else {

    stack_size = (interpreter_frame_tos_address() -

                  interpreter_frame_expression_stack() + 1)/element_size;

  }

  assert( stack_size <= (size_t)max_jint, "stack size too big");

  return ((jint)stack_size);

}

// (frame::interpreter_frame_sender_sp accessor is in frame_<arch>.cpp)

const char* frame::print_name() const {

  if (is_native_frame())      return "Native";

  if (is_interpreted_frame()) return "Interpreted";

  if (is_compiled_frame()) {

    if (is_deoptimized_frame()) return "Deoptimized";

    return "Compiled";

  }

  if (sp() == NULL)            return "Empty";

  return "C";

}

void frame::print_value_on(outputStream* st, JavaThread *thread) const {

  NOT_PRODUCT(address begin = pc()-40;)

  NOT_PRODUCT(address end   = NULL;)

  st->print("%s frame (sp=" INTPTR_FORMAT " unextended sp=" INTPTR_FORMAT, print_name(), p2i(sp()), p2i(unextended_sp()));

  if (sp() != NULL)

    st->print(", fp=" INTPTR_FORMAT ", real_fp=" INTPTR_FORMAT ", pc=" INTPTR_FORMAT,

              p2i(fp()), p2i(real_fp()), p2i(pc()));

  if (StubRoutines::contains(pc())) {

    st->print_cr(")");

    st->print("(");

    StubCodeDesc* desc = StubCodeDesc::desc_for(pc());

    st->print("~Stub::%s", desc->name());

    NOT_PRODUCT(begin = desc->begin(); end = desc->end();)

  } else if (Interpreter::contains(pc())) {

    st->print_cr(")");

    st->print("(");

    InterpreterCodelet* desc = Interpreter::codelet_containing(pc());

    if (desc != NULL) {

      st->print("~");

      desc->print_on(st);

      NOT_PRODUCT(begin = desc->code_begin(); end = desc->code_end();)

    } else {

      st->print("~interpreter");

    }