src/share/vm/c1/c1_Compilation.hpp

Fri, 12 Oct 2012 09:22:52 -0700

author
kvn
date
Fri, 12 Oct 2012 09:22:52 -0700
changeset 4164
d804e148cff8
parent 4153
b9a9ed0f8eeb
parent 4154
c3e799c37717
child 4860
46f6f063b272
permissions
-rw-r--r--

Merge

     1 /*
     2  * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     4  *
     5  * This code is free software; you can redistribute it and/or modify it
     6  * under the terms of the GNU General Public License version 2 only, as
     7  * published by the Free Software Foundation.
     8  *
     9  * This code is distributed in the hope that it will be useful, but WITHOUT
    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    12  * version 2 for more details (a copy is included in the LICENSE file that
    13  * accompanied this code).
    14  *
    15  * You should have received a copy of the GNU General Public License version
    16  * 2 along with this work; if not, write to the Free Software Foundation,
    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    18  *
    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
    20  * or visit www.oracle.com if you need additional information or have any
    21  * questions.
    22  *
    23  */
    25 #ifndef SHARE_VM_C1_C1_COMPILATION_HPP
    26 #define SHARE_VM_C1_C1_COMPILATION_HPP
    28 #include "ci/ciEnv.hpp"
    29 #include "code/exceptionHandlerTable.hpp"
    30 #include "memory/resourceArea.hpp"
    32 class CompilationResourceObj;
    33 class XHandlers;
    34 class ExceptionInfo;
    35 class DebugInformationRecorder;
    36 class FrameMap;
    37 class IR;
    38 class IRScope;
    39 class Instruction;
    40 class LinearScan;
    41 class OopMap;
    42 class LIR_Emitter;
    43 class LIR_Assembler;
    44 class CodeEmitInfo;
    45 class ciEnv;
    46 class ciMethod;
    47 class ValueStack;
    48 class LIR_OprDesc;
    49 class C1_MacroAssembler;
    50 class CFGPrinter;
    51 typedef LIR_OprDesc* LIR_Opr;
    54 define_array(BasicTypeArray, BasicType)
    55 define_stack(BasicTypeList, BasicTypeArray)
    57 define_array(ExceptionInfoArray, ExceptionInfo*)
    58 define_stack(ExceptionInfoList,  ExceptionInfoArray)
    60 class Compilation: public StackObj {
    61   friend class CompilationResourceObj;
    62  private:
    63   // compilation specifics
    64   Arena* _arena;
    65   int _next_id;
    66   int _next_block_id;
    67   AbstractCompiler*  _compiler;
    68   ciEnv*             _env;
    69   CompileLog*        _log;
    70   ciMethod*          _method;
    71   int                _osr_bci;
    72   IR*                _hir;
    73   int                _max_spills;
    74   FrameMap*          _frame_map;
    75   C1_MacroAssembler* _masm;
    76   bool               _has_exception_handlers;
    77   bool               _has_fpu_code;
    78   bool               _has_unsafe_access;
    79   bool               _would_profile;
    80   bool               _has_method_handle_invokes;  // True if this method has MethodHandle invokes.
    81   const char*        _bailout_msg;
    82   ExceptionInfoList* _exception_info_list;
    83   ExceptionHandlerTable _exception_handler_table;
    84   ImplicitExceptionTable _implicit_exception_table;
    85   LinearScan*        _allocator;
    86   CodeOffsets        _offsets;
    87   CodeBuffer         _code;
    89   // compilation helpers
    90   void initialize();
    91   void build_hir();
    92   void emit_lir();
    94   void emit_code_epilog(LIR_Assembler* assembler);
    95   int  emit_code_body();
    97   int  compile_java_method();
    98   void install_code(int frame_size);
    99   void compile_method();
   101   void generate_exception_handler_table();
   103   ExceptionInfoList* exception_info_list() const { return _exception_info_list; }
   104   ExceptionHandlerTable* exception_handler_table() { return &_exception_handler_table; }
   106   LinearScan* allocator()                          { return _allocator;      }
   107   void        set_allocator(LinearScan* allocator) { _allocator = allocator; }
   109   Instruction*       _current_instruction;       // the instruction currently being processed
   110 #ifndef PRODUCT
   111   Instruction*       _last_instruction_printed;  // the last instruction printed during traversal
   112 #endif // PRODUCT
   114  public:
   115   // creation
   116   Compilation(AbstractCompiler* compiler, ciEnv* env, ciMethod* method,
   117               int osr_bci, BufferBlob* buffer_blob);
   118   ~Compilation();
   121   static Compilation* current() {
   122     return (Compilation*) ciEnv::current()->compiler_data();
   123   }
   125   // accessors
   126   ciEnv* env() const                             { return _env; }
   127   CompileLog* log() const                        { return _log; }
   128   AbstractCompiler* compiler() const             { return _compiler; }
   129   bool has_exception_handlers() const            { return _has_exception_handlers; }
   130   bool has_fpu_code() const                      { return _has_fpu_code; }
   131   bool has_unsafe_access() const                 { return _has_unsafe_access; }
   132   int max_vector_size() const                    { return 0; }
   133   ciMethod* method() const                       { return _method; }
   134   int osr_bci() const                            { return _osr_bci; }
   135   bool is_osr_compile() const                    { return osr_bci() >= 0; }
   136   IR* hir() const                                { return _hir; }
   137   int max_spills() const                         { return _max_spills; }
   138   FrameMap* frame_map() const                    { return _frame_map; }
   139   CodeBuffer* code()                             { return &_code; }
   140   C1_MacroAssembler* masm() const                { return _masm; }
   141   CodeOffsets* offsets()                         { return &_offsets; }
   142   Arena* arena()                                 { return _arena; }
   144   // Instruction ids
   145   int get_next_id()                              { return _next_id++; }
   146   int number_of_instructions() const             { return _next_id; }
   148   // BlockBegin ids
   149   int get_next_block_id()                        { return _next_block_id++; }
   150   int number_of_blocks() const                   { return _next_block_id; }
   152   // setters
   153   void set_has_exception_handlers(bool f)        { _has_exception_handlers = f; }
   154   void set_has_fpu_code(bool f)                  { _has_fpu_code = f; }
   155   void set_has_unsafe_access(bool f)             { _has_unsafe_access = f; }
   156   void set_would_profile(bool f)                 { _would_profile = f; }
   157   // Add a set of exception handlers covering the given PC offset
   158   void add_exception_handlers_for_pco(int pco, XHandlers* exception_handlers);
   159   // Statistics gathering
   160   void notice_inlined_method(ciMethod* method);
   162   // JSR 292
   163   bool     has_method_handle_invokes() const { return _has_method_handle_invokes;     }
   164   void set_has_method_handle_invokes(bool z) {        _has_method_handle_invokes = z; }
   166   DebugInformationRecorder* debug_info_recorder() const; // = _env->debug_info();
   167   Dependencies* dependency_recorder() const; // = _env->dependencies()
   168   ImplicitExceptionTable* implicit_exception_table()     { return &_implicit_exception_table; }
   170   Instruction* current_instruction() const       { return _current_instruction; }
   171   Instruction* set_current_instruction(Instruction* instr) {
   172     Instruction* previous = _current_instruction;
   173     _current_instruction = instr;
   174     return previous;
   175   }
   177 #ifndef PRODUCT
   178   void maybe_print_current_instruction();
   179 #endif // PRODUCT
   181   // error handling
   182   void bailout(const char* msg);
   183   bool bailed_out() const                        { return _bailout_msg != NULL; }
   184   const char* bailout_msg() const                { return _bailout_msg; }
   186   static int desired_max_code_buffer_size() {
   187 #ifndef PPC
   188     return (int) NMethodSizeLimit;  // default 256K or 512K
   189 #else
   190     // conditional branches on PPC are restricted to 16 bit signed
   191     return MIN2((unsigned int)NMethodSizeLimit,32*K);
   192 #endif
   193   }
   194   static int desired_max_constant_size() {
   195     return desired_max_code_buffer_size() / 10;
   196   }
   198   static bool setup_code_buffer(CodeBuffer* cb, int call_stub_estimate);
   200   // timers
   201   static void print_timers();
   203 #ifndef PRODUCT
   204   // debugging support.
   205   // produces a file named c1compileonly in the current directory with
   206   // directives to compile only the current method and it's inlines.
   207   // The file can be passed to the command line option -XX:Flags=<filename>
   208   void compile_only_this_method();
   209   void compile_only_this_scope(outputStream* st, IRScope* scope);
   210   void exclude_this_method();
   211 #endif // PRODUCT
   213   bool is_profiling() {
   214     return env()->comp_level() == CompLevel_full_profile ||
   215            env()->comp_level() == CompLevel_limited_profile;
   216   }
   217   bool count_invocations() { return is_profiling(); }
   218   bool count_backedges()   { return is_profiling(); }
   220   // Helpers for generation of profile information
   221   bool profile_branches() {
   222     return env()->comp_level() == CompLevel_full_profile &&
   223       C1UpdateMethodData && C1ProfileBranches;
   224   }
   225   bool profile_calls() {
   226     return env()->comp_level() == CompLevel_full_profile &&
   227       C1UpdateMethodData && C1ProfileCalls;
   228   }
   229   bool profile_inlined_calls() {
   230     return profile_calls() && C1ProfileInlinedCalls;
   231   }
   232   bool profile_checkcasts() {
   233     return env()->comp_level() == CompLevel_full_profile &&
   234       C1UpdateMethodData && C1ProfileCheckcasts;
   235   }
   236 };
   239 // Macro definitions for unified bailout-support
   240 // The methods bailout() and bailed_out() are present in all classes
   241 // that might bailout, but forward all calls to Compilation
   242 #define BAILOUT(msg)               { bailout(msg); return;              }
   243 #define BAILOUT_(msg, res)         { bailout(msg); return res;          }
   245 #define CHECK_BAILOUT()            { if (bailed_out()) return;          }
   246 #define CHECK_BAILOUT_(res)        { if (bailed_out()) return res;      }
   249 class InstructionMark: public StackObj {
   250  private:
   251   Compilation* _compilation;
   252   Instruction*  _previous;
   254  public:
   255   InstructionMark(Compilation* compilation, Instruction* instr) {
   256     _compilation = compilation;
   257     _previous = _compilation->set_current_instruction(instr);
   258   }
   259   ~InstructionMark() {
   260     _compilation->set_current_instruction(_previous);
   261   }
   262 };
   265 //----------------------------------------------------------------------
   266 // Base class for objects allocated by the compiler in the compilation arena
   267 class CompilationResourceObj ALLOCATION_SUPER_CLASS_SPEC {
   268  public:
   269   void* operator new(size_t size) { return Compilation::current()->arena()->Amalloc(size); }
   270   void* operator new(size_t size, Arena* arena) {
   271     return arena->Amalloc(size);
   272   }
   273   void  operator delete(void* p) {} // nothing to do
   274 };
   277 //----------------------------------------------------------------------
   278 // Class for aggregating exception handler information.
   280 // Effectively extends XHandlers class with PC offset of
   281 // potentially exception-throwing instruction.
   282 // This class is used at the end of the compilation to build the
   283 // ExceptionHandlerTable.
   284 class ExceptionInfo: public CompilationResourceObj {
   285  private:
   286   int             _pco;                // PC of potentially exception-throwing instruction
   287   XHandlers*      _exception_handlers; // flat list of exception handlers covering this PC
   289  public:
   290   ExceptionInfo(int pco, XHandlers* exception_handlers)
   291     : _pco(pco)
   292     , _exception_handlers(exception_handlers)
   293   { }
   295   int pco()                                      { return _pco; }
   296   XHandlers* exception_handlers()                { return _exception_handlers; }
   297 };
   299 #endif // SHARE_VM_C1_C1_COMPILATION_HPP

mercurial