jdk8-mips64-public/hotspot: src/share/vm/shark/sharkState.hpp@710a3c8b516e (annotated)

src/share/vm/shark/sharkState.hpp@710a3c8b516e (annotated)

src/share/vm/shark/sharkState.hpp

Tue, 08 Aug 2017 15:57:29 +0800

author: aoqi
date: Tue, 08 Aug 2017 15:57:29 +0800
changeset 6876: 710a3c8b516e
parent 2314: f95d63e2154a
parent 0: f90c822e73f8
permissions: -rw-r--r--

merge

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

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/shark/sharkState.hpp@710a3c8b516e (annotated)

src/share/vm/shark/sharkState.hpp