Mercurial > hg > truffle
annotate src/share/vm/c1/c1_Compilation.hpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | 0bf37f737702 |
| children | 52b4284cb496 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
12146
9758d9f36299
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
8860
diff
changeset
|
2 * Copyright (c) 1999, 2013, 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" | |
| 8860 | 29 #include "ci/ciMethodData.hpp" |
| 1972 | 30 #include "code/exceptionHandlerTable.hpp" |
| 31 #include "memory/resourceArea.hpp" | |
| 8860 | 32 #include "runtime/deoptimization.hpp" |
| 1972 | 33 |
| 0 | 34 class CompilationResourceObj; |
| 35 class XHandlers; | |
| 36 class ExceptionInfo; | |
| 37 class DebugInformationRecorder; | |
| 38 class FrameMap; | |
| 39 class IR; | |
| 40 class IRScope; | |
| 41 class Instruction; | |
| 42 class LinearScan; | |
| 43 class OopMap; | |
| 44 class LIR_Emitter; | |
| 45 class LIR_Assembler; | |
| 46 class CodeEmitInfo; | |
| 47 class ciEnv; | |
| 48 class ciMethod; | |
| 49 class ValueStack; | |
| 50 class LIR_OprDesc; | |
| 51 class C1_MacroAssembler; | |
| 52 class CFGPrinter; | |
| 53 typedef LIR_OprDesc* LIR_Opr; | |
| 54 | |
| 55 | |
| 56 define_array(BasicTypeArray, BasicType) | |
| 57 define_stack(BasicTypeList, BasicTypeArray) | |
| 58 | |
| 59 define_array(ExceptionInfoArray, ExceptionInfo*) | |
| 60 define_stack(ExceptionInfoList, ExceptionInfoArray) | |
| 61 | |
| 62 class Compilation: public StackObj { | |
| 63 friend class CompilationResourceObj; | |
| 64 private: | |
| 65 // compilation specifics | |
| 1584 | 66 Arena* _arena; |
| 67 int _next_id; | |
| 68 int _next_block_id; | |
| 0 | 69 AbstractCompiler* _compiler; |
| 70 ciEnv* _env; | |
| 6843 | 71 CompileLog* _log; |
| 0 | 72 ciMethod* _method; |
| 73 int _osr_bci; | |
| 74 IR* _hir; | |
| 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; | |
| 1783 | 81 bool _would_profile; |
|
1691
4a665be40fd3
6975855: don't emit deopt MH handler in C1 if not required
twisti
parents:
1681
diff
changeset
|
82 bool _has_method_handle_invokes; // True if this method has MethodHandle invokes. |
| 0 | 83 const char* _bailout_msg; |
| 84 ExceptionInfoList* _exception_info_list; | |
| 85 ExceptionHandlerTable _exception_handler_table; | |
| 86 ImplicitExceptionTable _implicit_exception_table; | |
| 87 LinearScan* _allocator; | |
| 88 CodeOffsets _offsets; | |
| 89 CodeBuffer _code; | |
| 8860 | 90 bool _has_access_indexed; |
|
17980
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
91 int _interpreter_frame_size; // Stack space needed in case of a deoptimization |
| 0 | 92 |
| 93 // compilation helpers | |
| 94 void initialize(); | |
| 95 void build_hir(); | |
| 96 void emit_lir(); | |
| 97 | |
| 98 void emit_code_epilog(LIR_Assembler* assembler); | |
| 99 int emit_code_body(); | |
| 100 | |
| 101 int compile_java_method(); | |
| 102 void install_code(int frame_size); | |
| 103 void compile_method(); | |
| 104 | |
| 105 void generate_exception_handler_table(); | |
| 106 | |
| 107 ExceptionInfoList* exception_info_list() const { return _exception_info_list; } | |
| 108 ExceptionHandlerTable* exception_handler_table() { return &_exception_handler_table; } | |
| 109 | |
| 110 LinearScan* allocator() { return _allocator; } | |
| 111 void set_allocator(LinearScan* allocator) { _allocator = allocator; } | |
| 112 | |
| 113 Instruction* _current_instruction; // the instruction currently being processed | |
| 114 #ifndef PRODUCT | |
| 115 Instruction* _last_instruction_printed; // the last instruction printed during traversal | |
| 116 #endif // PRODUCT | |
| 117 | |
| 118 public: | |
| 119 // creation | |
| 1584 | 120 Compilation(AbstractCompiler* compiler, ciEnv* env, ciMethod* method, |
| 121 int osr_bci, BufferBlob* buffer_blob); | |
| 0 | 122 ~Compilation(); |
| 123 | |
| 1584 | 124 |
| 125 static Compilation* current() { | |
| 126 return (Compilation*) ciEnv::current()->compiler_data(); | |
| 127 } | |
| 0 | 128 |
| 129 // accessors | |
| 130 ciEnv* env() const { return _env; } | |
| 6843 | 131 CompileLog* log() const { return _log; } |
| 0 | 132 AbstractCompiler* compiler() const { return _compiler; } |
| 133 bool has_exception_handlers() const { return _has_exception_handlers; } | |
| 134 bool has_fpu_code() const { return _has_fpu_code; } | |
| 135 bool has_unsafe_access() const { return _has_unsafe_access; } | |
|
6792
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
2426
diff
changeset
|
136 int max_vector_size() const { return 0; } |
| 0 | 137 ciMethod* method() const { return _method; } |
| 138 int osr_bci() const { return _osr_bci; } | |
| 139 bool is_osr_compile() const { return osr_bci() >= 0; } | |
| 140 IR* hir() const { return _hir; } | |
| 141 int max_spills() const { return _max_spills; } | |
| 142 FrameMap* frame_map() const { return _frame_map; } | |
| 143 CodeBuffer* code() { return &_code; } | |
| 144 C1_MacroAssembler* masm() const { return _masm; } | |
| 145 CodeOffsets* offsets() { return &_offsets; } | |
| 1584 | 146 Arena* arena() { return _arena; } |
| 8860 | 147 bool has_access_indexed() { return _has_access_indexed; } |
| 1584 | 148 |
| 149 // Instruction ids | |
| 150 int get_next_id() { return _next_id++; } | |
| 151 int number_of_instructions() const { return _next_id; } | |
| 152 | |
| 153 // BlockBegin ids | |
| 154 int get_next_block_id() { return _next_block_id++; } | |
| 155 int number_of_blocks() const { return _next_block_id; } | |
| 0 | 156 |
| 157 // setters | |
| 158 void set_has_exception_handlers(bool f) { _has_exception_handlers = f; } | |
| 159 void set_has_fpu_code(bool f) { _has_fpu_code = f; } | |
| 160 void set_has_unsafe_access(bool f) { _has_unsafe_access = f; } | |
| 1783 | 161 void set_would_profile(bool f) { _would_profile = f; } |
| 8860 | 162 void set_has_access_indexed(bool f) { _has_access_indexed = f; } |
| 0 | 163 // Add a set of exception handlers covering the given PC offset |
| 164 void add_exception_handlers_for_pco(int pco, XHandlers* exception_handlers); | |
| 165 // Statistics gathering | |
| 166 void notice_inlined_method(ciMethod* method); | |
| 167 | |
|
1691
4a665be40fd3
6975855: don't emit deopt MH handler in C1 if not required
twisti
parents:
1681
diff
changeset
|
168 // JSR 292 |
|
4a665be40fd3
6975855: don't emit deopt MH handler in C1 if not required
twisti
parents:
1681
diff
changeset
|
169 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
|
170 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
|
171 |
| 0 | 172 DebugInformationRecorder* debug_info_recorder() const; // = _env->debug_info(); |
| 173 Dependencies* dependency_recorder() const; // = _env->dependencies() | |
| 174 ImplicitExceptionTable* implicit_exception_table() { return &_implicit_exception_table; } | |
| 175 | |
| 176 Instruction* current_instruction() const { return _current_instruction; } | |
| 177 Instruction* set_current_instruction(Instruction* instr) { | |
| 178 Instruction* previous = _current_instruction; | |
| 179 _current_instruction = instr; | |
| 180 return previous; | |
| 181 } | |
| 182 | |
| 183 #ifndef PRODUCT | |
| 184 void maybe_print_current_instruction(); | |
| 185 #endif // PRODUCT | |
| 186 | |
| 187 // error handling | |
| 188 void bailout(const char* msg); | |
| 189 bool bailed_out() const { return _bailout_msg != NULL; } | |
| 190 const char* bailout_msg() const { return _bailout_msg; } | |
| 191 | |
| 1584 | 192 static int desired_max_code_buffer_size() { |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1584
diff
changeset
|
193 #ifndef PPC |
| 1584 | 194 return (int) NMethodSizeLimit; // default 256K or 512K |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1584
diff
changeset
|
195 #else |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1584
diff
changeset
|
196 // conditional branches on PPC are restricted to 16 bit signed |
| 1899 | 197 return MIN2((unsigned int)NMethodSizeLimit,32*K); |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1584
diff
changeset
|
198 #endif |
| 1584 | 199 } |
| 200 static int desired_max_constant_size() { | |
| 1899 | 201 return desired_max_code_buffer_size() / 10; |
| 1584 | 202 } |
| 203 | |
|
2098
2f9d59b0fa5c
7009268: guarantee(middle - slop > start) failed: need enough space to divide up
bobv
parents:
1972
diff
changeset
|
204 static bool setup_code_buffer(CodeBuffer* cb, int call_stub_estimate); |
| 1584 | 205 |
| 0 | 206 // timers |
| 207 static void print_timers(); | |
| 208 | |
| 209 #ifndef PRODUCT | |
| 210 // debugging support. | |
| 211 // produces a file named c1compileonly in the current directory with | |
| 212 // directives to compile only the current method and it's inlines. | |
| 213 // The file can be passed to the command line option -XX:Flags=<filename> | |
| 214 void compile_only_this_method(); | |
| 215 void compile_only_this_scope(outputStream* st, IRScope* scope); | |
| 216 void exclude_this_method(); | |
| 217 #endif // PRODUCT | |
| 1783 | 218 |
| 219 bool is_profiling() { | |
| 220 return env()->comp_level() == CompLevel_full_profile || | |
| 221 env()->comp_level() == CompLevel_limited_profile; | |
| 222 } | |
| 223 bool count_invocations() { return is_profiling(); } | |
| 224 bool count_backedges() { return is_profiling(); } | |
| 225 | |
| 226 // Helpers for generation of profile information | |
| 227 bool profile_branches() { | |
| 228 return env()->comp_level() == CompLevel_full_profile && | |
| 229 C1UpdateMethodData && C1ProfileBranches; | |
| 230 } | |
| 231 bool profile_calls() { | |
| 232 return env()->comp_level() == CompLevel_full_profile && | |
| 233 C1UpdateMethodData && C1ProfileCalls; | |
| 234 } | |
| 235 bool profile_inlined_calls() { | |
| 236 return profile_calls() && C1ProfileInlinedCalls; | |
| 237 } | |
| 238 bool profile_checkcasts() { | |
| 239 return env()->comp_level() == CompLevel_full_profile && | |
| 240 C1UpdateMethodData && C1ProfileCheckcasts; | |
| 241 } | |
|
12962
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
242 bool profile_parameters() { |
|
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
243 return env()->comp_level() == CompLevel_full_profile && |
|
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
244 C1UpdateMethodData && MethodData::profile_parameters(); |
|
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
245 } |
|
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
246 bool profile_arguments() { |
|
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
247 return env()->comp_level() == CompLevel_full_profile && |
|
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
248 C1UpdateMethodData && MethodData::profile_arguments(); |
|
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
249 } |
|
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
250 bool profile_return() { |
|
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
251 return env()->comp_level() == CompLevel_full_profile && |
|
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
252 C1UpdateMethodData && MethodData::profile_return(); |
|
5ccbab1c69f3
8026251: New type profiling points: parameters to methods
roland
parents:
12875
diff
changeset
|
253 } |
| 8860 | 254 // will compilation make optimistic assumptions that might lead to |
| 255 // deoptimization and that the runtime will account for? | |
| 256 bool is_optimistic() const { | |
| 257 return !TieredCompilation && | |
| 258 (RangeCheckElimination || UseLoopInvariantCodeMotion) && | |
| 259 method()->method_data()->trap_count(Deoptimization::Reason_none) == 0; | |
| 260 } | |
|
12875
d13d7aba8c12
8023657: New type profiling points: arguments to call
roland
parents:
12146
diff
changeset
|
261 |
|
d13d7aba8c12
8023657: New type profiling points: arguments to call
roland
parents:
12146
diff
changeset
|
262 ciKlass* cha_exact_type(ciType* type); |
| 17622 | 263 |
| 264 // Dump inlining replay data to the stream. | |
| 265 void dump_inline_data(outputStream* out) { /* do nothing now */ } | |
|
17980
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
266 |
|
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
267 // How much stack space would the interpreter need in case of a |
|
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
268 // deoptimization (worst case) |
|
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
269 void update_interpreter_frame_size(int size) { |
|
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
270 if (_interpreter_frame_size < size) { |
|
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
271 _interpreter_frame_size = size; |
|
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
272 } |
|
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
273 } |
|
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
274 |
|
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
275 int interpreter_frame_size() const { |
|
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
276 return _interpreter_frame_size; |
|
0bf37f737702
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents:
17622
diff
changeset
|
277 } |
| 0 | 278 }; |
| 279 | |
| 280 | |
| 281 // Macro definitions for unified bailout-support | |
| 282 // The methods bailout() and bailed_out() are present in all classes | |
| 283 // that might bailout, but forward all calls to Compilation | |
| 284 #define BAILOUT(msg) { bailout(msg); return; } | |
| 285 #define BAILOUT_(msg, res) { bailout(msg); return res; } | |
| 286 | |
| 287 #define CHECK_BAILOUT() { if (bailed_out()) return; } | |
| 288 #define CHECK_BAILOUT_(res) { if (bailed_out()) return res; } | |
| 289 | |
| 290 | |
| 291 class InstructionMark: public StackObj { | |
| 292 private: | |
| 293 Compilation* _compilation; | |
| 294 Instruction* _previous; | |
| 295 | |
| 296 public: | |
| 297 InstructionMark(Compilation* compilation, Instruction* instr) { | |
| 298 _compilation = compilation; | |
| 299 _previous = _compilation->set_current_instruction(instr); | |
| 300 } | |
| 301 ~InstructionMark() { | |
| 302 _compilation->set_current_instruction(_previous); | |
| 303 } | |
| 304 }; | |
| 305 | |
| 306 | |
| 307 //---------------------------------------------------------------------- | |
| 308 // Base class for objects allocated by the compiler in the compilation arena | |
| 309 class CompilationResourceObj ALLOCATION_SUPER_CLASS_SPEC { | |
| 310 public: | |
|
12146
9758d9f36299
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
8860
diff
changeset
|
311 void* operator new(size_t size) throw() { return Compilation::current()->arena()->Amalloc(size); } |
|
9758d9f36299
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
8860
diff
changeset
|
312 void* operator new(size_t size, Arena* arena) throw() { |
| 1584 | 313 return arena->Amalloc(size); |
| 314 } | |
| 0 | 315 void operator delete(void* p) {} // nothing to do |
| 316 }; | |
| 317 | |
| 318 | |
| 319 //---------------------------------------------------------------------- | |
| 320 // Class for aggregating exception handler information. | |
| 321 | |
| 322 // Effectively extends XHandlers class with PC offset of | |
| 323 // potentially exception-throwing instruction. | |
| 324 // This class is used at the end of the compilation to build the | |
| 325 // ExceptionHandlerTable. | |
| 326 class ExceptionInfo: public CompilationResourceObj { | |
| 327 private: | |
| 328 int _pco; // PC of potentially exception-throwing instruction | |
| 329 XHandlers* _exception_handlers; // flat list of exception handlers covering this PC | |
| 330 | |
| 331 public: | |
| 332 ExceptionInfo(int pco, XHandlers* exception_handlers) | |
| 333 : _pco(pco) | |
| 334 , _exception_handlers(exception_handlers) | |
| 335 { } | |
| 336 | |
| 337 int pco() { return _pco; } | |
| 338 XHandlers* exception_handlers() { return _exception_handlers; } | |
| 339 }; | |
| 1972 | 340 |
| 341 #endif // SHARE_VM_C1_C1_COMPILATION_HPP |