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