/*

 * Copyright (c) 1997, 2011, 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 "classfile/systemDictionary.hpp"

#include "code/debugInfoRec.hpp"

#include "code/nmethod.hpp"

#include "code/pcDesc.hpp"

#include "code/scopeDesc.hpp"

#include "interpreter/bytecode.hpp"

#include "interpreter/interpreter.hpp"

#include "interpreter/oopMapCache.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/methodOop.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/sharedRuntime.hpp"

#include "runtime/signature.hpp"

#include "runtime/stubRoutines.hpp"

#include "runtime/thread.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vframeArray.hpp"

#include "runtime/vframe_hp.hpp"

#include "utilities/events.hpp"

#include "utilities/xmlstream.hpp"

#ifdef TARGET_ARCH_x86

# include "vmreg_x86.inline.hpp"

#endif

#ifdef TARGET_ARCH_sparc

# include "vmreg_sparc.inline.hpp"

#endif

#ifdef TARGET_ARCH_zero

# include "vmreg_zero.inline.hpp"

#endif

#ifdef TARGET_ARCH_arm

# include "vmreg_arm.inline.hpp"

#endif

#ifdef TARGET_ARCH_ppc

# include "vmreg_ppc.inline.hpp"

#endif

#ifdef COMPILER2

#ifdef TARGET_ARCH_MODEL_x86_32

# include "adfiles/ad_x86_32.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_x86_64

# include "adfiles/ad_x86_64.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_sparc

# include "adfiles/ad_sparc.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_zero

# include "adfiles/ad_zero.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_arm

# include "adfiles/ad_arm.hpp"

#endif

#ifdef TARGET_ARCH_MODEL_ppc

# include "adfiles/ad_ppc.hpp"

#endif

#endif

bool DeoptimizationMarker::_is_active = false;

Deoptimization::UnrollBlock::UnrollBlock(int  size_of_deoptimized_frame,

                                         int  caller_adjustment,

                                         int  number_of_frames,

                                         intptr_t* frame_sizes,

                                         address* frame_pcs,

                                         BasicType return_type) {

  _size_of_deoptimized_frame = size_of_deoptimized_frame;

  _caller_adjustment         = caller_adjustment;

  _number_of_frames          = number_of_frames;

  _frame_sizes               = frame_sizes;

  _frame_pcs                 = frame_pcs;

  _register_block            = NEW_C_HEAP_ARRAY(intptr_t, RegisterMap::reg_count * 2);

  _return_type               = return_type;

  _initial_fp                = 0;

  // PD (x86 only)

  _counter_temp              = 0;

  _unpack_kind               = 0;

  _sender_sp_temp            = 0;

  _total_frame_sizes         = size_of_frames();

}

Deoptimization::UnrollBlock::~UnrollBlock() {

  FREE_C_HEAP_ARRAY(intptr_t, _frame_sizes);

  FREE_C_HEAP_ARRAY(intptr_t, _frame_pcs);

  FREE_C_HEAP_ARRAY(intptr_t, _register_block);

}

intptr_t* Deoptimization::UnrollBlock::value_addr_at(int register_number) const {

  assert(register_number < RegisterMap::reg_count, "checking register number");

  return &_register_block[register_number * 2];

}

int Deoptimization::UnrollBlock::size_of_frames() const {

  // Acount first for the adjustment of the initial frame

  int result = _caller_adjustment;

  for (int index = 0; index < number_of_frames(); index++) {

    result += frame_sizes()[index];

  }

  return result;

}

void Deoptimization::UnrollBlock::print() {

  ttyLocker ttyl;

  tty->print_cr("UnrollBlock");

  tty->print_cr("  size_of_deoptimized_frame = %d", _size_of_deoptimized_frame);

  tty->print(   "  frame_sizes: ");

  for (int index = 0; index < number_of_frames(); index++) {

    tty->print("%d ", frame_sizes()[index]);

  }

  tty->cr();

}

// In order to make fetch_unroll_info work properly with escape

// analysis, The method was changed from JRT_LEAF to JRT_BLOCK_ENTRY and

// ResetNoHandleMark and HandleMark were removed from it. The actual reallocation

// of previously eliminated objects occurs in realloc_objects, which is

// called from the method fetch_unroll_info_helper below.

JRT_BLOCK_ENTRY(Deoptimization::UnrollBlock*, Deoptimization::fetch_unroll_info(JavaThread* thread))

  // It is actually ok to allocate handles in a leaf method. It causes no safepoints,

  // but makes the entry a little slower. There is however a little dance we have to

  // do in debug mode to get around the NoHandleMark code in the JRT_LEAF macro

  // fetch_unroll_info() is called at the beginning of the deoptimization

  // handler. Note this fact before we start generating temporary frames

  // that can confuse an asynchronous stack walker. This counter is

  // decremented at the end of unpack_frames().

  thread->inc_in_deopt_handler();

  return fetch_unroll_info_helper(thread);

JRT_END

// This is factored, since it is both called from a JRT_LEAF (deoptimization) and a JRT_ENTRY (uncommon_trap)

Deoptimization::UnrollBlock* Deoptimization::fetch_unroll_info_helper(JavaThread* thread) {

  // Note: there is a safepoint safety issue here. No matter whether we enter

  // via vanilla deopt or uncommon trap we MUST NOT stop at a safepoint once

  // the vframeArray is created.

  //

  // Allocate our special deoptimization ResourceMark

  DeoptResourceMark* dmark = new DeoptResourceMark(thread);

  assert(thread->deopt_mark() == NULL, "Pending deopt!");

  thread->set_deopt_mark(dmark);

  frame stub_frame = thread->last_frame(); // Makes stack walkable as side effect

  RegisterMap map(thread, true);

  RegisterMap dummy_map(thread, false);

  // Now get the deoptee with a valid map

  frame deoptee = stub_frame.sender(&map);

  // Set the deoptee nmethod

  assert(thread->deopt_nmethod() == NULL, "Pending deopt!");

  thread->set_deopt_nmethod(deoptee.cb()->as_nmethod_or_null());

  if (VerifyStack) {

    thread->validate_frame_layout();

  }

  // Create a growable array of VFrames where each VFrame represents an inlined

  // Java frame.  This storage is allocated with the usual system arena.

  assert(deoptee.is_compiled_frame(), "Wrong frame type");

  GrowableArray<compiledVFrame*>* chunk = new GrowableArray<compiledVFrame*>(10);

  vframe* vf = vframe::new_vframe(&deoptee, &map, thread);

  while (!vf->is_top()) {

    assert(vf->is_compiled_frame(), "Wrong frame type");

    chunk->push(compiledVFrame::cast(vf));

    vf = vf->sender();

  }

  assert(vf->is_compiled_frame(), "Wrong frame type");

  chunk->push(compiledVFrame::cast(vf));

#ifdef COMPILER2

  // Reallocate the non-escaping objects and restore their fields. Then

  // relock objects if synchronization on them was eliminated.

  if (DoEscapeAnalysis) {

    if (EliminateAllocations) {

      assert (chunk->at(0)->scope() != NULL,"expect only compiled java frames");

      GrowableArray<ScopeValue*>* objects = chunk->at(0)->scope()->objects();

      // The flag return_oop() indicates call sites which return oop

      // in compiled code. Such sites include java method calls,

      // runtime calls (for example, used to allocate new objects/arrays

      // on slow code path) and any other calls generated in compiled code.

      // It is not guaranteed that we can get such information here only

      // by analyzing bytecode in deoptimized frames. This is why this flag

      // is set during method compilation (see Compile::Process_OopMap_Node()).

      bool save_oop_result = chunk->at(0)->scope()->return_oop();

      Handle return_value;

      if (save_oop_result) {

        // Reallocation may trigger GC. If deoptimization happened on return from

        // call which returns oop we need to save it since it is not in oopmap.

        oop result = deoptee.saved_oop_result(&map);

        assert(result == NULL || result->is_oop(), "must be oop");

        return_value = Handle(thread, result);

        assert(Universe::heap()->is_in_or_null(result), "must be heap pointer");

        if (TraceDeoptimization) {

          tty->print_cr("SAVED OOP RESULT " INTPTR_FORMAT " in thread " INTPTR_FORMAT, result, thread);

        }

      }

      bool reallocated = false;

      if (objects != NULL) {

        JRT_BLOCK

          reallocated = realloc_objects(thread, &deoptee, objects, THREAD);

        JRT_END

      }

      if (reallocated) {

        reassign_fields(&deoptee, &map, objects);

#ifndef PRODUCT

        if (TraceDeoptimization) {

          ttyLocker ttyl;

          tty->print_cr("REALLOC OBJECTS in thread " INTPTR_FORMAT, thread);

          print_objects(objects);

        }

#endif

      }

      if (save_oop_result) {

        // Restore result.

        deoptee.set_saved_oop_result(&map, return_value());

      }

    }

    if (EliminateLocks) {

#ifndef PRODUCT

      bool first = true;

#endif

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

        compiledVFrame* cvf = chunk->at(i);

        assert (cvf->scope() != NULL,"expect only compiled java frames");

        GrowableArray<MonitorInfo*>* monitors = cvf->monitors();

        if (monitors->is_nonempty()) {

          relock_objects(monitors, thread);

#ifndef PRODUCT

          if (TraceDeoptimization) {

            ttyLocker ttyl;

            for (int j = 0; j < monitors->length(); j++) {

              MonitorInfo* mi = monitors->at(j);

              if (mi->eliminated()) {

                if (first) {

                  first = false;

                  tty->print_cr("RELOCK OBJECTS in thread " INTPTR_FORMAT, thread);

                }

                tty->print_cr("     object <" INTPTR_FORMAT "> locked", mi->owner());

              }

            }

          }

#endif

        }

      }

    }

  }

#endif // COMPILER2

  // Ensure that no safepoint is taken after pointers have been stored

  // in fields of rematerialized objects.  If a safepoint occurs from here on

  // out the java state residing in the vframeArray will be missed.

  No_Safepoint_Verifier no_safepoint;

  vframeArray* array = create_vframeArray(thread, deoptee, &map, chunk);

  assert(thread->vframe_array_head() == NULL, "Pending deopt!");;

  thread->set_vframe_array_head(array);

  // Now that the vframeArray has been created if we have any deferred local writes

  // added by jvmti then we can free up that structure as the data is now in the

  // vframeArray

  if (thread->deferred_locals() != NULL) {

    GrowableArray<jvmtiDeferredLocalVariableSet*>* list = thread->deferred_locals();

    int i = 0;

    do {

      // Because of inlining we could have multiple vframes for a single frame

      // and several of the vframes could have deferred writes. Find them all.

      if (list->at(i)->id() == array->original().id()) {

        jvmtiDeferredLocalVariableSet* dlv = list->at(i);

        list->remove_at(i);

        // individual jvmtiDeferredLocalVariableSet are CHeapObj's

        delete dlv;

      } else {

        i++;

      }

    } while ( i < list->length() );

    if (list->length() == 0) {

      thread->set_deferred_locals(NULL);

      // free the list and elements back to C heap.

      delete list;

    }

  }

#ifndef SHARK

  // Compute the caller frame based on the sender sp of stub_frame and stored frame sizes info.

  CodeBlob* cb = stub_frame.cb();

  // Verify we have the right vframeArray

  assert(cb->frame_size() >= 0, "Unexpected frame size");

  intptr_t* unpack_sp = stub_frame.sp() + cb->frame_size();

  // If the deopt call site is a MethodHandle invoke call site we have

  // to adjust the unpack_sp.

  nmethod* deoptee_nm = deoptee.cb()->as_nmethod_or_null();

  if (deoptee_nm != NULL && deoptee_nm->is_method_handle_return(deoptee.pc()))

    unpack_sp = deoptee.unextended_sp();

#ifdef ASSERT

  assert(cb->is_deoptimization_stub() || cb->is_uncommon_trap_stub(), "just checking");

  Events::log("fetch unroll sp " INTPTR_FORMAT, unpack_sp);

#endif

#else

  intptr_t* unpack_sp = stub_frame.sender(&dummy_map).unextended_sp();

#endif // !SHARK

  // This is a guarantee instead of an assert because if vframe doesn't match

  // we will unpack the wrong deoptimized frame and wind up in strange places

  // where it will be very difficult to figure out what went wrong. Better

  // to die an early death here than some very obscure death later when the

  // trail is cold.

  // Note: on ia64 this guarantee can be fooled by frames with no memory stack

  // in that it will fail to detect a problem when there is one. This needs

  // more work in tiger timeframe.

  guarantee(array->unextended_sp() == unpack_sp, "vframe_array_head must contain the vframeArray to unpack");

  int number_of_frames = array->frames();

  // Compute the vframes' sizes.  Note that frame_sizes[] entries are ordered from outermost to innermost

  // virtual activation, which is the reverse of the elements in the vframes array.

  intptr_t* frame_sizes = NEW_C_HEAP_ARRAY(intptr_t, number_of_frames);

  // +1 because we always have an interpreter return address for the final slot.

  address* frame_pcs = NEW_C_HEAP_ARRAY(address, number_of_frames + 1);

  int callee_parameters = 0;

  int callee_locals = 0;

  int popframe_extra_args = 0;

  // Create an interpreter return address for the stub to use as its return

  // address so the skeletal frames are perfectly walkable

  frame_pcs[number_of_frames] = Interpreter::deopt_entry(vtos, 0);

  // PopFrame requires that the preserved incoming arguments from the recently-popped topmost

  // activation be put back on the expression stack of the caller for reexecution

  if (JvmtiExport::can_pop_frame() && thread->popframe_forcing_deopt_reexecution()) {

    popframe_extra_args = in_words(thread->popframe_preserved_args_size_in_words());

  }

  //

  // frame_sizes/frame_pcs[0] oldest frame (int or c2i)

  // frame_sizes/frame_pcs[1] next oldest frame (int)

  // frame_sizes/frame_pcs[n] youngest frame (int)

  //

  // Now a pc in frame_pcs is actually the return address to the frame's caller (a frame

  // owns the space for the return address to it's caller).  Confusing ain't it.

  //

  // The vframe array can address vframes with indices running from

  // 0.._frames-1. Index  0 is the youngest frame and _frame - 1 is the oldest (root) frame.

  // When we create the skeletal frames we need the oldest frame to be in the zero slot

  // in the frame_sizes/frame_pcs so the assembly code can do a trivial walk.

  // so things look a little strange in this loop.

  //

  for (int index = 0; index < array->frames(); index++ ) {

    // frame[number_of_frames - 1 ] = on_stack_size(youngest)

    // frame[number_of_frames - 2 ] = on_stack_size(sender(youngest))

    // frame[number_of_frames - 3 ] = on_stack_size(sender(sender(youngest)))

    frame_sizes[number_of_frames - 1 - index] = BytesPerWord * array->element(index)->on_stack_size(callee_parameters,

                                                                                                    callee_locals,

                                                                                                    index == 0,

                                                                                                    popframe_extra_args);

    // This pc doesn't have to be perfect just good enough to identify the frame

    // as interpreted so the skeleton frame will be walkable

    // The correct pc will be set when the skeleton frame is completely filled out

    // The final pc we store in the loop is wrong and will be overwritten below

    frame_pcs[number_of_frames - 1 - index ] = Interpreter::deopt_entry(vtos, 0) - frame::pc_return_offset;

    callee_parameters = array->element(index)->method()->size_of_parameters();

    callee_locals = array->element(index)->method()->max_locals();

    popframe_extra_args = 0;

  }

  // Compute whether the root vframe returns a float or double value.

  BasicType return_type;

  {

    HandleMark hm;

    methodHandle method(thread, array->element(0)->method());

    Bytecode_invoke invoke = Bytecode_invoke_check(method, array->element(0)->bci());

    return_type = invoke.is_valid() ? invoke.result_type() : T_ILLEGAL;

  }

  // Compute information for handling adapters and adjusting the frame size of the caller.

  int caller_adjustment = 0;

  // Find the current pc for sender of the deoptee. Since the sender may have been deoptimized

  // itself since the deoptee vframeArray was created we must get a fresh value of the pc rather

  // than simply use array->sender.pc(). This requires us to walk the current set of frames

  //

  frame deopt_sender = stub_frame.sender(&dummy_map); // First is the deoptee frame

  deopt_sender = deopt_sender.sender(&dummy_map);     // Now deoptee caller

  // It's possible that the number of paramters at the call site is

  // different than number of arguments in the callee when method

  // handles are used.  If the caller is interpreted get the real

  // value so that the proper amount of space can be added to it's

  // frame.

  int sender_callee_parameters = callee_parameters;

  if (deopt_sender.is_interpreted_frame()) {

    methodHandle method = deopt_sender.interpreter_frame_method();

    Bytecode_invoke cur = Bytecode_invoke_check(method,

                                                deopt_sender.interpreter_frame_bci());

    Symbol* signature = method->constants()->signature_ref_at(cur.index());

    ArgumentSizeComputer asc(signature);

  }

  // Compute the amount the oldest interpreter frame will have to adjust

  // its caller's stack by. If the caller is a compiled frame then

  // we pretend that the callee has no parameters so that the

  // extension counts for the full amount of locals and not just

  // locals-parms. This is because without a c2i adapter the parm

  // area as created by the compiled frame will not be usable by

  // the interpreter. (Depending on the calling convention there

  // may not even be enough space).

  // QQQ I'd rather see this pushed down into last_frame_adjust

  // and have it take the sender (aka caller).

  if (deopt_sender.is_compiled_frame()) {

    caller_adjustment = last_frame_adjust(0, callee_locals);

  } else if (callee_locals > sender_callee_parameters) {

    // The caller frame may need extending to accommodate

    // non-parameter locals of the first unpacked interpreted frame.

    // Compute that adjustment.

    caller_adjustment = last_frame_adjust(sender_callee_parameters, callee_locals);

  }

  // If the sender is deoptimized the we must retrieve the address of the handler

  // since the frame will "magically" show the original pc before the deopt

  // and we'd undo the deopt.

  frame_pcs[0] = deopt_sender.raw_pc();

#ifndef SHARK

  assert(CodeCache::find_blob_unsafe(frame_pcs[0]) != NULL, "bad pc");

#endif // SHARK

  UnrollBlock* info = new UnrollBlock(array->frame_size() * BytesPerWord,

                                      caller_adjustment * BytesPerWord,

                                      number_of_frames,

                                      frame_sizes,

                                      frame_pcs,

                                      return_type);

  // On some platforms, we need a way to pass fp to the unpacking code

  // so the skeletal frames come out correct.

  info->set_initial_fp((intptr_t) array->sender().fp());

  if (array->frames() > 1) {

    if (VerifyStack && TraceDeoptimization) {

      tty->print_cr("Deoptimizing method containing inlining");

    }

  }

  array->set_unroll_block(info);

  return info;

}

// Called to cleanup deoptimization data structures in normal case

// after unpacking to stack and when stack overflow error occurs

void Deoptimization::cleanup_deopt_info(JavaThread *thread,

                                        vframeArray *array) {

  // Get array if coming from exception

  if (array == NULL) {

    array = thread->vframe_array_head();

  }

  thread->set_vframe_array_head(NULL);

  // Free the previous UnrollBlock

  vframeArray* old_array = thread->vframe_array_last();

  thread->set_vframe_array_last(array);

  if (old_array != NULL) {

    UnrollBlock* old_info = old_array->unroll_block();

    old_array->set_unroll_block(NULL);

    delete old_info;

    delete old_array;