/*

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

 *

 */

#ifndef SHARE_VM_SHARK_SHARKSTATE_HPP

#define SHARE_VM_SHARK_SHARKSTATE_HPP

#include "ci/ciMethod.hpp"

#include "memory/allocation.hpp"

#include "shark/llvmHeaders.hpp"

#include "shark/sharkBuilder.hpp"

#include "shark/sharkInvariants.hpp"

#include "shark/sharkValue.hpp"

class SharkState : public SharkTargetInvariants {

 public:

  SharkState(const SharkTargetInvariants* parent)

    : SharkTargetInvariants(parent),

      _method(NULL),

      _oop_tmp(NULL),

      _has_safepointed(false) { initialize(NULL); }

  SharkState(const SharkState* state)

    : SharkTargetInvariants(state),

      _method(state->_method),

      _oop_tmp(state->_oop_tmp),

      _has_safepointed(state->_has_safepointed) { initialize(state); }

 private:

  void initialize(const SharkState* state);

 private:

  llvm::Value* _method;

  SharkValue** _locals;

  SharkValue** _stack;

  SharkValue** _sp;

  int          _num_monitors;

  llvm::Value* _oop_tmp;

  bool         _has_safepointed;

  // Method

 public:

  llvm::Value** method_addr() {

    return &_method;

  }

  llvm::Value* method() const {

    return _method;

  }

 protected:

  void set_method(llvm::Value* method) {

    _method = method;

  }

  // Local variables

 public:

  SharkValue** local_addr(int index) const {

    assert(index >= 0 && index < max_locals(), "bad local variable index");

    return &_locals[index];

  }

  SharkValue* local(int index) const {

    return *local_addr(index);

  }

  void set_local(int index, SharkValue* value) {

    *local_addr(index) = value;

  }

  // Expression stack

 public:

  SharkValue** stack_addr(int slot) const {

    assert(slot >= 0 && slot < stack_depth(), "bad stack slot");

    return &_sp[-(slot + 1)];

  }

  SharkValue* stack(int slot) const {

    return *stack_addr(slot);

  }

 protected:

  void set_stack(int slot, SharkValue* value) {

    *stack_addr(slot) = value;

  }

 public:

  int stack_depth() const {

    return _sp - _stack;

  }

  void push(SharkValue* value) {

    assert(stack_depth() < max_stack(), "stack overrun");

    *(_sp++) = value;

  }

  SharkValue* pop() {

    assert(stack_depth() > 0, "stack underrun");

    return *(--_sp);

  }

  // Monitors

 public:

  int num_monitors() const {

    return _num_monitors;

  }

  void set_num_monitors(int num_monitors) {

    _num_monitors = num_monitors;

  }

  // Temporary oop slot

 public:

  llvm::Value** oop_tmp_addr() {

    return &_oop_tmp;

  }

  llvm::Value* oop_tmp() const {

    return _oop_tmp;

  }

  void set_oop_tmp(llvm::Value* oop_tmp) {

    _oop_tmp = oop_tmp;

  }

  // Safepointed status

 public:

  bool has_safepointed() const {

    return _has_safepointed;

  }

  void set_has_safepointed(bool has_safepointed) {

    _has_safepointed = has_safepointed;

  }

  // Comparison

 public:

  bool equal_to(SharkState* other);

  // Copy and merge

 public:

  SharkState* copy() const {

    return new SharkState(this);

  }

  void merge(SharkState*       other,

             llvm::BasicBlock* other_block,

             llvm::BasicBlock* this_block);

  // Value replacement

 public:

  void replace_all(SharkValue* old_value, SharkValue* new_value);

};

class SharkTopLevelBlock;

// SharkNormalEntryState objects are used to create the state

// that the method will be entered with for a normal invocation.

class SharkNormalEntryState : public SharkState {

 public:

  SharkNormalEntryState(SharkTopLevelBlock* block,

                        llvm::Value*        method);

};

// SharkOSREntryState objects are used to create the state

// that the method will be entered with for an OSR invocation.

class SharkOSREntryState : public SharkState {

 public:

  SharkOSREntryState(SharkTopLevelBlock* block,

                     llvm::Value*        method,

                     llvm::Value*        osr_buf);

};

// SharkPHIState objects are used to manage the entry state

// for blocks with more than one entry path or for blocks

// entered from blocks that will be compiled later.

class SharkPHIState : public SharkState {

 public:

  SharkPHIState(SharkTopLevelBlock* block);

 private:

  SharkTopLevelBlock* _block;

 private:

  SharkTopLevelBlock* block() const {

    return _block;

  }

 public:

  void add_incoming(SharkState* incoming_state);

};

#endif // SHARE_VM_SHARK_SHARKSTATE_HPP