Mercurial > hg > graal-compiler
view src/share/vm/shark/sharkInvariants.hpp @ 17472:2a907fd129cb
Merge
author | chegar |
---|---|
date | Fri, 06 Sep 2013 09:55:38 +0100 |
parents | c095a7f289aa |
children | de6a9e811145 |
line wrap: on
line source
/* * 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_SHARKINVARIANTS_HPP #define SHARE_VM_SHARK_SHARKINVARIANTS_HPP #include "ci/ciEnv.hpp" #include "ci/ciInstanceKlass.hpp" #include "ci/ciMethod.hpp" #include "ci/ciTypeFlow.hpp" #include "code/debugInfoRec.hpp" #include "code/dependencies.hpp" #include "memory/allocation.hpp" #include "shark/llvmHeaders.hpp" #include "shark/sharkBuilder.hpp" // Base classes used to track various values through the compilation. // SharkCompileInvariants is used to track values which remain the // same for the top-level method and any inlined methods it may have // (ie for the whole compilation). SharkTargetInvariants is used to // track values which differ between methods. class SharkCompileInvariants : public ResourceObj { protected: SharkCompileInvariants(ciEnv* env, SharkBuilder* builder) : _env(env), _builder(builder), _thread(NULL) {} SharkCompileInvariants(const SharkCompileInvariants* parent) : _env(parent->_env), _builder(parent->_builder), _thread(parent->_thread) {} private: ciEnv* _env; SharkBuilder* _builder; llvm::Value* _thread; // Top-level broker for HotSpot's Compiler Interface. // // Its main purpose is to allow the various CI classes to access // oops in the VM without having to worry about safepointing. In // addition to this it acts as a holder for various recorders and // memory allocators. // // Accessing this directly is kind of ugly, so it's private. Add // new accessors below if you need something from it. protected: ciEnv* env() const { assert(_env != NULL, "env not available"); return _env; } // The SharkBuilder that is used to build LLVM IR. protected: SharkBuilder* builder() const { return _builder; } // Pointer to this thread's JavaThread object. This is not // available until a short way into SharkFunction creation // so a setter is required. Assertions are used to enforce // invariance. protected: llvm::Value* thread() const { assert(_thread != NULL, "thread not available"); return _thread; } void set_thread(llvm::Value* thread) { assert(_thread == NULL, "thread already set"); _thread = thread; } // Objects that handle various aspects of the compilation. protected: DebugInformationRecorder* debug_info() const { return env()->debug_info(); } SharkCodeBuffer* code_buffer() const { return builder()->code_buffer(); } public: Dependencies* dependencies() const { return env()->dependencies(); } // Commonly used classes protected: ciInstanceKlass* java_lang_Object_klass() const { return env()->Object_klass(); } ciInstanceKlass* java_lang_Throwable_klass() const { return env()->Throwable_klass(); } }; class SharkTargetInvariants : public SharkCompileInvariants { protected: SharkTargetInvariants(ciEnv* env, SharkBuilder* builder, ciTypeFlow* flow) : SharkCompileInvariants(env, builder), _target(flow->method()), _flow(flow), _max_monitors(count_monitors()) {} SharkTargetInvariants(const SharkCompileInvariants* parent, ciMethod* target) : SharkCompileInvariants(parent), _target(target), _flow(NULL), _max_monitors(count_monitors()) {} SharkTargetInvariants(const SharkTargetInvariants* parent) : SharkCompileInvariants(parent), _target(parent->_target), _flow(parent->_flow), _max_monitors(parent->_max_monitors) {} private: int count_monitors(); private: ciMethod* _target; ciTypeFlow* _flow; int _max_monitors; // The method being compiled. protected: ciMethod* target() const { return _target; } // Typeflow analysis of the method being compiled. protected: ciTypeFlow* flow() const { assert(_flow != NULL, "typeflow not available"); return _flow; } // Properties of the method. protected: int max_locals() const { return target()->max_locals(); } int max_stack() const { return target()->max_stack(); } int max_monitors() const { return _max_monitors; } int arg_size() const { return target()->arg_size(); } bool is_static() const { return target()->is_static(); } bool is_synchronized() const { return target()->is_synchronized(); } }; #endif // SHARE_VM_SHARK_SHARKINVARIANTS_HPP