/*

 * Copyright 2008, 2009, 2010 Red Hat, Inc.

 * 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 "ci/ciField.hpp"

#include "ci/ciInstance.hpp"

#include "ci/ciObjArrayKlass.hpp"

#include "ci/ciStreams.hpp"

#include "ci/ciType.hpp"

#include "ci/ciTypeFlow.hpp"

#include "interpreter/bytecodes.hpp"

#include "memory/allocation.hpp"

#include "runtime/deoptimization.hpp"

#include "shark/llvmHeaders.hpp"

#include "shark/llvmValue.hpp"

#include "shark/sharkBuilder.hpp"

#include "shark/sharkCacheDecache.hpp"

#include "shark/sharkConstant.hpp"

#include "shark/sharkInliner.hpp"

#include "shark/sharkState.hpp"

#include "shark/sharkTopLevelBlock.hpp"

#include "shark/sharkValue.hpp"

#include "shark/shark_globals.hpp"

#include "utilities/debug.hpp"

using namespace llvm;

void SharkTopLevelBlock::scan_for_traps() {

  // If typeflow found a trap then don't scan past it

  int limit_bci = ciblock()->has_trap() ? ciblock()->trap_bci() : limit();

  // Scan the bytecode for traps that are always hit

  iter()->reset_to_bci(start());

  while (iter()->next_bci() < limit_bci) {

    iter()->next();

    ciField *field;

    ciMethod *method;

    ciInstanceKlass *klass;

    bool will_link;

    bool is_field;

    switch (bc()) {

    case Bytecodes::_ldc:

    case Bytecodes::_ldc_w:

      if (!SharkConstant::for_ldc(iter())->is_loaded()) {

        set_trap(

          Deoptimization::make_trap_request(

            Deoptimization::Reason_uninitialized,

            Deoptimization::Action_reinterpret), bci());

        return;

      }

      break;

    case Bytecodes::_getfield:

    case Bytecodes::_getstatic:

    case Bytecodes::_putfield:

    case Bytecodes::_putstatic:

      field = iter()->get_field(will_link);

      assert(will_link, "typeflow responsibility");

      is_field = (bc() == Bytecodes::_getfield || bc() == Bytecodes::_putfield);

      // If the bytecode does not match the field then bail out to

      // the interpreter to throw an IncompatibleClassChangeError

      if (is_field == field->is_static()) {

        set_trap(

          Deoptimization::make_trap_request(

            Deoptimization::Reason_unhandled,

            Deoptimization::Action_none), bci());

        return;

      }

      // Bail out if we are trying to access a static variable

      // before the class initializer has completed.

      if (!is_field && !field->holder()->is_initialized()) {

        if (!static_field_ok_in_clinit(field)) {

          set_trap(

            Deoptimization::make_trap_request(

              Deoptimization::Reason_uninitialized,

              Deoptimization::Action_reinterpret), bci());

          return;

        }

      }

      break;

    case Bytecodes::_invokestatic:

    case Bytecodes::_invokespecial:

    case Bytecodes::_invokevirtual:

    case Bytecodes::_invokeinterface:

      method = iter()->get_method(will_link);

      assert(will_link, "typeflow responsibility");

      if (!method->holder()->is_linked()) {

        set_trap(

          Deoptimization::make_trap_request(

            Deoptimization::Reason_uninitialized,

            Deoptimization::Action_reinterpret), bci());

          return;

      }

      if (bc() == Bytecodes::_invokevirtual) {

        klass = ciEnv::get_instance_klass_for_declared_method_holder(

          iter()->get_declared_method_holder());

        if (!klass->is_linked()) {

          set_trap(

            Deoptimization::make_trap_request(

              Deoptimization::Reason_uninitialized,

              Deoptimization::Action_reinterpret), bci());

            return;

        }

      }

      break;

    case Bytecodes::_new:

      klass = iter()->get_klass(will_link)->as_instance_klass();

      assert(will_link, "typeflow responsibility");

      // Bail out if the class is unloaded

      if (iter()->is_unresolved_klass() || !klass->is_initialized()) {

        set_trap(

          Deoptimization::make_trap_request(

            Deoptimization::Reason_uninitialized,

            Deoptimization::Action_reinterpret), bci());

        return;

      }

      // Bail out if the class cannot be instantiated

      if (klass->is_abstract() || klass->is_interface() ||

          klass->name() == ciSymbol::java_lang_Class()) {

        set_trap(

          Deoptimization::make_trap_request(

            Deoptimization::Reason_unhandled,

            Deoptimization::Action_reinterpret), bci());

        return;

      }

      break;

    }

  }

  // Trap if typeflow trapped (and we didn't before)

  if (ciblock()->has_trap()) {

    set_trap(

      Deoptimization::make_trap_request(

        Deoptimization::Reason_unloaded,

        Deoptimization::Action_reinterpret,

        ciblock()->trap_index()), ciblock()->trap_bci());

    return;

  }

}

bool SharkTopLevelBlock::static_field_ok_in_clinit(ciField* field) {

  assert(field->is_static(), "should be");

  // This code is lifted pretty much verbatim from C2's

  // Parse::static_field_ok_in_clinit() in parse3.cpp.

  bool access_OK = false;

  if (target()->holder()->is_subclass_of(field->holder())) {

    if (target()->is_static()) {

      if (target()->name() == ciSymbol::class_initializer_name()) {

        // It's OK to access static fields from the class initializer

        access_OK = true;

      }

    }

    else {

      if (target()->name() == ciSymbol::object_initializer_name()) {

        // It's also OK to access static fields inside a constructor,

        // because any thread calling the constructor must first have

        // synchronized on the class by executing a "new" bytecode.

        access_OK = true;

      }

    }

  }

  return access_OK;

}

SharkState* SharkTopLevelBlock::entry_state() {

  if (_entry_state == NULL) {

    assert(needs_phis(), "should do");

    _entry_state = new SharkPHIState(this);

  }

  return _entry_state;

}

void SharkTopLevelBlock::add_incoming(SharkState* incoming_state) {

  if (needs_phis()) {

    ((SharkPHIState *) entry_state())->add_incoming(incoming_state);

  }

  else if (_entry_state == NULL) {

    _entry_state = incoming_state;

  }

  else {

    assert(entry_state()->equal_to(incoming_state), "should be");

  }

}

void SharkTopLevelBlock::enter(SharkTopLevelBlock* predecessor,

                               bool is_exception) {

  // This block requires phis:

  //  - if it is entered more than once

  //  - if it is an exception handler, because in which

  //    case we assume it's entered more than once.

  //  - if the predecessor will be compiled after this

  //    block, in which case we can't simple propagate

  //    the state forward.

  if (!needs_phis() &&

      (entered() ||

       is_exception ||

       (predecessor && predecessor->index() >= index())))

    _needs_phis = true;

  // Recurse into the tree

  if (!entered()) {

    _entered = true;

    scan_for_traps();

    if (!has_trap()) {

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

        successor(i)->enter(this, false);

      }

    }

    compute_exceptions();

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

      SharkTopLevelBlock *handler = exception(i);

      if (handler)

        handler->enter(this, true);

    }

  }

}

void SharkTopLevelBlock::initialize() {

  char name[28];

  snprintf(name, sizeof(name),

           "bci_%d%s",

           start(), is_backedge_copy() ? "_backedge_copy" : "");

  _entry_block = function()->CreateBlock(name);

}

void SharkTopLevelBlock::decache_for_Java_call(ciMethod *callee) {

  SharkJavaCallDecacher(function(), bci(), callee).scan(current_state());

  for (int i = 0; i < callee->arg_size(); i++)

    xpop();

}

void SharkTopLevelBlock::cache_after_Java_call(ciMethod *callee) {

  if (callee->return_type()->size()) {

    ciType *type;

    switch (callee->return_type()->basic_type()) {

    case T_BOOLEAN:

    case T_BYTE:

    case T_CHAR:

    case T_SHORT:

      type = ciType::make(T_INT);

      break;

    default:

      type = callee->return_type();

    }

    push(SharkValue::create_generic(type, NULL, false));

  }

  SharkJavaCallCacher(function(), callee).scan(current_state());

}

void SharkTopLevelBlock::decache_for_VM_call() {

  SharkVMCallDecacher(function(), bci()).scan(current_state());

}

void SharkTopLevelBlock::cache_after_VM_call() {

  SharkVMCallCacher(function()).scan(current_state());

}

void SharkTopLevelBlock::decache_for_trap() {

  SharkTrapDecacher(function(), bci()).scan(current_state());

}

void SharkTopLevelBlock::emit_IR() {

  builder()->SetInsertPoint(entry_block());

  // Parse the bytecode

  parse_bytecode(start(), limit());

  // If this block falls through to the next then it won't have been

  // terminated by a bytecode and we have to add the branch ourselves

  if (falls_through() && !has_trap())

    do_branch(ciTypeFlow::FALL_THROUGH);

}

SharkTopLevelBlock* SharkTopLevelBlock::bci_successor(int bci) const {

  // XXX now with Linear Search Technology (tm)

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

    ciTypeFlow::Block *successor = ciblock()->successors()->at(i);

    if (successor->start() == bci)

      return function()->block(successor->pre_order());

  }

  ShouldNotReachHere();

}

void SharkTopLevelBlock::do_zero_check(SharkValue *value) {

  if (value->is_phi() && value->as_phi()->all_incomers_zero_checked()) {

    function()->add_deferred_zero_check(this, value);

  }

  else {

    BasicBlock *continue_block = function()->CreateBlock("not_zero");

    SharkState *saved_state = current_state();

    set_current_state(saved_state->copy());

    zero_check_value(value, continue_block);

    builder()->SetInsertPoint(continue_block);

    set_current_state(saved_state);

  }

  value->set_zero_checked(true);

}

void SharkTopLevelBlock::do_deferred_zero_check(SharkValue* value,

                                                int         bci,

                                                SharkState* saved_state,

                                                BasicBlock* continue_block) {

  if (value->as_phi()->all_incomers_zero_checked()) {

    builder()->CreateBr(continue_block);

  }

  else {

    iter()->force_bci(start());

    set_current_state(saved_state);

    zero_check_value(value, continue_block);

  }

}

void SharkTopLevelBlock::zero_check_value(SharkValue* value,

                                          BasicBlock* continue_block) {

  BasicBlock *zero_block = builder()->CreateBlock(continue_block, "zero");

  Value *a, *b;

  switch (value->basic_type()) {

  case T_BYTE:

  case T_CHAR:

  case T_SHORT:

  case T_INT:

    a = value->jint_value();

    b = LLVMValue::jint_constant(0);

    break;

  case T_LONG:

    a = value->jlong_value();

    b = LLVMValue::jlong_constant(0);

    break;

  case T_OBJECT:

  case T_ARRAY:

    a = value->jobject_value();

    b = LLVMValue::LLVMValue::null();

    break;

  default:

    tty->print_cr("Unhandled type %s", type2name(value->basic_type()));

    ShouldNotReachHere();

  }

  builder()->CreateCondBr(

    builder()->CreateICmpNE(a, b), continue_block, zero_block);

  builder()->SetInsertPoint(zero_block);

  if (value->is_jobject()) {

    call_vm(

      builder()->throw_NullPointerException(),

      builder()->CreateIntToPtr(

        LLVMValue::intptr_constant((intptr_t) __FILE__),

        PointerType::getUnqual(SharkType::jbyte_type())),

      LLVMValue::jint_constant(__LINE__),

      EX_CHECK_NONE);

  }

  else {

    call_vm(

      builder()->throw_ArithmeticException(),

      builder()->CreateIntToPtr(

        LLVMValue::intptr_constant((intptr_t) __FILE__),

        PointerType::getUnqual(SharkType::jbyte_type())),

      LLVMValue::jint_constant(__LINE__),

      EX_CHECK_NONE);

  }

  Value *pending_exception = get_pending_exception();

  clear_pending_exception();

  handle_exception(pending_exception, EX_CHECK_FULL);

}

void SharkTopLevelBlock::check_bounds(SharkValue* array, SharkValue* index) {

  BasicBlock *out_of_bounds = function()->CreateBlock("out_of_bounds");

  BasicBlock *in_bounds     = function()->CreateBlock("in_bounds");

  Value *length = builder()->CreateArrayLength(array->jarray_value());

  // we use an unsigned comparison to catch negative values

  builder()->CreateCondBr(

    builder()->CreateICmpULT(index->jint_value(), length),

    in_bounds, out_of_bounds);

  builder()->SetInsertPoint(out_of_bounds);

  SharkState *saved_state = current_state()->copy();

  call_vm(

    builder()->throw_ArrayIndexOutOfBoundsException(),

    builder()->CreateIntToPtr(

      LLVMValue::intptr_constant((intptr_t) __FILE__),

      PointerType::getUnqual(SharkType::jbyte_type())),

    LLVMValue::jint_constant(__LINE__),

    index->jint_value(),

    EX_CHECK_NONE);

  Value *pending_exception = get_pending_exception();

  clear_pending_exception();

  handle_exception(pending_exception, EX_CHECK_FULL);

  set_current_state(saved_state);

  builder()->SetInsertPoint(in_bounds);

}

void SharkTopLevelBlock::check_pending_exception(int action) {

  assert(action & EAM_CHECK, "should be");

  BasicBlock *exception    = function()->CreateBlock("exception");

  BasicBlock *no_exception = function()->CreateBlock("no_exception");

  Value *pending_exception = get_pending_exception();

  builder()->CreateCondBr(

    builder()->CreateICmpEQ(pending_exception, LLVMValue::null()),

    no_exception, exception);

  builder()->SetInsertPoint(exception);

  SharkState *saved_state = current_state()->copy();

  if (action & EAM_MONITOR_FUDGE) {

    // The top monitor is marked live, but the exception was thrown

    // while setting it up so we need to mark it dead before we enter

    // any exception handlers as they will not expect it to be there.

    set_num_monitors(num_monitors() - 1);

    action ^= EAM_MONITOR_FUDGE;

  }

  clear_pending_exception();

  handle_exception(pending_exception, action);

  set_current_state(saved_state);

  builder()->SetInsertPoint(no_exception);

}

void SharkTopLevelBlock::compute_exceptions() {

  ciExceptionHandlerStream str(target(), start());

  int exc_count = str.count();

  _exc_handlers = new GrowableArray<ciExceptionHandler*>(exc_count);

  _exceptions   = new GrowableArray<SharkTopLevelBlock*>(exc_count);

  int index = 0;

  for (; !str.is_done(); str.next()) {

    ciExceptionHandler *handler = str.handler();

    if (handler->handler_bci() == -1)

      break;

    _exc_handlers->append(handler);

    // Try and get this exception's handler from typeflow.  We should

    // do it this way always, really, except that typeflow sometimes

    // doesn't record exceptions, even loaded ones, and sometimes it

    // returns them with a different handler bci.  Why???

    SharkTopLevelBlock *block = NULL;

    ciInstanceKlass* klass;

    if (handler->is_catch_all()) {

      klass = java_lang_Throwable_klass();

    }

    else {

      klass = handler->catch_klass();

    }

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

      if (klass == ciblock()->exc_klasses()->at(i)) {

        block = function()->block(ciblock()->exceptions()->at(i)->pre_order());

        if (block->start() == handler->handler_bci())

          break;

        else

          block = NULL;

      }

    }

    // If typeflow let us down then try and figure it out ourselves

    if (block == NULL) {

      for (int i = 0; i < function()->block_count(); i++) {

        SharkTopLevelBlock *candidate = function()->block(i);

        if (candidate->start() == handler->handler_bci()) {

          if (block != NULL) {

            NOT_PRODUCT(warning("there may be trouble ahead"));

            block = NULL;

            break;

          }

          block = candidate;

        }

      }

    }

    _exceptions->append(block);

  }

}

void SharkTopLevelBlock::handle_exception(Value* exception, int action) {

  if (action & EAM_HANDLE && num_exceptions() != 0) {

    // Clear the stack and push the exception onto it

    while (xstack_depth())

      pop();

    push(SharkValue::create_jobject(exception, true));

    // Work out how many options we have to check

    bool has_catch_all = exc_handler(num_exceptions() - 1)->is_catch_all();

    int num_options = num_exceptions();

    if (has_catch_all)