/*

 * Copyright 1997-2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

#include "incls/_precompiled.incl"

#include "incls/_deoptimization.cpp.incl"

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;

  // PD (x86 only)

  _counter_temp              = 0;

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

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

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

    }

  }

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

#ifdef ASSERT

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

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

#endif

  // 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_at_check(method, array->element(0)->bci());

    return_type = (invoke != NULL) ? invoke->result_type(thread) : 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

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

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

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

                                      caller_adjustment * BytesPerWord,

                                      number_of_frames,

                                      frame_sizes,

                                      frame_pcs,

                                      return_type);

#if defined(IA32) || defined(AMD64)

  // We need a way to pass fp to the unpacking code so the skeletal frames

  // come out correct. This is only needed for x86 because of c2 using ebp

  // as an allocatable register. So this update is useless (and harmless)

  // on the other platforms. It would be nice to do this in a different

  // way but even the old style deoptimization had a problem with deriving

  // this value. NEEDS_CLEANUP

  // Note: now that c1 is using c2's deopt blob we must do this on all

  // x86 based platforms

  intptr_t** fp_addr = (intptr_t**) (((address)info) + info->initial_fp_offset_in_bytes());

  *fp_addr = array->sender().fp(); // was adapter_caller

#endif /* IA32 || AMD64 */

  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;

  }

  // Deallocate any resource creating in this routine and any ResourceObjs allocated

  // inside the vframeArray (StackValueCollections)

  delete thread->deopt_mark();

  thread->set_deopt_mark(NULL);

  if (JvmtiExport::can_pop_frame()) {

#ifndef CC_INTERP

    // Regardless of whether we entered this routine with the pending

    // popframe condition bit set, we should always clear it now

    thread->clear_popframe_condition();

#else

    // C++ interpeter will clear has_pending_popframe when it enters

    // with method_resume. For deopt_resume2 we clear it now.

    if (thread->popframe_forcing_deopt_reexecution())

        thread->clear_popframe_condition();

#endif /* CC_INTERP */

  }

  // unpack_frames() is called at the end of the deoptimization handler

  // and (in C2) at the end of the uncommon trap handler. Note this fact

  // so that an asynchronous stack walker can work again. This counter is

  // incremented at the beginning of fetch_unroll_info() and (in C2) at

  // the beginning of uncommon_trap().

  thread->dec_in_deopt_handler();

}

// Return BasicType of value being returned

JRT_LEAF(BasicType, Deoptimization::unpack_frames(JavaThread* thread, int exec_mode))

  // We are already active int he special DeoptResourceMark any ResourceObj's we

  // allocate will be freed at the end of the routine.

  // 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

  ResetNoHandleMark rnhm; // No-op in release/product versions

  HandleMark hm;

  frame stub_frame = thread->last_frame();

  // Since the frame to unpack is the top frame of this thread, the vframe_array_head

  // must point to the vframeArray for the unpack frame.

  vframeArray* array = thread->vframe_array_head();

#ifndef PRODUCT

  if (TraceDeoptimization) {

    tty->print_cr("DEOPT UNPACKING thread " INTPTR_FORMAT " vframeArray " INTPTR_FORMAT " mode %d", thread, array, exec_mode);

  }

#endif

  UnrollBlock* info = array->unroll_block();

  // Unpack the interpreter frames and any adapter frame (c2 only) we might create.

  array->unpack_to_stack(stub_frame, exec_mode);

  BasicType bt = info->return_type();

  // If we have an exception pending, claim that the return type is an oop

  // so the deopt_blob does not overwrite the exception_oop.

  if (exec_mode == Unpack_exception)

    bt = T_OBJECT;

  // Cleanup thread deopt data

  cleanup_deopt_info(thread, array);

#ifndef PRODUCT

  if (VerifyStack) {

    ResourceMark res_mark;

    // Verify that the just-unpacked frames match the interpreter's

    // notions of expression stack and locals

    vframeArray* cur_array = thread->vframe_array_last();

    RegisterMap rm(thread, false);

    rm.set_include_argument_oops(false);

    bool is_top_frame = true;

    int callee_size_of_parameters = 0;

    int callee_max_locals = 0;

    for (int i = 0; i < cur_array->frames(); i++) {

      vframeArrayElement* el = cur_array->element(i);

      frame* iframe = el->iframe();

      guarantee(iframe->is_interpreted_frame(), "Wrong frame type");

      // Get the oop map for this bci

      InterpreterOopMap mask;

      int cur_invoke_parameter_size = 0;

      bool try_next_mask = false;

      int next_mask_expression_stack_size = -1;

      int top_frame_expression_stack_adjustment = 0;

      methodHandle mh(thread, iframe->interpreter_frame_method());

      OopMapCache::compute_one_oop_map(mh, iframe->interpreter_frame_bci(), &mask);

      BytecodeStream str(mh);

      str.set_start(iframe->interpreter_frame_bci());

      int max_bci = mh->code_size();

      // Get to the next bytecode if possible

      assert(str.bci() < max_bci, "bci in interpreter frame out of bounds");

      // Check to see if we can grab the number of outgoing arguments

      // at an uncommon trap for an invoke (where the compiler

      // generates debug info before the invoke has executed)

      Bytecodes::Code cur_code = str.next();

      if (cur_code == Bytecodes::_invokevirtual ||

          cur_code == Bytecodes::_invokespecial ||

          cur_code == Bytecodes::_invokestatic  ||

          cur_code == Bytecodes::_invokeinterface) {

        Bytecode_invoke* invoke = Bytecode_invoke_at(mh, iframe->interpreter_frame_bci());

        symbolHandle signature(thread, invoke->signature());

        ArgumentSizeComputer asc(signature);

        cur_invoke_parameter_size = asc.size();

        if (cur_code != Bytecodes::_invokestatic) {

          // Add in receiver

          ++cur_invoke_parameter_size;

        }

      }

      if (str.bci() < max_bci) {

        Bytecodes::Code bc = str.next();

        if (bc >= 0) {

          // The interpreter oop map generator reports results before

          // the current bytecode has executed except in the case of