/*

 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.

 * Copyright 2008, 2009 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/ciTypeFlow.hpp"

#include "memory/allocation.hpp"

#include "shark/llvmHeaders.hpp"

#include "shark/llvmValue.hpp"

#include "shark/sharkBuilder.hpp"

#include "shark/sharkEntry.hpp"

#include "shark/sharkFunction.hpp"

#include "shark/sharkState.hpp"

#include "shark/sharkTopLevelBlock.hpp"

#include "shark/shark_globals.hpp"

#include "utilities/debug.hpp"

using namespace llvm;

void SharkFunction::initialize(const char *name) {

  // Create the function

  _function = Function::Create(

    entry_point_type(),

    GlobalVariable::InternalLinkage,

    name);

  // Get our arguments

  Function::arg_iterator ai = function()->arg_begin();

  Argument *method = ai++;

  method->setName("method");

  Argument *osr_buf = NULL;

  if (is_osr()) {

    osr_buf = ai++;

    osr_buf->setName("osr_buf");

  }

  Argument *base_pc = ai++;

  base_pc->setName("base_pc");

  code_buffer()->set_base_pc(base_pc);

  Argument *thread = ai++;

  thread->setName("thread");

  set_thread(thread);

  // Create the list of blocks

  set_block_insertion_point(NULL);

  _blocks = NEW_RESOURCE_ARRAY(SharkTopLevelBlock*, block_count());

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

    ciTypeFlow::Block *b = flow()->pre_order_at(i);

    // Work around a bug in pre_order_at() that does not return

    // the correct pre-ordering.  If pre_order_at() were correct

    // this line could simply be:

    // _blocks[i] = new SharkTopLevelBlock(this, b);

    _blocks[b->pre_order()] = new SharkTopLevelBlock(this, b);

  }

  // Walk the tree from the start block to determine which

  // blocks are entered and which blocks require phis

  SharkTopLevelBlock *start_block = block(flow()->start_block_num());

  if (is_osr() && start_block->stack_depth_at_entry() != 0) {

    env()->record_method_not_compilable("can't compile OSR block with incoming stack-depth > 0");

    return;

  }

  assert(start_block->start() == flow()->start_bci(), "blocks out of order");

  start_block->enter();

  // Initialize all entered blocks

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

    if (block(i)->entered())

      block(i)->initialize();

  }

  // Create and push our stack frame

  set_block_insertion_point(&function()->front());

  builder()->SetInsertPoint(CreateBlock());

  _stack = SharkStack::CreateBuildAndPushFrame(this, method);

  // Create the entry state

  SharkState *entry_state;

  if (is_osr()) {

    entry_state = new SharkOSREntryState(start_block, method, osr_buf);

    // Free the OSR buffer

    builder()->CreateCall(builder()->osr_migration_end(), osr_buf);

  }

  else {

    entry_state = new SharkNormalEntryState(start_block, method);

    // Lock if necessary

    if (is_synchronized()) {

      SharkTopLevelBlock *locker =

        new SharkTopLevelBlock(this, start_block->ciblock());

      locker->add_incoming(entry_state);

      set_block_insertion_point(start_block->entry_block());

      locker->acquire_method_lock();

      entry_state = locker->current_state();

    }

  }

  // Transition into the method proper

  start_block->add_incoming(entry_state);

  builder()->CreateBr(start_block->entry_block());

  // Parse the blocks

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

    if (!block(i)->entered())

      continue;

    if (i + 1 < block_count())

      set_block_insertion_point(block(i + 1)->entry_block());

    else

      set_block_insertion_point(NULL);

    block(i)->emit_IR();

  }

  do_deferred_zero_checks();

}

class DeferredZeroCheck : public SharkTargetInvariants {

 public:

  DeferredZeroCheck(SharkTopLevelBlock* block, SharkValue* value)

    : SharkTargetInvariants(block),

      _block(block),

      _value(value),

      _bci(block->bci()),

      _state(block->current_state()->copy()),

      _check_block(builder()->GetInsertBlock()),

      _continue_block(function()->CreateBlock("not_zero")) {

    builder()->SetInsertPoint(continue_block());

  }

 private:

  SharkTopLevelBlock* _block;

  SharkValue*         _value;

  int                 _bci;

  SharkState*         _state;

  BasicBlock*         _check_block;

  BasicBlock*         _continue_block;

 public:

  SharkTopLevelBlock* block() const {

    return _block;

  }

  SharkValue* value() const {

    return _value;

  }

  int bci() const {

    return _bci;

  }

  SharkState* state() const {

    return _state;

  }

  BasicBlock* check_block() const {

    return _check_block;

  }

  BasicBlock* continue_block() const {

    return _continue_block;

  }

 public:

  SharkFunction* function() const {

    return block()->function();

  }

 public:

  void process() const {

    builder()->SetInsertPoint(check_block());

    block()->do_deferred_zero_check(value(), bci(), state(), continue_block());

  }

};

void SharkFunction::add_deferred_zero_check(SharkTopLevelBlock* block,

                                            SharkValue*         value) {

  deferred_zero_checks()->append(new DeferredZeroCheck(block, value));

}

void SharkFunction::do_deferred_zero_checks() {

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

    deferred_zero_checks()->at(i)->process();

}