Mercurial > hg > truffle
annotate src/share/vm/opto/compile.hpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
| author | ysr |
|---|---|
| date | Tue, 07 Dec 2010 21:55:53 -0800 |
| parents | f95d63e2154a |
| children | 2f644f85485d |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1397
diff
changeset
|
2 * Copyright (c) 1997, 2010, 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_OPTO_COMPILE_HPP |
| 26 #define SHARE_VM_OPTO_COMPILE_HPP | |
| 27 | |
| 28 #include "asm/codeBuffer.hpp" | |
| 29 #include "ci/compilerInterface.hpp" | |
| 30 #include "code/debugInfoRec.hpp" | |
| 31 #include "code/exceptionHandlerTable.hpp" | |
| 32 #include "compiler/compilerOracle.hpp" | |
| 33 #include "libadt/dict.hpp" | |
| 34 #include "libadt/port.hpp" | |
| 35 #include "libadt/vectset.hpp" | |
| 36 #include "memory/resourceArea.hpp" | |
| 37 #include "opto/idealGraphPrinter.hpp" | |
| 38 #include "opto/phase.hpp" | |
| 39 #include "opto/regmask.hpp" | |
| 40 #include "runtime/deoptimization.hpp" | |
| 41 #include "runtime/vmThread.hpp" | |
| 42 | |
| 0 | 43 class Block; |
| 44 class Bundle; | |
| 45 class C2Compiler; | |
| 46 class CallGenerator; | |
| 47 class ConnectionGraph; | |
| 48 class InlineTree; | |
| 49 class Int_Array; | |
| 50 class Matcher; | |
| 51 class MachNode; | |
|
38
b789bcaf2dd9
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
0
diff
changeset
|
52 class MachSafePointNode; |
| 0 | 53 class Node; |
| 54 class Node_Array; | |
| 55 class Node_Notes; | |
| 56 class OptoReg; | |
| 57 class PhaseCFG; | |
| 58 class PhaseGVN; | |
| 1172 | 59 class PhaseIterGVN; |
| 0 | 60 class PhaseRegAlloc; |
| 61 class PhaseCCP; | |
| 62 class PhaseCCP_DCE; | |
| 63 class RootNode; | |
| 64 class relocInfo; | |
| 65 class Scope; | |
| 66 class StartNode; | |
| 67 class SafePointNode; | |
| 68 class JVMState; | |
| 69 class TypeData; | |
| 70 class TypePtr; | |
| 71 class TypeFunc; | |
| 72 class Unique_Node_List; | |
| 73 class nmethod; | |
| 74 class WarmCallInfo; | |
| 75 | |
| 76 //------------------------------Compile---------------------------------------- | |
| 77 // This class defines a top-level Compiler invocation. | |
| 78 | |
| 79 class Compile : public Phase { | |
| 80 public: | |
| 81 // Fixed alias indexes. (See also MergeMemNode.) | |
| 82 enum { | |
| 83 AliasIdxTop = 1, // pseudo-index, aliases to nothing (used as sentinel value) | |
| 84 AliasIdxBot = 2, // pseudo-index, aliases to everything | |
| 85 AliasIdxRaw = 3 // hard-wired index for TypeRawPtr::BOTTOM | |
| 86 }; | |
| 87 | |
| 88 // Variant of TraceTime(NULL, &_t_accumulator, TimeCompiler); | |
| 89 // Integrated with logging. If logging is turned on, and dolog is true, | |
| 90 // then brackets are put into the log, with time stamps and node counts. | |
| 91 // (The time collection itself is always conditionalized on TimeCompiler.) | |
| 92 class TracePhase : public TraceTime { | |
| 93 private: | |
| 94 Compile* C; | |
| 95 CompileLog* _log; | |
| 96 public: | |
| 97 TracePhase(const char* name, elapsedTimer* accumulator, bool dolog); | |
| 98 ~TracePhase(); | |
| 99 }; | |
| 100 | |
| 101 // Information per category of alias (memory slice) | |
| 102 class AliasType { | |
| 103 private: | |
| 104 friend class Compile; | |
| 105 | |
| 106 int _index; // unique index, used with MergeMemNode | |
| 107 const TypePtr* _adr_type; // normalized address type | |
| 108 ciField* _field; // relevant instance field, or null if none | |
| 109 bool _is_rewritable; // false if the memory is write-once only | |
| 110 int _general_index; // if this is type is an instance, the general | |
| 111 // type that this is an instance of | |
| 112 | |
| 113 void Init(int i, const TypePtr* at); | |
| 114 | |
| 115 public: | |
| 116 int index() const { return _index; } | |
| 117 const TypePtr* adr_type() const { return _adr_type; } | |
| 118 ciField* field() const { return _field; } | |
| 119 bool is_rewritable() const { return _is_rewritable; } | |
| 120 bool is_volatile() const { return (_field ? _field->is_volatile() : false); } | |
| 121 int general_index() const { return (_general_index != 0) ? _general_index : _index; } | |
| 122 | |
| 123 void set_rewritable(bool z) { _is_rewritable = z; } | |
| 124 void set_field(ciField* f) { | |
| 125 assert(!_field,""); | |
| 126 _field = f; | |
| 127 if (f->is_final()) _is_rewritable = false; | |
| 128 } | |
| 129 | |
| 130 void print_on(outputStream* st) PRODUCT_RETURN; | |
| 131 }; | |
| 132 | |
| 133 enum { | |
| 134 logAliasCacheSize = 6, | |
| 135 AliasCacheSize = (1<<logAliasCacheSize) | |
| 136 }; | |
| 137 struct AliasCacheEntry { const TypePtr* _adr_type; int _index; }; // simple duple type | |
| 138 enum { | |
| 139 trapHistLength = methodDataOopDesc::_trap_hist_limit | |
| 140 }; | |
| 141 | |
| 142 private: | |
| 143 // Fixed parameters to this compilation. | |
| 144 const int _compile_id; | |
| 145 const bool _save_argument_registers; // save/restore arg regs for trampolines | |
| 146 const bool _subsume_loads; // Load can be matched as part of a larger op. | |
|
38
b789bcaf2dd9
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
0
diff
changeset
|
147 const bool _do_escape_analysis; // Do escape analysis. |
| 0 | 148 ciMethod* _method; // The method being compiled. |
| 149 int _entry_bci; // entry bci for osr methods. | |
| 150 const TypeFunc* _tf; // My kind of signature | |
| 151 InlineTree* _ilt; // Ditto (temporary). | |
| 152 address _stub_function; // VM entry for stub being compiled, or NULL | |
| 153 const char* _stub_name; // Name of stub or adapter being compiled, or NULL | |
| 154 address _stub_entry_point; // Compile code entry for generated stub, or NULL | |
| 155 | |
| 156 // Control of this compilation. | |
| 157 int _num_loop_opts; // Number of iterations for doing loop optimiztions | |
| 158 int _max_inline_size; // Max inline size for this compilation | |
| 159 int _freq_inline_size; // Max hot method inline size for this compilation | |
| 160 int _fixed_slots; // count of frame slots not allocated by the register | |
| 161 // allocator i.e. locks, original deopt pc, etc. | |
| 162 // For deopt | |
| 163 int _orig_pc_slot; | |
| 164 int _orig_pc_slot_offset_in_bytes; | |
| 165 | |
| 166 int _major_progress; // Count of something big happening | |
| 167 bool _has_loops; // True if the method _may_ have some loops | |
| 168 bool _has_split_ifs; // True if the method _may_ have some split-if | |
| 169 bool _has_unsafe_access; // True if the method _may_ produce faults in unsafe loads or stores. | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
170 bool _has_stringbuilder; // True StringBuffers or StringBuilders are allocated |
| 0 | 171 uint _trap_hist[trapHistLength]; // Cumulative traps |
| 172 bool _trap_can_recompile; // Have we emitted a recompiling trap? | |
| 173 uint _decompile_count; // Cumulative decompilation counts. | |
| 174 bool _do_inlining; // True if we intend to do inlining | |
| 175 bool _do_scheduling; // True if we intend to do scheduling | |
| 418 | 176 bool _do_freq_based_layout; // True if we intend to do frequency based block layout |
| 0 | 177 bool _do_count_invocations; // True if we generate code to count invocations |
| 178 bool _do_method_data_update; // True if we generate code to update methodDataOops | |
| 179 int _AliasLevel; // Locally-adjusted version of AliasLevel flag. | |
| 180 bool _print_assembly; // True if we should dump assembly code for this compilation | |
| 181 #ifndef PRODUCT | |
| 182 bool _trace_opto_output; | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
183 bool _parsed_irreducible_loop; // True if ciTypeFlow detected irreducible loops during parsing |
| 0 | 184 #endif |
| 185 | |
| 1265 | 186 // JSR 292 |
| 187 bool _has_method_handle_invokes; // True if this method has MethodHandle invokes. | |
| 188 | |
| 0 | 189 // Compilation environment. |
| 190 Arena _comp_arena; // Arena with lifetime equivalent to Compile | |
| 191 ciEnv* _env; // CI interface | |
| 192 CompileLog* _log; // from CompilerThread | |
| 193 const char* _failure_reason; // for record_failure/failing pattern | |
| 194 GrowableArray<CallGenerator*>* _intrinsics; // List of intrinsics. | |
| 195 GrowableArray<Node*>* _macro_nodes; // List of nodes which need to be expanded before matching. | |
| 1172 | 196 GrowableArray<Node*>* _predicate_opaqs; // List of Opaque1 nodes for the loop predicates. |
| 0 | 197 ConnectionGraph* _congraph; |
| 198 #ifndef PRODUCT | |
| 199 IdealGraphPrinter* _printer; | |
| 200 #endif | |
| 201 | |
| 202 // Node management | |
| 203 uint _unique; // Counter for unique Node indices | |
| 204 debug_only(static int _debug_idx;) // Monotonic counter (not reset), use -XX:BreakAtNode=<idx> | |
| 205 Arena _node_arena; // Arena for new-space Nodes | |
| 206 Arena _old_arena; // Arena for old-space Nodes, lifetime during xform | |
| 207 RootNode* _root; // Unique root of compilation, or NULL after bail-out. | |
| 208 Node* _top; // Unique top node. (Reset by various phases.) | |
| 209 | |
| 210 Node* _immutable_memory; // Initial memory state | |
| 211 | |
| 212 Node* _recent_alloc_obj; | |
| 213 Node* _recent_alloc_ctl; | |
| 214 | |
| 215 // Blocked array of debugging and profiling information, | |
| 216 // tracked per node. | |
| 217 enum { _log2_node_notes_block_size = 8, | |
| 218 _node_notes_block_size = (1<<_log2_node_notes_block_size) | |
| 219 }; | |
| 220 GrowableArray<Node_Notes*>* _node_note_array; | |
| 221 Node_Notes* _default_node_notes; // default notes for new nodes | |
| 222 | |
| 223 // After parsing and every bulk phase we hang onto the Root instruction. | |
| 224 // The RootNode instruction is where the whole program begins. It produces | |
| 225 // the initial Control and BOTTOM for everybody else. | |
| 226 | |
| 227 // Type management | |
| 228 Arena _Compile_types; // Arena for all types | |
| 229 Arena* _type_arena; // Alias for _Compile_types except in Initialize_shared() | |
| 230 Dict* _type_dict; // Intern table | |
| 231 void* _type_hwm; // Last allocation (see Type::operator new/delete) | |
| 232 size_t _type_last_size; // Last allocation size (see Type::operator new/delete) | |
| 233 ciMethod* _last_tf_m; // Cache for | |
| 234 const TypeFunc* _last_tf; // TypeFunc::make | |
| 235 AliasType** _alias_types; // List of alias types seen so far. | |
| 236 int _num_alias_types; // Logical length of _alias_types | |
| 237 int _max_alias_types; // Physical length of _alias_types | |
| 238 AliasCacheEntry _alias_cache[AliasCacheSize]; // Gets aliases w/o data structure walking | |
| 239 | |
| 240 // Parsing, optimization | |
| 241 PhaseGVN* _initial_gvn; // Results of parse-time PhaseGVN | |
| 242 Unique_Node_List* _for_igvn; // Initial work-list for next round of Iterative GVN | |
| 243 WarmCallInfo* _warm_calls; // Sorted work-list for heat-based inlining. | |
| 244 | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
245 GrowableArray<CallGenerator*> _late_inlines; // List of CallGenerators to be revisited after |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
246 // main parsing has finished. |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
247 |
| 0 | 248 // Matching, CFG layout, allocation, code generation |
| 249 PhaseCFG* _cfg; // Results of CFG finding | |
| 250 bool _select_24_bit_instr; // We selected an instruction with a 24-bit result | |
| 251 bool _in_24_bit_fp_mode; // We are emitting instructions with 24-bit results | |
|
859
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
418
diff
changeset
|
252 int _java_calls; // Number of java calls in the method |
|
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
418
diff
changeset
|
253 int _inner_loops; // Number of inner loops in the method |
| 0 | 254 Matcher* _matcher; // Engine to map ideal to machine instructions |
| 255 PhaseRegAlloc* _regalloc; // Results of register allocation. | |
| 256 int _frame_slots; // Size of total frame in stack slots | |
| 257 CodeOffsets _code_offsets; // Offsets into the code for various interesting entries | |
| 258 RegMask _FIRST_STACK_mask; // All stack slots usable for spills (depends on frame layout) | |
| 259 Arena* _indexSet_arena; // control IndexSet allocation within PhaseChaitin | |
| 260 void* _indexSet_free_block_list; // free list of IndexSet bit blocks | |
| 261 | |
| 262 uint _node_bundling_limit; | |
| 263 Bundle* _node_bundling_base; // Information for instruction bundling | |
| 264 | |
| 265 // Instruction bits passed off to the VM | |
| 266 int _method_size; // Size of nmethod code segment in bytes | |
| 267 CodeBuffer _code_buffer; // Where the code is assembled | |
| 268 int _first_block_size; // Size of unvalidated entry point code / OSR poison code | |
| 269 ExceptionHandlerTable _handler_table; // Table of native-code exception handlers | |
| 270 ImplicitExceptionTable _inc_table; // Table of implicit null checks in native code | |
| 271 OopMapSet* _oop_map_set; // Table of oop maps (one for each safepoint location) | |
| 272 static int _CompiledZap_count; // counter compared against CompileZap[First/Last] | |
| 273 BufferBlob* _scratch_buffer_blob; // For temporary code buffers. | |
| 274 relocInfo* _scratch_locs_memory; // For temporary code buffers. | |
| 275 | |
| 276 public: | |
| 277 // Accessors | |
| 278 | |
| 279 // The Compile instance currently active in this (compiler) thread. | |
| 280 static Compile* current() { | |
| 281 return (Compile*) ciEnv::current()->compiler_data(); | |
| 282 } | |
| 283 | |
| 284 // ID for this compilation. Useful for setting breakpoints in the debugger. | |
| 285 int compile_id() const { return _compile_id; } | |
| 286 | |
| 287 // Does this compilation allow instructions to subsume loads? User | |
| 288 // instructions that subsume a load may result in an unschedulable | |
| 289 // instruction sequence. | |
| 290 bool subsume_loads() const { return _subsume_loads; } | |
|
38
b789bcaf2dd9
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
0
diff
changeset
|
291 // Do escape analysis. |
|
b789bcaf2dd9
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
0
diff
changeset
|
292 bool do_escape_analysis() const { return _do_escape_analysis; } |
| 0 | 293 bool save_argument_registers() const { return _save_argument_registers; } |
| 294 | |
| 295 | |
| 296 // Other fixed compilation parameters. | |
| 297 ciMethod* method() const { return _method; } | |
| 298 int entry_bci() const { return _entry_bci; } | |
| 299 bool is_osr_compilation() const { return _entry_bci != InvocationEntryBci; } | |
| 300 bool is_method_compilation() const { return (_method != NULL && !_method->flags().is_native()); } | |
| 301 const TypeFunc* tf() const { assert(_tf!=NULL, ""); return _tf; } | |
| 302 void init_tf(const TypeFunc* tf) { assert(_tf==NULL, ""); _tf = tf; } | |
| 303 InlineTree* ilt() const { return _ilt; } | |
| 304 address stub_function() const { return _stub_function; } | |
| 305 const char* stub_name() const { return _stub_name; } | |
| 306 address stub_entry_point() const { return _stub_entry_point; } | |
| 307 | |
| 308 // Control of this compilation. | |
| 309 int fixed_slots() const { assert(_fixed_slots >= 0, ""); return _fixed_slots; } | |
| 310 void set_fixed_slots(int n) { _fixed_slots = n; } | |
| 311 int major_progress() const { return _major_progress; } | |
| 312 void set_major_progress() { _major_progress++; } | |
| 313 void clear_major_progress() { _major_progress = 0; } | |
| 314 int num_loop_opts() const { return _num_loop_opts; } | |
| 315 void set_num_loop_opts(int n) { _num_loop_opts = n; } | |
| 316 int max_inline_size() const { return _max_inline_size; } | |
| 317 void set_freq_inline_size(int n) { _freq_inline_size = n; } | |
| 318 int freq_inline_size() const { return _freq_inline_size; } | |
| 319 void set_max_inline_size(int n) { _max_inline_size = n; } | |
| 320 bool has_loops() const { return _has_loops; } | |
| 321 void set_has_loops(bool z) { _has_loops = z; } | |
| 322 bool has_split_ifs() const { return _has_split_ifs; } | |
| 323 void set_has_split_ifs(bool z) { _has_split_ifs = z; } | |
| 324 bool has_unsafe_access() const { return _has_unsafe_access; } | |
| 325 void set_has_unsafe_access(bool z) { _has_unsafe_access = z; } | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
326 bool has_stringbuilder() const { return _has_stringbuilder; } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
327 void set_has_stringbuilder(bool z) { _has_stringbuilder = z; } |
| 0 | 328 void set_trap_count(uint r, uint c) { assert(r < trapHistLength, "oob"); _trap_hist[r] = c; } |
| 329 uint trap_count(uint r) const { assert(r < trapHistLength, "oob"); return _trap_hist[r]; } | |
| 330 bool trap_can_recompile() const { return _trap_can_recompile; } | |
| 331 void set_trap_can_recompile(bool z) { _trap_can_recompile = z; } | |
| 332 uint decompile_count() const { return _decompile_count; } | |
| 333 void set_decompile_count(uint c) { _decompile_count = c; } | |
| 334 bool allow_range_check_smearing() const; | |
| 335 bool do_inlining() const { return _do_inlining; } | |
| 336 void set_do_inlining(bool z) { _do_inlining = z; } | |
| 337 bool do_scheduling() const { return _do_scheduling; } | |
| 338 void set_do_scheduling(bool z) { _do_scheduling = z; } | |
| 418 | 339 bool do_freq_based_layout() const{ return _do_freq_based_layout; } |
| 340 void set_do_freq_based_layout(bool z){ _do_freq_based_layout = z; } | |
| 0 | 341 bool do_count_invocations() const{ return _do_count_invocations; } |
| 342 void set_do_count_invocations(bool z){ _do_count_invocations = z; } | |
| 343 bool do_method_data_update() const { return _do_method_data_update; } | |
| 344 void set_do_method_data_update(bool z) { _do_method_data_update = z; } | |
| 345 int AliasLevel() const { return _AliasLevel; } | |
| 346 bool print_assembly() const { return _print_assembly; } | |
| 347 void set_print_assembly(bool z) { _print_assembly = z; } | |
| 348 // check the CompilerOracle for special behaviours for this compile | |
| 349 bool method_has_option(const char * option) { | |
| 350 return method() != NULL && method()->has_option(option); | |
| 351 } | |
| 352 #ifndef PRODUCT | |
| 353 bool trace_opto_output() const { return _trace_opto_output; } | |
|
367
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
354 bool parsed_irreducible_loop() const { return _parsed_irreducible_loop; } |
|
194b8e3a2fc4
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
196
diff
changeset
|
355 void set_parsed_irreducible_loop(bool z) { _parsed_irreducible_loop = z; } |
| 0 | 356 #endif |
| 357 | |
| 1265 | 358 // JSR 292 |
| 359 bool has_method_handle_invokes() const { return _has_method_handle_invokes; } | |
| 360 void set_has_method_handle_invokes(bool z) { _has_method_handle_invokes = z; } | |
| 361 | |
| 0 | 362 void begin_method() { |
| 363 #ifndef PRODUCT | |
| 364 if (_printer) _printer->begin_method(this); | |
| 365 #endif | |
| 366 } | |
| 367 void print_method(const char * name, int level = 1) { | |
| 368 #ifndef PRODUCT | |
| 369 if (_printer) _printer->print_method(this, name, level); | |
| 370 #endif | |
| 371 } | |
| 372 void end_method() { | |
| 373 #ifndef PRODUCT | |
| 374 if (_printer) _printer->end_method(); | |
| 375 #endif | |
| 376 } | |
| 377 | |
| 378 int macro_count() { return _macro_nodes->length(); } | |
| 1172 | 379 int predicate_count() { return _predicate_opaqs->length();} |
| 0 | 380 Node* macro_node(int idx) { return _macro_nodes->at(idx); } |
| 1172 | 381 Node* predicate_opaque1_node(int idx) { return _predicate_opaqs->at(idx);} |
| 0 | 382 ConnectionGraph* congraph() { return _congraph;} |
|
1634
60a14ad85270
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
1552
diff
changeset
|
383 void set_congraph(ConnectionGraph* congraph) { _congraph = congraph;} |
| 0 | 384 void add_macro_node(Node * n) { |
| 385 //assert(n->is_macro(), "must be a macro node"); | |
| 386 assert(!_macro_nodes->contains(n), " duplicate entry in expand list"); | |
| 387 _macro_nodes->append(n); | |
| 388 } | |
| 389 void remove_macro_node(Node * n) { | |
| 390 // this function may be called twice for a node so check | |
| 391 // that the node is in the array before attempting to remove it | |
| 392 if (_macro_nodes->contains(n)) | |
| 393 _macro_nodes->remove(n); | |
| 1172 | 394 // remove from _predicate_opaqs list also if it is there |
| 395 if (predicate_count() > 0 && _predicate_opaqs->contains(n)){ | |
| 396 _predicate_opaqs->remove(n); | |
| 397 } | |
| 0 | 398 } |
| 1172 | 399 void add_predicate_opaq(Node * n) { |
| 400 assert(!_predicate_opaqs->contains(n), " duplicate entry in predicate opaque1"); | |
| 401 assert(_macro_nodes->contains(n), "should have already been in macro list"); | |
| 402 _predicate_opaqs->append(n); | |
| 403 } | |
| 404 // remove the opaque nodes that protect the predicates so that the unused checks and | |
| 405 // uncommon traps will be eliminated from the graph. | |
| 406 void cleanup_loop_predicates(PhaseIterGVN &igvn); | |
| 0 | 407 |
| 408 // Compilation environment. | |
| 409 Arena* comp_arena() { return &_comp_arena; } | |
| 410 ciEnv* env() const { return _env; } | |
| 411 CompileLog* log() const { return _log; } | |
| 412 bool failing() const { return _env->failing() || _failure_reason != NULL; } | |
| 413 const char* failure_reason() { return _failure_reason; } | |
| 414 bool failure_reason_is(const char* r) { return (r==_failure_reason) || (r!=NULL && _failure_reason!=NULL && strcmp(r, _failure_reason)==0); } | |
| 415 | |
| 416 void record_failure(const char* reason); | |
| 417 void record_method_not_compilable(const char* reason, bool all_tiers = false) { | |
| 418 // All bailouts cover "all_tiers" when TieredCompilation is off. | |
| 419 if (!TieredCompilation) all_tiers = true; | |
| 420 env()->record_method_not_compilable(reason, all_tiers); | |
| 421 // Record failure reason. | |
| 422 record_failure(reason); | |
| 423 } | |
| 424 void record_method_not_compilable_all_tiers(const char* reason) { | |
| 425 record_method_not_compilable(reason, true); | |
| 426 } | |
| 427 bool check_node_count(uint margin, const char* reason) { | |
| 428 if (unique() + margin > (uint)MaxNodeLimit) { | |
| 429 record_method_not_compilable(reason); | |
| 430 return true; | |
| 431 } else { | |
| 432 return false; | |
| 433 } | |
| 434 } | |
| 435 | |
| 436 // Node management | |
| 437 uint unique() const { return _unique; } | |
| 438 uint next_unique() { return _unique++; } | |
| 439 void set_unique(uint i) { _unique = i; } | |
| 440 static int debug_idx() { return debug_only(_debug_idx)+0; } | |
| 441 static void set_debug_idx(int i) { debug_only(_debug_idx = i); } | |
| 442 Arena* node_arena() { return &_node_arena; } | |
| 443 Arena* old_arena() { return &_old_arena; } | |
| 444 RootNode* root() const { return _root; } | |
| 445 void set_root(RootNode* r) { _root = r; } | |
| 446 StartNode* start() const; // (Derived from root.) | |
| 447 void init_start(StartNode* s); | |
| 448 Node* immutable_memory(); | |
| 449 | |
| 450 Node* recent_alloc_ctl() const { return _recent_alloc_ctl; } | |
| 451 Node* recent_alloc_obj() const { return _recent_alloc_obj; } | |
| 452 void set_recent_alloc(Node* ctl, Node* obj) { | |
| 453 _recent_alloc_ctl = ctl; | |
| 454 _recent_alloc_obj = obj; | |
| 455 } | |
| 456 | |
| 457 // Handy undefined Node | |
| 458 Node* top() const { return _top; } | |
| 459 | |
| 460 // these are used by guys who need to know about creation and transformation of top: | |
| 461 Node* cached_top_node() { return _top; } | |
| 462 void set_cached_top_node(Node* tn); | |
| 463 | |
| 464 GrowableArray<Node_Notes*>* node_note_array() const { return _node_note_array; } | |
| 465 void set_node_note_array(GrowableArray<Node_Notes*>* arr) { _node_note_array = arr; } | |
| 466 Node_Notes* default_node_notes() const { return _default_node_notes; } | |
| 467 void set_default_node_notes(Node_Notes* n) { _default_node_notes = n; } | |
| 468 | |
| 469 Node_Notes* node_notes_at(int idx) { | |
| 470 return locate_node_notes(_node_note_array, idx, false); | |
| 471 } | |
| 472 inline bool set_node_notes_at(int idx, Node_Notes* value); | |
| 473 | |
| 474 // Copy notes from source to dest, if they exist. | |
| 475 // Overwrite dest only if source provides something. | |
| 476 // Return true if information was moved. | |
| 477 bool copy_node_notes_to(Node* dest, Node* source); | |
| 478 | |
| 479 // Workhorse function to sort out the blocked Node_Notes array: | |
| 480 inline Node_Notes* locate_node_notes(GrowableArray<Node_Notes*>* arr, | |
| 481 int idx, bool can_grow = false); | |
| 482 | |
| 483 void grow_node_notes(GrowableArray<Node_Notes*>* arr, int grow_by); | |
| 484 | |
| 485 // Type management | |
| 486 Arena* type_arena() { return _type_arena; } | |
| 487 Dict* type_dict() { return _type_dict; } | |
| 488 void* type_hwm() { return _type_hwm; } | |
| 489 size_t type_last_size() { return _type_last_size; } | |
| 490 int num_alias_types() { return _num_alias_types; } | |
| 491 | |
| 492 void init_type_arena() { _type_arena = &_Compile_types; } | |
| 493 void set_type_arena(Arena* a) { _type_arena = a; } | |
| 494 void set_type_dict(Dict* d) { _type_dict = d; } | |
| 495 void set_type_hwm(void* p) { _type_hwm = p; } | |
| 496 void set_type_last_size(size_t sz) { _type_last_size = sz; } | |
| 497 | |
| 498 const TypeFunc* last_tf(ciMethod* m) { | |
| 499 return (m == _last_tf_m) ? _last_tf : NULL; | |
| 500 } | |
| 501 void set_last_tf(ciMethod* m, const TypeFunc* tf) { | |
| 502 assert(m != NULL || tf == NULL, ""); | |
| 503 _last_tf_m = m; | |
| 504 _last_tf = tf; | |
| 505 } | |
| 506 | |
| 507 AliasType* alias_type(int idx) { assert(idx < num_alias_types(), "oob"); return _alias_types[idx]; } | |
| 508 AliasType* alias_type(const TypePtr* adr_type) { return find_alias_type(adr_type, false); } | |
| 509 bool have_alias_type(const TypePtr* adr_type); | |
| 510 AliasType* alias_type(ciField* field); | |
| 511 | |
| 512 int get_alias_index(const TypePtr* at) { return alias_type(at)->index(); } | |
| 513 const TypePtr* get_adr_type(uint aidx) { return alias_type(aidx)->adr_type(); } | |
| 514 int get_general_index(uint aidx) { return alias_type(aidx)->general_index(); } | |
| 515 | |
| 516 // Building nodes | |
| 517 void rethrow_exceptions(JVMState* jvms); | |
| 518 void return_values(JVMState* jvms); | |
| 519 JVMState* build_start_state(StartNode* start, const TypeFunc* tf); | |
| 520 | |
| 521 // Decide how to build a call. | |
| 522 // The profile factor is a discount to apply to this site's interp. profile. | |
| 523 CallGenerator* call_generator(ciMethod* call_method, int vtable_index, bool call_is_virtual, JVMState* jvms, bool allow_inline, float profile_factor); | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
524 bool should_delay_inlining(ciMethod* call_method, JVMState* jvms); |
| 0 | 525 |
| 526 // Report if there were too many traps at a current method and bci. | |
| 527 // Report if a trap was recorded, and/or PerMethodTrapLimit was exceeded. | |
| 528 // If there is no MDO at all, report no trap unless told to assume it. | |
| 529 bool too_many_traps(ciMethod* method, int bci, Deoptimization::DeoptReason reason); | |
| 530 // This version, unspecific to a particular bci, asks if | |
| 531 // PerMethodTrapLimit was exceeded for all inlined methods seen so far. | |
| 532 bool too_many_traps(Deoptimization::DeoptReason reason, | |
| 533 // Privately used parameter for logging: | |
| 534 ciMethodData* logmd = NULL); | |
| 535 // Report if there were too many recompiles at a method and bci. | |
| 536 bool too_many_recompiles(ciMethod* method, int bci, Deoptimization::DeoptReason reason); | |
| 537 | |
| 538 // Parsing, optimization | |
| 539 PhaseGVN* initial_gvn() { return _initial_gvn; } | |
| 540 Unique_Node_List* for_igvn() { return _for_igvn; } | |
| 541 inline void record_for_igvn(Node* n); // Body is after class Unique_Node_List. | |
| 542 void set_initial_gvn(PhaseGVN *gvn) { _initial_gvn = gvn; } | |
| 543 void set_for_igvn(Unique_Node_List *for_igvn) { _for_igvn = for_igvn; } | |
| 544 | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
545 // Replace n by nn using initial_gvn, calling hash_delete and |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
546 // record_for_igvn as needed. |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
547 void gvn_replace_by(Node* n, Node* nn); |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
548 |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
549 |
| 0 | 550 void identify_useful_nodes(Unique_Node_List &useful); |
| 551 void remove_useless_nodes (Unique_Node_List &useful); | |
| 552 | |
| 553 WarmCallInfo* warm_calls() const { return _warm_calls; } | |
| 554 void set_warm_calls(WarmCallInfo* l) { _warm_calls = l; } | |
| 555 WarmCallInfo* pop_warm_call(); | |
| 556 | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
557 // Record this CallGenerator for inlining at the end of parsing. |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
558 void add_late_inline(CallGenerator* cg) { _late_inlines.push(cg); } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
948
diff
changeset
|
559 |
| 0 | 560 // Matching, CFG layout, allocation, code generation |
| 561 PhaseCFG* cfg() { return _cfg; } | |
| 562 bool select_24_bit_instr() const { return _select_24_bit_instr; } | |
| 563 bool in_24_bit_fp_mode() const { return _in_24_bit_fp_mode; } | |
|
859
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
418
diff
changeset
|
564 bool has_java_calls() const { return _java_calls > 0; } |
|
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
418
diff
changeset
|
565 int java_calls() const { return _java_calls; } |
|
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
418
diff
changeset
|
566 int inner_loops() const { return _inner_loops; } |
| 0 | 567 Matcher* matcher() { return _matcher; } |
| 568 PhaseRegAlloc* regalloc() { return _regalloc; } | |
| 569 int frame_slots() const { return _frame_slots; } | |
| 570 int frame_size_in_words() const; // frame_slots in units of the polymorphic 'words' | |
| 571 RegMask& FIRST_STACK_mask() { return _FIRST_STACK_mask; } | |
| 572 Arena* indexSet_arena() { return _indexSet_arena; } | |
| 573 void* indexSet_free_block_list() { return _indexSet_free_block_list; } | |
| 574 uint node_bundling_limit() { return _node_bundling_limit; } | |
| 575 Bundle* node_bundling_base() { return _node_bundling_base; } | |
| 576 void set_node_bundling_limit(uint n) { _node_bundling_limit = n; } | |
| 577 void set_node_bundling_base(Bundle* b) { _node_bundling_base = b; } | |
| 578 bool starts_bundle(const Node *n) const; | |
| 579 bool need_stack_bang(int frame_size_in_bytes) const; | |
| 580 bool need_register_stack_bang() const; | |
| 581 | |
| 582 void set_matcher(Matcher* m) { _matcher = m; } | |
| 583 //void set_regalloc(PhaseRegAlloc* ra) { _regalloc = ra; } | |
| 584 void set_indexSet_arena(Arena* a) { _indexSet_arena = a; } | |
| 585 void set_indexSet_free_block_list(void* p) { _indexSet_free_block_list = p; } | |
| 586 | |
| 587 // Remember if this compilation changes hardware mode to 24-bit precision | |
| 588 void set_24_bit_selection_and_mode(bool selection, bool mode) { | |
| 589 _select_24_bit_instr = selection; | |
| 590 _in_24_bit_fp_mode = mode; | |
| 591 } | |
| 592 | |
|
859
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
418
diff
changeset
|
593 void set_java_calls(int z) { _java_calls = z; } |
|
ea3f9723b5cf
6860599: nodes limit could be reached during Output phase
kvn
parents:
418
diff
changeset
|
594 void set_inner_loops(int z) { _inner_loops = z; } |
| 0 | 595 |
| 596 // Instruction bits passed off to the VM | |
| 597 int code_size() { return _method_size; } | |
| 598 CodeBuffer* code_buffer() { return &_code_buffer; } | |
| 599 int first_block_size() { return _first_block_size; } | |
| 600 void set_frame_complete(int off) { _code_offsets.set_value(CodeOffsets::Frame_Complete, off); } | |
| 601 ExceptionHandlerTable* handler_table() { return &_handler_table; } | |
| 602 ImplicitExceptionTable* inc_table() { return &_inc_table; } | |
| 603 OopMapSet* oop_map_set() { return _oop_map_set; } | |
| 604 DebugInformationRecorder* debug_info() { return env()->debug_info(); } | |
| 605 Dependencies* dependencies() { return env()->dependencies(); } | |
| 606 static int CompiledZap_count() { return _CompiledZap_count; } | |
| 607 BufferBlob* scratch_buffer_blob() { return _scratch_buffer_blob; } | |
| 608 void init_scratch_buffer_blob(); | |
| 609 void set_scratch_buffer_blob(BufferBlob* b) { _scratch_buffer_blob = b; } | |
| 610 relocInfo* scratch_locs_memory() { return _scratch_locs_memory; } | |
| 611 void set_scratch_locs_memory(relocInfo* b) { _scratch_locs_memory = b; } | |
| 612 | |
| 613 // emit to scratch blob, report resulting size | |
| 614 uint scratch_emit_size(const Node* n); | |
| 615 | |
| 616 enum ScratchBufferBlob { | |
| 617 MAX_inst_size = 1024, | |
| 618 MAX_locs_size = 128, // number of relocInfo elements | |
| 619 MAX_const_size = 128, | |
| 620 MAX_stubs_size = 128 | |
| 621 }; | |
| 622 | |
| 623 // Major entry point. Given a Scope, compile the associated method. | |
| 624 // For normal compilations, entry_bci is InvocationEntryBci. For on stack | |
| 625 // replacement, entry_bci indicates the bytecode for which to compile a | |
| 626 // continuation. | |
| 627 Compile(ciEnv* ci_env, C2Compiler* compiler, ciMethod* target, | |
|
38
b789bcaf2dd9
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
0
diff
changeset
|
628 int entry_bci, bool subsume_loads, bool do_escape_analysis); |
| 0 | 629 |
| 630 // Second major entry point. From the TypeFunc signature, generate code | |
| 631 // to pass arguments from the Java calling convention to the C calling | |
| 632 // convention. | |
| 633 Compile(ciEnv* ci_env, const TypeFunc *(*gen)(), | |
| 634 address stub_function, const char *stub_name, | |
| 635 int is_fancy_jump, bool pass_tls, | |
| 636 bool save_arg_registers, bool return_pc); | |
| 637 | |
| 638 // From the TypeFunc signature, generate code to pass arguments | |
| 639 // from Compiled calling convention to Interpreter's calling convention | |
| 640 void Generate_Compiled_To_Interpreter_Graph(const TypeFunc *tf, address interpreter_entry); | |
| 641 | |
| 642 // From the TypeFunc signature, generate code to pass arguments | |
| 643 // from Interpreter's calling convention to Compiler's calling convention | |
| 644 void Generate_Interpreter_To_Compiled_Graph(const TypeFunc *tf); | |
| 645 | |
| 646 // Are we compiling a method? | |
| 647 bool has_method() { return method() != NULL; } | |
| 648 | |
| 649 // Maybe print some information about this compile. | |
| 650 void print_compile_messages(); | |
| 651 | |
| 652 // Final graph reshaping, a post-pass after the regular optimizer is done. | |
| 653 bool final_graph_reshaping(); | |
| 654 | |
| 655 // returns true if adr is completely contained in the given alias category | |
| 656 bool must_alias(const TypePtr* adr, int alias_idx); | |
| 657 | |
| 658 // returns true if adr overlaps with the given alias category | |
| 659 bool can_alias(const TypePtr* adr, int alias_idx); | |
| 660 | |
| 661 // Driver for converting compiler's IR into machine code bits | |
| 662 void Output(); | |
| 663 | |
| 664 // Accessors for node bundling info. | |
| 665 Bundle* node_bundling(const Node *n); | |
| 666 bool valid_bundle_info(const Node *n); | |
| 667 | |
| 668 // Schedule and Bundle the instructions | |
| 669 void ScheduleAndBundle(); | |
| 670 | |
| 671 // Build OopMaps for each GC point | |
| 672 void BuildOopMaps(); | |
|
63
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
673 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
674 // Append debug info for the node "local" at safepoint node "sfpt" to the |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
675 // "array", May also consult and add to "objs", which describes the |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
676 // scalar-replaced objects. |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
677 void FillLocArray( int idx, MachSafePointNode* sfpt, |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
678 Node *local, GrowableArray<ScopeValue*> *array, |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
679 GrowableArray<ScopeValue*> *objs ); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
680 |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
681 // If "objs" contains an ObjectValue whose id is "id", returns it, else NULL. |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
682 static ObjectValue* sv_for_node_id(GrowableArray<ScopeValue*> *objs, int id); |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
683 // Requres that "objs" does not contains an ObjectValue whose id matches |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
684 // that of "sv. Appends "sv". |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
685 static void set_sv_for_object_node(GrowableArray<ScopeValue*> *objs, |
|
eac007780a58
6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents:
38
diff
changeset
|
686 ObjectValue* sv ); |
| 0 | 687 |
| 688 // Process an OopMap Element while emitting nodes | |
| 689 void Process_OopMap_Node(MachNode *mach, int code_offset); | |
| 690 | |
| 691 // Write out basic block data to code buffer | |
| 692 void Fill_buffer(); | |
| 693 | |
| 694 // Determine which variable sized branches can be shortened | |
| 695 void Shorten_branches(Label *labels, int& code_size, int& reloc_size, int& stub_size, int& const_size); | |
| 696 | |
| 697 // Compute the size of first NumberOfLoopInstrToAlign instructions | |
| 698 // at the head of a loop. | |
| 699 void compute_loop_first_inst_sizes(); | |
| 700 | |
| 701 // Compute the information for the exception tables | |
| 702 void FillExceptionTables(uint cnt, uint *call_returns, uint *inct_starts, Label *blk_labels); | |
| 703 | |
| 704 // Stack slots that may be unused by the calling convention but must | |
| 705 // otherwise be preserved. On Intel this includes the return address. | |
| 706 // On PowerPC it includes the 4 words holding the old TOC & LR glue. | |
| 707 uint in_preserve_stack_slots(); | |
| 708 | |
| 709 // "Top of Stack" slots that may be unused by the calling convention but must | |
| 710 // otherwise be preserved. | |
| 711 // On Intel these are not necessary and the value can be zero. | |
| 712 // On Sparc this describes the words reserved for storing a register window | |
| 713 // when an interrupt occurs. | |
| 714 static uint out_preserve_stack_slots(); | |
| 715 | |
| 716 // Number of outgoing stack slots killed above the out_preserve_stack_slots | |
| 717 // for calls to C. Supports the var-args backing area for register parms. | |
| 718 uint varargs_C_out_slots_killed() const; | |
| 719 | |
| 720 // Number of Stack Slots consumed by a synchronization entry | |
| 721 int sync_stack_slots() const; | |
| 722 | |
| 723 // Compute the name of old_SP. See <arch>.ad for frame layout. | |
| 724 OptoReg::Name compute_old_SP(); | |
| 725 | |
| 726 #ifdef ENABLE_ZAP_DEAD_LOCALS | |
| 727 static bool is_node_getting_a_safepoint(Node*); | |
| 728 void Insert_zap_nodes(); | |
| 729 Node* call_zap_node(MachSafePointNode* n, int block_no); | |
| 730 #endif | |
| 731 | |
| 732 private: | |
| 733 // Phase control: | |
| 734 void Init(int aliaslevel); // Prepare for a single compilation | |
| 735 int Inline_Warm(); // Find more inlining work. | |
| 736 void Finish_Warm(); // Give up on further inlines. | |
| 737 void Optimize(); // Given a graph, optimize it | |
| 738 void Code_Gen(); // Generate code from a graph | |
| 739 | |
| 740 // Management of the AliasType table. | |
| 741 void grow_alias_types(); | |
| 742 AliasCacheEntry* probe_alias_cache(const TypePtr* adr_type); | |
| 743 const TypePtr *flatten_alias_type(const TypePtr* adr_type) const; | |
| 744 AliasType* find_alias_type(const TypePtr* adr_type, bool no_create); | |
| 745 | |
| 746 void verify_top(Node*) const PRODUCT_RETURN; | |
| 747 | |
| 748 // Intrinsic setup. | |
| 749 void register_library_intrinsics(); // initializer | |
| 750 CallGenerator* make_vm_intrinsic(ciMethod* m, bool is_virtual); // constructor | |
| 751 int intrinsic_insertion_index(ciMethod* m, bool is_virtual); // helper | |
| 752 CallGenerator* find_intrinsic(ciMethod* m, bool is_virtual); // query fn | |
| 753 void register_intrinsic(CallGenerator* cg); // update fn | |
| 754 | |
| 755 #ifndef PRODUCT | |
| 756 static juint _intrinsic_hist_count[vmIntrinsics::ID_LIMIT]; | |
| 757 static jubyte _intrinsic_hist_flags[vmIntrinsics::ID_LIMIT]; | |
| 758 #endif | |
| 759 | |
| 760 public: | |
| 761 | |
| 762 // Note: Histogram array size is about 1 Kb. | |
| 763 enum { // flag bits: | |
| 764 _intrinsic_worked = 1, // succeeded at least once | |
| 765 _intrinsic_failed = 2, // tried it but it failed | |
| 766 _intrinsic_disabled = 4, // was requested but disabled (e.g., -XX:-InlineUnsafeOps) | |
| 767 _intrinsic_virtual = 8, // was seen in the virtual form (rare) | |
| 768 _intrinsic_both = 16 // was seen in the non-virtual form (usual) | |
| 769 }; | |
| 770 // Update histogram. Return boolean if this is a first-time occurrence. | |
| 771 static bool gather_intrinsic_statistics(vmIntrinsics::ID id, | |
| 772 bool is_virtual, int flags) PRODUCT_RETURN0; | |
| 773 static void print_intrinsic_statistics() PRODUCT_RETURN; | |
| 774 | |
| 775 // Graph verification code | |
| 776 // Walk the node list, verifying that there is a one-to-one | |
| 777 // correspondence between Use-Def edges and Def-Use edges | |
| 778 // The option no_dead_code enables stronger checks that the | |
| 779 // graph is strongly connected from root in both directions. | |
| 780 void verify_graph_edges(bool no_dead_code = false) PRODUCT_RETURN; | |
| 781 | |
| 782 // Print bytecodes, including the scope inlining tree | |
| 783 void print_codes(); | |
| 784 | |
| 785 // End-of-run dumps. | |
| 786 static void print_statistics() PRODUCT_RETURN; | |
| 787 | |
| 788 // Dump formatted assembly | |
| 789 void dump_asm(int *pcs = NULL, uint pc_limit = 0) PRODUCT_RETURN; | |
| 790 void dump_pc(int *pcs, int pc_limit, Node *n); | |
| 791 | |
| 792 // Verify ADLC assumptions during startup | |
| 793 static void adlc_verification() PRODUCT_RETURN; | |
| 794 | |
| 795 // Definitions of pd methods | |
| 796 static void pd_compiler2_init(); | |
| 797 }; | |
| 1972 | 798 |
| 799 #endif // SHARE_VM_OPTO_COMPILE_HPP |