/*

 * Copyright 1997-2008 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/_frame.cpp.incl"

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 "] = ", 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()) {

    return ((nmethod*) cb())->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_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_nmethod() &&

      ((nmethod*)_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()->anchor()->last_Java_sp() == NULL;

}

bool frame::should_be_deoptimized() const {

  if (_deopt_state == is_deoptimized ||

      !is_compiled_frame() ) return false;

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

  nmethod* nm = (nmethod *)_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;

  nmethod* nm = (nmethod*)_cb;

  if( !nm->can_be_deoptimized() )

    return false;

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

}

void frame::deoptimize(JavaThread* thread, bool thread_is_known_safe) {

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

  // Store the original pc before an patch (or request to self-deopt)

  // in the published location of the frame.

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

  nmethod* nm = (nmethod*)_cb;

  // This is a fix for register window patching race

  if (NeedsDeoptSuspend && !thread_is_known_safe) {

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

    //

    JavaThreadState state = thread->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

  address deopt = nm->deopt_handler_begin();

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

  nm->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 = result.sender(map);

  }

  return result;

}

// Note: called by profiler - NOT for current thread

frame frame::profile_find_Java_sender_frame(JavaThread *thread) {

// If we don't recognize this frame, walk back up the stack until we do

  RegisterMap map(thread, false);

  frame first_java_frame = frame();

  // Find the first Java frame on the stack starting with input frame

  if (is_java_frame()) {

    // top frame is compiled frame or deoptimized frame

    first_java_frame = *this;

  } else if (safe_for_sender(thread)) {

    for (frame sender_frame = sender(&map);

      sender_frame.safe_for_sender(thread) && !sender_frame.is_first_frame();

      sender_frame = sender_frame.sender(&map)) {

      if (sender_frame.is_java_frame()) {

        first_java_frame = sender_frame;

        break;

      }

    }

  }

  return first_java_frame;

}

// Interpreter frames

void frame::interpreter_frame_set_locals(intptr_t* locs)  {

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

  *interpreter_frame_locals_addr() = locs;

}

methodOop frame::interpreter_frame_method() const {

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

  methodOop m = *interpreter_frame_method_addr();

  assert(m->is_perm(), "bad methodOop in interpreter frame");

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

  return m;

}

void frame::interpreter_frame_set_method(methodOop method) {

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

  *interpreter_frame_method_addr() = method;

}

void frame::interpreter_frame_set_bcx(intptr_t bcx) {

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

  if (ProfileInterpreter) {

    bool formerly_bci = is_bci(interpreter_frame_bcx());

    bool is_now_bci = is_bci(bcx);

    *interpreter_frame_bcx_addr() = bcx;

    intptr_t mdx = interpreter_frame_mdx();

    if (mdx != 0) {

      if (formerly_bci) {

        if (!is_now_bci) {

          // The bcx was just converted from bci to bcp.

          // Convert the mdx in parallel.

          methodDataOop mdo = interpreter_frame_method()->method_data();

          assert(mdo != NULL, "");

          int mdi = mdx - 1; // We distinguish valid mdi from zero by adding one.

          address mdp = mdo->di_to_dp(mdi);

          interpreter_frame_set_mdx((intptr_t)mdp);

        }

      } else {

        if (is_now_bci) {

          // The bcx was just converted from bcp to bci.

          // Convert the mdx in parallel.

          methodDataOop mdo = interpreter_frame_method()->method_data();

          assert(mdo != NULL, "");

          int mdi = mdo->dp_to_di((address)mdx);

          interpreter_frame_set_mdx((intptr_t)mdi + 1); // distinguish valid from 0.

        }

      }

    }

  } else {

    *interpreter_frame_bcx_addr() = bcx;

  }

}

jint frame::interpreter_frame_bci() const {

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

  intptr_t bcx = interpreter_frame_bcx();

  return is_bci(bcx) ? bcx : interpreter_frame_method()->bci_from((address)bcx);

}

void frame::interpreter_frame_set_bci(jint bci) {

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

  assert(!is_bci(interpreter_frame_bcx()), "should not set bci during GC");

  interpreter_frame_set_bcx((intptr_t)interpreter_frame_method()->bcp_from(bci));

}

address frame::interpreter_frame_bcp() const {

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

  intptr_t bcx = interpreter_frame_bcx();

  return is_bci(bcx) ? interpreter_frame_method()->bcp_from(bcx) : (address)bcx;

}

void frame::interpreter_frame_set_bcp(address bcp) {

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

  assert(!is_bci(interpreter_frame_bcx()), "should not set bcp during GC");

  interpreter_frame_set_bcx((intptr_t)bcp);

}

void frame::interpreter_frame_set_mdx(intptr_t mdx) {

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

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

  *interpreter_frame_mdx_addr() = mdx;

}

address frame::interpreter_frame_mdp() const {

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

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

  intptr_t bcx = interpreter_frame_bcx();

  intptr_t mdx = interpreter_frame_mdx();

  assert(!is_bci(bcx), "should not access mdp during GC");

  return (address)mdx;

}

void frame::interpreter_frame_set_mdp(address mdp) {

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

  if (mdp == NULL) {

    // Always allow the mdp to be cleared.

    interpreter_frame_set_mdx((intptr_t)mdp);

  }

  intptr_t bcx = interpreter_frame_bcx();

  assert(!is_bci(bcx), "should not set mdp during GC");

  interpreter_frame_set_mdx((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]);

}

frame::Tag frame::interpreter_frame_local_tag(int index) const {

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

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

}

void frame::interpreter_frame_set_local_tag(int index, Tag tag) const {

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

  (*interpreter_frame_locals_addr())[n] = (intptr_t)tag;

}

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::stackElementSize()) +

                 Interpreter::value_offset_in_bytes())/wordSize;

  return &(interpreter_frame_expression_stack()[n]);

}

frame::Tag frame::interpreter_frame_expression_stack_tag(jint offset) const {

  const int i = offset * interpreter_frame_expression_stack_direction();

  const int n = ((i * Interpreter::stackElementSize()) +

                 Interpreter::tag_offset_in_bytes())/wordSize;

  return (Tag)(interpreter_frame_expression_stack()[n]);

}

void frame::interpreter_frame_set_expression_stack_tag(jint offset,

                                                       Tag tag) const {

  const int i = offset * interpreter_frame_expression_stack_direction();

  const int n = ((i * Interpreter::stackElementSize()) +

                 Interpreter::tag_offset_in_bytes())/wordSize;

  interpreter_frame_expression_stack()[n] = (intptr_t)tag;

}

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

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

    return (interpreter_frame_expression_stack() -

            interpreter_frame_tos_address() + 1)/element_size;

  } else {

    return (interpreter_frame_tos_address() -

            interpreter_frame_expression_stack() + 1)/element_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(), sp(), unextended_sp());

  if (sp() != NULL)

    st->print(", fp=" INTPTR_FORMAT ", pc=" INTPTR_FORMAT, fp(), pc());