< prev index next >

src/hotspot/share/c1/c1_Compilation.hpp

Print this page

 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  */
 24 
 25 #ifndef SHARE_C1_C1_COMPILATION_HPP
 26 #define SHARE_C1_C1_COMPILATION_HPP
 27 
 28 #include "ci/ciEnv.hpp"
 29 #include "ci/ciMethodData.hpp"
 30 #include "code/exceptionHandlerTable.hpp"
 31 #include "compiler/compiler_globals.hpp"
 32 #include "compiler/compilerDirectives.hpp"
 33 #include "memory/resourceArea.hpp"
 34 #include "runtime/deoptimization.hpp"

 35 
 36 class CompilationResourceObj;
 37 class XHandlers;
 38 class ExceptionInfo;
 39 class DebugInformationRecorder;
 40 class FrameMap;
 41 class IR;
 42 class IRScope;
 43 class Instruction;
 44 class LinearScan;
 45 class OopMap;
 46 class LIR_Emitter;
 47 class LIR_Assembler;
 48 class CodeEmitInfo;
 49 class ciEnv;
 50 class ciMethod;
 51 class ValueStack;
 52 class C1_MacroAssembler;
 53 class CFGPrinter;
 54 class CFGPrinterOutput;

 74   int                _max_spills;
 75   FrameMap*          _frame_map;
 76   C1_MacroAssembler* _masm;
 77   bool               _has_exception_handlers;
 78   bool               _has_fpu_code;
 79   bool               _has_unsafe_access;
 80   bool               _has_irreducible_loops;
 81   bool               _would_profile;
 82   bool               _has_method_handle_invokes;  // True if this method has MethodHandle invokes.
 83   bool               _has_reserved_stack_access;
 84   bool               _install_code;
 85   const char*        _bailout_msg;
 86   ExceptionInfoList* _exception_info_list;
 87   ExceptionHandlerTable _exception_handler_table;
 88   ImplicitExceptionTable _implicit_exception_table;
 89   LinearScan*        _allocator;
 90   CodeOffsets        _offsets;
 91   CodeBuffer         _code;
 92   bool               _has_access_indexed;
 93   int                _interpreter_frame_size; // Stack space needed in case of a deoptimization

 94 
 95   // compilation helpers
 96   void initialize();
 97   void build_hir();
 98   void emit_lir();
 99 
100   void emit_code_epilog(LIR_Assembler* assembler);
101   int  emit_code_body();
102 
103   int  compile_java_method();
104   void install_code(int frame_size);
105   void compile_method();
106 
107   void generate_exception_handler_table();
108 
109   ExceptionInfoList* exception_info_list() const { return _exception_info_list; }
110   ExceptionHandlerTable* exception_handler_table() { return &_exception_handler_table; }
111 
112   void        set_allocator(LinearScan* allocator) { _allocator = allocator; }
113 

241   }
242   bool profile_inlined_calls() {
243     return profile_calls() && C1ProfileInlinedCalls;
244   }
245   bool profile_checkcasts() {
246     return env()->comp_level() == CompLevel_full_profile &&
247       C1UpdateMethodData && C1ProfileCheckcasts;
248   }
249   bool profile_parameters() {
250     return env()->comp_level() == CompLevel_full_profile &&
251       C1UpdateMethodData && MethodData::profile_parameters();
252   }
253   bool profile_arguments() {
254     return env()->comp_level() == CompLevel_full_profile &&
255       C1UpdateMethodData && MethodData::profile_arguments();
256   }
257   bool profile_return() {
258     return env()->comp_level() == CompLevel_full_profile &&
259       C1UpdateMethodData && MethodData::profile_return();
260   }




