Mercurial > hg > truffle
annotate src/share/vm/c1/c1_Compilation.hpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
| author | tonyp |
|---|---|
| date | Fri, 16 Dec 2011 02:14:27 -0500 |
| parents | 1d1603768966 |
| children | 137868b7aa6f |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2098
diff
changeset
|
2 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1397
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1397
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1397
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_C1_C1_COMPILATION_HPP |
| 26 #define SHARE_VM_C1_C1_COMPILATION_HPP | |
| 27 | |
| 28 #include "ci/ciEnv.hpp" | |
| 29 #include "code/exceptionHandlerTable.hpp" | |
| 30 #include "memory/resourceArea.hpp" | |
| 31 | |
| 0 | 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; | |
| 52 | |
| 53 | |
| 54 define_array(BasicTypeArray, BasicType) | |
| 55 define_stack(BasicTypeList, BasicTypeArray) | |
| 56 | |
| 57 define_array(ExceptionInfoArray, ExceptionInfo*) | |
| 58 define_stack(ExceptionInfoList, ExceptionInfoArray) | |
| 59 | |
| 60 class Compilation: public StackObj { | |
| 61 friend class CompilationResourceObj; | |
| 62 private: | |
| 63 // compilation specifics | |
| 1584 | 64 Arena* _arena; |
| 65 int _next_id; | |
| 66 int _next_block_id; | |
| 0 | 67 AbstractCompiler* _compiler; |
| 68 ciEnv* _env; | |
| 69 ciMethod* _method; | |
| 70 int _osr_bci; | |
| 71 IR* _hir; | |
| 72 int _max_spills; | |
| 73 FrameMap* _frame_map; | |
| 74 C1_MacroAssembler* _masm; | |
| 75 bool _has_exception_handlers; | |
| 76 bool _has_fpu_code; | |
| 77 bool _has_unsafe_access; | |
| 1783 | 78 bool _would_profile; |
|
1691
4a665be40fd3
6975855: don't emit deopt MH handler in C1 if not required
twisti
parents:
1681
diff
changeset
|
79 bool _has_method_handle_invokes; // True if this method has MethodHandle invokes. |
| 0 | 80 const char* _bailout_msg; |
| 81 ExceptionInfoList* _exception_info_list; | |
| 82 ExceptionHandlerTable _exception_handler_table; | |
| 83 ImplicitExceptionTable _implicit_exception_table; | |
| 84 LinearScan* _allocator; | |
| 85 CodeOffsets _offsets; | |
| 86 CodeBuffer _code; | |
| 87 | |
| 88 // compilation helpers | |
| 89 void initialize(); | |
| 90 void build_hir(); | |
| 91 void emit_lir(); | |
| 92 | |
| 93 void emit_code_epilog(LIR_Assembler* assembler); | |
| 94 int emit_code_body(); | |
| 95 | |
| 96 int compile_java_method(); | |
| 97 void install_code(int frame_size); | |
| 98 void compile_method(); | |
| 99 | |
| 100 void generate_exception_handler_table(); | |
| 101 | |
| 102 ExceptionInfoList* exception_info_list() const { return _exception_info_list; } | |
| 103 ExceptionHandlerTable* exception_handler_table() { return &_exception_handler_table; } | |
| 104 | |
| 105 LinearScan* allocator() { return _allocator; } | |
| 106 void set_allocator(LinearScan* allocator) { _allocator = allocator; } | |
| 107 | |
| 108 Instruction* _current_instruction; // the instruction currently being processed | |
| 109 #ifndef PRODUCT | |
| 110 Instruction* _last_instruction_printed; // the last instruction printed during traversal | |
| 111 #endif // PRODUCT | |
| 112 | |
| 113 public: | |
| 114 // creation | |
| 1584 | 115 Compilation(AbstractCompiler* compiler, ciEnv* env, ciMethod* method, |
| 116 int osr_bci, BufferBlob* buffer_blob); | |
| 0 | 117 ~Compilation(); |
| 118 | |
| 1584 | 119 |
| 120 static Compilation* current() { | |
| 121 return (Compilation*) ciEnv::current()->compiler_data(); | |
| 122 } | |
| 0 | 123 |
| 124 // accessors | |
| 125 ciEnv* env() const { return _env; } | |
| 126 AbstractCompiler* compiler() const { return _compiler; } | |
| 127 bool has_exception_handlers() const { return _has_exception_handlers; } | |
| 128 bool has_fpu_code() const { return _has_fpu_code; } | |
| 129 bool has_unsafe_access() const { return _has_unsafe_access; } | |
| 130 ciMethod* method() const { return _method; } | |
| 131 int osr_bci() const { return _osr_bci; } | |
| 132 bool is_osr_compile() const { return osr_bci() >= 0; } | |
| 133 IR* hir() const { return _hir; } | |
| 134 int max_spills() const { return _max_spills; } | |
| 135 FrameMap* frame_map() const { return _frame_map; } | |
| 136 CodeBuffer* code() { return &_code; } | |
| 137 C1_MacroAssembler* masm() const { return _masm; } | |
| 138 CodeOffsets* offsets() { return &_offsets; } | |
| 1584 | 139 Arena* arena() { return _arena; } |
| 140 | |
| 141 // Instruction ids | |
| 142 int get_next_id() { return _next_id++; } | |
| 143 int number_of_instructions() const { return _next_id; } | |
| 144 | |
| 145 // BlockBegin ids | |
| 146 int get_next_block_id() { return _next_block_id++; } | |
| 147 int number_of_blocks() const { return _next_block_id; } | |
| 0 | 148 |
| 149 // setters | |
| 150 void set_has_exception_handlers(bool f) { _has_exception_handlers = f; } | |
| 151 void set_has_fpu_code(bool f) { _has_fpu_code = f; } | |
| 152 void set_has_unsafe_access(bool f) { _has_unsafe_access = f; } | |
| 1783 | 153 void set_would_profile(bool f) { _would_profile = f; } |
| 0 | 154 // Add a set of exception handlers covering the given PC offset |
| 155 void add_exception_handlers_for_pco(int pco, XHandlers* exception_handlers); | |
| 156 // Statistics gathering | |
| 157 void notice_inlined_method(ciMethod* method); | |
| 158 | |
|
1691
4a665be40fd3
6975855: don't emit deopt MH handler in C1 if not required
twisti
parents:
1681
diff
changeset
|
159 // JSR 292 |
|
4a665be40fd3
6975855: don't emit deopt MH handler in C1 if not required
twisti
parents:
1681
diff
changeset
|
160 bool has_method_handle_invokes() const { return _has_method_handle_invokes; } |
|
4a665be40fd3
6975855: don't emit deopt MH handler in C1 if not required
twisti
parents:
1681
diff
changeset
|
161 void set_has_method_handle_invokes(bool z) { _has_method_handle_invokes = z; } |
|
4a665be40fd3
6975855: don't emit deopt MH handler in C1 if not required
twisti
parents:
1681
diff
changeset
|
162 |
| 0 | 163 DebugInformationRecorder* debug_info_recorder() const; // = _env->debug_info(); |
| 164 Dependencies* dependency_recorder() const; // = _env->dependencies() | |
| 165 ImplicitExceptionTable* implicit_exception_table() { return &_implicit_exception_table; } | |
| 166 | |
| 167 Instruction* current_instruction() const { return _current_instruction; } | |
| 168 Instruction* set_current_instruction(Instruction* instr) { | |
| 169 Instruction* previous = _current_instruction; | |
| 170 _current_instruction = instr; | |
| 171 return previous; | |
| 172 } | |
| 173 | |
| 174 #ifndef PRODUCT | |
| 175 void maybe_print_current_instruction(); | |
| 176 #endif // PRODUCT | |
| 177 | |
| 178 // error handling | |
| 179 void bailout(const char* msg); | |
| 180 bool bailed_out() const { return _bailout_msg != NULL; } | |
| 181 const char* bailout_msg() const { return _bailout_msg; } | |
| 182 | |
| 1584 | 183 static int desired_max_code_buffer_size() { |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1584
diff
changeset
|
184 #ifndef PPC |
| 1584 | 185 return (int) NMethodSizeLimit; // default 256K or 512K |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1584
diff
changeset
|
186 #else |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1584
diff
changeset
|
187 // conditional branches on PPC are restricted to 16 bit signed |
| 1899 | 188 return MIN2((unsigned int)NMethodSizeLimit,32*K); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1584
diff
changeset
|
189 #endif |
| 1584 | 190 } |
| 191 static int desired_max_constant_size() { | |
| 1899 | 192 return desired_max_code_buffer_size() / 10; |
| 1584 | 193 } |
| 194 | |
|
2098
2f9d59b0fa5c
7009268: guarantee(middle - slop > start) failed: need enough space to divide up
bobv
parents:
1972
diff
changeset
|
195 static bool setup_code_buffer(CodeBuffer* cb, int call_stub_estimate); |
| 1584 | 196 |
| 0 | 197 // timers |
| 198 static void print_timers(); | |
| 199 | |
| 200 #ifndef PRODUCT | |
| 201 // debugging support. | |
| 202 // produces a file named c1compileonly in the current directory with | |
| 203 // directives to compile only the current method and it's inlines. | |
| 204 // The file can be passed to the command line option -XX:Flags=<filename> | |
| 205 void compile_only_this_method(); | |
| 206 void compile_only_this_scope(outputStream* st, IRScope* scope); | |
| 207 void exclude_this_method(); | |
| 208 #endif // PRODUCT | |
| 1783 | 209 |
| 210 bool is_profiling() { | |
| 211 return env()->comp_level() == CompLevel_full_profile || | |
| 212 env()->comp_level() == CompLevel_limited_profile; | |
| 213 } | |
| 214 bool count_invocations() { return is_profiling(); } | |
| 215 bool count_backedges() { return is_profiling(); } | |
| 216 | |
| 217 // Helpers for generation of profile information | |
| 218 bool profile_branches() { | |
| 219 return env()->comp_level() == CompLevel_full_profile && | |
| 220 C1UpdateMethodData && C1ProfileBranches; | |
| 221 } | |
| 222 bool profile_calls() { | |
| 223 return env()->comp_level() == CompLevel_full_profile && | |
| 224 C1UpdateMethodData && C1ProfileCalls; | |
| 225 } | |
| 226 bool profile_inlined_calls() { | |
| 227 return profile_calls() && C1ProfileInlinedCalls; | |
| 228 } | |
| 229 bool profile_checkcasts() { | |
| 230 return env()->comp_level() == CompLevel_full_profile && | |
| 231 C1UpdateMethodData && C1ProfileCheckcasts; | |
| 232 } | |
| 0 | 233 }; |
| 234 | |
| 235 | |
| 236 // Macro definitions for unified bailout-support | |
| 237 // The methods bailout() and bailed_out() are present in all classes | |
| 238 // that might bailout, but forward all calls to Compilation | |
| 239 #define BAILOUT(msg) { bailout(msg); return; } | |
| 240 #define BAILOUT_(msg, res) { bailout(msg); return res; } | |
| 241 | |
| 242 #define CHECK_BAILOUT() { if (bailed_out()) return; } | |
| 243 #define CHECK_BAILOUT_(res) { if (bailed_out()) return res; } | |
| 244 | |
| 245 | |
| 246 class InstructionMark: public StackObj { | |
| 247 private: | |
| 248 Compilation* _compilation; | |
| 249 Instruction* _previous; | |
| 250 | |
| 251 public: | |
| 252 InstructionMark(Compilation* compilation, Instruction* instr) { | |
| 253 _compilation = compilation; | |
| 254 _previous = _compilation->set_current_instruction(instr); | |
| 255 } | |
| 256 ~InstructionMark() { | |
| 257 _compilation->set_current_instruction(_previous); | |
| 258 } | |
| 259 }; | |
| 260 | |
| 261 | |
| 262 //---------------------------------------------------------------------- | |
| 263 // Base class for objects allocated by the compiler in the compilation arena | |
| 264 class CompilationResourceObj ALLOCATION_SUPER_CLASS_SPEC { | |
| 265 public: | |
| 1584 | 266 void* operator new(size_t size) { return Compilation::current()->arena()->Amalloc(size); } |
| 267 void* operator new(size_t size, Arena* arena) { | |
| 268 return arena->Amalloc(size); | |
| 269 } | |
| 0 | 270 void operator delete(void* p) {} // nothing to do |
| 271 }; | |
| 272 | |
| 273 | |
| 274 //---------------------------------------------------------------------- | |
| 275 // Class for aggregating exception handler information. | |
| 276 | |
| 277 // Effectively extends XHandlers class with PC offset of | |
| 278 // potentially exception-throwing instruction. | |
| 279 // This class is used at the end of the compilation to build the | |
| 280 // ExceptionHandlerTable. | |
| 281 class ExceptionInfo: public CompilationResourceObj { | |
| 282 private: | |
| 283 int _pco; // PC of potentially exception-throwing instruction | |
| 284 XHandlers* _exception_handlers; // flat list of exception handlers covering this PC | |
| 285 | |
| 286 public: | |
| 287 ExceptionInfo(int pco, XHandlers* exception_handlers) | |
| 288 : _pco(pco) | |
| 289 , _exception_handlers(exception_handlers) | |
| 290 { } | |
| 291 | |
| 292 int pco() { return _pco; } | |
| 293 XHandlers* exception_handlers() { return _exception_handlers; } | |
| 294 }; | |
| 1972 | 295 |
| 296 #endif // SHARE_VM_C1_C1_COMPILATION_HPP |