261   bool age_code() const {
262     return _method->profile_aging();
263   }
264 
265   // will compilation make optimistic assumptions that might lead to
266   // deoptimization and that the runtime will account for?
267   bool is_optimistic() {
268     return CompilerConfig::is_c1_only_no_jvmci() && !is_profiling() &&
269       (RangeCheckElimination || UseLoopInvariantCodeMotion) &&
270       method()->method_data()->trap_count(Deoptimization::Reason_none) == 0;
271   }
272 
273   ciKlass* cha_exact_type(ciType* type);
274 
275   // Dump inlining replay data to the stream.
276   void dump_inline_data(outputStream* out) { /* do nothing now */ }
277 
278   // How much stack space would the interpreter need in case of a
279   // deoptimization (worst case)
280   void update_interpreter_frame_size(int size) {
281     if (_interpreter_frame_size < size) {
282       _interpreter_frame_size = size;
283     }
284   }
285 
286   int interpreter_frame_size() const {
287     return _interpreter_frame_size;
288   }







289 };
290 
291 
292 // Macro definitions for unified bailout-support
293 // The methods bailout() and bailed_out() are present in all classes
294 // that might bailout, but forward all calls to Compilation
295 #define BAILOUT(msg)               { bailout(msg); return;              }
296 #define BAILOUT_(msg, res)         { bailout(msg); return res;          }
297 
298 #define CHECK_BAILOUT()            { if (bailed_out()) return;          }
299 #define CHECK_BAILOUT_(res)        { if (bailed_out()) return res;      }
300 
301 // BAILOUT check with reset of bound labels
302 #define CHECK_BAILOUT1(l1)         { if (bailed_out()) { l1.reset();                         return; } }
303 #define CHECK_BAILOUT2(l1, l2)     { if (bailed_out()) { l1.reset(); l2.reset();             return; } }
304 #define CHECK_BAILOUT3(l1, l2, l3) { if (bailed_out()) { l1.reset(); l2.reset(); l3.reset(); return; } }
305 
306 
307 class InstructionMark: public StackObj {
308  private:

 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  */
 24 
 25 #ifndef SHARE_C1_C1_COMPILATION_HPP
 26 #define SHARE_C1_C1_COMPILATION_HPP
 27 
 28 #include "ci/ciEnv.hpp"
 29 #include "ci/ciMethodData.hpp"
 30 #include "code/exceptionHandlerTable.hpp"
 31 #include "compiler/compiler_globals.hpp"
 32 #include "compiler/compilerDirectives.hpp"
 33 #include "memory/resourceArea.hpp"
 34 #include "runtime/deoptimization.hpp"
 35 #include "runtime/sharedRuntime.hpp"
 36 
 37 class CompilationResourceObj;
 38 class XHandlers;
 39 class ExceptionInfo;
 40 class DebugInformationRecorder;
 41 class FrameMap;
 42 class IR;
 43 class IRScope;
 44 class Instruction;
 45 class LinearScan;
 46 class OopMap;
 47 class LIR_Emitter;
 48 class LIR_Assembler;
 49 class CodeEmitInfo;
 50 class ciEnv;
 51 class ciMethod;
 52 class ValueStack;
 53 class C1_MacroAssembler;
 54 class CFGPrinter;
 55 class CFGPrinterOutput;

 75   int                _max_spills;
 76   FrameMap*          _frame_map;
 77   C1_MacroAssembler* _masm;
 78   bool               _has_exception_handlers;
 79   bool               _has_fpu_code;
 80   bool               _has_unsafe_access;
 81   bool               _has_irreducible_loops;
 82   bool               _would_profile;
 83   bool               _has_method_handle_invokes;  // True if this method has MethodHandle invokes.
 84   bool               _has_reserved_stack_access;
 85   bool               _install_code;
 86   const char*        _bailout_msg;
 87   ExceptionInfoList* _exception_info_list;
 88   ExceptionHandlerTable _exception_handler_table;
 89   ImplicitExceptionTable _implicit_exception_table;
 90   LinearScan*        _allocator;
 91   CodeOffsets        _offsets;
 92   CodeBuffer         _code;
 93   bool               _has_access_indexed;
 94   int                _interpreter_frame_size; // Stack space needed in case of a deoptimization
 95   CompiledEntrySignature _compiled_entry_signature;
 96 
 97   // compilation helpers
 98   void initialize();
 99   void build_hir();
100   void emit_lir();
101 
102   void emit_code_epilog(LIR_Assembler* assembler);
103   int  emit_code_body();
104 
105   int  compile_java_method();
106   void install_code(int frame_size);
107   void compile_method();
108 
109   void generate_exception_handler_table();
110 
111   ExceptionInfoList* exception_info_list() const { return _exception_info_list; }
112   ExceptionHandlerTable* exception_handler_table() { return &_exception_handler_table; }
113 
114   void        set_allocator(LinearScan* allocator) { _allocator = allocator; }
115 

243   }
244   bool profile_inlined_calls() {
245     return profile_calls() && C1ProfileInlinedCalls;
246   }
247   bool profile_checkcasts() {
248     return env()->comp_level() == CompLevel_full_profile &&
249       C1UpdateMethodData && C1ProfileCheckcasts;
250   }
251   bool profile_parameters() {
252     return env()->comp_level() == CompLevel_full_profile &&
253       C1UpdateMethodData && MethodData::profile_parameters();
254   }
255   bool profile_arguments() {
256     return env()->comp_level() == CompLevel_full_profile &&
257       C1UpdateMethodData && MethodData::profile_arguments();
258   }
259   bool profile_return() {
260     return env()->comp_level() == CompLevel_full_profile &&
261       C1UpdateMethodData && MethodData::profile_return();
262   }
263   bool profile_array_accesses() {
264     return env()->comp_level() == CompLevel_full_profile &&
265       C1UpdateMethodData;
266   }
267   bool age_code() const {
268     return _method->profile_aging();
269   }
270 
271   // will compilation make optimistic assumptions that might lead to
272   // deoptimization and that the runtime will account for?
273   bool is_optimistic() {
274     return CompilerConfig::is_c1_only_no_jvmci() && !is_profiling() &&
275       (RangeCheckElimination || UseLoopInvariantCodeMotion) &&
276       method()->method_data()->trap_count(Deoptimization::Reason_none) == 0;
277   }
278 
279   ciKlass* cha_exact_type(ciType* type);
280 
281   // Dump inlining replay data to the stream.
282   void dump_inline_data(outputStream* out) { /* do nothing now */ }
283 
284   // How much stack space would the interpreter need in case of a
285   // deoptimization (worst case)
286   void update_interpreter_frame_size(int size) {
287     if (_interpreter_frame_size < size) {
288       _interpreter_frame_size = size;
289     }
290   }
291 
292   int interpreter_frame_size() const {
293     return _interpreter_frame_size;
294   }
295 
296   const CompiledEntrySignature* compiled_entry_signature() const {
297     return &_compiled_entry_signature;
298   }
299   bool needs_stack_repair() const {
300     return compiled_entry_signature()->c1_needs_stack_repair();
301   }
302 };
303 
304 
305 // Macro definitions for unified bailout-support
306 // The methods bailout() and bailed_out() are present in all classes
307 // that might bailout, but forward all calls to Compilation
308 #define BAILOUT(msg)               { bailout(msg); return;              }
309 #define BAILOUT_(msg, res)         { bailout(msg); return res;          }
310 
311 #define CHECK_BAILOUT()            { if (bailed_out()) return;          }
312 #define CHECK_BAILOUT_(res)        { if (bailed_out()) return res;      }
313 
314 // BAILOUT check with reset of bound labels
315 #define CHECK_BAILOUT1(l1)         { if (bailed_out()) { l1.reset();                         return; } }
316 #define CHECK_BAILOUT2(l1, l2)     { if (bailed_out()) { l1.reset(); l2.reset();             return; } }
317 #define CHECK_BAILOUT3(l1, l2, l3) { if (bailed_out()) { l1.reset(); l2.reset(); l3.reset(); return; } }
318 
319 
320 class InstructionMark: public StackObj {
321  private:
< prev index next >