author | kvn |
Tue, 28 Jan 2014 12:28:17 -0800 | |
changeset 22873 | 74aaad871363 |
parent 22872 | b6902ee5bc8d |
parent 22800 | fbb2ab3f06ec |
child 22911 | ff49c48c887d |
permissions | -rw-r--r-- |
1 | 1 |
/* |
18025 | 2 |
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. |
1 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5353
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5353
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5353
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14623
diff
changeset
|
26 |
#include "asm/macroAssembler.hpp" |
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14623
diff
changeset
|
27 |
#include "asm/macroAssembler.inline.hpp" |
22243 | 28 |
#include "ci/ciReplay.hpp" |
7397 | 29 |
#include "classfile/systemDictionary.hpp" |
30 |
#include "code/exceptionHandlerTable.hpp" |
|
31 |
#include "code/nmethod.hpp" |
|
32 |
#include "compiler/compileLog.hpp" |
|
14626
0cf4eccf130f
8003240: x86: move MacroAssembler into separate file
twisti
parents:
14623
diff
changeset
|
33 |
#include "compiler/disassembler.hpp" |
7397 | 34 |
#include "compiler/oopMap.hpp" |
35 |
#include "opto/addnode.hpp" |
|
36 |
#include "opto/block.hpp" |
|
37 |
#include "opto/c2compiler.hpp" |
|
38 |
#include "opto/callGenerator.hpp" |
|
39 |
#include "opto/callnode.hpp" |
|
40 |
#include "opto/cfgnode.hpp" |
|
41 |
#include "opto/chaitin.hpp" |
|
42 |
#include "opto/compile.hpp" |
|
43 |
#include "opto/connode.hpp" |
|
44 |
#include "opto/divnode.hpp" |
|
45 |
#include "opto/escape.hpp" |
|
46 |
#include "opto/idealGraphPrinter.hpp" |
|
47 |
#include "opto/loopnode.hpp" |
|
48 |
#include "opto/machnode.hpp" |
|
49 |
#include "opto/macro.hpp" |
|
50 |
#include "opto/matcher.hpp" |
|
20715
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
51 |
#include "opto/mathexactnode.hpp" |
7397 | 52 |
#include "opto/memnode.hpp" |
53 |
#include "opto/mulnode.hpp" |
|
54 |
#include "opto/node.hpp" |
|
55 |
#include "opto/opcodes.hpp" |
|
56 |
#include "opto/output.hpp" |
|
57 |
#include "opto/parse.hpp" |
|
58 |
#include "opto/phaseX.hpp" |
|
59 |
#include "opto/rootnode.hpp" |
|
60 |
#include "opto/runtime.hpp" |
|
61 |
#include "opto/stringopts.hpp" |
|
62 |
#include "opto/type.hpp" |
|
63 |
#include "opto/vectornode.hpp" |
|
64 |
#include "runtime/arguments.hpp" |
|
65 |
#include "runtime/signature.hpp" |
|
66 |
#include "runtime/stubRoutines.hpp" |
|
67 |
#include "runtime/timer.hpp" |
|
18025 | 68 |
#include "trace/tracing.hpp" |
7397 | 69 |
#include "utilities/copy.hpp" |
70 |
#ifdef TARGET_ARCH_MODEL_x86_32 |
|
71 |
# include "adfiles/ad_x86_32.hpp" |
|
72 |
#endif |
|
73 |
#ifdef TARGET_ARCH_MODEL_x86_64 |
|
74 |
# include "adfiles/ad_x86_64.hpp" |
|
75 |
#endif |
|
76 |
#ifdef TARGET_ARCH_MODEL_sparc |
|
77 |
# include "adfiles/ad_sparc.hpp" |
|
78 |
#endif |
|
79 |
#ifdef TARGET_ARCH_MODEL_zero |
|
80 |
# include "adfiles/ad_zero.hpp" |
|
81 |
#endif |
|
8107
78e5bd944384
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
7715
diff
changeset
|
82 |
#ifdef TARGET_ARCH_MODEL_arm |
78e5bd944384
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
7715
diff
changeset
|
83 |
# include "adfiles/ad_arm.hpp" |
78e5bd944384
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
7715
diff
changeset
|
84 |
#endif |
22807 | 85 |
#ifdef TARGET_ARCH_MODEL_ppc_32 |
86 |
# include "adfiles/ad_ppc_32.hpp" |
|
87 |
#endif |
|
88 |
#ifdef TARGET_ARCH_MODEL_ppc_64 |
|
89 |
# include "adfiles/ad_ppc_64.hpp" |
|
8107
78e5bd944384
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
7715
diff
changeset
|
90 |
#endif |
1 | 91 |
|
7433 | 92 |
|
93 |
// -------------------- Compile::mach_constant_base_node ----------------------- |
|
94 |
// Constant table base node singleton. |
|
95 |
MachConstantBaseNode* Compile::mach_constant_base_node() { |
|
96 |
if (_mach_constant_base_node == NULL) { |
|
97 |
_mach_constant_base_node = new (C) MachConstantBaseNode(); |
|
98 |
_mach_constant_base_node->add_req(C->root()); |
|
99 |
} |
|
100 |
return _mach_constant_base_node; |
|
101 |
} |
|
102 |
||
103 |
||
1 | 104 |
/// Support for intrinsics. |
105 |
||
106 |
// Return the index at which m must be inserted (or already exists). |
|
107 |
// The sort order is by the address of the ciMethod, with is_virtual as minor key. |
|
108 |
int Compile::intrinsic_insertion_index(ciMethod* m, bool is_virtual) { |
|
109 |
#ifdef ASSERT |
|
110 |
for (int i = 1; i < _intrinsics->length(); i++) { |
|
111 |
CallGenerator* cg1 = _intrinsics->at(i-1); |
|
112 |
CallGenerator* cg2 = _intrinsics->at(i); |
|
113 |
assert(cg1->method() != cg2->method() |
|
114 |
? cg1->method() < cg2->method() |
|
115 |
: cg1->is_virtual() < cg2->is_virtual(), |
|
116 |
"compiler intrinsics list must stay sorted"); |
|
117 |
} |
|
118 |
#endif |
|
119 |
// Binary search sorted list, in decreasing intervals [lo, hi]. |
|
120 |
int lo = 0, hi = _intrinsics->length()-1; |
|
121 |
while (lo <= hi) { |
|
122 |
int mid = (uint)(hi + lo) / 2; |
|
123 |
ciMethod* mid_m = _intrinsics->at(mid)->method(); |
|
124 |
if (m < mid_m) { |
|
125 |
hi = mid-1; |
|
126 |
} else if (m > mid_m) { |
|
127 |
lo = mid+1; |
|
128 |
} else { |
|
129 |
// look at minor sort key |
|
130 |
bool mid_virt = _intrinsics->at(mid)->is_virtual(); |
|
131 |
if (is_virtual < mid_virt) { |
|
132 |
hi = mid-1; |
|
133 |
} else if (is_virtual > mid_virt) { |
|
134 |
lo = mid+1; |
|
135 |
} else { |
|
136 |
return mid; // exact match |
|
137 |
} |
|
138 |
} |
|
139 |
} |
|
140 |
return lo; // inexact match |
|
141 |
} |
|
142 |
||
143 |
void Compile::register_intrinsic(CallGenerator* cg) { |
|
144 |
if (_intrinsics == NULL) { |
|
15113 | 145 |
_intrinsics = new (comp_arena())GrowableArray<CallGenerator*>(comp_arena(), 60, 0, NULL); |
1 | 146 |
} |
147 |
// This code is stolen from ciObjectFactory::insert. |
|
148 |
// Really, GrowableArray should have methods for |
|
149 |
// insert_at, remove_at, and binary_search. |
|
150 |
int len = _intrinsics->length(); |
|
151 |
int index = intrinsic_insertion_index(cg->method(), cg->is_virtual()); |
|
152 |
if (index == len) { |
|
153 |
_intrinsics->append(cg); |
|
154 |
} else { |
|
155 |
#ifdef ASSERT |
|
156 |
CallGenerator* oldcg = _intrinsics->at(index); |
|
157 |
assert(oldcg->method() != cg->method() || oldcg->is_virtual() != cg->is_virtual(), "don't register twice"); |
|
158 |
#endif |
|
159 |
_intrinsics->append(_intrinsics->at(len-1)); |
|
160 |
int pos; |
|
161 |
for (pos = len-2; pos >= index; pos--) { |
|
162 |
_intrinsics->at_put(pos+1,_intrinsics->at(pos)); |
|
163 |
} |
|
164 |
_intrinsics->at_put(index, cg); |
|
165 |
} |
|
166 |
assert(find_intrinsic(cg->method(), cg->is_virtual()) == cg, "registration worked"); |
|
167 |
} |
|
168 |
||
169 |
CallGenerator* Compile::find_intrinsic(ciMethod* m, bool is_virtual) { |
|
170 |
assert(m->is_loaded(), "don't try this on unloaded methods"); |
|
171 |
if (_intrinsics != NULL) { |
|
172 |
int index = intrinsic_insertion_index(m, is_virtual); |
|
173 |
if (index < _intrinsics->length() |
|
174 |
&& _intrinsics->at(index)->method() == m |
|
175 |
&& _intrinsics->at(index)->is_virtual() == is_virtual) { |
|
176 |
return _intrinsics->at(index); |
|
177 |
} |
|
178 |
} |
|
179 |
// Lazily create intrinsics for intrinsic IDs well-known in the runtime. |
|
3273
6acf7084b1d3
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
2259
diff
changeset
|
180 |
if (m->intrinsic_id() != vmIntrinsics::_none && |
6acf7084b1d3
6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents:
2259
diff
changeset
|
181 |
m->intrinsic_id() <= vmIntrinsics::LAST_COMPILER_INLINE) { |
1 | 182 |
CallGenerator* cg = make_vm_intrinsic(m, is_virtual); |
183 |
if (cg != NULL) { |
|
184 |
// Save it for next time: |
|
185 |
register_intrinsic(cg); |
|
186 |
return cg; |
|
187 |
} else { |
|
188 |
gather_intrinsic_statistics(m->intrinsic_id(), is_virtual, _intrinsic_disabled); |
|
189 |
} |
|
190 |
} |
|
191 |
return NULL; |
|
192 |
} |
|
193 |
||
194 |
// Compile:: register_library_intrinsics and make_vm_intrinsic are defined |
|
195 |
// in library_call.cpp. |
|
196 |
||
197 |
||
198 |
#ifndef PRODUCT |
|
199 |
// statistics gathering... |
|
200 |
||
201 |
juint Compile::_intrinsic_hist_count[vmIntrinsics::ID_LIMIT] = {0}; |
|
202 |
jubyte Compile::_intrinsic_hist_flags[vmIntrinsics::ID_LIMIT] = {0}; |
|
203 |
||
204 |
bool Compile::gather_intrinsic_statistics(vmIntrinsics::ID id, bool is_virtual, int flags) { |
|
205 |
assert(id > vmIntrinsics::_none && id < vmIntrinsics::ID_LIMIT, "oob"); |
|
206 |
int oflags = _intrinsic_hist_flags[id]; |
|
207 |
assert(flags != 0, "what happened?"); |
|
208 |
if (is_virtual) { |
|
209 |
flags |= _intrinsic_virtual; |
|
210 |
} |
|
211 |
bool changed = (flags != oflags); |
|
212 |
if ((flags & _intrinsic_worked) != 0) { |
|
213 |
juint count = (_intrinsic_hist_count[id] += 1); |
|
214 |
if (count == 1) { |
|
215 |
changed = true; // first time |
|
216 |
} |
|
217 |
// increment the overall count also: |
|
218 |
_intrinsic_hist_count[vmIntrinsics::_none] += 1; |
|
219 |
} |
|
220 |
if (changed) { |
|
221 |
if (((oflags ^ flags) & _intrinsic_virtual) != 0) { |
|
222 |
// Something changed about the intrinsic's virtuality. |
|
223 |
if ((flags & _intrinsic_virtual) != 0) { |
|
224 |
// This is the first use of this intrinsic as a virtual call. |
|
225 |
if (oflags != 0) { |
|
226 |
// We already saw it as a non-virtual, so note both cases. |
|
227 |
flags |= _intrinsic_both; |
|
228 |
} |
|
229 |
} else if ((oflags & _intrinsic_both) == 0) { |
|
230 |
// This is the first use of this intrinsic as a non-virtual |
|
231 |
flags |= _intrinsic_both; |
|
232 |
} |
|
233 |
} |
|
234 |
_intrinsic_hist_flags[id] = (jubyte) (oflags | flags); |
|
235 |
} |
|
236 |
// update the overall flags also: |
|
237 |
_intrinsic_hist_flags[vmIntrinsics::_none] |= (jubyte) flags; |
|
238 |
return changed; |
|
239 |
} |
|
240 |
||
241 |
static char* format_flags(int flags, char* buf) { |
|
242 |
buf[0] = 0; |
|
243 |
if ((flags & Compile::_intrinsic_worked) != 0) strcat(buf, ",worked"); |
|
244 |
if ((flags & Compile::_intrinsic_failed) != 0) strcat(buf, ",failed"); |
|
245 |
if ((flags & Compile::_intrinsic_disabled) != 0) strcat(buf, ",disabled"); |
|
246 |
if ((flags & Compile::_intrinsic_virtual) != 0) strcat(buf, ",virtual"); |
|
247 |
if ((flags & Compile::_intrinsic_both) != 0) strcat(buf, ",nonvirtual"); |
|
248 |
if (buf[0] == 0) strcat(buf, ","); |
|
249 |
assert(buf[0] == ',', "must be"); |
|
250 |
return &buf[1]; |
|
251 |
} |
|
252 |
||
253 |
void Compile::print_intrinsic_statistics() { |
|
254 |
char flagsbuf[100]; |
|
255 |
ttyLocker ttyl; |
|
256 |
if (xtty != NULL) xtty->head("statistics type='intrinsic'"); |
|
257 |
tty->print_cr("Compiler intrinsic usage:"); |
|
258 |
juint total = _intrinsic_hist_count[vmIntrinsics::_none]; |
|
259 |
if (total == 0) total = 1; // avoid div0 in case of no successes |
|
260 |
#define PRINT_STAT_LINE(name, c, f) \ |
|
261 |
tty->print_cr(" %4d (%4.1f%%) %s (%s)", (int)(c), ((c) * 100.0) / total, name, f); |
|
262 |
for (int index = 1 + (int)vmIntrinsics::_none; index < (int)vmIntrinsics::ID_LIMIT; index++) { |
|
263 |
vmIntrinsics::ID id = (vmIntrinsics::ID) index; |
|
264 |
int flags = _intrinsic_hist_flags[id]; |
|
265 |
juint count = _intrinsic_hist_count[id]; |
|
266 |
if ((flags | count) != 0) { |
|
267 |
PRINT_STAT_LINE(vmIntrinsics::name_at(id), count, format_flags(flags, flagsbuf)); |
|
268 |
} |
|
269 |
} |
|
270 |
PRINT_STAT_LINE("total", total, format_flags(_intrinsic_hist_flags[vmIntrinsics::_none], flagsbuf)); |
|
271 |
if (xtty != NULL) xtty->tail("statistics"); |
|
272 |
} |
|
273 |
||
274 |
void Compile::print_statistics() { |
|
275 |
{ ttyLocker ttyl; |
|
276 |
if (xtty != NULL) xtty->head("statistics type='opto'"); |
|
277 |
Parse::print_statistics(); |
|
278 |
PhaseCCP::print_statistics(); |
|
279 |
PhaseRegAlloc::print_statistics(); |
|
280 |
Scheduling::print_statistics(); |
|
281 |
PhasePeephole::print_statistics(); |
|
282 |
PhaseIdealLoop::print_statistics(); |
|
283 |
if (xtty != NULL) xtty->tail("statistics"); |
|
284 |
} |
|
285 |
if (_intrinsic_hist_flags[vmIntrinsics::_none] != 0) { |
|
286 |
// put this under its own <statistics> element. |
|
287 |
print_intrinsic_statistics(); |
|
288 |
} |
|
289 |
} |
|
290 |
#endif //PRODUCT |
|
291 |
||
292 |
// Support for bundling info |
|
293 |
Bundle* Compile::node_bundling(const Node *n) { |
|
294 |
assert(valid_bundle_info(n), "oob"); |
|
295 |
return &_node_bundling_base[n->_idx]; |
|
296 |
} |
|
297 |
||
298 |
bool Compile::valid_bundle_info(const Node *n) { |
|
299 |
return (_node_bundling_limit > n->_idx); |
|
300 |
} |
|
301 |
||
302 |
||
4450
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
303 |
void Compile::gvn_replace_by(Node* n, Node* nn) { |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
304 |
for (DUIterator_Last imin, i = n->last_outs(imin); i >= imin; ) { |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
305 |
Node* use = n->last_out(i); |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
306 |
bool is_in_table = initial_gvn()->hash_delete(use); |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
307 |
uint uses_found = 0; |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
308 |
for (uint j = 0; j < use->len(); j++) { |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
309 |
if (use->in(j) == n) { |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
310 |
if (j < use->req()) |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
311 |
use->set_req(j, nn); |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
312 |
else |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
313 |
use->set_prec(j, nn); |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
314 |
uses_found++; |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
315 |
} |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
316 |
} |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
317 |
if (is_in_table) { |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
318 |
// reinsert into table |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
319 |
initial_gvn()->hash_find_insert(use); |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
320 |
} |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
321 |
record_for_igvn(use); |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
322 |
i -= uses_found; // we deleted 1 or more copies of this edge |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
323 |
} |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
324 |
} |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
325 |
|
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
326 |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
327 |
static inline bool not_a_node(const Node* n) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
328 |
if (n == NULL) return true; |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
329 |
if (((intptr_t)n & 1) != 0) return true; // uninitialized, etc. |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
330 |
if (*(address*)n == badAddress) return true; // kill by Node::destruct |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
331 |
return false; |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
332 |
} |
4450
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
333 |
|
1 | 334 |
// Identify all nodes that are reachable from below, useful. |
335 |
// Use breadth-first pass that records state in a Unique_Node_List, |
|
336 |
// recursive traversal is slower. |
|
337 |
void Compile::identify_useful_nodes(Unique_Node_List &useful) { |
|
338 |
int estimated_worklist_size = unique(); |
|
339 |
useful.map( estimated_worklist_size, NULL ); // preallocate space |
|
340 |
||
341 |
// Initialize worklist |
|
342 |
if (root() != NULL) { useful.push(root()); } |
|
343 |
// If 'top' is cached, declare it useful to preserve cached node |
|
344 |
if( cached_top_node() ) { useful.push(cached_top_node()); } |
|
345 |
||
346 |
// Push all useful nodes onto the list, breadthfirst |
|
347 |
for( uint next = 0; next < useful.size(); ++next ) { |
|
348 |
assert( next < unique(), "Unique useful nodes < total nodes"); |
|
349 |
Node *n = useful.at(next); |
|
350 |
uint max = n->len(); |
|
351 |
for( uint i = 0; i < max; ++i ) { |
|
352 |
Node *m = n->in(i); |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
353 |
if (not_a_node(m)) continue; |
1 | 354 |
useful.push(m); |
355 |
} |
|
356 |
} |
|
357 |
} |
|
358 |
||
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
359 |
// Update dead_node_list with any missing dead nodes using useful |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
360 |
// list. Consider all non-useful nodes to be useless i.e., dead nodes. |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
361 |
void Compile::update_dead_node_list(Unique_Node_List &useful) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
362 |
uint max_idx = unique(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
363 |
VectorSet& useful_node_set = useful.member_set(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
364 |
|
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
365 |
for (uint node_idx = 0; node_idx < max_idx; node_idx++) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
366 |
// If node with index node_idx is not in useful set, |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
367 |
// mark it as dead in dead node list. |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
368 |
if (! useful_node_set.test(node_idx) ) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
369 |
record_dead_node(node_idx); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
370 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
371 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
372 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
373 |
|
15113 | 374 |
void Compile::remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Unique_Node_List &useful) { |
375 |
int shift = 0; |
|
376 |
for (int i = 0; i < inlines->length(); i++) { |
|
377 |
CallGenerator* cg = inlines->at(i); |
|
378 |
CallNode* call = cg->call_node(); |
|
379 |
if (shift > 0) { |
|
380 |
inlines->at_put(i-shift, cg); |
|
381 |
} |
|
382 |
if (!useful.member(call)) { |
|
383 |
shift++; |
|
384 |
} |
|
385 |
} |
|
386 |
inlines->trunc_to(inlines->length()-shift); |
|
387 |
} |
|
388 |
||
1 | 389 |
// Disconnect all useless nodes by disconnecting those at the boundary. |
390 |
void Compile::remove_useless_nodes(Unique_Node_List &useful) { |
|
391 |
uint next = 0; |
|
10988
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
392 |
while (next < useful.size()) { |
1 | 393 |
Node *n = useful.at(next++); |
394 |
// Use raw traversal of out edges since this code removes out edges |
|
395 |
int max = n->outcnt(); |
|
10988
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
396 |
for (int j = 0; j < max; ++j) { |
1 | 397 |
Node* child = n->raw_out(j); |
10988
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
398 |
if (! useful.member(child)) { |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
399 |
assert(!child->is_top() || child != top(), |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
400 |
"If top is cached in Compile object it is in useful list"); |
1 | 401 |
// Only need to remove this out-edge to the useless node |
402 |
n->raw_del_out(j); |
|
403 |
--j; |
|
404 |
--max; |
|
405 |
} |
|
406 |
} |
|
407 |
if (n->outcnt() == 1 && n->has_special_unique_user()) { |
|
10988
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
408 |
record_for_igvn(n->unique_out()); |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
409 |
} |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
410 |
} |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
411 |
// Remove useless macro and predicate opaq nodes |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
412 |
for (int i = C->macro_count()-1; i >= 0; i--) { |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
413 |
Node* n = C->macro_node(i); |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
414 |
if (!useful.member(n)) { |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
415 |
remove_macro_node(n); |
1 | 416 |
} |
417 |
} |
|
15618
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
418 |
// Remove useless expensive node |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
419 |
for (int i = C->expensive_count()-1; i >= 0; i--) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
420 |
Node* n = C->expensive_node(i); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
421 |
if (!useful.member(n)) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
422 |
remove_expensive_node(n); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
423 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
424 |
} |
15113 | 425 |
// clean up the late inline lists |
426 |
remove_useless_late_inlines(&_string_late_inlines, useful); |
|
17383 | 427 |
remove_useless_late_inlines(&_boxing_late_inlines, useful); |
15113 | 428 |
remove_useless_late_inlines(&_late_inlines, useful); |
1 | 429 |
debug_only(verify_graph_edges(true/*check for no_dead_code*/);) |
430 |
} |
|
431 |
||
432 |
//------------------------------frame_size_in_words----------------------------- |
|
433 |
// frame_slots in units of words |
|
434 |
int Compile::frame_size_in_words() const { |
|
435 |
// shift is 0 in LP32 and 1 in LP64 |
|
436 |
const int shift = (LogBytesPerWord - LogBytesPerInt); |
|
437 |
int words = _frame_slots >> shift; |
|
438 |
assert( words << shift == _frame_slots, "frame size must be properly aligned in LP64" ); |
|
439 |
return words; |
|
440 |
} |
|
441 |
||
442 |
// ============================================================================ |
|
443 |
//------------------------------CompileWrapper--------------------------------- |
|
444 |
class CompileWrapper : public StackObj { |
|
445 |
Compile *const _compile; |
|
446 |
public: |
|
447 |
CompileWrapper(Compile* compile); |
|
448 |
||
449 |
~CompileWrapper(); |
|
450 |
}; |
|
451 |
||
452 |
CompileWrapper::CompileWrapper(Compile* compile) : _compile(compile) { |
|
453 |
// the Compile* pointer is stored in the current ciEnv: |
|
454 |
ciEnv* env = compile->env(); |
|
455 |
assert(env == ciEnv::current(), "must already be a ciEnv active"); |
|
456 |
assert(env->compiler_data() == NULL, "compile already active?"); |
|
457 |
env->set_compiler_data(compile); |
|
458 |
assert(compile == Compile::current(), "sanity"); |
|
459 |
||
460 |
compile->set_type_dict(NULL); |
|
461 |
compile->set_type_hwm(NULL); |
|
462 |
compile->set_type_last_size(0); |
|
463 |
compile->set_last_tf(NULL, NULL); |
|
464 |
compile->set_indexSet_arena(NULL); |
|
465 |
compile->set_indexSet_free_block_list(NULL); |
|
466 |
compile->init_type_arena(); |
|
467 |
Type::Initialize(compile); |
|
468 |
_compile->set_scratch_buffer_blob(NULL); |
|
469 |
_compile->begin_method(); |
|
470 |
} |
|
471 |
CompileWrapper::~CompileWrapper() { |
|
472 |
_compile->end_method(); |
|
473 |
if (_compile->scratch_buffer_blob() != NULL) |
|
474 |
BufferBlob::free(_compile->scratch_buffer_blob()); |
|
475 |
_compile->env()->set_compiler_data(NULL); |
|
476 |
} |
|
477 |
||
478 |
||
479 |
//----------------------------print_compile_messages--------------------------- |
|
480 |
void Compile::print_compile_messages() { |
|
481 |
#ifndef PRODUCT |
|
482 |
// Check if recompiling |
|
483 |
if (_subsume_loads == false && PrintOpto) { |
|
484 |
// Recompiling without allowing machine instructions to subsume loads |
|
485 |
tty->print_cr("*********************************************************"); |
|
486 |
tty->print_cr("** Bailout: Recompile without subsuming loads **"); |
|
487 |
tty->print_cr("*********************************************************"); |
|
488 |
} |
|
211
e2b60448c234
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
1
diff
changeset
|
489 |
if (_do_escape_analysis != DoEscapeAnalysis && PrintOpto) { |
e2b60448c234
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
1
diff
changeset
|
490 |
// Recompiling without escape analysis |
e2b60448c234
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
1
diff
changeset
|
491 |
tty->print_cr("*********************************************************"); |
e2b60448c234
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
1
diff
changeset
|
492 |
tty->print_cr("** Bailout: Recompile without escape analysis **"); |
e2b60448c234
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
1
diff
changeset
|
493 |
tty->print_cr("*********************************************************"); |
e2b60448c234
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
1
diff
changeset
|
494 |
} |
17383 | 495 |
if (_eliminate_boxing != EliminateAutoBox && PrintOpto) { |
496 |
// Recompiling without boxing elimination |
|
497 |
tty->print_cr("*********************************************************"); |
|
498 |
tty->print_cr("** Bailout: Recompile without boxing elimination **"); |
|
499 |
tty->print_cr("*********************************************************"); |
|
500 |
} |
|
1 | 501 |
if (env()->break_at_compile()) { |
2131 | 502 |
// Open the debugger when compiling this method. |
1 | 503 |
tty->print("### Breaking when compiling: "); |
504 |
method()->print_short_name(); |
|
505 |
tty->cr(); |
|
506 |
BREAKPOINT; |
|
507 |
} |
|
508 |
||
509 |
if( PrintOpto ) { |
|
510 |
if (is_osr_compilation()) { |
|
511 |
tty->print("[OSR]%3d", _compile_id); |
|
512 |
} else { |
|
513 |
tty->print("%3d", _compile_id); |
|
514 |
} |
|
515 |
} |
|
516 |
#endif |
|
517 |
} |
|
518 |
||
519 |
||
7715
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
520 |
//-----------------------init_scratch_buffer_blob------------------------------ |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
521 |
// Construct a temporary BufferBlob and cache it for this compile. |
7433 | 522 |
void Compile::init_scratch_buffer_blob(int const_size) { |
7715
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
523 |
// If there is already a scratch buffer blob allocated and the |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
524 |
// constant section is big enough, use it. Otherwise free the |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
525 |
// current and allocate a new one. |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
526 |
BufferBlob* blob = scratch_buffer_blob(); |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
527 |
if ((blob != NULL) && (const_size <= _scratch_const_size)) { |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
528 |
// Use the current blob. |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
529 |
} else { |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
530 |
if (blob != NULL) { |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
531 |
BufferBlob::free(blob); |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
532 |
} |
1 | 533 |
|
7715
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
534 |
ResourceMark rm; |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
535 |
_scratch_const_size = const_size; |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
536 |
int size = (MAX_inst_size + MAX_stubs_size + _scratch_const_size); |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
537 |
blob = BufferBlob::create("Compile::scratch_buffer", size); |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
538 |
// Record the buffer blob for next time. |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
539 |
set_scratch_buffer_blob(blob); |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
540 |
// Have we run out of code space? |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
541 |
if (scratch_buffer_blob() == NULL) { |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
542 |
// Let CompilerBroker disable further compilations. |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
543 |
record_failure("Not enough space for scratch buffer in CodeCache"); |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
544 |
return; |
12998f95a334
7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents:
7433
diff
changeset
|
545 |
} |
589 | 546 |
} |
1 | 547 |
|
548 |
// Initialize the relocation buffers |
|
6418 | 549 |
relocInfo* locs_buf = (relocInfo*) blob->content_end() - MAX_locs_size; |
1 | 550 |
set_scratch_locs_memory(locs_buf); |
551 |
} |
|
552 |
||
553 |
||
554 |
//-----------------------scratch_emit_size------------------------------------- |
|
555 |
// Helper function that computes size by emitting code |
|
556 |
uint Compile::scratch_emit_size(const Node* n) { |
|
7433 | 557 |
// Start scratch_emit_size section. |
558 |
set_in_scratch_emit_size(true); |
|
559 |
||
1 | 560 |
// Emit into a trash buffer and count bytes emitted. |
561 |
// This is a pretty expensive way to compute a size, |
|
562 |
// but it works well enough if seldom used. |
|
563 |
// All common fixed-size instructions are given a size |
|
564 |
// method by the AD file. |
|
565 |
// Note that the scratch buffer blob and locs memory are |
|
566 |
// allocated at the beginning of the compile task, and |
|
567 |
// may be shared by several calls to scratch_emit_size. |
|
568 |
// The allocation of the scratch buffer blob is particularly |
|
569 |
// expensive, since it has to grab the code cache lock. |
|
570 |
BufferBlob* blob = this->scratch_buffer_blob(); |
|
571 |
assert(blob != NULL, "Initialize BufferBlob at start"); |
|
572 |
assert(blob->size() > MAX_inst_size, "sanity"); |
|
573 |
relocInfo* locs_buf = scratch_locs_memory(); |
|
6418 | 574 |
address blob_begin = blob->content_begin(); |
1 | 575 |
address blob_end = (address)locs_buf; |
6418 | 576 |
assert(blob->content_contains(blob_end), "sanity"); |
1 | 577 |
CodeBuffer buf(blob_begin, blob_end - blob_begin); |
7433 | 578 |
buf.initialize_consts_size(_scratch_const_size); |
1 | 579 |
buf.initialize_stubs_size(MAX_stubs_size); |
580 |
assert(locs_buf != NULL, "sanity"); |
|
7433 | 581 |
int lsize = MAX_locs_size / 3; |
582 |
buf.consts()->initialize_shared_locs(&locs_buf[lsize * 0], lsize); |
|
583 |
buf.insts()->initialize_shared_locs( &locs_buf[lsize * 1], lsize); |
|
584 |
buf.stubs()->initialize_shared_locs( &locs_buf[lsize * 2], lsize); |
|
585 |
||
586 |
// Do the emission. |
|
10252 | 587 |
|
588 |
Label fakeL; // Fake label for branch instructions. |
|
10266
2ea344c79e33
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
10252
diff
changeset
|
589 |
Label* saveL = NULL; |
2ea344c79e33
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
10252
diff
changeset
|
590 |
uint save_bnum = 0; |
2ea344c79e33
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
10252
diff
changeset
|
591 |
bool is_branch = n->is_MachBranch(); |
10252 | 592 |
if (is_branch) { |
593 |
MacroAssembler masm(&buf); |
|
594 |
masm.bind(fakeL); |
|
10266
2ea344c79e33
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
10252
diff
changeset
|
595 |
n->as_MachBranch()->save_label(&saveL, &save_bnum); |
2ea344c79e33
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
10252
diff
changeset
|
596 |
n->as_MachBranch()->label_set(&fakeL, 0); |
10252 | 597 |
} |
1 | 598 |
n->emit(buf, this->regalloc()); |
10266
2ea344c79e33
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
10252
diff
changeset
|
599 |
if (is_branch) // Restore label. |
2ea344c79e33
7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents:
10252
diff
changeset
|
600 |
n->as_MachBranch()->label_set(saveL, save_bnum); |
7433 | 601 |
|
602 |
// End scratch_emit_size section. |
|
603 |
set_in_scratch_emit_size(false); |
|
604 |
||
6418 | 605 |
return buf.insts_size(); |
1 | 606 |
} |
607 |
||
608 |
||
609 |
// ============================================================================ |
|
610 |
//------------------------------Compile standard------------------------------- |
|
611 |
debug_only( int Compile::_debug_idx = 100000; ) |
|
612 |
||
613 |
// Compile a method. entry_bci is -1 for normal compilations and indicates |
|
614 |
// the continuation bci for on stack replacement. |
|
615 |
||
616 |
||
17383 | 617 |
Compile::Compile( ciEnv* ci_env, C2Compiler* compiler, ciMethod* target, int osr_bci, |
618 |
bool subsume_loads, bool do_escape_analysis, bool eliminate_boxing ) |
|
1 | 619 |
: Phase(Compiler), |
620 |
_env(ci_env), |
|
621 |
_log(ci_env->log()), |
|
622 |
_compile_id(ci_env->compile_id()), |
|
623 |
_save_argument_registers(false), |
|
624 |
_stub_name(NULL), |
|
625 |
_stub_function(NULL), |
|
626 |
_stub_entry_point(NULL), |
|
627 |
_method(target), |
|
628 |
_entry_bci(osr_bci), |
|
629 |
_initial_gvn(NULL), |
|
630 |
_for_igvn(NULL), |
|
631 |
_warm_calls(NULL), |
|
632 |
_subsume_loads(subsume_loads), |
|
211
e2b60448c234
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
1
diff
changeset
|
633 |
_do_escape_analysis(do_escape_analysis), |
17383 | 634 |
_eliminate_boxing(eliminate_boxing), |
1 | 635 |
_failure_reason(NULL), |
636 |
_code_buffer("Compile::Fill_buffer"), |
|
637 |
_orig_pc_slot(0), |
|
638 |
_orig_pc_slot_offset_in_bytes(0), |
|
4906 | 639 |
_has_method_handle_invokes(false), |
7433 | 640 |
_mach_constant_base_node(NULL), |
1 | 641 |
_node_bundling_limit(0), |
642 |
_node_bundling_base(NULL), |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
643 |
_java_calls(0), |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
644 |
_inner_loops(0), |
7433 | 645 |
_scratch_const_size(-1), |
646 |
_in_scratch_emit_size(false), |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
647 |
_dead_node_list(comp_arena()), |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
648 |
_dead_node_count(0), |
1 | 649 |
#ifndef PRODUCT |
650 |
_trace_opto_output(TraceOptoOutput || method()->has_option("TraceOptoOutput")), |
|
22854
2787e48d6df9
8029025: PPC64 (part 203): opto: Move static _in_dump_cnt to Compile object.
goetz
parents:
22851
diff
changeset
|
651 |
_in_dump_cnt(0), |
1 | 652 |
_printer(IdealGraphPrinter::printer()), |
653 |
#endif |
|
14828
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
654 |
_congraph(NULL), |
22243 | 655 |
_replay_inline_data(NULL), |
15113 | 656 |
_late_inlines(comp_arena(), 2, 0, NULL), |
657 |
_string_late_inlines(comp_arena(), 2, 0, NULL), |
|
17383 | 658 |
_boxing_late_inlines(comp_arena(), 2, 0, NULL), |
15113 | 659 |
_late_inlines_pos(0), |
660 |
_number_of_mh_late_inlines(0), |
|
661 |
_inlining_progress(false), |
|
662 |
_inlining_incrementally(false), |
|
14828
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
663 |
_print_inlining_list(NULL), |
21089
e1986ff6fe2e
8024069: replace_in_map() should operate on parent maps
roland
parents:
20715
diff
changeset
|
664 |
_print_inlining_idx(0), |
e1986ff6fe2e
8024069: replace_in_map() should operate on parent maps
roland
parents:
20715
diff
changeset
|
665 |
_preserve_jvm_state(0) { |
1 | 666 |
C = this; |
667 |
||
668 |
CompileWrapper cw(this); |
|
669 |
#ifndef PRODUCT |
|
670 |
if (TimeCompiler2) { |
|
671 |
tty->print(" "); |
|
672 |
target->holder()->name()->print(); |
|
673 |
tty->print("."); |
|
674 |
target->print_short_name(); |
|
675 |
tty->print(" "); |
|
676 |
} |
|
677 |
TraceTime t1("Total compilation time", &_t_totalCompilation, TimeCompiler, TimeCompiler2); |
|
678 |
TraceTime t2(NULL, &_t_methodCompilation, TimeCompiler, false); |
|
347
df859fcca515
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
238
diff
changeset
|
679 |
bool print_opto_assembly = PrintOptoAssembly || _method->has_option("PrintOptoAssembly"); |
df859fcca515
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
238
diff
changeset
|
680 |
if (!print_opto_assembly) { |
df859fcca515
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
238
diff
changeset
|
681 |
bool print_assembly = (PrintAssembly || _method->should_print_assembly()); |
df859fcca515
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
238
diff
changeset
|
682 |
if (print_assembly && !Disassembler::can_decode()) { |
df859fcca515
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
238
diff
changeset
|
683 |
tty->print_cr("PrintAssembly request changed to PrintOptoAssembly"); |
df859fcca515
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
238
diff
changeset
|
684 |
print_opto_assembly = true; |
df859fcca515
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
238
diff
changeset
|
685 |
} |
df859fcca515
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
238
diff
changeset
|
686 |
} |
df859fcca515
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
238
diff
changeset
|
687 |
set_print_assembly(print_opto_assembly); |
1399
9648dfd4ce09
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
1137
diff
changeset
|
688 |
set_parsed_irreducible_loop(false); |
22243 | 689 |
|
690 |
if (method()->has_option("ReplayInline")) { |
|
691 |
_replay_inline_data = ciReplay::load_inline_data(method(), entry_bci(), ci_env->comp_level()); |
|
692 |
} |
|
1 | 693 |
#endif |
20073 | 694 |
set_print_inlining(PrintInlining || method()->has_option("PrintInlining") NOT_PRODUCT( || PrintOptoInlining)); |
695 |
set_print_intrinsics(PrintIntrinsics || method()->has_option("PrintIntrinsics")); |
|
1 | 696 |
|
697 |
if (ProfileTraps) { |
|
698 |
// Make sure the method being compiled gets its own MDO, |
|
699 |
// so we can at least track the decompile_count(). |
|
7432
f06f1253c317
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents:
7397
diff
changeset
|
700 |
method()->ensure_method_data(); |
1 | 701 |
} |
702 |
||
703 |
Init(::AliasLevel); |
|
704 |
||
705 |
||
706 |
print_compile_messages(); |
|
707 |
||
22800 | 708 |
_ilt = InlineTree::build_inline_tree_root(); |
1 | 709 |
|
710 |
// Even if NO memory addresses are used, MergeMem nodes must have at least 1 slice |
|
711 |
assert(num_alias_types() >= AliasIdxRaw, ""); |
|
712 |
||
713 |
#define MINIMUM_NODE_HASH 1023 |
|
714 |
// Node list that Iterative GVN will start with |
|
715 |
Unique_Node_List for_igvn(comp_arena()); |
|
716 |
set_for_igvn(&for_igvn); |
|
717 |
||
718 |
// GVN that will be run immediately on new nodes |
|
719 |
uint estimated_size = method()->code_size()*4+64; |
|
720 |
estimated_size = (estimated_size < MINIMUM_NODE_HASH ? MINIMUM_NODE_HASH : estimated_size); |
|
721 |
PhaseGVN gvn(node_arena(), estimated_size); |
|
722 |
set_initial_gvn(&gvn); |
|
723 |
||
20073 | 724 |
if (print_inlining() || print_intrinsics()) { |
14828
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
725 |
_print_inlining_list = new (comp_arena())GrowableArray<PrintInliningBuffer>(comp_arena(), 1, 1, PrintInliningBuffer()); |
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
726 |
} |
1 | 727 |
{ // Scope for timing the parser |
728 |
TracePhase t3("parse", &_t_parser, true); |
|
729 |
||
730 |
// Put top into the hash table ASAP. |
|
731 |
initial_gvn()->transform_no_reclaim(top()); |
|
732 |
||
733 |
// Set up tf(), start(), and find a CallGenerator. |
|
9176
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
734 |
CallGenerator* cg = NULL; |
1 | 735 |
if (is_osr_compilation()) { |
736 |
const TypeTuple *domain = StartOSRNode::osr_domain(); |
|
737 |
const TypeTuple *range = TypeTuple::make_range(method()->signature()); |
|
738 |
init_tf(TypeFunc::make(domain, range)); |
|
13895
f6dfe4123709
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
13886
diff
changeset
|
739 |
StartNode* s = new (this) StartOSRNode(root(), domain); |
1 | 740 |
initial_gvn()->set_type_bottom(s); |
741 |
init_start(s); |
|
742 |
cg = CallGenerator::for_osr(method(), entry_bci()); |
|
743 |
} else { |
|
744 |
// Normal case. |
|
745 |
init_tf(TypeFunc::make(method())); |
|
13895
f6dfe4123709
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
13886
diff
changeset
|
746 |
StartNode* s = new (this) StartNode(root(), tf()->domain()); |
1 | 747 |
initial_gvn()->set_type_bottom(s); |
748 |
init_start(s); |
|
9176
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
749 |
if (method()->intrinsic_id() == vmIntrinsics::_Reference_get && UseG1GC) { |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
750 |
// With java.lang.ref.reference.get() we must go through the |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
751 |
// intrinsic when G1 is enabled - even when get() is the root |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
752 |
// method of the compile - so that, if necessary, the value in |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
753 |
// the referent field of the reference object gets recorded by |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
754 |
// the pre-barrier code. |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
755 |
// Specifically, if G1 is enabled, the value in the referent |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
756 |
// field is recorded by the G1 SATB pre barrier. This will |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
757 |
// result in the referent being marked live and the reference |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
758 |
// object removed from the list of discovered references during |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
759 |
// reference processing. |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
760 |
cg = find_intrinsic(method(), false); |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
761 |
} |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
762 |
if (cg == NULL) { |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
763 |
float past_uses = method()->interpreter_invocation_count(); |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
764 |
float expected_uses = past_uses; |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
765 |
cg = CallGenerator::for_inline(method(), expected_uses); |
42d9d1010f38
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
9175
diff
changeset
|
766 |
} |
1 | 767 |
} |
768 |
if (failing()) return; |
|
769 |
if (cg == NULL) { |
|
770 |
record_method_not_compilable_all_tiers("cannot parse method"); |
|
771 |
return; |
|
772 |
} |
|
773 |
JVMState* jvms = build_start_state(start(), tf()); |
|
21089
e1986ff6fe2e
8024069: replace_in_map() should operate on parent maps
roland
parents:
20715
diff
changeset
|
774 |
if ((jvms = cg->generate(jvms, NULL)) == NULL) { |
1 | 775 |
record_method_not_compilable("method parse failed"); |
776 |
return; |
|
777 |
} |
|
778 |
GraphKit kit(jvms); |
|
779 |
||
780 |
if (!kit.stopped()) { |
|
781 |
// Accept return values, and transfer control we know not where. |
|
782 |
// This is done by a special, unique ReturnNode bound to root. |
|
783 |
return_values(kit.jvms()); |
|
784 |
} |
|
785 |
||
786 |
if (kit.has_exceptions()) { |
|
787 |
// Any exceptions that escape from this call must be rethrown |
|
788 |
// to whatever caller is dynamically above us on the stack. |
|
789 |
// This is done by a special, unique RethrowNode bound to root. |
|
790 |
rethrow_exceptions(kit.transfer_exceptions_into_jvms()); |
|
791 |
} |
|
792 |
||
15113 | 793 |
assert(IncrementalInline || (_late_inlines.length() == 0 && !has_mh_late_inlines()), "incremental inlining is off"); |
794 |
||
795 |
if (_late_inlines.length() == 0 && !has_mh_late_inlines() && !failing() && has_stringbuilder()) { |
|
796 |
inline_string_calls(true); |
|
4450
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
797 |
} |
15113 | 798 |
|
799 |
if (failing()) return; |
|
4450
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
800 |
|
18025 | 801 |
print_method(PHASE_BEFORE_REMOVEUSELESS, 3); |
1399
9648dfd4ce09
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
1137
diff
changeset
|
802 |
|
1 | 803 |
// Remove clutter produced by parsing. |
804 |
if (!failing()) { |
|
805 |
ResourceMark rm; |
|
806 |
PhaseRemoveUseless pru(initial_gvn(), &for_igvn); |
|
807 |
} |
|
808 |
} |
|
809 |
||
810 |
// Note: Large methods are capped off in do_one_bytecode(). |
|
811 |
if (failing()) return; |
|
812 |
||
813 |
// After parsing, node notes are no longer automagic. |
|
814 |
// They must be propagated by register_new_node_with_optimizer(), |
|
815 |
// clone(), or the like. |
|
816 |
set_default_node_notes(NULL); |
|
817 |
||
818 |
for (;;) { |
|
819 |
int successes = Inline_Warm(); |
|
820 |
if (failing()) return; |
|
821 |
if (successes == 0) break; |
|
822 |
} |
|
823 |
||
824 |
// Drain the list. |
|
825 |
Finish_Warm(); |
|
826 |
#ifndef PRODUCT |
|
827 |
if (_printer) { |
|
828 |
_printer->print_inlining(this); |
|
829 |
} |
|
830 |
#endif |
|
831 |
||
832 |
if (failing()) return; |
|
833 |
NOT_PRODUCT( verify_graph_edges(); ) |
|
834 |
||
835 |
// Now optimize |
|
836 |
Optimize(); |
|
837 |
if (failing()) return; |
|
838 |
NOT_PRODUCT( verify_graph_edges(); ) |
|
839 |
||
840 |
#ifndef PRODUCT |
|
841 |
if (PrintIdeal) { |
|
842 |
ttyLocker ttyl; // keep the following output all in one block |
|
843 |
// This output goes directly to the tty, not the compiler log. |
|
844 |
// To enable tools to match it up with the compilation activity, |
|
845 |
// be sure to tag this tty output with the compile ID. |
|
846 |
if (xtty != NULL) { |
|
847 |
xtty->head("ideal compile_id='%d'%s", compile_id(), |
|
848 |
is_osr_compilation() ? " compile_kind='osr'" : |
|
849 |
""); |
|
850 |
} |
|
851 |
root()->dump(9999); |
|
852 |
if (xtty != NULL) { |
|
853 |
xtty->tail("ideal"); |
|
854 |
} |
|
855 |
} |
|
856 |
#endif |
|
857 |
||
21526
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
858 |
NOT_PRODUCT( verify_barriers(); ) |
22243 | 859 |
|
860 |
// Dump compilation data to replay it. |
|
861 |
if (method()->has_option("DumpReplay")) { |
|
862 |
env()->dump_replay_data(_compile_id); |
|
863 |
} |
|
864 |
if (method()->has_option("DumpInline") && (ilt() != NULL)) { |
|
865 |
env()->dump_inline_data(_compile_id); |
|
866 |
} |
|
867 |
||
1 | 868 |
// Now that we know the size of all the monitors we can add a fixed slot |
869 |
// for the original deopt pc. |
|
870 |
||
871 |
_orig_pc_slot = fixed_slots(); |
|
872 |
int next_slot = _orig_pc_slot + (sizeof(address) / VMRegImpl::stack_slot_size); |
|
873 |
set_fixed_slots(next_slot); |
|
874 |
||
22856
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
875 |
// Compute when to use implicit null checks. Used by matching trap based |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
876 |
// nodes and NullCheck optimization. |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
877 |
set_allowed_deopt_reasons(); |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
878 |
|
1 | 879 |
// Now generate code |
880 |
Code_Gen(); |
|
881 |
if (failing()) return; |
|
882 |
||
883 |
// Check if we want to skip execution of all compiled code. |
|
884 |
{ |
|
885 |
#ifndef PRODUCT |
|
886 |
if (OptoNoExecute) { |
|
887 |
record_method_not_compilable("+OptoNoExecute"); // Flag as failed |
|
888 |
return; |
|
889 |
} |
|
890 |
TracePhase t2("install_code", &_t_registerMethod, TimeCompiler); |
|
891 |
#endif |
|
892 |
||
893 |
if (is_osr_compilation()) { |
|
894 |
_code_offsets.set_value(CodeOffsets::Verified_Entry, 0); |
|
895 |
_code_offsets.set_value(CodeOffsets::OSR_Entry, _first_block_size); |
|
896 |
} else { |
|
897 |
_code_offsets.set_value(CodeOffsets::Verified_Entry, _first_block_size); |
|
898 |
_code_offsets.set_value(CodeOffsets::OSR_Entry, 0); |
|
899 |
} |
|
900 |
||
901 |
env()->register_method(_method, _entry_bci, |
|
902 |
&_code_offsets, |
|
903 |
_orig_pc_slot_offset_in_bytes, |
|
904 |
code_buffer(), |
|
905 |
frame_size_in_words(), _oop_map_set, |
|
906 |
&_handler_table, &_inc_table, |
|
907 |
compiler, |
|
908 |
env()->comp_level(), |
|
13883
6979b9850feb
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
13728
diff
changeset
|
909 |
has_unsafe_access(), |
6979b9850feb
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
13728
diff
changeset
|
910 |
SharedRuntime::is_wide_vector(max_vector_size()) |
1 | 911 |
); |
13964 | 912 |
|
913 |
if (log() != NULL) // Print code cache state into compiler log |
|
914 |
log()->code_cache_state(); |
|
1 | 915 |
} |
916 |
} |
|
917 |
||
918 |
//------------------------------Compile---------------------------------------- |
|
919 |
// Compile a runtime stub |
|
920 |
Compile::Compile( ciEnv* ci_env, |
|
921 |
TypeFunc_generator generator, |
|
922 |
address stub_function, |
|
923 |
const char *stub_name, |
|
924 |
int is_fancy_jump, |
|
925 |
bool pass_tls, |
|
926 |
bool save_arg_registers, |
|
927 |
bool return_pc ) |
|
928 |
: Phase(Compiler), |
|
929 |
_env(ci_env), |
|
930 |
_log(ci_env->log()), |
|
15946
f688e7528dc6
8005772: Stubs report compile id -1 in phase events
neliasso
parents:
15874
diff
changeset
|
931 |
_compile_id(0), |
1 | 932 |
_save_argument_registers(save_arg_registers), |
933 |
_method(NULL), |
|
934 |
_stub_name(stub_name), |
|
935 |
_stub_function(stub_function), |
|
936 |
_stub_entry_point(NULL), |
|
937 |
_entry_bci(InvocationEntryBci), |
|
938 |
_initial_gvn(NULL), |
|
939 |
_for_igvn(NULL), |
|
940 |
_warm_calls(NULL), |
|
941 |
_orig_pc_slot(0), |
|
942 |
_orig_pc_slot_offset_in_bytes(0), |
|
943 |
_subsume_loads(true), |
|
211
e2b60448c234
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
1
diff
changeset
|
944 |
_do_escape_analysis(false), |
17383 | 945 |
_eliminate_boxing(false), |
1 | 946 |
_failure_reason(NULL), |
947 |
_code_buffer("Compile::Fill_buffer"), |
|
4906 | 948 |
_has_method_handle_invokes(false), |
7433 | 949 |
_mach_constant_base_node(NULL), |
1 | 950 |
_node_bundling_limit(0), |
951 |
_node_bundling_base(NULL), |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
952 |
_java_calls(0), |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
953 |
_inner_loops(0), |
1 | 954 |
#ifndef PRODUCT |
955 |
_trace_opto_output(TraceOptoOutput), |
|
22854
2787e48d6df9
8029025: PPC64 (part 203): opto: Move static _in_dump_cnt to Compile object.
goetz
parents:
22851
diff
changeset
|
956 |
_in_dump_cnt(0), |
1 | 957 |
_printer(NULL), |
958 |
#endif |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
959 |
_dead_node_list(comp_arena()), |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
960 |
_dead_node_count(0), |
14828
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
961 |
_congraph(NULL), |
22243 | 962 |
_replay_inline_data(NULL), |
15113 | 963 |
_number_of_mh_late_inlines(0), |
964 |
_inlining_progress(false), |
|
965 |
_inlining_incrementally(false), |
|
14828
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
966 |
_print_inlining_list(NULL), |
21089
e1986ff6fe2e
8024069: replace_in_map() should operate on parent maps
roland
parents:
20715
diff
changeset
|
967 |
_print_inlining_idx(0), |
22856
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
968 |
_preserve_jvm_state(0), |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
969 |
_allowed_reasons(0) { |
1 | 970 |
C = this; |
971 |
||
972 |
#ifndef PRODUCT |
|
973 |
TraceTime t1(NULL, &_t_totalCompilation, TimeCompiler, false); |
|
974 |
TraceTime t2(NULL, &_t_stubCompilation, TimeCompiler, false); |
|
975 |
set_print_assembly(PrintFrameConverterAssembly); |
|
1399
9648dfd4ce09
6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents:
1137
diff
changeset
|
976 |
set_parsed_irreducible_loop(false); |
1 | 977 |
#endif |
978 |
CompileWrapper cw(this); |
|
979 |
Init(/*AliasLevel=*/ 0); |
|
980 |
init_tf((*generator)()); |
|
981 |
||
982 |
{ |
|
983 |
// The following is a dummy for the sake of GraphKit::gen_stub |
|
984 |
Unique_Node_List for_igvn(comp_arena()); |
|
985 |
set_for_igvn(&for_igvn); // not used, but some GraphKit guys push on this |
|
986 |
PhaseGVN gvn(Thread::current()->resource_area(),255); |
|
987 |
set_initial_gvn(&gvn); // not significant, but GraphKit guys use it pervasively |
|
988 |
gvn.transform_no_reclaim(top()); |
|
989 |
||
990 |
GraphKit kit; |
|
991 |
kit.gen_stub(stub_function, stub_name, is_fancy_jump, pass_tls, return_pc); |
|
992 |
} |
|
993 |
||
994 |
NOT_PRODUCT( verify_graph_edges(); ) |
|
995 |
Code_Gen(); |
|
996 |
if (failing()) return; |
|
997 |
||
998 |
||
999 |
// Entry point will be accessed using compile->stub_entry_point(); |
|
1000 |
if (code_buffer() == NULL) { |
|
1001 |
Matcher::soft_match_failure(); |
|
1002 |
} else { |
|
1003 |
if (PrintAssembly && (WizardMode || Verbose)) |
|
1004 |
tty->print_cr("### Stub::%s", stub_name); |
|
1005 |
||
1006 |
if (!failing()) { |
|
1007 |
assert(_fixed_slots == 0, "no fixed slots used for runtime stubs"); |
|
1008 |
||
1009 |
// Make the NMethod |
|
1010 |
// For now we mark the frame as never safe for profile stackwalking |
|
1011 |
RuntimeStub *rs = RuntimeStub::new_runtime_stub(stub_name, |
|
1012 |
code_buffer(), |
|
1013 |
CodeOffsets::frame_never_safe, |
|
1014 |
// _code_offsets.value(CodeOffsets::Frame_Complete), |
|
1015 |
frame_size_in_words(), |
|
1016 |
_oop_map_set, |
|
1017 |
save_arg_registers); |
|
1018 |
assert(rs != NULL && rs->is_runtime_stub(), "sanity check"); |
|
1019 |
||
1020 |
_stub_entry_point = rs->entry_point(); |
|
1021 |
} |
|
1022 |
} |
|
1023 |
} |
|
1024 |
||
1025 |
//------------------------------Init------------------------------------------- |
|
1026 |
// Prepare for a single compilation |
|
1027 |
void Compile::Init(int aliaslevel) { |
|
1028 |
_unique = 0; |
|
1029 |
_regalloc = NULL; |
|
1030 |
||
1031 |
_tf = NULL; // filled in later |
|
1032 |
_top = NULL; // cached later |
|
1033 |
_matcher = NULL; // filled in later |
|
1034 |
_cfg = NULL; // filled in later |
|
1035 |
||
1036 |
set_24_bit_selection_and_mode(Use24BitFP, false); |
|
1037 |
||
1038 |
_node_note_array = NULL; |
|
1039 |
_default_node_notes = NULL; |
|
1040 |
||
1041 |
_immutable_memory = NULL; // filled in at first inquiry |
|
1042 |
||
1043 |
// Globally visible Nodes |
|
1044 |
// First set TOP to NULL to give safe behavior during creation of RootNode |
|
1045 |
set_cached_top_node(NULL); |
|
13895
f6dfe4123709
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
13886
diff
changeset
|
1046 |
set_root(new (this) RootNode()); |
1 | 1047 |
// Now that you have a Root to point to, create the real TOP |
13895
f6dfe4123709
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
13886
diff
changeset
|
1048 |
set_cached_top_node( new (this) ConNode(Type::TOP) ); |
1 | 1049 |
set_recent_alloc(NULL, NULL); |
1050 |
||
1051 |
// Create Debug Information Recorder to record scopes, oopmaps, etc. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
1052 |
env()->set_oop_recorder(new OopRecorder(env()->arena())); |
1 | 1053 |
env()->set_debug_info(new DebugInformationRecorder(env()->oop_recorder())); |
1054 |
env()->set_dependencies(new Dependencies(env())); |
|
1055 |
||
1056 |
_fixed_slots = 0; |
|
1057 |
set_has_split_ifs(false); |
|
1058 |
set_has_loops(has_method() && method()->has_loops()); // first approximation |
|
4450
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
1059 |
set_has_stringbuilder(false); |
17383 | 1060 |
set_has_boxed_value(false); |
1 | 1061 |
_trap_can_recompile = false; // no traps emitted yet |
1062 |
_major_progress = true; // start out assuming good things will happen |
|
1063 |
set_has_unsafe_access(false); |
|
13883
6979b9850feb
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
13728
diff
changeset
|
1064 |
set_max_vector_size(0); |
1 | 1065 |
Copy::zero_to_bytes(_trap_hist, sizeof(_trap_hist)); |
1066 |
set_decompile_count(0); |
|
1067 |
||
1498 | 1068 |
set_do_freq_based_layout(BlockLayoutByFrequency || method_has_option("BlockLayoutByFrequency")); |
6453 | 1069 |
set_num_loop_opts(LoopOptsCount); |
1070 |
set_do_inlining(Inline); |
|
1071 |
set_max_inline_size(MaxInlineSize); |
|
1072 |
set_freq_inline_size(FreqInlineSize); |
|
1073 |
set_do_scheduling(OptoScheduling); |
|
1074 |
set_do_count_invocations(false); |
|
1075 |
set_do_method_data_update(false); |
|
1 | 1076 |
|
1077 |
if (debug_info()->recording_non_safepoints()) { |
|
1078 |
set_node_note_array(new(comp_arena()) GrowableArray<Node_Notes*> |
|
1079 |
(comp_arena(), 8, 0, NULL)); |
|
1080 |
set_default_node_notes(Node_Notes::make(this)); |
|
1081 |
} |
|
1082 |
||
1083 |
// // -- Initialize types before each compile -- |
|
1084 |
// // Update cached type information |
|
1085 |
// if( _method && _method->constants() ) |
|
1086 |
// Type::update_loaded_types(_method, _method->constants()); |
|
1087 |
||
1088 |
// Init alias_type map. |
|
211
e2b60448c234
6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents:
1
diff
changeset
|
1089 |
if (!_do_escape_analysis && aliaslevel == 3) |
1 | 1090 |
aliaslevel = 2; // No unique types without escape analysis |
1091 |
_AliasLevel = aliaslevel; |
|
1092 |
const int grow_ats = 16; |
|
1093 |
_max_alias_types = grow_ats; |
|
1094 |
_alias_types = NEW_ARENA_ARRAY(comp_arena(), AliasType*, grow_ats); |
|
1095 |
AliasType* ats = NEW_ARENA_ARRAY(comp_arena(), AliasType, grow_ats); |
|
1096 |
Copy::zero_to_bytes(ats, sizeof(AliasType)*grow_ats); |
|
1097 |
{ |
|
1098 |
for (int i = 0; i < grow_ats; i++) _alias_types[i] = &ats[i]; |
|
1099 |
} |
|
1100 |
// Initialize the first few types. |
|
1101 |
_alias_types[AliasIdxTop]->Init(AliasIdxTop, NULL); |
|
1102 |
_alias_types[AliasIdxBot]->Init(AliasIdxBot, TypePtr::BOTTOM); |
|
1103 |
_alias_types[AliasIdxRaw]->Init(AliasIdxRaw, TypeRawPtr::BOTTOM); |
|
1104 |
_num_alias_types = AliasIdxRaw+1; |
|
1105 |
// Zero out the alias type cache. |
|
1106 |
Copy::zero_to_bytes(_alias_cache, sizeof(_alias_cache)); |
|
1107 |
// A NULL adr_type hits in the cache right away. Preload the right answer. |
|
1108 |
probe_alias_cache(NULL)->_index = AliasIdxTop; |
|
1109 |
||
1110 |
_intrinsics = NULL; |
|
6180 | 1111 |
_macro_nodes = new(comp_arena()) GrowableArray<Node*>(comp_arena(), 8, 0, NULL); |
1112 |
_predicate_opaqs = new(comp_arena()) GrowableArray<Node*>(comp_arena(), 8, 0, NULL); |
|
15618
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
1113 |
_expensive_nodes = new(comp_arena()) GrowableArray<Node*>(comp_arena(), 8, 0, NULL); |
1 | 1114 |
register_library_intrinsics(); |
1115 |
} |
|
1116 |
||
1117 |
//---------------------------init_start---------------------------------------- |
|
1118 |
// Install the StartNode on this compile object. |
|
1119 |
void Compile::init_start(StartNode* s) { |
|
1120 |
if (failing()) |
|
1121 |
return; // already failing |
|
1122 |
assert(s == start(), ""); |
|
1123 |
} |
|
1124 |
||
1125 |
StartNode* Compile::start() const { |
|
1126 |
assert(!failing(), ""); |
|
1127 |
for (DUIterator_Fast imax, i = root()->fast_outs(imax); i < imax; i++) { |
|
1128 |
Node* start = root()->fast_out(i); |
|
1129 |
if( start->is_Start() ) |
|
1130 |
return start->as_Start(); |
|
1131 |
} |
|
1132 |
ShouldNotReachHere(); |
|
1133 |
return NULL; |
|
1134 |
} |
|
1135 |
||
1136 |
//-------------------------------immutable_memory------------------------------------- |
|
1137 |
// Access immutable memory |
|
1138 |
Node* Compile::immutable_memory() { |
|
1139 |
if (_immutable_memory != NULL) { |
|
1140 |
return _immutable_memory; |
|
1141 |
} |
|
1142 |
StartNode* s = start(); |
|
1143 |
for (DUIterator_Fast imax, i = s->fast_outs(imax); true; i++) { |
|
1144 |
Node *p = s->fast_out(i); |
|
1145 |
if (p != s && p->as_Proj()->_con == TypeFunc::Memory) { |
|
1146 |
_immutable_memory = p; |
|
1147 |
return _immutable_memory; |
|
1148 |
} |
|
1149 |
} |
|
1150 |
ShouldNotReachHere(); |
|
1151 |
return NULL; |
|
1152 |
} |
|
1153 |
||
1154 |
//----------------------set_cached_top_node------------------------------------ |
|
1155 |
// Install the cached top node, and make sure Node::is_top works correctly. |
|
1156 |
void Compile::set_cached_top_node(Node* tn) { |
|
1157 |
if (tn != NULL) verify_top(tn); |
|
1158 |
Node* old_top = _top; |
|
1159 |
_top = tn; |
|
1160 |
// Calling Node::setup_is_top allows the nodes the chance to adjust |
|
1161 |
// their _out arrays. |
|
1162 |
if (_top != NULL) _top->setup_is_top(); |
|
1163 |
if (old_top != NULL) old_top->setup_is_top(); |
|
1164 |
assert(_top == NULL || top()->is_top(), ""); |
|
1165 |
} |
|
1166 |
||
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1167 |
#ifdef ASSERT |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1168 |
uint Compile::count_live_nodes_by_graph_walk() { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1169 |
Unique_Node_List useful(comp_arena()); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1170 |
// Get useful node list by walking the graph. |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1171 |
identify_useful_nodes(useful); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1172 |
return useful.size(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1173 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1174 |
|
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1175 |
void Compile::print_missing_nodes() { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1176 |
|
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1177 |
// Return if CompileLog is NULL and PrintIdealNodeCount is false. |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1178 |
if ((_log == NULL) && (! PrintIdealNodeCount)) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1179 |
return; |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1180 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1181 |
|
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1182 |
// This is an expensive function. It is executed only when the user |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1183 |
// specifies VerifyIdealNodeCount option or otherwise knows the |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1184 |
// additional work that needs to be done to identify reachable nodes |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1185 |
// by walking the flow graph and find the missing ones using |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1186 |
// _dead_node_list. |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1187 |
|
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1188 |
Unique_Node_List useful(comp_arena()); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1189 |
// Get useful node list by walking the graph. |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1190 |
identify_useful_nodes(useful); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1191 |
|
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1192 |
uint l_nodes = C->live_nodes(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1193 |
uint l_nodes_by_walk = useful.size(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1194 |
|
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1195 |
if (l_nodes != l_nodes_by_walk) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1196 |
if (_log != NULL) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1197 |
_log->begin_head("mismatched_nodes count='%d'", abs((int) (l_nodes - l_nodes_by_walk))); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1198 |
_log->stamp(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1199 |
_log->end_head(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1200 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1201 |
VectorSet& useful_member_set = useful.member_set(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1202 |
int last_idx = l_nodes_by_walk; |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1203 |
for (int i = 0; i < last_idx; i++) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1204 |
if (useful_member_set.test(i)) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1205 |
if (_dead_node_list.test(i)) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1206 |
if (_log != NULL) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1207 |
_log->elem("mismatched_node_info node_idx='%d' type='both live and dead'", i); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1208 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1209 |
if (PrintIdealNodeCount) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1210 |
// Print the log message to tty |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1211 |
tty->print_cr("mismatched_node idx='%d' both live and dead'", i); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1212 |
useful.at(i)->dump(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1213 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1214 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1215 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1216 |
else if (! _dead_node_list.test(i)) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1217 |
if (_log != NULL) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1218 |
_log->elem("mismatched_node_info node_idx='%d' type='neither live nor dead'", i); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1219 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1220 |
if (PrintIdealNodeCount) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1221 |
// Print the log message to tty |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1222 |
tty->print_cr("mismatched_node idx='%d' type='neither live nor dead'", i); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1223 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1224 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1225 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1226 |
if (_log != NULL) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1227 |
_log->tail("mismatched_nodes"); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1228 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1229 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1230 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1231 |
#endif |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
1232 |
|
1 | 1233 |
#ifndef PRODUCT |
1234 |
void Compile::verify_top(Node* tn) const { |
|
1235 |
if (tn != NULL) { |
|
1236 |
assert(tn->is_Con(), "top node must be a constant"); |
|
1237 |
assert(((ConNode*)tn)->type() == Type::TOP, "top node must have correct type"); |
|
1238 |
assert(tn->in(0) != NULL, "must have live top node"); |
|
1239 |
} |
|
1240 |
} |
|
1241 |
#endif |
|
1242 |
||
1243 |
||
1244 |
///-------------------Managing Per-Node Debug & Profile Info------------------- |
|
1245 |
||
1246 |
void Compile::grow_node_notes(GrowableArray<Node_Notes*>* arr, int grow_by) { |
|
1247 |
guarantee(arr != NULL, ""); |
|
1248 |
int num_blocks = arr->length(); |
|
1249 |
if (grow_by < num_blocks) grow_by = num_blocks; |
|
1250 |
int num_notes = grow_by * _node_notes_block_size; |
|
1251 |
Node_Notes* notes = NEW_ARENA_ARRAY(node_arena(), Node_Notes, num_notes); |
|
1252 |
Copy::zero_to_bytes(notes, num_notes * sizeof(Node_Notes)); |
|
1253 |
while (num_notes > 0) { |
|
1254 |
arr->append(notes); |
|
1255 |
notes += _node_notes_block_size; |
|
1256 |
num_notes -= _node_notes_block_size; |
|
1257 |
} |
|
1258 |
assert(num_notes == 0, "exact multiple, please"); |
|
1259 |
} |
|
1260 |
||
1261 |
bool Compile::copy_node_notes_to(Node* dest, Node* source) { |
|
1262 |
if (source == NULL || dest == NULL) return false; |
|
1263 |
||
1264 |
if (dest->is_Con()) |
|
1265 |
return false; // Do not push debug info onto constants. |
|
1266 |
||
1267 |
#ifdef ASSERT |
|
1268 |
// Leave a bread crumb trail pointing to the original node: |
|
1269 |
if (dest != NULL && dest != source && dest->debug_orig() == NULL) { |
|
1270 |
dest->set_debug_orig(source); |
|
1271 |
} |
|
1272 |
#endif |
|
1273 |
||
1274 |
if (node_note_array() == NULL) |
|
1275 |
return false; // Not collecting any notes now. |
|
1276 |
||
1277 |
// This is a copy onto a pre-existing node, which may already have notes. |
|
1278 |
// If both nodes have notes, do not overwrite any pre-existing notes. |
|
1279 |
Node_Notes* source_notes = node_notes_at(source->_idx); |
|
1280 |
if (source_notes == NULL || source_notes->is_clear()) return false; |
|
1281 |
Node_Notes* dest_notes = node_notes_at(dest->_idx); |
|
1282 |
if (dest_notes == NULL || dest_notes->is_clear()) { |
|
1283 |
return set_node_notes_at(dest->_idx, source_notes); |
|
1284 |
} |
|
1285 |
||
1286 |
Node_Notes merged_notes = (*source_notes); |
|
1287 |
// The order of operations here ensures that dest notes will win... |
|
1288 |
merged_notes.update_from(dest_notes); |
|
1289 |
return set_node_notes_at(dest->_idx, &merged_notes); |
|
1290 |
} |
|
1291 |
||
1292 |
||
1293 |
//--------------------------allow_range_check_smearing------------------------- |
|
1294 |
// Gating condition for coalescing similar range checks. |
|
1295 |
// Sometimes we try 'speculatively' replacing a series of a range checks by a |
|
1296 |
// single covering check that is at least as strong as any of them. |
|
1297 |
// If the optimization succeeds, the simplified (strengthened) range check |
|
1298 |
// will always succeed. If it fails, we will deopt, and then give up |
|
1299 |
// on the optimization. |
|
1300 |
bool Compile::allow_range_check_smearing() const { |
|
1301 |
// If this method has already thrown a range-check, |
|
1302 |
// assume it was because we already tried range smearing |
|
1303 |
// and it failed. |
|
1304 |
uint already_trapped = trap_count(Deoptimization::Reason_range_check); |
|
1305 |
return !already_trapped; |
|
1306 |
} |
|
1307 |
||
1308 |
||
1309 |
//------------------------------flatten_alias_type----------------------------- |
|
1310 |
const TypePtr *Compile::flatten_alias_type( const TypePtr *tj ) const { |
|
1311 |
int offset = tj->offset(); |
|
1312 |
TypePtr::PTR ptr = tj->ptr(); |
|
1313 |
||
955 | 1314 |
// Known instance (scalarizable allocation) alias only with itself. |
1315 |
bool is_known_inst = tj->isa_oopptr() != NULL && |
|
1316 |
tj->is_oopptr()->is_known_instance(); |
|
1317 |
||
1 | 1318 |
// Process weird unsafe references. |
1319 |
if (offset == Type::OffsetBot && (tj->isa_instptr() /*|| tj->isa_klassptr()*/)) { |
|
1320 |
assert(InlineUnsafeOps, "indeterminate pointers come only from unsafe ops"); |
|
955 | 1321 |
assert(!is_known_inst, "scalarizable allocation should not have unsafe references"); |
1 | 1322 |
tj = TypeOopPtr::BOTTOM; |
1323 |
ptr = tj->ptr(); |
|
1324 |
offset = tj->offset(); |
|
1325 |
} |
|
1326 |
||
1327 |
// Array pointers need some flattening |
|
1328 |
const TypeAryPtr *ta = tj->isa_aryptr(); |
|
19770
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1329 |
if (ta && ta->is_stable()) { |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1330 |
// Erase stability property for alias analysis. |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1331 |
tj = ta = ta->cast_to_stable(false); |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1332 |
} |
955 | 1333 |
if( ta && is_known_inst ) { |
1334 |
if ( offset != Type::OffsetBot && |
|
1335 |
offset > arrayOopDesc::length_offset_in_bytes() ) { |
|
1336 |
offset = Type::OffsetBot; // Flatten constant access into array body only |
|
1337 |
tj = ta = TypeAryPtr::make(ptr, ta->ary(), ta->klass(), true, offset, ta->instance_id()); |
|
1338 |
} |
|
1339 |
} else if( ta && _AliasLevel >= 2 ) { |
|
1 | 1340 |
// For arrays indexed by constant indices, we flatten the alias |
1341 |
// space to include all of the array body. Only the header, klass |
|
1342 |
// and array length can be accessed un-aliased. |
|
1343 |
if( offset != Type::OffsetBot ) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
1344 |
if( ta->const_oop() ) { // MethodData* or Method* |
1 | 1345 |
offset = Type::OffsetBot; // Flatten constant access into array body |
955 | 1346 |
tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),ta->ary(),ta->klass(),false,offset); |
1 | 1347 |
} else if( offset == arrayOopDesc::length_offset_in_bytes() ) { |
1348 |
// range is OK as-is. |
|
1349 |
tj = ta = TypeAryPtr::RANGE; |
|
1350 |
} else if( offset == oopDesc::klass_offset_in_bytes() ) { |
|
1351 |
tj = TypeInstPtr::KLASS; // all klass loads look alike |
|
1352 |
ta = TypeAryPtr::RANGE; // generic ignored junk |
|
1353 |
ptr = TypePtr::BotPTR; |
|
1354 |
} else if( offset == oopDesc::mark_offset_in_bytes() ) { |
|
1355 |
tj = TypeInstPtr::MARK; |
|
1356 |
ta = TypeAryPtr::RANGE; // generic ignored junk |
|
1357 |
ptr = TypePtr::BotPTR; |
|
1358 |
} else { // Random constant offset into array body |
|
1359 |
offset = Type::OffsetBot; // Flatten constant access into array body |
|
955 | 1360 |
tj = ta = TypeAryPtr::make(ptr,ta->ary(),ta->klass(),false,offset); |
1 | 1361 |
} |
1362 |
} |
|
1363 |
// Arrays of fixed size alias with arrays of unknown size. |
|
1364 |
if (ta->size() != TypeInt::POS) { |
|
1365 |
const TypeAry *tary = TypeAry::make(ta->elem(), TypeInt::POS); |
|
955 | 1366 |
tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,ta->klass(),false,offset); |
1 | 1367 |
} |
1368 |
// Arrays of known objects become arrays of unknown objects. |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
1369 |
if (ta->elem()->isa_narrowoop() && ta->elem() != TypeNarrowOop::BOTTOM) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
1370 |
const TypeAry *tary = TypeAry::make(TypeNarrowOop::BOTTOM, ta->size()); |
955 | 1371 |
tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,NULL,false,offset); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
1372 |
} |
1 | 1373 |
if (ta->elem()->isa_oopptr() && ta->elem() != TypeInstPtr::BOTTOM) { |
1374 |
const TypeAry *tary = TypeAry::make(TypeInstPtr::BOTTOM, ta->size()); |
|
955 | 1375 |
tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,NULL,false,offset); |
1 | 1376 |
} |
1377 |
// Arrays of bytes and of booleans both use 'bastore' and 'baload' so |
|
1378 |
// cannot be distinguished by bytecode alone. |
|
1379 |
if (ta->elem() == TypeInt::BOOL) { |
|
1380 |
const TypeAry *tary = TypeAry::make(TypeInt::BYTE, ta->size()); |
|
1381 |
ciKlass* aklass = ciTypeArrayKlass::make(T_BYTE); |
|
955 | 1382 |
tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,aklass,false,offset); |
1 | 1383 |
} |
1384 |
// During the 2nd round of IterGVN, NotNull castings are removed. |
|
1385 |
// Make sure the Bottom and NotNull variants alias the same. |
|
1386 |
// Also, make sure exact and non-exact variants alias the same. |
|
21099 | 1387 |
if (ptr == TypePtr::NotNull || ta->klass_is_exact() || ta->speculative() != NULL) { |
10012 | 1388 |
tj = ta = TypeAryPtr::make(TypePtr::BotPTR,ta->ary(),ta->klass(),false,offset); |
1 | 1389 |
} |
1390 |
} |
|
1391 |
||
1392 |
// Oop pointers need some flattening |
|
1393 |
const TypeInstPtr *to = tj->isa_instptr(); |
|
1394 |
if( to && _AliasLevel >= 2 && to != TypeOopPtr::BOTTOM ) { |
|
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1395 |
ciInstanceKlass *k = to->klass()->as_instance_klass(); |
1 | 1396 |
if( ptr == TypePtr::Constant ) { |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1397 |
if (to->klass() != ciEnv::current()->Class_klass() || |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1398 |
offset < k->size_helper() * wordSize) { |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1399 |
// No constant oop pointers (such as Strings); they alias with |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1400 |
// unknown strings. |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1401 |
assert(!is_known_inst, "not scalarizable allocation"); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1402 |
tj = to = TypeInstPtr::make(TypePtr::BotPTR,to->klass(),false,0,offset); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1403 |
} |
955 | 1404 |
} else if( is_known_inst ) { |
589 | 1405 |
tj = to; // Keep NotNull and klass_is_exact for instance type |
1 | 1406 |
} else if( ptr == TypePtr::NotNull || to->klass_is_exact() ) { |
1407 |
// During the 2nd round of IterGVN, NotNull castings are removed. |
|
1408 |
// Make sure the Bottom and NotNull variants alias the same. |
|
1409 |
// Also, make sure exact and non-exact variants alias the same. |
|
955 | 1410 |
tj = to = TypeInstPtr::make(TypePtr::BotPTR,to->klass(),false,0,offset); |
1 | 1411 |
} |
21099 | 1412 |
if (to->speculative() != NULL) { |
1413 |
tj = to = TypeInstPtr::make(to->ptr(),to->klass(),to->klass_is_exact(),to->const_oop(),to->offset(), to->instance_id()); |
|
1414 |
} |
|
1 | 1415 |
// Canonicalize the holder of this field |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
1416 |
if (offset >= 0 && offset < instanceOopDesc::base_offset_in_bytes()) { |
1 | 1417 |
// First handle header references such as a LoadKlassNode, even if the |
1418 |
// object's klass is unloaded at compile time (4965979). |
|
955 | 1419 |
if (!is_known_inst) { // Do it only for non-instance types |
1420 |
tj = to = TypeInstPtr::make(TypePtr::BotPTR, env()->Object_klass(), false, NULL, offset); |
|
1421 |
} |
|
1 | 1422 |
} else if (offset < 0 || offset >= k->size_helper() * wordSize) { |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1423 |
// Static fields are in the space above the normal instance |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1424 |
// fields in the java.lang.Class instance. |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1425 |
if (to->klass() != ciEnv::current()->Class_klass()) { |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1426 |
to = NULL; |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1427 |
tj = TypeOopPtr::BOTTOM; |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1428 |
offset = tj->offset(); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1429 |
} |
1 | 1430 |
} else { |
1431 |
ciInstanceKlass *canonical_holder = k->get_canonical_holder(offset); |
|
1432 |
if (!k->equals(canonical_holder) || tj->offset() != offset) { |
|
955 | 1433 |
if( is_known_inst ) { |
1434 |
tj = to = TypeInstPtr::make(to->ptr(), canonical_holder, true, NULL, offset, to->instance_id()); |
|
1435 |
} else { |
|
1436 |
tj = to = TypeInstPtr::make(to->ptr(), canonical_holder, false, NULL, offset); |
|
1437 |
} |
|
1 | 1438 |
} |
1439 |
} |
|
1440 |
} |
|
1441 |
||
1442 |
// Klass pointers to object array klasses need some flattening |
|
1443 |
const TypeKlassPtr *tk = tj->isa_klassptr(); |
|
1444 |
if( tk ) { |
|
1445 |
// If we are referencing a field within a Klass, we need |
|
1446 |
// to assume the worst case of an Object. Both exact and |
|
11428
7496cc6cc1a9
7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents:
11191
diff
changeset
|
1447 |
// inexact types must flatten to the same alias class so |
7496cc6cc1a9
7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents:
11191
diff
changeset
|
1448 |
// use NotNull as the PTR. |
1 | 1449 |
if ( offset == Type::OffsetBot || (offset >= 0 && (size_t)offset < sizeof(Klass)) ) { |
1450 |
||
11428
7496cc6cc1a9
7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents:
11191
diff
changeset
|
1451 |
tj = tk = TypeKlassPtr::make(TypePtr::NotNull, |
1 | 1452 |
TypeKlassPtr::OBJECT->klass(), |
1453 |
offset); |
|
1454 |
} |
|
1455 |
||
1456 |
ciKlass* klass = tk->klass(); |
|
1457 |
if( klass->is_obj_array_klass() ) { |
|
1458 |
ciKlass* k = TypeAryPtr::OOPS->klass(); |
|
1459 |
if( !k || !k->is_loaded() ) // Only fails for some -Xcomp runs |
|
1460 |
k = TypeInstPtr::BOTTOM->klass(); |
|
1461 |
tj = tk = TypeKlassPtr::make( TypePtr::NotNull, k, offset ); |
|
1462 |
} |
|
1463 |
||
1464 |
// Check for precise loads from the primary supertype array and force them |
|
1465 |
// to the supertype cache alias index. Check for generic array loads from |
|
1466 |
// the primary supertype array and also force them to the supertype cache |
|
1467 |
// alias index. Since the same load can reach both, we need to merge |
|
1468 |
// these 2 disparate memories into the same alias class. Since the |
|
1469 |
// primary supertype array is read-only, there's no chance of confusion |
|
1470 |
// where we bypass an array load and an array store. |
|
11430
718fc06da49a
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
11428
diff
changeset
|
1471 |
int primary_supers_offset = in_bytes(Klass::primary_supers_offset()); |
11428
7496cc6cc1a9
7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents:
11191
diff
changeset
|
1472 |
if (offset == Type::OffsetBot || |
7496cc6cc1a9
7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents:
11191
diff
changeset
|
1473 |
(offset >= primary_supers_offset && |
7496cc6cc1a9
7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents:
11191
diff
changeset
|
1474 |
offset < (int)(primary_supers_offset + Klass::primary_super_limit() * wordSize)) || |
11430
718fc06da49a
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
11428
diff
changeset
|
1475 |
offset == (int)in_bytes(Klass::secondary_super_cache_offset())) { |
718fc06da49a
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
11428
diff
changeset
|
1476 |
offset = in_bytes(Klass::secondary_super_cache_offset()); |
1 | 1477 |
tj = tk = TypeKlassPtr::make( TypePtr::NotNull, tk->klass(), offset ); |
1478 |
} |
|
1479 |
} |
|
1480 |
||
1481 |
// Flatten all Raw pointers together. |
|
1482 |
if (tj->base() == Type::RawPtr) |
|
1483 |
tj = TypeRawPtr::BOTTOM; |
|
1484 |
||
1485 |
if (tj->base() == Type::AnyPtr) |
|
1486 |
tj = TypePtr::BOTTOM; // An error, which the caller must check for. |
|
1487 |
||
1488 |
// Flatten all to bottom for now |
|
1489 |
switch( _AliasLevel ) { |
|
1490 |
case 0: |
|
1491 |
tj = TypePtr::BOTTOM; |
|
1492 |
break; |
|
1493 |
case 1: // Flatten to: oop, static, field or array |
|
1494 |
switch (tj->base()) { |
|
1495 |
//case Type::AryPtr: tj = TypeAryPtr::RANGE; break; |
|
1496 |
case Type::RawPtr: tj = TypeRawPtr::BOTTOM; break; |
|
1497 |
case Type::AryPtr: // do not distinguish arrays at all |
|
1498 |
case Type::InstPtr: tj = TypeInstPtr::BOTTOM; break; |
|
1499 |
case Type::KlassPtr: tj = TypeKlassPtr::OBJECT; break; |
|
1500 |
case Type::AnyPtr: tj = TypePtr::BOTTOM; break; // caller checks it |
|
1501 |
default: ShouldNotReachHere(); |
|
1502 |
} |
|
1503 |
break; |
|
2131 | 1504 |
case 2: // No collapsing at level 2; keep all splits |
1505 |
case 3: // No collapsing at level 3; keep all splits |
|
1 | 1506 |
break; |
1507 |
default: |
|
1508 |
Unimplemented(); |
|
1509 |
} |
|
1510 |
||
1511 |
offset = tj->offset(); |
|
1512 |
assert( offset != Type::OffsetTop, "Offset has fallen from constant" ); |
|
1513 |
||
1514 |
assert( (offset != Type::OffsetBot && tj->base() != Type::AryPtr) || |
|
1515 |
(offset == Type::OffsetBot && tj->base() == Type::AryPtr) || |
|
1516 |
(offset == Type::OffsetBot && tj == TypeOopPtr::BOTTOM) || |
|
1517 |
(offset == Type::OffsetBot && tj == TypePtr::BOTTOM) || |
|
1518 |
(offset == oopDesc::mark_offset_in_bytes() && tj->base() == Type::AryPtr) || |
|
1519 |
(offset == oopDesc::klass_offset_in_bytes() && tj->base() == Type::AryPtr) || |
|
1520 |
(offset == arrayOopDesc::length_offset_in_bytes() && tj->base() == Type::AryPtr) , |
|
1521 |
"For oops, klasses, raw offset must be constant; for arrays the offset is never known" ); |
|
1522 |
assert( tj->ptr() != TypePtr::TopPTR && |
|
1523 |
tj->ptr() != TypePtr::AnyNull && |
|
1524 |
tj->ptr() != TypePtr::Null, "No imprecise addresses" ); |
|
1525 |
// assert( tj->ptr() != TypePtr::Constant || |
|
1526 |
// tj->base() == Type::RawPtr || |
|
1527 |
// tj->base() == Type::KlassPtr, "No constant oop addresses" ); |
|
1528 |
||
1529 |
return tj; |
|
1530 |
} |
|
1531 |
||
1532 |
void Compile::AliasType::Init(int i, const TypePtr* at) { |
|
1533 |
_index = i; |
|
1534 |
_adr_type = at; |
|
1535 |
_field = NULL; |
|
19770
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1536 |
_element = NULL; |
1 | 1537 |
_is_rewritable = true; // default |
1538 |
const TypeOopPtr *atoop = (at != NULL) ? at->isa_oopptr() : NULL; |
|
769 | 1539 |
if (atoop != NULL && atoop->is_known_instance()) { |
1540 |
const TypeOopPtr *gt = atoop->cast_to_instance_id(TypeOopPtr::InstanceBot); |
|
1 | 1541 |
_general_index = Compile::current()->get_alias_index(gt); |
1542 |
} else { |
|
1543 |
_general_index = 0; |
|
1544 |
} |
|
1545 |
} |
|
1546 |
||
1547 |
//---------------------------------print_on------------------------------------ |
|
1548 |
#ifndef PRODUCT |
|
1549 |
void Compile::AliasType::print_on(outputStream* st) { |
|
1550 |
if (index() < 10) |
|
1551 |
st->print("@ <%d> ", index()); |
|
1552 |
else st->print("@ <%d>", index()); |
|
1553 |
st->print(is_rewritable() ? " " : " RO"); |
|
1554 |
int offset = adr_type()->offset(); |
|
1555 |
if (offset == Type::OffsetBot) |
|
1556 |
st->print(" +any"); |
|
1557 |
else st->print(" +%-3d", offset); |
|
1558 |
st->print(" in "); |
|
1559 |
adr_type()->dump_on(st); |
|
1560 |
const TypeOopPtr* tjp = adr_type()->isa_oopptr(); |
|
1561 |
if (field() != NULL && tjp) { |
|
1562 |
if (tjp->klass() != field()->holder() || |
|
1563 |
tjp->offset() != field()->offset_in_bytes()) { |
|
1564 |
st->print(" != "); |
|
1565 |
field()->print(); |
|
1566 |
st->print(" ***"); |
|
1567 |
} |
|
1568 |
} |
|
1569 |
} |
|
1570 |
||
1571 |
void print_alias_types() { |
|
1572 |
Compile* C = Compile::current(); |
|
1573 |
tty->print_cr("--- Alias types, AliasIdxBot .. %d", C->num_alias_types()-1); |
|
1574 |
for (int idx = Compile::AliasIdxBot; idx < C->num_alias_types(); idx++) { |
|
1575 |
C->alias_type(idx)->print_on(tty); |
|
1576 |
tty->cr(); |
|
1577 |
} |
|
1578 |
} |
|
1579 |
#endif |
|
1580 |
||
1581 |
||
1582 |
//----------------------------probe_alias_cache-------------------------------- |
|
1583 |
Compile::AliasCacheEntry* Compile::probe_alias_cache(const TypePtr* adr_type) { |
|
1584 |
intptr_t key = (intptr_t) adr_type; |
|
1585 |
key ^= key >> logAliasCacheSize; |
|
1586 |
return &_alias_cache[key & right_n_bits(logAliasCacheSize)]; |
|
1587 |
} |
|
1588 |
||
1589 |
||
1590 |
//-----------------------------grow_alias_types-------------------------------- |
|
1591 |
void Compile::grow_alias_types() { |
|
1592 |
const int old_ats = _max_alias_types; // how many before? |
|
1593 |
const int new_ats = old_ats; // how many more? |
|
1594 |
const int grow_ats = old_ats+new_ats; // how many now? |
|
1595 |
_max_alias_types = grow_ats; |
|
1596 |
_alias_types = REALLOC_ARENA_ARRAY(comp_arena(), AliasType*, _alias_types, old_ats, grow_ats); |
|
1597 |
AliasType* ats = NEW_ARENA_ARRAY(comp_arena(), AliasType, new_ats); |
|
1598 |
Copy::zero_to_bytes(ats, sizeof(AliasType)*new_ats); |
|
1599 |
for (int i = 0; i < new_ats; i++) _alias_types[old_ats+i] = &ats[i]; |
|
1600 |
} |
|
1601 |
||
1602 |
||
1603 |
//--------------------------------find_alias_type------------------------------ |
|
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1604 |
Compile::AliasType* Compile::find_alias_type(const TypePtr* adr_type, bool no_create, ciField* original_field) { |
1 | 1605 |
if (_AliasLevel == 0) |
1606 |
return alias_type(AliasIdxBot); |
|
1607 |
||
1608 |
AliasCacheEntry* ace = probe_alias_cache(adr_type); |
|
1609 |
if (ace->_adr_type == adr_type) { |
|
1610 |
return alias_type(ace->_index); |
|
1611 |
} |
|
1612 |
||
1613 |
// Handle special cases. |
|
1614 |
if (adr_type == NULL) return alias_type(AliasIdxTop); |
|
1615 |
if (adr_type == TypePtr::BOTTOM) return alias_type(AliasIdxBot); |
|
1616 |
||
1617 |
// Do it the slow way. |
|
1618 |
const TypePtr* flat = flatten_alias_type(adr_type); |
|
1619 |
||
1620 |
#ifdef ASSERT |
|
1621 |
assert(flat == flatten_alias_type(flat), "idempotent"); |
|
1622 |
assert(flat != TypePtr::BOTTOM, "cannot alias-analyze an untyped ptr"); |
|
1623 |
if (flat->isa_oopptr() && !flat->isa_klassptr()) { |
|
1624 |
const TypeOopPtr* foop = flat->is_oopptr(); |
|
955 | 1625 |
// Scalarizable allocations have exact klass always. |
1626 |
bool exact = !foop->klass_is_exact() || foop->is_known_instance(); |
|
1627 |
const TypePtr* xoop = foop->cast_to_exactness(exact)->is_ptr(); |
|
1 | 1628 |
assert(foop == flatten_alias_type(xoop), "exactness must not affect alias type"); |
1629 |
} |
|
1630 |
assert(flat == flatten_alias_type(flat), "exact bit doesn't matter"); |
|
1631 |
#endif |
|
1632 |
||
1633 |
int idx = AliasIdxTop; |
|
1634 |
for (int i = 0; i < num_alias_types(); i++) { |
|
1635 |
if (alias_type(i)->adr_type() == flat) { |
|
1636 |
idx = i; |
|
1637 |
break; |
|
1638 |
} |
|
1639 |
} |
|
1640 |
||
1641 |
if (idx == AliasIdxTop) { |
|
1642 |
if (no_create) return NULL; |
|
1643 |
// Grow the array if necessary. |
|
1644 |
if (_num_alias_types == _max_alias_types) grow_alias_types(); |
|
1645 |
// Add a new alias type. |
|
1646 |
idx = _num_alias_types++; |
|
1647 |
_alias_types[idx]->Init(idx, flat); |
|
1648 |
if (flat == TypeInstPtr::KLASS) alias_type(idx)->set_rewritable(false); |
|
1649 |
if (flat == TypeAryPtr::RANGE) alias_type(idx)->set_rewritable(false); |
|
1650 |
if (flat->isa_instptr()) { |
|
1651 |
if (flat->offset() == java_lang_Class::klass_offset_in_bytes() |
|
1652 |
&& flat->is_instptr()->klass() == env()->Class_klass()) |
|
1653 |
alias_type(idx)->set_rewritable(false); |
|
1654 |
} |
|
19770
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1655 |
if (flat->isa_aryptr()) { |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1656 |
#ifdef ASSERT |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1657 |
const int header_size_min = arrayOopDesc::base_offset_in_bytes(T_BYTE); |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1658 |
// (T_BYTE has the weakest alignment and size restrictions...) |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1659 |
assert(flat->offset() < header_size_min, "array body reference must be OffsetBot"); |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1660 |
#endif |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1661 |
if (flat->offset() == TypePtr::OffsetBot) { |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1662 |
alias_type(idx)->set_element(flat->is_aryptr()->elem()); |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1663 |
} |
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1664 |
} |
1 | 1665 |
if (flat->isa_klassptr()) { |
11430
718fc06da49a
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
11428
diff
changeset
|
1666 |
if (flat->offset() == in_bytes(Klass::super_check_offset_offset())) |
1 | 1667 |
alias_type(idx)->set_rewritable(false); |
11430
718fc06da49a
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
11428
diff
changeset
|
1668 |
if (flat->offset() == in_bytes(Klass::modifier_flags_offset())) |
1 | 1669 |
alias_type(idx)->set_rewritable(false); |
11430
718fc06da49a
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
11428
diff
changeset
|
1670 |
if (flat->offset() == in_bytes(Klass::access_flags_offset())) |
1 | 1671 |
alias_type(idx)->set_rewritable(false); |
11430
718fc06da49a
7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents:
11428
diff
changeset
|
1672 |
if (flat->offset() == in_bytes(Klass::java_mirror_offset())) |
1 | 1673 |
alias_type(idx)->set_rewritable(false); |
1674 |
} |
|
1675 |
// %%% (We would like to finalize JavaThread::threadObj_offset(), |
|
1676 |
// but the base pointer type is not distinctive enough to identify |
|
1677 |
// references into JavaThread.) |
|
1678 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1679 |
// Check for final fields. |
1 | 1680 |
const TypeInstPtr* tinst = flat->isa_instptr(); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
1681 |
if (tinst && tinst->offset() >= instanceOopDesc::base_offset_in_bytes()) { |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1682 |
ciField* field; |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1683 |
if (tinst->const_oop() != NULL && |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1684 |
tinst->klass() == ciEnv::current()->Class_klass() && |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1685 |
tinst->offset() >= (tinst->klass()->as_instance_klass()->size_helper() * wordSize)) { |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1686 |
// static field |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1687 |
ciInstanceKlass* k = tinst->const_oop()->as_instance()->java_lang_Class_klass()->as_instance_klass(); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1688 |
field = k->get_field_by_offset(tinst->offset(), true); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1689 |
} else { |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1690 |
ciInstanceKlass *k = tinst->klass()->as_instance_klass(); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1691 |
field = k->get_field_by_offset(tinst->offset(), false); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1692 |
} |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1693 |
assert(field == NULL || |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1694 |
original_field == NULL || |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1695 |
(field->holder() == original_field->holder() && |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1696 |
field->offset() == original_field->offset() && |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1697 |
field->is_static() == original_field->is_static()), "wrong field?"); |
1 | 1698 |
// Set field() and is_rewritable() attributes. |
1699 |
if (field != NULL) alias_type(idx)->set_field(field); |
|
1700 |
} |
|
1701 |
} |
|
1702 |
||
1703 |
// Fill the cache for next time. |
|
1704 |
ace->_adr_type = adr_type; |
|
1705 |
ace->_index = idx; |
|
1706 |
assert(alias_type(adr_type) == alias_type(idx), "type must be installed"); |
|
1707 |
||
1708 |
// Might as well try to fill the cache for the flattened version, too. |
|
1709 |
AliasCacheEntry* face = probe_alias_cache(flat); |
|
1710 |
if (face->_adr_type == NULL) { |
|
1711 |
face->_adr_type = flat; |
|
1712 |
face->_index = idx; |
|
1713 |
assert(alias_type(flat) == alias_type(idx), "flat type must work too"); |
|
1714 |
} |
|
1715 |
||
1716 |
return alias_type(idx); |
|
1717 |
} |
|
1718 |
||
1719 |
||
1720 |
Compile::AliasType* Compile::alias_type(ciField* field) { |
|
1721 |
const TypeOopPtr* t; |
|
1722 |
if (field->is_static()) |
|
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1723 |
t = TypeInstPtr::make(field->holder()->java_mirror()); |
1 | 1724 |
else |
1725 |
t = TypeOopPtr::make_from_klass_raw(field->holder()); |
|
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1726 |
AliasType* atp = alias_type(t->add_offset(field->offset_in_bytes()), field); |
19770
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
19717
diff
changeset
|
1727 |
assert((field->is_final() || field->is_stable()) == !atp->is_rewritable(), "must get the rewritable bits correct"); |
1 | 1728 |
return atp; |
1729 |
} |
|
1730 |
||
1731 |
||
1732 |
//------------------------------have_alias_type-------------------------------- |
|
1733 |
bool Compile::have_alias_type(const TypePtr* adr_type) { |
|
1734 |
AliasCacheEntry* ace = probe_alias_cache(adr_type); |
|
1735 |
if (ace->_adr_type == adr_type) { |
|
1736 |
return true; |
|
1737 |
} |
|
1738 |
||
1739 |
// Handle special cases. |
|
1740 |
if (adr_type == NULL) return true; |
|
1741 |
if (adr_type == TypePtr::BOTTOM) return true; |
|
1742 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8107
diff
changeset
|
1743 |
return find_alias_type(adr_type, true, NULL) != NULL; |
1 | 1744 |
} |
1745 |
||
1746 |
//-----------------------------must_alias-------------------------------------- |
|
1747 |
// True if all values of the given address type are in the given alias category. |
|
1748 |
bool Compile::must_alias(const TypePtr* adr_type, int alias_idx) { |
|
1749 |
if (alias_idx == AliasIdxBot) return true; // the universal category |
|
1750 |
if (adr_type == NULL) return true; // NULL serves as TypePtr::TOP |
|
1751 |
if (alias_idx == AliasIdxTop) return false; // the empty category |
|
1752 |
if (adr_type->base() == Type::AnyPtr) return false; // TypePtr::BOTTOM or its twins |
|
1753 |
||
1754 |
// the only remaining possible overlap is identity |
|
1755 |
int adr_idx = get_alias_index(adr_type); |
|
1756 |
assert(adr_idx != AliasIdxBot && adr_idx != AliasIdxTop, ""); |
|
1757 |
assert(adr_idx == alias_idx || |
|
1758 |
(alias_type(alias_idx)->adr_type() != TypeOopPtr::BOTTOM |
|
1759 |
&& adr_type != TypeOopPtr::BOTTOM), |
|
1760 |
"should not be testing for overlap with an unsafe pointer"); |
|
1761 |
return adr_idx == alias_idx; |
|
1762 |
} |
|
1763 |
||
1764 |
//------------------------------can_alias-------------------------------------- |
|
1765 |
// True if any values of the given address type are in the given alias category. |
|
1766 |
bool Compile::can_alias(const TypePtr* adr_type, int alias_idx) { |
|
1767 |
if (alias_idx == AliasIdxTop) return false; // the empty category |
|
1768 |
if (adr_type == NULL) return false; // NULL serves as TypePtr::TOP |
|
1769 |
if (alias_idx == AliasIdxBot) return true; // the universal category |
|
1770 |
if (adr_type->base() == Type::AnyPtr) return true; // TypePtr::BOTTOM or its twins |
|
1771 |
||
1772 |
// the only remaining possible overlap is identity |
|
1773 |
int adr_idx = get_alias_index(adr_type); |
|
1774 |
assert(adr_idx != AliasIdxBot && adr_idx != AliasIdxTop, ""); |
|
1775 |
return adr_idx == alias_idx; |
|
1776 |
} |
|
1777 |
||
1778 |
||
1779 |
||
1780 |
//---------------------------pop_warm_call------------------------------------- |
|
1781 |
WarmCallInfo* Compile::pop_warm_call() { |
|
1782 |
WarmCallInfo* wci = _warm_calls; |
|
1783 |
if (wci != NULL) _warm_calls = wci->remove_from(wci); |
|
1784 |
return wci; |
|
1785 |
} |
|
1786 |
||
1787 |
//----------------------------Inline_Warm-------------------------------------- |
|
1788 |
int Compile::Inline_Warm() { |
|
1789 |
// If there is room, try to inline some more warm call sites. |
|
1790 |
// %%% Do a graph index compaction pass when we think we're out of space? |
|
1791 |
if (!InlineWarmCalls) return 0; |
|
1792 |
||
1793 |
int calls_made_hot = 0; |
|
1794 |
int room_to_grow = NodeCountInliningCutoff - unique(); |
|
1795 |
int amount_to_grow = MIN2(room_to_grow, (int)NodeCountInliningStep); |
|
1796 |
int amount_grown = 0; |
|
1797 |
WarmCallInfo* call; |
|
1798 |
while (amount_to_grow > 0 && (call = pop_warm_call()) != NULL) { |
|
1799 |
int est_size = (int)call->size(); |
|
1800 |
if (est_size > (room_to_grow - amount_grown)) { |
|
1801 |
// This one won't fit anyway. Get rid of it. |
|
1802 |
call->make_cold(); |
|
1803 |
continue; |
|
1804 |
} |
|
1805 |
call->make_hot(); |
|
1806 |
calls_made_hot++; |
|
1807 |
amount_grown += est_size; |
|
1808 |
amount_to_grow -= est_size; |
|
1809 |
} |
|
1810 |
||
1811 |
if (calls_made_hot > 0) set_major_progress(); |
|
1812 |
return calls_made_hot; |
|
1813 |
} |
|
1814 |
||
1815 |
||
1816 |
//----------------------------Finish_Warm-------------------------------------- |
|
1817 |
void Compile::Finish_Warm() { |
|
1818 |
if (!InlineWarmCalls) return; |
|
1819 |
if (failing()) return; |
|
1820 |
if (warm_calls() == NULL) return; |
|
1821 |
||
1822 |
// Clean up loose ends, if we are out of space for inlining. |
|
1823 |
WarmCallInfo* call; |
|
1824 |
while ((call = pop_warm_call()) != NULL) { |
|
1825 |
call->make_cold(); |
|
1826 |
} |
|
1827 |
} |
|
1828 |
||
4643 | 1829 |
//---------------------cleanup_loop_predicates----------------------- |
1830 |
// Remove the opaque nodes that protect the predicates so that all unused |
|
1831 |
// checks and uncommon_traps will be eliminated from the ideal graph |
|
1832 |
void Compile::cleanup_loop_predicates(PhaseIterGVN &igvn) { |
|
1833 |
if (predicate_count()==0) return; |
|
1834 |
for (int i = predicate_count(); i > 0; i--) { |
|
1835 |
Node * n = predicate_opaque1_node(i-1); |
|
1836 |
assert(n->Opcode() == Op_Opaque1, "must be"); |
|
1837 |
igvn.replace_node(n, n->in(1)); |
|
1838 |
} |
|
1839 |
assert(predicate_count()==0, "should be clean!"); |
|
1840 |
} |
|
1 | 1841 |
|
15113 | 1842 |
// StringOpts and late inlining of string methods |
1843 |
void Compile::inline_string_calls(bool parse_time) { |
|
1844 |
{ |
|
1845 |
// remove useless nodes to make the usage analysis simpler |
|
1846 |
ResourceMark rm; |
|
1847 |
PhaseRemoveUseless pru(initial_gvn(), for_igvn()); |
|
1848 |
} |
|
1849 |
||
1850 |
{ |
|
1851 |
ResourceMark rm; |
|
18025 | 1852 |
print_method(PHASE_BEFORE_STRINGOPTS, 3); |
15113 | 1853 |
PhaseStringOpts pso(initial_gvn(), for_igvn()); |
18025 | 1854 |
print_method(PHASE_AFTER_STRINGOPTS, 3); |
15113 | 1855 |
} |
1856 |
||
1857 |
// now inline anything that we skipped the first time around |
|
1858 |
if (!parse_time) { |
|
1859 |
_late_inlines_pos = _late_inlines.length(); |
|
1860 |
} |
|
1861 |
||
1862 |
while (_string_late_inlines.length() > 0) { |
|
1863 |
CallGenerator* cg = _string_late_inlines.pop(); |
|
1864 |
cg->do_late_inline(); |
|
1865 |
if (failing()) return; |
|
1866 |
} |
|
1867 |
_string_late_inlines.trunc_to(0); |
|
1868 |
} |
|
1869 |
||
17383 | 1870 |
// Late inlining of boxing methods |
1871 |
void Compile::inline_boxing_calls(PhaseIterGVN& igvn) { |
|
1872 |
if (_boxing_late_inlines.length() > 0) { |
|
1873 |
assert(has_boxed_value(), "inconsistent"); |
|
1874 |
||
1875 |
PhaseGVN* gvn = initial_gvn(); |
|
1876 |
set_inlining_incrementally(true); |
|
1877 |
||
1878 |
assert( igvn._worklist.size() == 0, "should be done with igvn" ); |
|
1879 |
for_igvn()->clear(); |
|
1880 |
gvn->replace_with(&igvn); |
|
1881 |
||
1882 |
while (_boxing_late_inlines.length() > 0) { |
|
1883 |
CallGenerator* cg = _boxing_late_inlines.pop(); |
|
1884 |
cg->do_late_inline(); |
|
1885 |
if (failing()) return; |
|
1886 |
} |
|
1887 |
_boxing_late_inlines.trunc_to(0); |
|
1888 |
||
1889 |
{ |
|
1890 |
ResourceMark rm; |
|
1891 |
PhaseRemoveUseless pru(gvn, for_igvn()); |
|
1892 |
} |
|
1893 |
||
1894 |
igvn = PhaseIterGVN(gvn); |
|
1895 |
igvn.optimize(); |
|
1896 |
||
1897 |
set_inlining_progress(false); |
|
1898 |
set_inlining_incrementally(false); |
|
1899 |
} |
|
1900 |
} |
|
1901 |
||
15113 | 1902 |
void Compile::inline_incrementally_one(PhaseIterGVN& igvn) { |
1903 |
assert(IncrementalInline, "incremental inlining should be on"); |
|
1904 |
PhaseGVN* gvn = initial_gvn(); |
|
1905 |
||
1906 |
set_inlining_progress(false); |
|
1907 |
for_igvn()->clear(); |
|
1908 |
gvn->replace_with(&igvn); |
|
1909 |
||
1910 |
int i = 0; |
|
1911 |
||
1912 |
for (; i <_late_inlines.length() && !inlining_progress(); i++) { |
|
1913 |
CallGenerator* cg = _late_inlines.at(i); |
|
1914 |
_late_inlines_pos = i+1; |
|
1915 |
cg->do_late_inline(); |
|
1916 |
if (failing()) return; |
|
1917 |
} |
|
1918 |
int j = 0; |
|
1919 |
for (; i < _late_inlines.length(); i++, j++) { |
|
1920 |
_late_inlines.at_put(j, _late_inlines.at(i)); |
|
1921 |
} |
|
1922 |
_late_inlines.trunc_to(j); |
|
1923 |
||
1924 |
{ |
|
1925 |
ResourceMark rm; |
|
17383 | 1926 |
PhaseRemoveUseless pru(gvn, for_igvn()); |
15113 | 1927 |
} |
1928 |
||
1929 |
igvn = PhaseIterGVN(gvn); |
|
1930 |
} |
|
1931 |
||
1932 |
// Perform incremental inlining until bound on number of live nodes is reached |
|
1933 |
void Compile::inline_incrementally(PhaseIterGVN& igvn) { |
|
1934 |
PhaseGVN* gvn = initial_gvn(); |
|
1935 |
||
1936 |
set_inlining_incrementally(true); |
|
1937 |
set_inlining_progress(true); |
|
1938 |
uint low_live_nodes = 0; |
|
1939 |
||
1940 |
while(inlining_progress() && _late_inlines.length() > 0) { |
|
1941 |
||
1942 |
if (live_nodes() > (uint)LiveNodeCountInliningCutoff) { |
|
1943 |
if (low_live_nodes < (uint)LiveNodeCountInliningCutoff * 8 / 10) { |
|
1944 |
// PhaseIdealLoop is expensive so we only try it once we are |
|
1945 |
// out of loop and we only try it again if the previous helped |
|
1946 |
// got the number of nodes down significantly |
|
1947 |
PhaseIdealLoop ideal_loop( igvn, false, true ); |
|
1948 |
if (failing()) return; |
|
1949 |
low_live_nodes = live_nodes(); |
|
1950 |
_major_progress = true; |
|
1951 |
} |
|
1952 |
||
1953 |
if (live_nodes() > (uint)LiveNodeCountInliningCutoff) { |
|
1954 |
break; |
|
1955 |
} |
|
1956 |
} |
|
1957 |
||
1958 |
inline_incrementally_one(igvn); |
|
1959 |
||
1960 |
if (failing()) return; |
|
1961 |
||
1962 |
igvn.optimize(); |
|
1963 |
||
1964 |
if (failing()) return; |
|
1965 |
} |
|
1966 |
||
1967 |
assert( igvn._worklist.size() == 0, "should be done with igvn" ); |
|
1968 |
||
1969 |
if (_string_late_inlines.length() > 0) { |
|
1970 |
assert(has_stringbuilder(), "inconsistent"); |
|
1971 |
for_igvn()->clear(); |
|
1972 |
initial_gvn()->replace_with(&igvn); |
|
1973 |
||
1974 |
inline_string_calls(false); |
|
1975 |
||
1976 |
if (failing()) return; |
|
1977 |
||
1978 |
{ |
|
1979 |
ResourceMark rm; |
|
1980 |
PhaseRemoveUseless pru(initial_gvn(), for_igvn()); |
|
1981 |
} |
|
1982 |
||
1983 |
igvn = PhaseIterGVN(gvn); |
|
1984 |
||
1985 |
igvn.optimize(); |
|
1986 |
} |
|
1987 |
||
1988 |
set_inlining_incrementally(false); |
|
1989 |
} |
|
1990 |
||
1991 |
||
1 | 1992 |
//------------------------------Optimize--------------------------------------- |
1993 |
// Given a graph, optimize it. |
|
1994 |
void Compile::Optimize() { |
|
1995 |
TracePhase t1("optimizer", &_t_optimizer, true); |
|
1996 |
||
1997 |
#ifndef PRODUCT |
|
1998 |
if (env()->break_at_compile()) { |
|
1999 |
BREAKPOINT; |
|
2000 |
} |
|
2001 |
||
2002 |
#endif |
|
2003 |
||
2004 |
ResourceMark rm; |
|
2005 |
int loop_opts_cnt; |
|
2006 |
||
2007 |
NOT_PRODUCT( verify_graph_edges(); ) |
|
2008 |
||
18025 | 2009 |
print_method(PHASE_AFTER_PARSING); |
1 | 2010 |
|
2011 |
{ |
|
2012 |
// Iterative Global Value Numbering, including ideal transforms |
|
2013 |
// Initialize IterGVN with types and values from parse-time GVN |
|
2014 |
PhaseIterGVN igvn(initial_gvn()); |
|
2015 |
{ |
|
2016 |
NOT_PRODUCT( TracePhase t2("iterGVN", &_t_iterGVN, TimeCompiler); ) |
|
2017 |
igvn.optimize(); |
|
2018 |
} |
|
2019 |
||
18025 | 2020 |
print_method(PHASE_ITER_GVN1, 2); |
1 | 2021 |
|
2022 |
if (failing()) return; |
|
2023 |
||
17383 | 2024 |
{ |
2025 |
NOT_PRODUCT( TracePhase t2("incrementalInline", &_t_incrInline, TimeCompiler); ) |
|
2026 |
inline_incrementally(igvn); |
|
2027 |
} |
|
15113 | 2028 |
|
18025 | 2029 |
print_method(PHASE_INCREMENTAL_INLINE, 2); |
15113 | 2030 |
|
2031 |
if (failing()) return; |
|
2032 |
||
17383 | 2033 |
if (eliminate_boxing()) { |
2034 |
NOT_PRODUCT( TracePhase t2("incrementalInline", &_t_incrInline, TimeCompiler); ) |
|
2035 |
// Inline valueOf() methods now. |
|
2036 |
inline_boxing_calls(igvn); |
|
2037 |
||
18025 | 2038 |
print_method(PHASE_INCREMENTAL_BOXING_INLINE, 2); |
17383 | 2039 |
|
2040 |
if (failing()) return; |
|
2041 |
} |
|
2042 |
||
21099 | 2043 |
// Remove the speculative part of types and clean up the graph from |
2044 |
// the extra CastPP nodes whose only purpose is to carry them. Do |
|
2045 |
// that early so that optimizations are not disrupted by the extra |
|
2046 |
// CastPP nodes. |
|
2047 |
remove_speculative_types(igvn); |
|
2048 |
||
15618
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
2049 |
// No more new expensive nodes will be added to the list from here |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
2050 |
// so keep only the actual candidates for optimizations. |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
2051 |
cleanup_expensive_nodes(igvn); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
2052 |
|
5914
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2053 |
// Perform escape analysis |
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2054 |
if (_do_escape_analysis && ConnectionGraph::has_candidates(this)) { |
10988
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
2055 |
if (has_loops()) { |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
2056 |
// Cleanup graph (remove dead nodes). |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
2057 |
TracePhase t2("idealLoop", &_t_idealLoop, true); |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
2058 |
PhaseIdealLoop ideal_loop( igvn, false, true ); |
18025 | 2059 |
if (major_progress()) print_method(PHASE_PHASEIDEAL_BEFORE_EA, 2); |
10988
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
2060 |
if (failing()) return; |
a3b2bd43ef4f
7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents:
10508
diff
changeset
|
2061 |
} |
5914
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2062 |
ConnectionGraph::do_analysis(this, &igvn); |
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2063 |
|
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2064 |
if (failing()) return; |
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2065 |
|
11191 | 2066 |
// Optimize out fields loads from scalar replaceable allocations. |
5914
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2067 |
igvn.optimize(); |
18025 | 2068 |
print_method(PHASE_ITER_GVN_AFTER_EA, 2); |
5914
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2069 |
|
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2070 |
if (failing()) return; |
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2071 |
|
11191 | 2072 |
if (congraph() != NULL && macro_count() > 0) { |
12158
f24f2560da32
7147744: CTW: assert(false) failed: infinite EA connection graph build
kvn
parents:
11435
diff
changeset
|
2073 |
NOT_PRODUCT( TracePhase t2("macroEliminate", &_t_macroEliminate, TimeCompiler); ) |
11191 | 2074 |
PhaseMacroExpand mexp(igvn); |
2075 |
mexp.eliminate_macro_nodes(); |
|
2076 |
igvn.set_delay_transform(false); |
|
2077 |
||
2078 |
igvn.optimize(); |
|
18025 | 2079 |
print_method(PHASE_ITER_GVN_AFTER_ELIMINATION, 2); |
11191 | 2080 |
|
2081 |
if (failing()) return; |
|
2082 |
} |
|
5914
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2083 |
} |
8363e7e6915a
6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents:
5889
diff
changeset
|
2084 |
|
1 | 2085 |
// Loop transforms on the ideal graph. Range Check Elimination, |
2086 |
// peeling, unrolling, etc. |
|
2087 |
||
2088 |
// Set loop opts counter |
|
2089 |
loop_opts_cnt = num_loop_opts(); |
|
2090 |
if((loop_opts_cnt > 0) && (has_loops() || has_split_ifs())) { |
|
2091 |
{ |
|
2092 |
TracePhase t2("idealLoop", &_t_idealLoop, true); |
|
9101 | 2093 |
PhaseIdealLoop ideal_loop( igvn, true ); |
1 | 2094 |
loop_opts_cnt--; |
18025 | 2095 |
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP1, 2); |
1 | 2096 |
if (failing()) return; |
2097 |
} |
|
2098 |
// Loop opts pass if partial peeling occurred in previous pass |
|
2099 |
if(PartialPeelLoop && major_progress() && (loop_opts_cnt > 0)) { |
|
2100 |
TracePhase t3("idealLoop", &_t_idealLoop, true); |
|
9101 | 2101 |
PhaseIdealLoop ideal_loop( igvn, false ); |
1 | 2102 |
loop_opts_cnt--; |
18025 | 2103 |
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP2, 2); |
1 | 2104 |
if (failing()) return; |
2105 |
} |
|
2106 |
// Loop opts pass for loop-unrolling before CCP |
|
2107 |
if(major_progress() && (loop_opts_cnt > 0)) { |
|
2108 |
TracePhase t4("idealLoop", &_t_idealLoop, true); |
|
9101 | 2109 |
PhaseIdealLoop ideal_loop( igvn, false ); |
1 | 2110 |
loop_opts_cnt--; |
18025 | 2111 |
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP3, 2); |
1 | 2112 |
} |
3676
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2113 |
if (!failing()) { |
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2114 |
// Verify that last round of loop opts produced a valid graph |
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2115 |
NOT_PRODUCT( TracePhase t2("idealLoopVerify", &_t_idealLoopVerify, TimeCompiler); ) |
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2116 |
PhaseIdealLoop::verify(igvn); |
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2117 |
} |
1 | 2118 |
} |
2119 |
if (failing()) return; |
|
2120 |
||
2121 |
// Conditional Constant Propagation; |
|
2122 |
PhaseCCP ccp( &igvn ); |
|
2123 |
assert( true, "Break here to ccp.dump_nodes_and_types(_root,999,1)"); |
|
2124 |
{ |
|
2125 |
TracePhase t2("ccp", &_t_ccp, true); |
|
2126 |
ccp.do_transform(); |
|
2127 |
} |
|
18025 | 2128 |
print_method(PHASE_CPP1, 2); |
1 | 2129 |
|
2130 |
assert( true, "Break here to ccp.dump_old2new_map()"); |
|
2131 |
||
2132 |
// Iterative Global Value Numbering, including ideal transforms |
|
2133 |
{ |
|
2134 |
NOT_PRODUCT( TracePhase t2("iterGVN2", &_t_iterGVN2, TimeCompiler); ) |
|
2135 |
igvn = ccp; |
|
2136 |
igvn.optimize(); |
|
2137 |
} |
|
2138 |
||
18025 | 2139 |
print_method(PHASE_ITER_GVN2, 2); |
1 | 2140 |
|
2141 |
if (failing()) return; |
|
2142 |
||
2143 |
// Loop transforms on the ideal graph. Range Check Elimination, |
|
2144 |
// peeling, unrolling, etc. |
|
2145 |
if(loop_opts_cnt > 0) { |
|
2146 |
debug_only( int cnt = 0; ); |
|
2147 |
while(major_progress() && (loop_opts_cnt > 0)) { |
|
2148 |
TracePhase t2("idealLoop", &_t_idealLoop, true); |
|
2149 |
assert( cnt++ < 40, "infinite cycle in loop optimization" ); |
|
9101 | 2150 |
PhaseIdealLoop ideal_loop( igvn, true); |
1 | 2151 |
loop_opts_cnt--; |
18025 | 2152 |
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP_ITERATIONS, 2); |
1 | 2153 |
if (failing()) return; |
2154 |
} |
|
2155 |
} |
|
3676
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2156 |
|
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2157 |
{ |
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2158 |
// Verify that all previous optimizations produced a valid graph |
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2159 |
// at least to this point, even if no loop optimizations were done. |
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2160 |
NOT_PRODUCT( TracePhase t2("idealLoopVerify", &_t_idealLoopVerify, TimeCompiler); ) |
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2161 |
PhaseIdealLoop::verify(igvn); |
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2162 |
} |
3bac3e882cd3
6862956: PhaseIdealLoop should have a CFG verification mode
never
parents:
3276
diff
changeset
|
2163 |
|
1 | 2164 |
{ |
2165 |
NOT_PRODUCT( TracePhase t2("macroExpand", &_t_macroExpand, TimeCompiler); ) |
|
2166 |
PhaseMacroExpand mex(igvn); |
|
2167 |
if (mex.expand_macro_nodes()) { |
|
2168 |
assert(failing(), "must bail out w/ explicit message"); |
|
2169 |
return; |
|
2170 |
} |
|
2171 |
} |
|
2172 |
||
2173 |
} // (End scope of igvn; run destructor if necessary for asserts.) |
|
2174 |
||
15211 | 2175 |
dump_inlining(); |
1 | 2176 |
// A method with only infinite loops has no edges entering loops from root |
2177 |
{ |
|
2178 |
NOT_PRODUCT( TracePhase t2("graphReshape", &_t_graphReshaping, TimeCompiler); ) |
|
2179 |
if (final_graph_reshaping()) { |
|
2180 |
assert(failing(), "must bail out w/ explicit message"); |
|
2181 |
return; |
|
2182 |
} |
|
2183 |
} |
|
2184 |
||
18025 | 2185 |
print_method(PHASE_OPTIMIZE_FINISHED, 2); |
1 | 2186 |
} |
2187 |
||
2188 |
||
2189 |
//------------------------------Code_Gen--------------------------------------- |
|
2190 |
// Given a graph, generate code for it |
|
2191 |
void Compile::Code_Gen() { |
|
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2192 |
if (failing()) { |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2193 |
return; |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2194 |
} |
1 | 2195 |
|
2196 |
// Perform instruction selection. You might think we could reclaim Matcher |
|
2197 |
// memory PDQ, but actually the Matcher is used in generating spill code. |
|
2198 |
// Internals of the Matcher (including some VectorSets) must remain live |
|
2199 |
// for awhile - thus I cannot reclaim Matcher memory lest a VectorSet usage |
|
2200 |
// set a bit in reclaimed memory. |
|
2201 |
||
2202 |
// In debug mode can dump m._nodes.dump() for mapping of ideal to machine |
|
2203 |
// nodes. Mapping is only valid at the root of each matched subtree. |
|
2204 |
NOT_PRODUCT( verify_graph_edges(); ) |
|
2205 |
||
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2206 |
Matcher matcher; |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2207 |
_matcher = &matcher; |
1 | 2208 |
{ |
2209 |
TracePhase t2("matcher", &_t_matcher, true); |
|
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2210 |
matcher.match(); |
1 | 2211 |
} |
2212 |
// In debug mode can dump m._nodes.dump() for mapping of ideal to machine |
|
2213 |
// nodes. Mapping is only valid at the root of each matched subtree. |
|
2214 |
NOT_PRODUCT( verify_graph_edges(); ) |
|
2215 |
||
2216 |
// If you have too many nodes, or if matching has failed, bail out |
|
2217 |
check_node_count(0, "out of nodes matching instructions"); |
|
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2218 |
if (failing()) { |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2219 |
return; |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2220 |
} |
1 | 2221 |
|
2222 |
// Build a proper-looking CFG |
|
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2223 |
PhaseCFG cfg(node_arena(), root(), matcher); |
1 | 2224 |
_cfg = &cfg; |
2225 |
{ |
|
2226 |
NOT_PRODUCT( TracePhase t2("scheduler", &_t_scheduler, TimeCompiler); ) |
|
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2227 |
bool success = cfg.do_global_code_motion(); |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2228 |
if (!success) { |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2229 |
return; |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2230 |
} |
1 | 2231 |
|
18025 | 2232 |
print_method(PHASE_GLOBAL_CODE_MOTION, 2); |
1 | 2233 |
NOT_PRODUCT( verify_graph_edges(); ) |
2234 |
debug_only( cfg.verify(); ) |
|
2235 |
} |
|
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2236 |
|
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2237 |
PhaseChaitin regalloc(unique(), cfg, matcher); |
1 | 2238 |
_regalloc = ®alloc; |
2239 |
{ |
|
2240 |
TracePhase t2("regalloc", &_t_registerAllocation, true); |
|
2241 |
// Perform register allocation. After Chaitin, use-def chains are |
|
2242 |
// no longer accurate (at spill code) and so must be ignored. |
|
2243 |
// Node->LRG->reg mappings are still accurate. |
|
2244 |
_regalloc->Register_Allocate(); |
|
2245 |
||
2246 |
// Bail out if the allocator builds too many nodes |
|
17013 | 2247 |
if (failing()) { |
2248 |
return; |
|
2249 |
} |
|
1 | 2250 |
} |
2251 |
||
2252 |
// Prior to register allocation we kept empty basic blocks in case the |
|
2253 |
// the allocator needed a place to spill. After register allocation we |
|
2254 |
// are not adding any new instructions. If any basic block is empty, we |
|
2255 |
// can now safely remove it. |
|
2256 |
{ |
|
1498 | 2257 |
NOT_PRODUCT( TracePhase t2("blockOrdering", &_t_blockOrdering, TimeCompiler); ) |
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2258 |
cfg.remove_empty_blocks(); |
1498 | 2259 |
if (do_freq_based_layout()) { |
2260 |
PhaseBlockLayout layout(cfg); |
|
2261 |
} else { |
|
2262 |
cfg.set_loop_alignment(); |
|
2263 |
} |
|
2264 |
cfg.fixup_flow(); |
|
1 | 2265 |
} |
2266 |
||
2267 |
// Apply peephole optimizations |
|
2268 |
if( OptoPeephole ) { |
|
2269 |
NOT_PRODUCT( TracePhase t2("peephole", &_t_peephole, TimeCompiler); ) |
|
2270 |
PhasePeephole peep( _regalloc, cfg); |
|
2271 |
peep.do_transform(); |
|
2272 |
} |
|
2273 |
||
22844
90f76a40ed8a
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
22838
diff
changeset
|
2274 |
// Do late expand if CPU requires this. |
90f76a40ed8a
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
22838
diff
changeset
|
2275 |
if (Matcher::require_postalloc_expand) { |
90f76a40ed8a
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
22838
diff
changeset
|
2276 |
NOT_PRODUCT(TracePhase t2c("postalloc_expand", &_t_postalloc_expand, true)); |
90f76a40ed8a
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
22838
diff
changeset
|
2277 |
cfg.postalloc_expand(_regalloc); |
90f76a40ed8a
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
22838
diff
changeset
|
2278 |
} |
90f76a40ed8a
8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents:
22838
diff
changeset
|
2279 |
|
1 | 2280 |
// Convert Nodes to instruction bits in a buffer |
2281 |
{ |
|
2282 |
// %%%% workspace merge brought two timers together for one job |
|
2283 |
TracePhase t2a("output", &_t_output, true); |
|
2284 |
NOT_PRODUCT( TraceTime t2b(NULL, &_t_codeGeneration, TimeCompiler, false); ) |
|
2285 |
Output(); |
|
2286 |
} |
|
2287 |
||
18025 | 2288 |
print_method(PHASE_FINAL_CODE); |
1 | 2289 |
|
2290 |
// He's dead, Jim. |
|
2291 |
_cfg = (PhaseCFG*)0xdeadbeef; |
|
2292 |
_regalloc = (PhaseChaitin*)0xdeadbeef; |
|
2293 |
} |
|
2294 |
||
2295 |
||
2296 |
//------------------------------dump_asm--------------------------------------- |
|
2297 |
// Dump formatted assembly |
|
2298 |
#ifndef PRODUCT |
|
2299 |
void Compile::dump_asm(int *pcs, uint pc_limit) { |
|
2300 |
bool cut_short = false; |
|
2301 |
tty->print_cr("#"); |
|
2302 |
tty->print("# "); _tf->dump(); tty->cr(); |
|
2303 |
tty->print_cr("#"); |
|
2304 |
||
2305 |
// For all blocks |
|
2306 |
int pc = 0x0; // Program counter |
|
2307 |
char starts_bundle = ' '; |
|
2308 |
_regalloc->dump_frame(); |
|
2309 |
||
2310 |
Node *n = NULL; |
|
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2311 |
for (uint i = 0; i < _cfg->number_of_blocks(); i++) { |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2312 |
if (VMThread::should_terminate()) { |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2313 |
cut_short = true; |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2314 |
break; |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2315 |
} |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2316 |
Block* block = _cfg->get_block(i); |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2317 |
if (block->is_connector() && !Verbose) { |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2318 |
continue; |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2319 |
} |
19717
7819ffdaf0ff
8023691: Create interface for nodes in class Block
adlertz
parents:
19330
diff
changeset
|
2320 |
n = block->head(); |
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2321 |
if (pcs && n->_idx < pc_limit) { |
1 | 2322 |
tty->print("%3.3x ", pcs[n->_idx]); |
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2323 |
} else { |
1 | 2324 |
tty->print(" "); |
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2325 |
} |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2326 |
block->dump_head(_cfg); |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2327 |
if (block->is_connector()) { |
1 | 2328 |
tty->print_cr(" # Empty connector block"); |
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2329 |
} else if (block->num_preds() == 2 && block->pred(1)->is_CatchProj() && block->pred(1)->as_CatchProj()->_con == CatchProjNode::fall_through_index) { |
1 | 2330 |
tty->print_cr(" # Block is sole successor of call"); |
2331 |
} |
|
2332 |
||
2333 |
// For all instructions |
|
2334 |
Node *delay = NULL; |
|
19717
7819ffdaf0ff
8023691: Create interface for nodes in class Block
adlertz
parents:
19330
diff
changeset
|
2335 |
for (uint j = 0; j < block->number_of_nodes(); j++) { |
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2336 |
if (VMThread::should_terminate()) { |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2337 |
cut_short = true; |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2338 |
break; |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2339 |
} |
19717
7819ffdaf0ff
8023691: Create interface for nodes in class Block
adlertz
parents:
19330
diff
changeset
|
2340 |
n = block->get_node(j); |
1 | 2341 |
if (valid_bundle_info(n)) { |
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2342 |
Bundle* bundle = node_bundling(n); |
1 | 2343 |
if (bundle->used_in_unconditional_delay()) { |
2344 |
delay = n; |
|
2345 |
continue; |
|
2346 |
} |
|
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2347 |
if (bundle->starts_bundle()) { |
1 | 2348 |
starts_bundle = '+'; |
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2349 |
} |
1 | 2350 |
} |
2351 |
||
19330
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2352 |
if (WizardMode) { |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2353 |
n->dump(); |
49d6711171e6
8023003: Cleanup the public interface to PhaseCFG
adlertz
parents:
19279
diff
changeset
|
2354 |
} |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
2355 |
|
1 | 2356 |
if( !n->is_Region() && // Dont print in the Assembly |
2357 |
!n->is_Phi() && // a few noisely useless nodes |
|
2358 |
!n->is_Proj() && |
|
2359 |
!n->is_MachTemp() && |
|
4470
1e6edcab3109
6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents:
4450
diff
changeset
|
2360 |
!n->is_SafePointScalarObject() && |
1 | 2361 |
!n->is_Catch() && // Would be nice to print exception table targets |
2362 |
!n->is_MergeMem() && // Not very interesting |
|
2363 |
!n->is_top() && // Debug info table constants |
|
2364 |
!(n->is_Con() && !n->is_Mach())// Debug info table constants |
|
2365 |
) { |
|
2366 |
if (pcs && n->_idx < pc_limit) |
|
2367 |
tty->print("%3.3x", pcs[n->_idx]); |
|
2368 |
else |
|
2369 |
tty->print(" "); |
|
2370 |
tty->print(" %c ", starts_bundle); |
|
2371 |
starts_bundle = ' '; |
|
2372 |
tty->print("\t"); |
|
2373 |
n->format(_regalloc, tty); |
|
2374 |
tty->cr(); |
|
2375 |
} |
|
2376 |
||
2377 |
// If we have an instruction with a delay slot, and have seen a delay, |
|
2378 |
// then back up and print it |
|
2379 |
if (valid_bundle_info(n) && node_bundling(n)->use_unconditional_delay()) { |
|
2380 |
assert(delay != NULL, "no unconditional delay instruction"); |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
2381 |
if (WizardMode) delay->dump(); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
2382 |
|
1 | 2383 |
if (node_bundling(delay)->starts_bundle()) |
2384 |
starts_bundle = '+'; |
|
2385 |
if (pcs && n->_idx < pc_limit) |
|
2386 |
tty->print("%3.3x", pcs[n->_idx]); |
|
2387 |
else |
|
2388 |
tty->print(" "); |
|
2389 |
tty->print(" %c ", starts_bundle); |
|
2390 |
starts_bundle = ' '; |
|
2391 |
tty->print("\t"); |
|
2392 |
delay->format(_regalloc, tty); |
|
2393 |
tty->print_cr(""); |
|
2394 |
delay = NULL; |
|
2395 |
} |
|
2396 |
||
2397 |
// Dump the exception table as well |
|
2398 |
if( n->is_Catch() && (Verbose || WizardMode) ) { |
|
2399 |
// Print the exception table for this offset |
|
2400 |
_handler_table.print_subtable_for(pc); |
|
2401 |
} |
|
2402 |
} |
|
2403 |
||
2404 |
if (pcs && n->_idx < pc_limit) |
|
2405 |
tty->print_cr("%3.3x", pcs[n->_idx]); |
|
2406 |
else |
|
2407 |
tty->print_cr(""); |
|
2408 |
||
2409 |
assert(cut_short || delay == NULL, "no unconditional delay branch"); |
|
2410 |
||
2411 |
} // End of per-block dump |
|
2412 |
tty->print_cr(""); |
|
2413 |
||
2414 |
if (cut_short) tty->print_cr("*** disassembly is cut short ***"); |
|
2415 |
} |
|
2416 |
#endif |
|
2417 |
||
2418 |
//------------------------------Final_Reshape_Counts--------------------------- |
|
2419 |
// This class defines counters to help identify when a method |
|
2420 |
// may/must be executed using hardware with only 24-bit precision. |
|
2421 |
struct Final_Reshape_Counts : public StackObj { |
|
2422 |
int _call_count; // count non-inlined 'common' calls |
|
2423 |
int _float_count; // count float ops requiring 24-bit precision |
|
2424 |
int _double_count; // count double ops requiring more precision |
|
2425 |
int _java_call_count; // count non-inlined 'java' calls |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2426 |
int _inner_loop_count; // count loops which need alignment |
1 | 2427 |
VectorSet _visited; // Visitation flags |
2428 |
Node_List _tests; // Set of IfNodes & PCTableNodes |
|
2429 |
||
2430 |
Final_Reshape_Counts() : |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2431 |
_call_count(0), _float_count(0), _double_count(0), |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2432 |
_java_call_count(0), _inner_loop_count(0), |
1 | 2433 |
_visited( Thread::current()->resource_area() ) { } |
2434 |
||
2435 |
void inc_call_count () { _call_count ++; } |
|
2436 |
void inc_float_count () { _float_count ++; } |
|
2437 |
void inc_double_count() { _double_count++; } |
|
2438 |
void inc_java_call_count() { _java_call_count++; } |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2439 |
void inc_inner_loop_count() { _inner_loop_count++; } |
1 | 2440 |
|
2441 |
int get_call_count () const { return _call_count ; } |
|
2442 |
int get_float_count () const { return _float_count ; } |
|
2443 |
int get_double_count() const { return _double_count; } |
|
2444 |
int get_java_call_count() const { return _java_call_count; } |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2445 |
int get_inner_loop_count() const { return _inner_loop_count; } |
1 | 2446 |
}; |
2447 |
||
16670
4af09aff4237
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
15946
diff
changeset
|
2448 |
#ifdef ASSERT |
1 | 2449 |
static bool oop_offset_is_sane(const TypeInstPtr* tp) { |
2450 |
ciInstanceKlass *k = tp->klass()->as_instance_klass(); |
|
2451 |
// Make sure the offset goes inside the instance layout. |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
2452 |
return k->contains_field_offset(tp->offset()); |
1 | 2453 |
// Note that OffsetBot and OffsetTop are very negative. |
2454 |
} |
|
16670
4af09aff4237
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
15946
diff
changeset
|
2455 |
#endif |
1 | 2456 |
|
9175
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2457 |
// Eliminate trivially redundant StoreCMs and accumulate their |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2458 |
// precedence edges. |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2459 |
void Compile::eliminate_redundant_card_marks(Node* n) { |
9175
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2460 |
assert(n->Opcode() == Op_StoreCM, "expected StoreCM"); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2461 |
if (n->in(MemNode::Address)->outcnt() > 1) { |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2462 |
// There are multiple users of the same address so it might be |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2463 |
// possible to eliminate some of the StoreCMs |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2464 |
Node* mem = n->in(MemNode::Memory); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2465 |
Node* adr = n->in(MemNode::Address); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2466 |
Node* val = n->in(MemNode::ValueIn); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2467 |
Node* prev = n; |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2468 |
bool done = false; |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2469 |
// Walk the chain of StoreCMs eliminating ones that match. As |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2470 |
// long as it's a chain of single users then the optimization is |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2471 |
// safe. Eliminating partially redundant StoreCMs would require |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2472 |
// cloning copies down the other paths. |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2473 |
while (mem->Opcode() == Op_StoreCM && mem->outcnt() == 1 && !done) { |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2474 |
if (adr == mem->in(MemNode::Address) && |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2475 |
val == mem->in(MemNode::ValueIn)) { |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2476 |
// redundant StoreCM |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2477 |
if (mem->req() > MemNode::OopStore) { |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2478 |
// Hasn't been processed by this code yet. |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2479 |
n->add_prec(mem->in(MemNode::OopStore)); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2480 |
} else { |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2481 |
// Already converted to precedence edge |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2482 |
for (uint i = mem->req(); i < mem->len(); i++) { |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2483 |
// Accumulate any precedence edges |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2484 |
if (mem->in(i) != NULL) { |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2485 |
n->add_prec(mem->in(i)); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2486 |
} |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2487 |
} |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2488 |
// Everything above this point has been processed. |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2489 |
done = true; |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2490 |
} |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2491 |
// Eliminate the previous StoreCM |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2492 |
prev->set_req(MemNode::Memory, mem->in(MemNode::Memory)); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2493 |
assert(mem->outcnt() == 0, "should be dead"); |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2494 |
mem->disconnect_inputs(NULL, this); |
9175
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2495 |
} else { |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2496 |
prev = mem; |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2497 |
} |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2498 |
mem = prev->in(MemNode::Memory); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2499 |
} |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2500 |
} |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2501 |
} |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2502 |
|
1 | 2503 |
//------------------------------final_graph_reshaping_impl---------------------- |
2504 |
// Implement items 1-5 from final_graph_reshaping below. |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2505 |
void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) { |
1 | 2506 |
|
594
9f4474e5dbaf
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
590
diff
changeset
|
2507 |
if ( n->outcnt() == 0 ) return; // dead node |
1 | 2508 |
uint nop = n->Opcode(); |
2509 |
||
2510 |
// Check for 2-input instruction with "last use" on right input. |
|
2511 |
// Swap to left input. Implements item (2). |
|
2512 |
if( n->req() == 3 && // two-input instruction |
|
2513 |
n->in(1)->outcnt() > 1 && // left use is NOT a last use |
|
2514 |
(!n->in(1)->is_Phi() || n->in(1)->in(2) != n) && // it is not data loop |
|
2515 |
n->in(2)->outcnt() == 1 &&// right use IS a last use |
|
2516 |
!n->in(2)->is_Con() ) { // right use is not a constant |
|
2517 |
// Check for commutative opcode |
|
2518 |
switch( nop ) { |
|
2519 |
case Op_AddI: case Op_AddF: case Op_AddD: case Op_AddL: |
|
2520 |
case Op_MaxI: case Op_MinI: |
|
2521 |
case Op_MulI: case Op_MulF: case Op_MulD: case Op_MulL: |
|
2522 |
case Op_AndL: case Op_XorL: case Op_OrL: |
|
2523 |
case Op_AndI: case Op_XorI: case Op_OrI: { |
|
2524 |
// Move "last use" input to left by swapping inputs |
|
2525 |
n->swap_edges(1, 2); |
|
2526 |
break; |
|
2527 |
} |
|
2528 |
default: |
|
2529 |
break; |
|
2530 |
} |
|
2531 |
} |
|
2532 |
||
5889 | 2533 |
#ifdef ASSERT |
2534 |
if( n->is_Mem() ) { |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2535 |
int alias_idx = get_alias_index(n->as_Mem()->adr_type()); |
5889 | 2536 |
assert( n->in(0) != NULL || alias_idx != Compile::AliasIdxRaw || |
2537 |
// oop will be recorded in oop map if load crosses safepoint |
|
2538 |
n->is_Load() && (n->as_Load()->bottom_type()->isa_oopptr() || |
|
2539 |
LoadNode::is_immutable_value(n->in(MemNode::Address))), |
|
2540 |
"raw memory operations should have control edge"); |
|
2541 |
} |
|
2542 |
#endif |
|
1 | 2543 |
// Count FPU ops and common calls, implements item (3) |
2544 |
switch( nop ) { |
|
2545 |
// Count all float operations that may use FPU |
|
2546 |
case Op_AddF: |
|
2547 |
case Op_SubF: |
|
2548 |
case Op_MulF: |
|
2549 |
case Op_DivF: |
|
2550 |
case Op_NegF: |
|
2551 |
case Op_ModF: |
|
2552 |
case Op_ConvI2F: |
|
2553 |
case Op_ConF: |
|
2554 |
case Op_CmpF: |
|
2555 |
case Op_CmpF3: |
|
2556 |
// case Op_ConvL2F: // longs are split into 32-bit halves |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2557 |
frc.inc_float_count(); |
1 | 2558 |
break; |
2559 |
||
2560 |
case Op_ConvF2D: |
|
2561 |
case Op_ConvD2F: |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2562 |
frc.inc_float_count(); |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2563 |
frc.inc_double_count(); |
1 | 2564 |
break; |
2565 |
||
2566 |
// Count all double operations that may use FPU |
|
2567 |
case Op_AddD: |
|
2568 |
case Op_SubD: |
|
2569 |
case Op_MulD: |
|
2570 |
case Op_DivD: |
|
2571 |
case Op_NegD: |
|
2572 |
case Op_ModD: |
|
2573 |
case Op_ConvI2D: |
|
2574 |
case Op_ConvD2I: |
|
2575 |
// case Op_ConvL2D: // handled by leaf call |
|
2576 |
// case Op_ConvD2L: // handled by leaf call |
|
2577 |
case Op_ConD: |
|
2578 |
case Op_CmpD: |
|
2579 |
case Op_CmpD3: |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2580 |
frc.inc_double_count(); |
1 | 2581 |
break; |
2582 |
case Op_Opaque1: // Remove Opaque Nodes before matching |
|
2583 |
case Op_Opaque2: // Remove Opaque Nodes before matching |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2584 |
n->subsume_by(n->in(1), this); |
1 | 2585 |
break; |
2586 |
case Op_CallStaticJava: |
|
2587 |
case Op_CallJava: |
|
2588 |
case Op_CallDynamicJava: |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2589 |
frc.inc_java_call_count(); // Count java call site; |
1 | 2590 |
case Op_CallRuntime: |
2591 |
case Op_CallLeaf: |
|
2592 |
case Op_CallLeafNoFP: { |
|
2593 |
assert( n->is_Call(), "" ); |
|
2594 |
CallNode *call = n->as_Call(); |
|
2595 |
// Count call sites where the FP mode bit would have to be flipped. |
|
2596 |
// Do not count uncommon runtime calls: |
|
2597 |
// uncommon_trap, _complete_monitor_locking, _complete_monitor_unlocking, |
|
2598 |
// _new_Java, _new_typeArray, _new_objArray, _rethrow_Java, ... |
|
2599 |
if( !call->is_CallStaticJava() || !call->as_CallStaticJava()->_name ) { |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2600 |
frc.inc_call_count(); // Count the call site |
1 | 2601 |
} else { // See if uncommon argument is shared |
2602 |
Node *n = call->in(TypeFunc::Parms); |
|
2603 |
int nop = n->Opcode(); |
|
2604 |
// Clone shared simple arguments to uncommon calls, item (1). |
|
2605 |
if( n->outcnt() > 1 && |
|
2606 |
!n->is_Proj() && |
|
2607 |
nop != Op_CreateEx && |
|
2608 |
nop != Op_CheckCastPP && |
|
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2609 |
nop != Op_DecodeN && |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2610 |
nop != Op_DecodeNKlass && |
1 | 2611 |
!n->is_Mem() ) { |
2612 |
Node *x = n->clone(); |
|
2613 |
call->set_req( TypeFunc::Parms, x ); |
|
2614 |
} |
|
2615 |
} |
|
2616 |
break; |
|
2617 |
} |
|
2618 |
||
2619 |
case Op_StoreD: |
|
2620 |
case Op_LoadD: |
|
2621 |
case Op_LoadD_unaligned: |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2622 |
frc.inc_double_count(); |
1 | 2623 |
goto handle_mem; |
2624 |
case Op_StoreF: |
|
2625 |
case Op_LoadF: |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2626 |
frc.inc_float_count(); |
1 | 2627 |
goto handle_mem; |
2628 |
||
9175
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2629 |
case Op_StoreCM: |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2630 |
{ |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2631 |
// Convert OopStore dependence into precedence edge |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2632 |
Node* prec = n->in(MemNode::OopStore); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2633 |
n->del_req(MemNode::OopStore); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2634 |
n->add_prec(prec); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2635 |
eliminate_redundant_card_marks(n); |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2636 |
} |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2637 |
|
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2638 |
// fall through |
80221fe09772
7032963: StoreCM shouldn't participate in store elimination
never
parents:
8725
diff
changeset
|
2639 |
|
1 | 2640 |
case Op_StoreB: |
2641 |
case Op_StoreC: |
|
2642 |
case Op_StorePConditional: |
|
2643 |
case Op_StoreI: |
|
2644 |
case Op_StoreL: |
|
1500
bea9a90f3e8f
6462850: generate biased locking code in C2 ideal graph
kvn
parents:
1498
diff
changeset
|
2645 |
case Op_StoreIConditional: |
1 | 2646 |
case Op_StoreLConditional: |
2647 |
case Op_CompareAndSwapI: |
|
2648 |
case Op_CompareAndSwapL: |
|
2649 |
case Op_CompareAndSwapP: |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
2650 |
case Op_CompareAndSwapN: |
13886
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
13883
diff
changeset
|
2651 |
case Op_GetAndAddI: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
13883
diff
changeset
|
2652 |
case Op_GetAndAddL: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
13883
diff
changeset
|
2653 |
case Op_GetAndSetI: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
13883
diff
changeset
|
2654 |
case Op_GetAndSetL: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
13883
diff
changeset
|
2655 |
case Op_GetAndSetP: |
8d82c4dfa722
7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents:
13883
diff
changeset
|
2656 |
case Op_GetAndSetN: |
1 | 2657 |
case Op_StoreP: |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
2658 |
case Op_StoreN: |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2659 |
case Op_StoreNKlass: |
1 | 2660 |
case Op_LoadB: |
2150 | 2661 |
case Op_LoadUB: |
2022
28ce8115a91d
6796746: rename LoadC (char) opcode class to LoadUS (unsigned short)
twisti
parents:
1679
diff
changeset
|
2662 |
case Op_LoadUS: |
1 | 2663 |
case Op_LoadI: |
2664 |
case Op_LoadKlass: |
|
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
2665 |
case Op_LoadNKlass: |
1 | 2666 |
case Op_LoadL: |
2667 |
case Op_LoadL_unaligned: |
|
2668 |
case Op_LoadPLocked: |
|
2669 |
case Op_LoadP: |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
347
diff
changeset
|
2670 |
case Op_LoadN: |
1 | 2671 |
case Op_LoadRange: |
2672 |
case Op_LoadS: { |
|
2673 |
handle_mem: |
|
2674 |
#ifdef ASSERT |
|
2675 |
if( VerifyOptoOopOffsets ) { |
|
2676 |
assert( n->is_Mem(), "" ); |
|
2677 |
MemNode *mem = (MemNode*)n; |
|
2678 |
// Check to see if address types have grounded out somehow. |
|
2679 |
const TypeInstPtr *tp = mem->in(MemNode::Address)->bottom_type()->isa_instptr(); |
|
2680 |
assert( !tp || oop_offset_is_sane(tp), "" ); |
|
2681 |
} |
|
2682 |
#endif |
|
2683 |
break; |
|
2684 |
} |
|
2685 |
||
2686 |
case Op_AddP: { // Assert sane base pointers |
|
608
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2687 |
Node *addp = n->in(AddPNode::Address); |
1 | 2688 |
assert( !addp->is_AddP() || |
2689 |
addp->in(AddPNode::Base)->is_top() || // Top OK for allocation |
|
2690 |
addp->in(AddPNode::Base) == n->in(AddPNode::Base), |
|
2691 |
"Base pointers must match" ); |
|
608
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2692 |
#ifdef _LP64 |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19717
diff
changeset
|
2693 |
if ((UseCompressedOops || UseCompressedClassPointers) && |
608
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2694 |
addp->Opcode() == Op_ConP && |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2695 |
addp == n->in(AddPNode::Base) && |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2696 |
n->in(AddPNode::Offset)->is_Con()) { |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2697 |
// Use addressing with narrow klass to load with offset on x86. |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2698 |
// On sparc loading 32-bits constant and decoding it have less |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2699 |
// instructions (4) then load 64-bits constant (7). |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2700 |
// Do this transformation here since IGVN will convert ConN back to ConP. |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2701 |
const Type* t = addp->bottom_type(); |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2702 |
if (t->isa_oopptr() || t->isa_klassptr()) { |
608
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2703 |
Node* nn = NULL; |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2704 |
|
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2705 |
int op = t->isa_oopptr() ? Op_ConN : Op_ConNKlass; |
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2706 |
|
608
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2707 |
// Look for existing ConN node of the same exact type. |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2708 |
Node* r = root(); |
608
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2709 |
uint cnt = r->outcnt(); |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2710 |
for (uint i = 0; i < cnt; i++) { |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2711 |
Node* m = r->raw_out(i); |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2712 |
if (m!= NULL && m->Opcode() == op && |
767
64fb1fd7186d
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
608
diff
changeset
|
2713 |
m->bottom_type()->make_ptr() == t) { |
608
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2714 |
nn = m; |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2715 |
break; |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2716 |
} |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2717 |
} |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2718 |
if (nn != NULL) { |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2719 |
// Decode a narrow oop to match address |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2720 |
// [R12 + narrow_oop_reg<<3 + offset] |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2721 |
if (t->isa_oopptr()) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2722 |
nn = new (this) DecodeNNode(nn, t); |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2723 |
} else { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2724 |
nn = new (this) DecodeNKlassNode(nn, t); |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2725 |
} |
608
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2726 |
n->set_req(AddPNode::Base, nn); |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2727 |
n->set_req(AddPNode::Address, nn); |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2728 |
if (addp->outcnt() == 0) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2729 |
addp->disconnect_inputs(NULL, this); |
608
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2730 |
} |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2731 |
} |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2732 |
} |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2733 |
} |
fe8c5fbbc54e
6709093: Compressed Oops: reduce size of compiled methods
kvn
parents:
594
diff
changeset
|
2734 |
#endif |
1 | 2735 |
break; |
2736 |
} |
|
2737 |
||
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
2738 |
#ifdef _LP64 |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2739 |
case Op_CastPP: |
5698
091095915ee6
6954029: Improve implicit null check generation with compressed oops
kvn
parents:
5353
diff
changeset
|
2740 |
if (n->in(1)->is_DecodeN() && Matcher::gen_narrow_oop_implicit_null_checks()) { |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2741 |
Node* in1 = n->in(1); |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2742 |
const Type* t = n->bottom_type(); |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2743 |
Node* new_in1 = in1->clone(); |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2744 |
new_in1->as_DecodeN()->set_type(t); |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2745 |
|
5698
091095915ee6
6954029: Improve implicit null check generation with compressed oops
kvn
parents:
5353
diff
changeset
|
2746 |
if (!Matcher::narrow_oop_use_complex_address()) { |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2747 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2748 |
// x86, ARM and friends can handle 2 adds in addressing mode |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2749 |
// and Matcher can fold a DecodeN node into address by using |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2750 |
// a narrow oop directly and do implicit NULL check in address: |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2751 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2752 |
// [R12 + narrow_oop_reg<<3 + offset] |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2753 |
// NullCheck narrow_oop_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2754 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2755 |
// On other platforms (Sparc) we have to keep new DecodeN node and |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2756 |
// use it to do implicit NULL check in address: |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2757 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2758 |
// decode_not_null narrow_oop_reg, base_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2759 |
// [base_reg + offset] |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2760 |
// NullCheck base_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2761 |
// |
2131 | 2762 |
// Pin the new DecodeN node to non-null path on these platform (Sparc) |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2763 |
// to keep the information to which NULL check the new DecodeN node |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2764 |
// corresponds to use it as value in implicit_null_check(). |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2765 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2766 |
new_in1->set_req(0, n->in(0)); |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2767 |
} |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2768 |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2769 |
n->subsume_by(new_in1, this); |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2770 |
if (in1->outcnt() == 0) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2771 |
in1->disconnect_inputs(NULL, this); |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2772 |
} |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2773 |
} |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2774 |
break; |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2775 |
|
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
2776 |
case Op_CmpP: |
594
9f4474e5dbaf
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
590
diff
changeset
|
2777 |
// Do this transformation here to preserve CmpPNode::sub() and |
9f4474e5dbaf
6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents:
590
diff
changeset
|
2778 |
// other TypePtr related Ideal optimizations (for example, ptr nullness). |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2779 |
if (n->in(1)->is_DecodeNarrowPtr() || n->in(2)->is_DecodeNarrowPtr()) { |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2780 |
Node* in1 = n->in(1); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2781 |
Node* in2 = n->in(2); |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2782 |
if (!in1->is_DecodeNarrowPtr()) { |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2783 |
in2 = in1; |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2784 |
in1 = n->in(2); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2785 |
} |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2786 |
assert(in1->is_DecodeNarrowPtr(), "sanity"); |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2787 |
|
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2788 |
Node* new_in2 = NULL; |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2789 |
if (in2->is_DecodeNarrowPtr()) { |
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2790 |
assert(in2->Opcode() == in1->Opcode(), "must be same node type"); |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2791 |
new_in2 = in2->in(1); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2792 |
} else if (in2->Opcode() == Op_ConP) { |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2793 |
const Type* t = in2->bottom_type(); |
5698
091095915ee6
6954029: Improve implicit null check generation with compressed oops
kvn
parents:
5353
diff
changeset
|
2794 |
if (t == TypePtr::NULL_PTR) { |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2795 |
assert(in1->is_DecodeN(), "compare klass to null?"); |
5698
091095915ee6
6954029: Improve implicit null check generation with compressed oops
kvn
parents:
5353
diff
changeset
|
2796 |
// Don't convert CmpP null check into CmpN if compressed |
091095915ee6
6954029: Improve implicit null check generation with compressed oops
kvn
parents:
5353
diff
changeset
|
2797 |
// oops implicit null check is not generated. |
091095915ee6
6954029: Improve implicit null check generation with compressed oops
kvn
parents:
5353
diff
changeset
|
2798 |
// This will allow to generate normal oop implicit null check. |
091095915ee6
6954029: Improve implicit null check generation with compressed oops
kvn
parents:
5353
diff
changeset
|
2799 |
if (Matcher::gen_narrow_oop_implicit_null_checks()) |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2800 |
new_in2 = ConNode::make(this, TypeNarrowOop::NULL_PTR); |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2801 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2802 |
// This transformation together with CastPP transformation above |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2803 |
// will generated code for implicit NULL checks for compressed oops. |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2804 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2805 |
// The original code after Optimize() |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2806 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2807 |
// LoadN memory, narrow_oop_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2808 |
// decode narrow_oop_reg, base_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2809 |
// CmpP base_reg, NULL |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2810 |
// CastPP base_reg // NotNull |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2811 |
// Load [base_reg + offset], val_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2812 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2813 |
// after these transformations will be |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2814 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2815 |
// LoadN memory, narrow_oop_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2816 |
// CmpN narrow_oop_reg, NULL |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2817 |
// decode_not_null narrow_oop_reg, base_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2818 |
// Load [base_reg + offset], val_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2819 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2820 |
// and the uncommon path (== NULL) will use narrow_oop_reg directly |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2821 |
// since narrow oops can be used in debug info now (see the code in |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2822 |
// final_graph_reshaping_walk()). |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2823 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2824 |
// At the end the code will be matched to |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2825 |
// on x86: |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2826 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2827 |
// Load_narrow_oop memory, narrow_oop_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2828 |
// Load [R12 + narrow_oop_reg<<3 + offset], val_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2829 |
// NullCheck narrow_oop_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2830 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2831 |
// and on sparc: |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2832 |
// |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2833 |
// Load_narrow_oop memory, narrow_oop_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2834 |
// decode_not_null narrow_oop_reg, base_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2835 |
// Load [base_reg + offset], val_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2836 |
// NullCheck base_reg |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2837 |
// |
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
2838 |
} else if (t->isa_oopptr()) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2839 |
new_in2 = ConNode::make(this, t->make_narrowoop()); |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2840 |
} else if (t->isa_klassptr()) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2841 |
new_in2 = ConNode::make(this, t->make_narrowklass()); |
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
2842 |
} |
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
2843 |
} |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2844 |
if (new_in2 != NULL) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2845 |
Node* cmpN = new (this) CmpNNode(in1->in(1), new_in2); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2846 |
n->subsume_by(cmpN, this); |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2847 |
if (in1->outcnt() == 0) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2848 |
in1->disconnect_inputs(NULL, this); |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2849 |
} |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2850 |
if (in2->outcnt() == 0) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2851 |
in2->disconnect_inputs(NULL, this); |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
2852 |
} |
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
2853 |
} |
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
2854 |
} |
1055
f4fb9fb08038
6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents:
961
diff
changeset
|
2855 |
break; |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2856 |
|
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2857 |
case Op_DecodeN: |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2858 |
case Op_DecodeNKlass: |
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2859 |
assert(!n->in(1)->is_EncodeNarrowPtr(), "should be optimized out"); |
5698
091095915ee6
6954029: Improve implicit null check generation with compressed oops
kvn
parents:
5353
diff
changeset
|
2860 |
// DecodeN could be pinned when it can't be fold into |
1679
07b65f7cd0aa
6787050: assert(n->in(0) == 0L,"no control") with UseCompressedOops on sparcv9
kvn
parents:
1677
diff
changeset
|
2861 |
// an address expression, see the code for Op_CastPP above. |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2862 |
assert(n->in(0) == NULL || (UseCompressedOops && !Matcher::narrow_oop_use_complex_address()), "no control"); |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2863 |
break; |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2864 |
|
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2865 |
case Op_EncodeP: |
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2866 |
case Op_EncodePKlass: { |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2867 |
Node* in1 = n->in(1); |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2868 |
if (in1->is_DecodeNarrowPtr()) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2869 |
n->subsume_by(in1->in(1), this); |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2870 |
} else if (in1->Opcode() == Op_ConP) { |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2871 |
const Type* t = in1->bottom_type(); |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2872 |
if (t == TypePtr::NULL_PTR) { |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2873 |
assert(t->isa_oopptr(), "null klass?"); |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2874 |
n->subsume_by(ConNode::make(this, TypeNarrowOop::NULL_PTR), this); |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2875 |
} else if (t->isa_oopptr()) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2876 |
n->subsume_by(ConNode::make(this, t->make_narrowoop()), this); |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2877 |
} else if (t->isa_klassptr()) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2878 |
n->subsume_by(ConNode::make(this, t->make_narrowklass()), this); |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2879 |
} |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2880 |
} |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2881 |
if (in1->outcnt() == 0) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2882 |
in1->disconnect_inputs(NULL, this); |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2883 |
} |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2884 |
break; |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2885 |
} |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2886 |
|
4450
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2887 |
case Op_Proj: { |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2888 |
if (OptimizeStringConcat) { |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2889 |
ProjNode* p = n->as_Proj(); |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2890 |
if (p->_is_io_use) { |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2891 |
// Separate projections were used for the exception path which |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2892 |
// are normally removed by a late inline. If it wasn't inlined |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2893 |
// then they will hang around and should just be replaced with |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2894 |
// the original one. |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2895 |
Node* proj = NULL; |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2896 |
// Replace with just one |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2897 |
for (SimpleDUIterator i(p->in(0)); i.has_next(); i.next()) { |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2898 |
Node *use = i.get(); |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2899 |
if (use->is_Proj() && p != use && use->as_Proj()->_con == p->_con) { |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2900 |
proj = use; |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2901 |
break; |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2902 |
} |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2903 |
} |
11435 | 2904 |
assert(proj != NULL, "must be found"); |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2905 |
p->subsume_by(proj, this); |
4450
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2906 |
} |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2907 |
} |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2908 |
break; |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2909 |
} |
6d700b859b3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
3684
diff
changeset
|
2910 |
|
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2911 |
case Op_Phi: |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
2912 |
if (n->as_Phi()->bottom_type()->isa_narrowoop() || n->as_Phi()->bottom_type()->isa_narrowklass()) { |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2913 |
// The EncodeP optimization may create Phi with the same edges |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2914 |
// for all paths. It is not handled well by Register Allocator. |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2915 |
Node* unique_in = n->in(1); |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2916 |
assert(unique_in != NULL, ""); |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2917 |
uint cnt = n->req(); |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2918 |
for (uint i = 2; i < cnt; i++) { |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2919 |
Node* m = n->in(i); |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2920 |
assert(m != NULL, ""); |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2921 |
if (unique_in != m) |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2922 |
unique_in = NULL; |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2923 |
} |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2924 |
if (unique_in != NULL) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2925 |
n->subsume_by(unique_in, this); |
1400
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2926 |
} |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2927 |
} |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2928 |
break; |
afd034bb8c2e
6747051: Improve code and implicit null check generation for compressed oops
kvn
parents:
1399
diff
changeset
|
2929 |
|
590
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
2930 |
#endif |
2954744d7bba
6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents:
589
diff
changeset
|
2931 |
|
1 | 2932 |
case Op_ModI: |
2933 |
if (UseDivMod) { |
|
2934 |
// Check if a%b and a/b both exist |
|
2935 |
Node* d = n->find_similar(Op_DivI); |
|
2936 |
if (d) { |
|
2937 |
// Replace them with a fused divmod if supported |
|
2938 |
if (Matcher::has_match_rule(Op_DivModI)) { |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2939 |
DivModINode* divmod = DivModINode::make(this, n); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2940 |
d->subsume_by(divmod->div_proj(), this); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2941 |
n->subsume_by(divmod->mod_proj(), this); |
1 | 2942 |
} else { |
2943 |
// replace a%b with a-((a/b)*b) |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2944 |
Node* mult = new (this) MulINode(d, d->in(2)); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2945 |
Node* sub = new (this) SubINode(d->in(1), mult); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2946 |
n->subsume_by(sub, this); |
1 | 2947 |
} |
2948 |
} |
|
2949 |
} |
|
2950 |
break; |
|
2951 |
||
2952 |
case Op_ModL: |
|
2953 |
if (UseDivMod) { |
|
2954 |
// Check if a%b and a/b both exist |
|
2955 |
Node* d = n->find_similar(Op_DivL); |
|
2956 |
if (d) { |
|
2957 |
// Replace them with a fused divmod if supported |
|
2958 |
if (Matcher::has_match_rule(Op_DivModL)) { |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2959 |
DivModLNode* divmod = DivModLNode::make(this, n); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2960 |
d->subsume_by(divmod->div_proj(), this); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2961 |
n->subsume_by(divmod->mod_proj(), this); |
1 | 2962 |
} else { |
2963 |
// replace a%b with a-((a/b)*b) |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2964 |
Node* mult = new (this) MulLNode(d, d->in(2)); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2965 |
Node* sub = new (this) SubLNode(d->in(1), mult); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2966 |
n->subsume_by(sub, this); |
1 | 2967 |
} |
2968 |
} |
|
2969 |
} |
|
2970 |
break; |
|
2971 |
||
13104
657b387034fb
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
12957
diff
changeset
|
2972 |
case Op_LoadVector: |
657b387034fb
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
12957
diff
changeset
|
2973 |
case Op_StoreVector: |
1 | 2974 |
break; |
2975 |
||
2976 |
case Op_PackB: |
|
2977 |
case Op_PackS: |
|
2978 |
case Op_PackI: |
|
2979 |
case Op_PackF: |
|
2980 |
case Op_PackL: |
|
2981 |
case Op_PackD: |
|
2982 |
if (n->req()-1 > 2) { |
|
2983 |
// Replace many operand PackNodes with a binary tree for matching |
|
2984 |
PackNode* p = (PackNode*) n; |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2985 |
Node* btp = p->binary_tree_pack(this, 1, n->req()); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
2986 |
n->subsume_by(btp, this); |
1 | 2987 |
} |
2988 |
break; |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2989 |
case Op_Loop: |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2990 |
case Op_CountedLoop: |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2991 |
if (n->as_Loop()->is_inner_loop()) { |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2992 |
frc.inc_inner_loop_count(); |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2993 |
} |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
2994 |
break; |
8868
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
2995 |
case Op_LShiftI: |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
2996 |
case Op_RShiftI: |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
2997 |
case Op_URShiftI: |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
2998 |
case Op_LShiftL: |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
2999 |
case Op_RShiftL: |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3000 |
case Op_URShiftL: |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3001 |
if (Matcher::need_masked_shift_count) { |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3002 |
// The cpu's shift instructions don't restrict the count to the |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3003 |
// lower 5/6 bits. We need to do the masking ourselves. |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3004 |
Node* in2 = n->in(2); |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3005 |
juint mask = (n->bottom_type() == TypeInt::INT) ? (BitsPerInt - 1) : (BitsPerLong - 1); |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3006 |
const TypeInt* t = in2->find_int_type(); |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3007 |
if (t != NULL && t->is_con()) { |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3008 |
juint shift = t->get_con(); |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3009 |
if (shift > mask) { // Unsigned cmp |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3010 |
n->set_req(2, ConNode::make(this, TypeInt::make(shift & mask))); |
8868
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3011 |
} |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3012 |
} else { |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3013 |
if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3014 |
Node* shift = new (this) AndINode(in2, ConNode::make(this, TypeInt::make(mask))); |
8868
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3015 |
n->set_req(2, shift); |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3016 |
} |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3017 |
} |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3018 |
if (in2->outcnt() == 0) { // Remove dead node |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3019 |
in2->disconnect_inputs(NULL, this); |
8868
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3020 |
} |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3021 |
} |
1bae515b806b
7029017: Additional architecture support for c2 compiler
roland
parents:
8725
diff
changeset
|
3022 |
break; |
15874
57f16a8b609f
8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents:
15871
diff
changeset
|
3023 |
case Op_MemBarStoreStore: |
17383 | 3024 |
case Op_MemBarRelease: |
15874
57f16a8b609f
8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents:
15871
diff
changeset
|
3025 |
// Break the link with AllocateNode: it is no longer useful and |
57f16a8b609f
8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents:
15871
diff
changeset
|
3026 |
// confuses register allocation. |
57f16a8b609f
8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents:
15871
diff
changeset
|
3027 |
if (n->req() > MemBarNode::Precedent) { |
57f16a8b609f
8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents:
15871
diff
changeset
|
3028 |
n->set_req(MemBarNode::Precedent, top()); |
57f16a8b609f
8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents:
15871
diff
changeset
|
3029 |
} |
57f16a8b609f
8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents:
15871
diff
changeset
|
3030 |
break; |
20715
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3031 |
// Must set a control edge on all nodes that produce a FlagsProj |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3032 |
// so they can't escape the block that consumes the flags. |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3033 |
// Must also set the non throwing branch as the control |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3034 |
// for all nodes that depends on the result. Unless the node |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3035 |
// already have a control that isn't the control of the |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3036 |
// flag producer |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3037 |
case Op_FlagsProj: |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3038 |
{ |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3039 |
MathExactNode* math = (MathExactNode*) n->in(0); |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3040 |
Node* ctrl = math->control_node(); |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3041 |
Node* non_throwing = math->non_throwing_branch(); |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3042 |
math->set_req(0, ctrl); |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3043 |
|
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3044 |
Node* result = math->result_node(); |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3045 |
if (result != NULL) { |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3046 |
for (DUIterator_Fast jmax, j = result->fast_outs(jmax); j < jmax; j++) { |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3047 |
Node* out = result->fast_out(j); |
21096
3073d9608433
8026959: assert(!n->pinned() || n->is_MachConstantBase()) failed: only pinned MachConstantBase node is expected here
rbackman
parents:
21089
diff
changeset
|
3048 |
// Phi nodes shouldn't be moved. They would only match below if they |
3073d9608433
8026959: assert(!n->pinned() || n->is_MachConstantBase()) failed: only pinned MachConstantBase node is expected here
rbackman
parents:
21089
diff
changeset
|
3049 |
// had the same control as the MathExactNode. The only time that |
3073d9608433
8026959: assert(!n->pinned() || n->is_MachConstantBase()) failed: only pinned MachConstantBase node is expected here
rbackman
parents:
21089
diff
changeset
|
3050 |
// would happen is if the Phi is also an input to the MathExact |
21524
a354ac8e0de4
8027622: java.time.Instant.create failing since hs25-b56
rbackman
parents:
21099
diff
changeset
|
3051 |
// |
a354ac8e0de4
8027622: java.time.Instant.create failing since hs25-b56
rbackman
parents:
21099
diff
changeset
|
3052 |
// Cmp nodes shouldn't have control set at all. |
a354ac8e0de4
8027622: java.time.Instant.create failing since hs25-b56
rbackman
parents:
21099
diff
changeset
|
3053 |
if (out->is_Phi() || |
a354ac8e0de4
8027622: java.time.Instant.create failing since hs25-b56
rbackman
parents:
21099
diff
changeset
|
3054 |
out->is_Cmp()) { |
a354ac8e0de4
8027622: java.time.Instant.create failing since hs25-b56
rbackman
parents:
21099
diff
changeset
|
3055 |
continue; |
a354ac8e0de4
8027622: java.time.Instant.create failing since hs25-b56
rbackman
parents:
21099
diff
changeset
|
3056 |
} |
a354ac8e0de4
8027622: java.time.Instant.create failing since hs25-b56
rbackman
parents:
21099
diff
changeset
|
3057 |
|
a354ac8e0de4
8027622: java.time.Instant.create failing since hs25-b56
rbackman
parents:
21099
diff
changeset
|
3058 |
if (out->in(0) == NULL) { |
a354ac8e0de4
8027622: java.time.Instant.create failing since hs25-b56
rbackman
parents:
21099
diff
changeset
|
3059 |
out->set_req(0, non_throwing); |
a354ac8e0de4
8027622: java.time.Instant.create failing since hs25-b56
rbackman
parents:
21099
diff
changeset
|
3060 |
} else if (out->in(0) == ctrl) { |
a354ac8e0de4
8027622: java.time.Instant.create failing since hs25-b56
rbackman
parents:
21099
diff
changeset
|
3061 |
out->set_req(0, non_throwing); |
20715
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3062 |
} |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3063 |
} |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3064 |
} |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3065 |
} |
be1135dc1406
8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents:
20073
diff
changeset
|
3066 |
break; |
1 | 3067 |
default: |
3068 |
assert( !n->is_Call(), "" ); |
|
3069 |
assert( !n->is_Mem(), "" ); |
|
3070 |
break; |
|
3071 |
} |
|
374 | 3072 |
|
3073 |
// Collect CFG split points |
|
3074 |
if (n->is_MultiBranch()) |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3075 |
frc._tests.push(n); |
1 | 3076 |
} |
3077 |
||
3078 |
//------------------------------final_graph_reshaping_walk--------------------- |
|
3079 |
// Replacing Opaque nodes with their input in final_graph_reshaping_impl(), |
|
3080 |
// requires that the walk visits a node's inputs before visiting the node. |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3081 |
void Compile::final_graph_reshaping_walk( Node_Stack &nstack, Node *root, Final_Reshape_Counts &frc ) { |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3082 |
ResourceArea *area = Thread::current()->resource_area(); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3083 |
Unique_Node_List sfpt(area); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3084 |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3085 |
frc._visited.set(root->_idx); // first, mark node as visited |
1 | 3086 |
uint cnt = root->req(); |
3087 |
Node *n = root; |
|
3088 |
uint i = 0; |
|
3089 |
while (true) { |
|
3090 |
if (i < cnt) { |
|
3091 |
// Place all non-visited non-null inputs onto stack |
|
3092 |
Node* m = n->in(i); |
|
3093 |
++i; |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3094 |
if (m != NULL && !frc._visited.test_set(m->_idx)) { |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3095 |
if (m->is_SafePoint() && m->as_SafePoint()->jvms() != NULL) |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3096 |
sfpt.push(m); |
1 | 3097 |
cnt = m->req(); |
3098 |
nstack.push(n, i); // put on stack parent and next input's index |
|
3099 |
n = m; |
|
3100 |
i = 0; |
|
3101 |
} |
|
3102 |
} else { |
|
3103 |
// Now do post-visit work |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3104 |
final_graph_reshaping_impl( n, frc ); |
1 | 3105 |
if (nstack.is_empty()) |
3106 |
break; // finished |
|
3107 |
n = nstack.node(); // Get node from stack |
|
3108 |
cnt = n->req(); |
|
3109 |
i = nstack.index(); |
|
3110 |
nstack.pop(); // Shift to the next node on stack |
|
3111 |
} |
|
3112 |
} |
|
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3113 |
|
5698
091095915ee6
6954029: Improve implicit null check generation with compressed oops
kvn
parents:
5353
diff
changeset
|
3114 |
// Skip next transformation if compressed oops are not used. |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
3115 |
if ((UseCompressedOops && !Matcher::gen_narrow_oop_implicit_null_checks()) || |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19717
diff
changeset
|
3116 |
(!UseCompressedOops && !UseCompressedClassPointers)) |
5698
091095915ee6
6954029: Improve implicit null check generation with compressed oops
kvn
parents:
5353
diff
changeset
|
3117 |
return; |
091095915ee6
6954029: Improve implicit null check generation with compressed oops
kvn
parents:
5353
diff
changeset
|
3118 |
|
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
3119 |
// Go over safepoints nodes to skip DecodeN/DecodeNKlass nodes for debug edges. |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3120 |
// It could be done for an uncommon traps or any safepoints/calls |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
3121 |
// if the DecodeN/DecodeNKlass node is referenced only in a debug info. |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3122 |
while (sfpt.size() > 0) { |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3123 |
n = sfpt.pop(); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3124 |
JVMState *jvms = n->as_SafePoint()->jvms(); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3125 |
assert(jvms != NULL, "sanity"); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3126 |
int start = jvms->debug_start(); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3127 |
int end = n->req(); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3128 |
bool is_uncommon = (n->is_CallStaticJava() && |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3129 |
n->as_CallStaticJava()->uncommon_trap_request() != 0); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3130 |
for (int j = start; j < end; j++) { |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3131 |
Node* in = n->in(j); |
13969
d2a189b83b87
7054512: Compress class pointers after perm gen removal
roland
parents:
13964
diff
changeset
|
3132 |
if (in->is_DecodeNarrowPtr()) { |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3133 |
bool safe_to_skip = true; |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3134 |
if (!is_uncommon ) { |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3135 |
// Is it safe to skip? |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3136 |
for (uint i = 0; i < in->outcnt(); i++) { |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3137 |
Node* u = in->raw_out(i); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3138 |
if (!u->is_SafePoint() || |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3139 |
u->is_Call() && u->as_Call()->has_non_debug_use(n)) { |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3140 |
safe_to_skip = false; |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3141 |
} |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3142 |
} |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3143 |
} |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3144 |
if (safe_to_skip) { |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3145 |
n->set_req(j, in->in(1)); |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3146 |
} |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3147 |
if (in->outcnt() == 0) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3148 |
in->disconnect_inputs(NULL, this); |
1135
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3149 |
} |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3150 |
} |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3151 |
} |
9487203e5789
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
1055
diff
changeset
|
3152 |
} |
1 | 3153 |
} |
3154 |
||
3155 |
//------------------------------final_graph_reshaping-------------------------- |
|
3156 |
// Final Graph Reshaping. |
|
3157 |
// |
|
3158 |
// (1) Clone simple inputs to uncommon calls, so they can be scheduled late |
|
3159 |
// and not commoned up and forced early. Must come after regular |
|
3160 |
// optimizations to avoid GVN undoing the cloning. Clone constant |
|
3161 |
// inputs to Loop Phis; these will be split by the allocator anyways. |
|
3162 |
// Remove Opaque nodes. |
|
3163 |
// (2) Move last-uses by commutative operations to the left input to encourage |
|
3164 |
// Intel update-in-place two-address operations and better register usage |
|
3165 |
// on RISCs. Must come after regular optimizations to avoid GVN Ideal |
|
3166 |
// calls canonicalizing them back. |
|
3167 |
// (3) Count the number of double-precision FP ops, single-precision FP ops |
|
3168 |
// and call sites. On Intel, we can get correct rounding either by |
|
3169 |
// forcing singles to memory (requires extra stores and loads after each |
|
3170 |
// FP bytecode) or we can set a rounding mode bit (requires setting and |
|
3171 |
// clearing the mode bit around call sites). The mode bit is only used |
|
3172 |
// if the relative frequency of single FP ops to calls is low enough. |
|
3173 |
// This is a key transform for SPEC mpeg_audio. |
|
3174 |
// (4) Detect infinite loops; blobs of code reachable from above but not |
|
3175 |
// below. Several of the Code_Gen algorithms fail on such code shapes, |
|
3176 |
// so we simply bail out. Happens a lot in ZKM.jar, but also happens |
|
3177 |
// from time to time in other codes (such as -Xcomp finalizer loops, etc). |
|
3178 |
// Detection is by looking for IfNodes where only 1 projection is |
|
3179 |
// reachable from below or CatchNodes missing some targets. |
|
3180 |
// (5) Assert for insane oop offsets in debug mode. |
|
3181 |
||
3182 |
bool Compile::final_graph_reshaping() { |
|
3183 |
// an infinite loop may have been eliminated by the optimizer, |
|
3184 |
// in which case the graph will be empty. |
|
3185 |
if (root()->req() == 1) { |
|
3186 |
record_method_not_compilable("trivial infinite loop"); |
|
3187 |
return true; |
|
3188 |
} |
|
3189 |
||
15618
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3190 |
// Expensive nodes have their control input set to prevent the GVN |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3191 |
// from freely commoning them. There's no GVN beyond this point so |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3192 |
// no need to keep the control input. We want the expensive nodes to |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3193 |
// be freely moved to the least frequent code path by gcm. |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3194 |
assert(OptimizeExpensiveOps || expensive_count() == 0, "optimization off but list non empty?"); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3195 |
for (int i = 0; i < expensive_count(); i++) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3196 |
_expensive_nodes->at(i)->set_req(0, NULL); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3197 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3198 |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3199 |
Final_Reshape_Counts frc; |
1 | 3200 |
|
3201 |
// Visit everybody reachable! |
|
3202 |
// Allocate stack of size C->unique()/2 to avoid frequent realloc |
|
3203 |
Node_Stack nstack(unique() >> 1); |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3204 |
final_graph_reshaping_walk(nstack, root(), frc); |
1 | 3205 |
|
3206 |
// Check for unreachable (from below) code (i.e., infinite loops). |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3207 |
for( uint i = 0; i < frc._tests.size(); i++ ) { |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3208 |
MultiBranchNode *n = frc._tests[i]->as_MultiBranch(); |
374 | 3209 |
// Get number of CFG targets. |
1 | 3210 |
// Note that PCTables include exception targets after calls. |
374 | 3211 |
uint required_outcnt = n->required_outcnt(); |
3212 |
if (n->outcnt() != required_outcnt) { |
|
1 | 3213 |
// Check for a few special cases. Rethrow Nodes never take the |
3214 |
// 'fall-thru' path, so expected kids is 1 less. |
|
3215 |
if (n->is_PCTable() && n->in(0) && n->in(0)->in(0)) { |
|
3216 |
if (n->in(0)->in(0)->is_Call()) { |
|
3217 |
CallNode *call = n->in(0)->in(0)->as_Call(); |
|
3218 |
if (call->entry_point() == OptoRuntime::rethrow_stub()) { |
|
374 | 3219 |
required_outcnt--; // Rethrow always has 1 less kid |
1 | 3220 |
} else if (call->req() > TypeFunc::Parms && |
3221 |
call->is_CallDynamicJava()) { |
|
3222 |
// Check for null receiver. In such case, the optimizer has |
|
3223 |
// detected that the virtual call will always result in a null |
|
3224 |
// pointer exception. The fall-through projection of this CatchNode |
|
3225 |
// will not be populated. |
|
3226 |
Node *arg0 = call->in(TypeFunc::Parms); |
|
3227 |
if (arg0->is_Type() && |
|
3228 |
arg0->as_Type()->type()->higher_equal(TypePtr::NULL_PTR)) { |
|
374 | 3229 |
required_outcnt--; |
1 | 3230 |
} |
3231 |
} else if (call->entry_point() == OptoRuntime::new_array_Java() && |
|
3232 |
call->req() > TypeFunc::Parms+1 && |
|
3233 |
call->is_CallStaticJava()) { |
|
3234 |
// Check for negative array length. In such case, the optimizer has |
|
3235 |
// detected that the allocation attempt will always result in an |
|
3236 |
// exception. There is no fall-through projection of this CatchNode . |
|
3237 |
Node *arg1 = call->in(TypeFunc::Parms+1); |
|
3238 |
if (arg1->is_Type() && |
|
3239 |
arg1->as_Type()->type()->join(TypeInt::POS)->empty()) { |
|
374 | 3240 |
required_outcnt--; |
1 | 3241 |
} |
3242 |
} |
|
3243 |
} |
|
3244 |
} |
|
374 | 3245 |
// Recheck with a better notion of 'required_outcnt' |
3246 |
if (n->outcnt() != required_outcnt) { |
|
1 | 3247 |
record_method_not_compilable("malformed control flow"); |
3248 |
return true; // Not all targets reachable! |
|
3249 |
} |
|
3250 |
} |
|
3251 |
// Check that I actually visited all kids. Unreached kids |
|
3252 |
// must be infinite loops. |
|
3253 |
for (DUIterator_Fast jmax, j = n->fast_outs(jmax); j < jmax; j++) |
|
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3254 |
if (!frc._visited.test(n->fast_out(j)->_idx)) { |
1 | 3255 |
record_method_not_compilable("infinite loop"); |
3256 |
return true; // Found unvisited kid; must be unreach |
|
3257 |
} |
|
3258 |
} |
|
3259 |
||
3260 |
// If original bytecodes contained a mixture of floats and doubles |
|
3261 |
// check if the optimizer has made it homogenous, item (3). |
|
3684
0b6d63791583
6873777: FPU control word optimization still performed with SSE
never
parents:
3676
diff
changeset
|
3262 |
if( Use24BitFPMode && Use24BitFP && UseSSE == 0 && |
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3263 |
frc.get_float_count() > 32 && |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3264 |
frc.get_double_count() == 0 && |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3265 |
(10 * frc.get_call_count() < frc.get_float_count()) ) { |
1 | 3266 |
set_24_bit_selection_and_mode( false, true ); |
3267 |
} |
|
3268 |
||
3276
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3269 |
set_java_calls(frc.get_java_call_count()); |
bda7d4532054
6860599: nodes limit could be reached during Output phase
kvn
parents:
3273
diff
changeset
|
3270 |
set_inner_loops(frc.get_inner_loop_count()); |
1 | 3271 |
|
3272 |
// No infinite loops, no reason to bail out. |
|
3273 |
return false; |
|
3274 |
} |
|
3275 |
||
3276 |
//-----------------------------too_many_traps---------------------------------- |
|
3277 |
// Report if there are too many traps at the current method and bci. |
|
3278 |
// Return true if there was a trap, and/or PerMethodTrapLimit is exceeded. |
|
3279 |
bool Compile::too_many_traps(ciMethod* method, |
|
3280 |
int bci, |
|
3281 |
Deoptimization::DeoptReason reason) { |
|
3282 |
ciMethodData* md = method->method_data(); |
|
3283 |
if (md->is_empty()) { |
|
3284 |
// Assume the trap has not occurred, or that it occurred only |
|
3285 |
// because of a transient condition during start-up in the interpreter. |
|
3286 |
return false; |
|
3287 |
} |
|
3288 |
if (md->has_trap_at(bci, reason) != 0) { |
|
3289 |
// Assume PerBytecodeTrapLimit==0, for a more conservative heuristic. |
|
3290 |
// Also, if there are multiple reasons, or if there is no per-BCI record, |
|
3291 |
// assume the worst. |
|
3292 |
if (log()) |
|
3293 |
log()->elem("observe trap='%s' count='%d'", |
|
3294 |
Deoptimization::trap_reason_name(reason), |
|
3295 |
md->trap_count(reason)); |
|
3296 |
return true; |
|
3297 |
} else { |
|
3298 |
// Ignore method/bci and see if there have been too many globally. |
|
3299 |
return too_many_traps(reason, md); |
|
3300 |
} |
|
3301 |
} |
|
3302 |
||
3303 |
// Less-accurate variant which does not require a method and bci. |
|
3304 |
bool Compile::too_many_traps(Deoptimization::DeoptReason reason, |
|
3305 |
ciMethodData* logmd) { |
|
3306 |
if (trap_count(reason) >= (uint)PerMethodTrapLimit) { |
|
3307 |
// Too many traps globally. |
|
3308 |
// Note that we use cumulative trap_count, not just md->trap_count. |
|
3309 |
if (log()) { |
|
3310 |
int mcount = (logmd == NULL)? -1: (int)logmd->trap_count(reason); |
|
3311 |
log()->elem("observe trap='%s' count='0' mcount='%d' ccount='%d'", |
|
3312 |
Deoptimization::trap_reason_name(reason), |
|
3313 |
mcount, trap_count(reason)); |
|
3314 |
} |
|
3315 |
return true; |
|
3316 |
} else { |
|
3317 |
// The coast is clear. |
|
3318 |
return false; |
|
3319 |
} |
|
3320 |
} |
|
3321 |
||
3322 |
//--------------------------too_many_recompiles-------------------------------- |
|
3323 |
// Report if there are too many recompiles at the current method and bci. |
|
3324 |
// Consults PerBytecodeRecompilationCutoff and PerMethodRecompilationCutoff. |
|
3325 |
// Is not eager to return true, since this will cause the compiler to use |
|
3326 |
// Action_none for a trap point, to avoid too many recompilations. |
|
3327 |
bool Compile::too_many_recompiles(ciMethod* method, |
|
3328 |
int bci, |
|
3329 |
Deoptimization::DeoptReason reason) { |
|
3330 |
ciMethodData* md = method->method_data(); |
|
3331 |
if (md->is_empty()) { |
|
3332 |
// Assume the trap has not occurred, or that it occurred only |
|
3333 |
// because of a transient condition during start-up in the interpreter. |
|
3334 |
return false; |
|
3335 |
} |
|
3336 |
// Pick a cutoff point well within PerBytecodeRecompilationCutoff. |
|
3337 |
uint bc_cutoff = (uint) PerBytecodeRecompilationCutoff / 8; |
|
3338 |
uint m_cutoff = (uint) PerMethodRecompilationCutoff / 2 + 1; // not zero |
|
3339 |
Deoptimization::DeoptReason per_bc_reason |
|
3340 |
= Deoptimization::reason_recorded_per_bytecode_if_any(reason); |
|
3341 |
if ((per_bc_reason == Deoptimization::Reason_none |
|
3342 |
|| md->has_trap_at(bci, reason) != 0) |
|
3343 |
// The trap frequency measure we care about is the recompile count: |
|
3344 |
&& md->trap_recompiled_at(bci) |
|
3345 |
&& md->overflow_recompile_count() >= bc_cutoff) { |
|
3346 |
// Do not emit a trap here if it has already caused recompilations. |
|
3347 |
// Also, if there are multiple reasons, or if there is no per-BCI record, |
|
3348 |
// assume the worst. |
|
3349 |
if (log()) |
|
3350 |
log()->elem("observe trap='%s recompiled' count='%d' recompiles2='%d'", |
|
3351 |
Deoptimization::trap_reason_name(reason), |
|
3352 |
md->trap_count(reason), |
|
3353 |
md->overflow_recompile_count()); |
|
3354 |
return true; |
|
3355 |
} else if (trap_count(reason) != 0 |
|
3356 |
&& decompile_count() >= m_cutoff) { |
|
3357 |
// Too many recompiles globally, and we have seen this sort of trap. |
|
3358 |
// Use cumulative decompile_count, not just md->decompile_count. |
|
3359 |
if (log()) |
|
3360 |
log()->elem("observe trap='%s' count='%d' mcount='%d' decompiles='%d' mdecompiles='%d'", |
|
3361 |
Deoptimization::trap_reason_name(reason), |
|
3362 |
md->trap_count(reason), trap_count(reason), |
|
3363 |
md->decompile_count(), decompile_count()); |
|
3364 |
return true; |
|
3365 |
} else { |
|
3366 |
// The coast is clear. |
|
3367 |
return false; |
|
3368 |
} |
|
3369 |
} |
|
3370 |
||
22856
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3371 |
// Compute when not to trap. Used by matching trap based nodes and |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3372 |
// NullCheck optimization. |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3373 |
void Compile::set_allowed_deopt_reasons() { |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3374 |
_allowed_reasons = 0; |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3375 |
if (is_method_compilation()) { |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3376 |
for (int rs = (int)Deoptimization::Reason_none+1; rs < Compile::trapHistLength; rs++) { |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3377 |
assert(rs < BitsPerInt, "recode bit map"); |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3378 |
if (!too_many_traps((Deoptimization::DeoptReason) rs)) { |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3379 |
_allowed_reasons |= nth_bit(rs); |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3380 |
} |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3381 |
} |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3382 |
} |
03ad2cf18166
8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents:
22854
diff
changeset
|
3383 |
} |
1 | 3384 |
|
3385 |
#ifndef PRODUCT |
|
3386 |
//------------------------------verify_graph_edges--------------------------- |
|
3387 |
// Walk the Graph and verify that there is a one-to-one correspondence |
|
3388 |
// between Use-Def edges and Def-Use edges in the graph. |
|
3389 |
void Compile::verify_graph_edges(bool no_dead_code) { |
|
3390 |
if (VerifyGraphEdges) { |
|
3391 |
ResourceArea *area = Thread::current()->resource_area(); |
|
3392 |
Unique_Node_List visited(area); |
|
3393 |
// Call recursive graph walk to check edges |
|
3394 |
_root->verify_edges(visited); |
|
3395 |
if (no_dead_code) { |
|
3396 |
// Now make sure that no visited node is used by an unvisited node. |
|
3397 |
bool dead_nodes = 0; |
|
3398 |
Unique_Node_List checked(area); |
|
3399 |
while (visited.size() > 0) { |
|
3400 |
Node* n = visited.pop(); |
|
3401 |
checked.push(n); |
|
3402 |
for (uint i = 0; i < n->outcnt(); i++) { |
|
3403 |
Node* use = n->raw_out(i); |
|
3404 |
if (checked.member(use)) continue; // already checked |
|
3405 |
if (visited.member(use)) continue; // already in the graph |
|
3406 |
if (use->is_Con()) continue; // a dead ConNode is OK |
|
3407 |
// At this point, we have found a dead node which is DU-reachable. |
|
3408 |
if (dead_nodes++ == 0) |
|
3409 |
tty->print_cr("*** Dead nodes reachable via DU edges:"); |
|
3410 |
use->dump(2); |
|
3411 |
tty->print_cr("---"); |
|
3412 |
checked.push(use); // No repeats; pretend it is now checked. |
|
3413 |
} |
|
3414 |
} |
|
3415 |
assert(dead_nodes == 0, "using nodes must be reachable from root"); |
|
3416 |
} |
|
3417 |
} |
|
3418 |
} |
|
21526
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3419 |
|
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3420 |
// Verify GC barriers consistency |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3421 |
// Currently supported: |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3422 |
// - G1 pre-barriers (see GraphKit::g1_write_barrier_pre()) |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3423 |
void Compile::verify_barriers() { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3424 |
if (UseG1GC) { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3425 |
// Verify G1 pre-barriers |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3426 |
const int marking_offset = in_bytes(JavaThread::satb_mark_queue_offset() + PtrQueue::byte_offset_of_active()); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3427 |
|
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3428 |
ResourceArea *area = Thread::current()->resource_area(); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3429 |
Unique_Node_List visited(area); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3430 |
Node_List worklist(area); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3431 |
// We're going to walk control flow backwards starting from the Root |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3432 |
worklist.push(_root); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3433 |
while (worklist.size() > 0) { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3434 |
Node* x = worklist.pop(); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3435 |
if (x == NULL || x == top()) continue; |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3436 |
if (visited.member(x)) { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3437 |
continue; |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3438 |
} else { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3439 |
visited.push(x); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3440 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3441 |
|
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3442 |
if (x->is_Region()) { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3443 |
for (uint i = 1; i < x->req(); i++) { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3444 |
worklist.push(x->in(i)); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3445 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3446 |
} else { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3447 |
worklist.push(x->in(0)); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3448 |
// We are looking for the pattern: |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3449 |
// /->ThreadLocal |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3450 |
// If->Bool->CmpI->LoadB->AddP->ConL(marking_offset) |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3451 |
// \->ConI(0) |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3452 |
// We want to verify that the If and the LoadB have the same control |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3453 |
// See GraphKit::g1_write_barrier_pre() |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3454 |
if (x->is_If()) { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3455 |
IfNode *iff = x->as_If(); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3456 |
if (iff->in(1)->is_Bool() && iff->in(1)->in(1)->is_Cmp()) { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3457 |
CmpNode *cmp = iff->in(1)->in(1)->as_Cmp(); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3458 |
if (cmp->Opcode() == Op_CmpI && cmp->in(2)->is_Con() && cmp->in(2)->bottom_type()->is_int()->get_con() == 0 |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3459 |
&& cmp->in(1)->is_Load()) { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3460 |
LoadNode* load = cmp->in(1)->as_Load(); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3461 |
if (load->Opcode() == Op_LoadB && load->in(2)->is_AddP() && load->in(2)->in(2)->Opcode() == Op_ThreadLocal |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3462 |
&& load->in(2)->in(3)->is_Con() |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3463 |
&& load->in(2)->in(3)->bottom_type()->is_intptr_t()->get_con() == marking_offset) { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3464 |
|
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3465 |
Node* if_ctrl = iff->in(0); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3466 |
Node* load_ctrl = load->in(0); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3467 |
|
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3468 |
if (if_ctrl != load_ctrl) { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3469 |
// Skip possible CProj->NeverBranch in infinite loops |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3470 |
if ((if_ctrl->is_Proj() && if_ctrl->Opcode() == Op_CProj) |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3471 |
&& (if_ctrl->in(0)->is_MultiBranch() && if_ctrl->in(0)->Opcode() == Op_NeverBranch)) { |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3472 |
if_ctrl = if_ctrl->in(0)->in(0); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3473 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3474 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3475 |
assert(load_ctrl != NULL && if_ctrl == load_ctrl, "controls must match"); |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3476 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3477 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3478 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3479 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3480 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3481 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3482 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3483 |
} |
03b4acedb351
8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents:
21099
diff
changeset
|
3484 |
|
1 | 3485 |
#endif |
3486 |
||
3487 |
// The Compile object keeps track of failure reasons separately from the ciEnv. |
|
3488 |
// This is required because there is not quite a 1-1 relation between the |
|
3489 |
// ciEnv and its compilation task and the Compile object. Note that one |
|
3490 |
// ciEnv might use two Compile objects, if C2Compiler::compile_method decides |
|
3491 |
// to backtrack and retry without subsuming loads. Other than this backtracking |
|
3492 |
// behavior, the Compile's failure reason is quietly copied up to the ciEnv |
|
3493 |
// by the logic in C2Compiler. |
|
3494 |
void Compile::record_failure(const char* reason) { |
|
3495 |
if (log() != NULL) { |
|
3496 |
log()->elem("failure reason='%s' phase='compile'", reason); |
|
3497 |
} |
|
3498 |
if (_failure_reason == NULL) { |
|
3499 |
// Record the first failure reason. |
|
3500 |
_failure_reason = reason; |
|
3501 |
} |
|
18025 | 3502 |
|
3503 |
EventCompilerFailure event; |
|
3504 |
if (event.should_commit()) { |
|
3505 |
event.set_compileID(Compile::compile_id()); |
|
3506 |
event.set_failure(reason); |
|
3507 |
event.commit(); |
|
3508 |
} |
|
3509 |
||
768 | 3510 |
if (!C->failure_reason_is(C2Compiler::retry_no_subsuming_loads())) { |
18025 | 3511 |
C->print_method(PHASE_FAILURE); |
768 | 3512 |
} |
1 | 3513 |
_root = NULL; // flush the graph, too |
3514 |
} |
|
3515 |
||
3516 |
Compile::TracePhase::TracePhase(const char* name, elapsedTimer* accumulator, bool dolog) |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3517 |
: TraceTime(NULL, accumulator, false NOT_PRODUCT( || TimeCompiler ), false), |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3518 |
_phase_name(name), _dolog(dolog) |
1 | 3519 |
{ |
3520 |
if (dolog) { |
|
3521 |
C = Compile::current(); |
|
3522 |
_log = C->log(); |
|
3523 |
} else { |
|
3524 |
C = NULL; |
|
3525 |
_log = NULL; |
|
3526 |
} |
|
3527 |
if (_log != NULL) { |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3528 |
_log->begin_head("phase name='%s' nodes='%d' live='%d'", _phase_name, C->unique(), C->live_nodes()); |
1 | 3529 |
_log->stamp(); |
3530 |
_log->end_head(); |
|
3531 |
} |
|
3532 |
} |
|
3533 |
||
3534 |
Compile::TracePhase::~TracePhase() { |
|
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3535 |
|
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3536 |
C = Compile::current(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3537 |
if (_dolog) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3538 |
_log = C->log(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3539 |
} else { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3540 |
_log = NULL; |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3541 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3542 |
|
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3543 |
#ifdef ASSERT |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3544 |
if (PrintIdealNodeCount) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3545 |
tty->print_cr("phase name='%s' nodes='%d' live='%d' live_graph_walk='%d'", |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3546 |
_phase_name, C->unique(), C->live_nodes(), C->count_live_nodes_by_graph_walk()); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3547 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3548 |
|
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3549 |
if (VerifyIdealNodeCount) { |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3550 |
Compile::current()->print_missing_nodes(); |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3551 |
} |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3552 |
#endif |
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3553 |
|
1 | 3554 |
if (_log != NULL) { |
14623
70c4c1be0a14
7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents:
14126
diff
changeset
|
3555 |
_log->done("phase name='%s' nodes='%d' live='%d'", _phase_name, C->unique(), C->live_nodes()); |
1 | 3556 |
} |
3557 |
} |
|
7433 | 3558 |
|
3559 |
//============================================================================= |
|
3560 |
// Two Constant's are equal when the type and the value are equal. |
|
3561 |
bool Compile::Constant::operator==(const Constant& other) { |
|
3562 |
if (type() != other.type() ) return false; |
|
3563 |
if (can_be_reused() != other.can_be_reused()) return false; |
|
3564 |
// For floating point values we compare the bit pattern. |
|
3565 |
switch (type()) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3566 |
case T_FLOAT: return (_v._value.i == other._v._value.i); |
7433 | 3567 |
case T_LONG: |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3568 |
case T_DOUBLE: return (_v._value.j == other._v._value.j); |
7433 | 3569 |
case T_OBJECT: |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3570 |
case T_ADDRESS: return (_v._value.l == other._v._value.l); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3571 |
case T_VOID: return (_v._value.l == other._v._value.l); // jump-table entries |
14126
afb8a3a86f1f
8000623: tools/javac/Diagnostics/6769027/T6769027.java crashes in PSPromotionManager::copy_to_survivor_space
kvn
parents:
13970
diff
changeset
|
3572 |
case T_METADATA: return (_v._metadata == other._v._metadata); |
7433 | 3573 |
default: ShouldNotReachHere(); |
3574 |
} |
|
3575 |
return false; |
|
3576 |
} |
|
3577 |
||
3578 |
static int type_to_size_in_bytes(BasicType t) { |
|
3579 |
switch (t) { |
|
3580 |
case T_LONG: return sizeof(jlong ); |
|
3581 |
case T_FLOAT: return sizeof(jfloat ); |
|
3582 |
case T_DOUBLE: return sizeof(jdouble); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3583 |
case T_METADATA: return sizeof(Metadata*); |
7433 | 3584 |
// We use T_VOID as marker for jump-table entries (labels) which |
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3585 |
// need an internal word relocation. |
7433 | 3586 |
case T_VOID: |
3587 |
case T_ADDRESS: |
|
3588 |
case T_OBJECT: return sizeof(jobject); |
|
3589 |
} |
|
3590 |
||
3591 |
ShouldNotReachHere(); |
|
3592 |
return -1; |
|
3593 |
} |
|
3594 |
||
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3595 |
int Compile::ConstantTable::qsort_comparator(Constant* a, Constant* b) { |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3596 |
// sort descending |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3597 |
if (a->freq() > b->freq()) return -1; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3598 |
if (a->freq() < b->freq()) return 1; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3599 |
return 0; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3600 |
} |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3601 |
|
7433 | 3602 |
void Compile::ConstantTable::calculate_offsets_and_size() { |
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3603 |
// First, sort the array by frequencies. |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3604 |
_constants.sort(qsort_comparator); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3605 |
|
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3606 |
#ifdef ASSERT |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3607 |
// Make sure all jump-table entries were sorted to the end of the |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3608 |
// array (they have a negative frequency). |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3609 |
bool found_void = false; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3610 |
for (int i = 0; i < _constants.length(); i++) { |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3611 |
Constant con = _constants.at(i); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3612 |
if (con.type() == T_VOID) |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3613 |
found_void = true; // jump-tables |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3614 |
else |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3615 |
assert(!found_void, "wrong sorting"); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3616 |
} |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3617 |
#endif |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3618 |
|
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3619 |
int offset = 0; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3620 |
for (int i = 0; i < _constants.length(); i++) { |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3621 |
Constant* con = _constants.adr_at(i); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3622 |
|
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3623 |
// Align offset for type. |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3624 |
int typesize = type_to_size_in_bytes(con->type()); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3625 |
offset = align_size_up(offset, typesize); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3626 |
con->set_offset(offset); // set constant's offset |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3627 |
|
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3628 |
if (con->type() == T_VOID) { |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3629 |
MachConstantNode* n = (MachConstantNode*) con->get_jobject(); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3630 |
offset = offset + typesize * n->outcnt(); // expand jump-table |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3631 |
} else { |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3632 |
offset = offset + typesize; |
7433 | 3633 |
} |
3634 |
} |
|
3635 |
||
3636 |
// Align size up to the next section start (which is insts; see |
|
3637 |
// CodeBuffer::align_at_start). |
|
3638 |
assert(_size == -1, "already set?"); |
|
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3639 |
_size = align_size_up(offset, CodeEntryAlignment); |
7433 | 3640 |
} |
3641 |
||
3642 |
void Compile::ConstantTable::emit(CodeBuffer& cb) { |
|
3643 |
MacroAssembler _masm(&cb); |
|
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3644 |
for (int i = 0; i < _constants.length(); i++) { |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3645 |
Constant con = _constants.at(i); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3646 |
address constant_addr; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3647 |
switch (con.type()) { |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3648 |
case T_LONG: constant_addr = _masm.long_constant( con.get_jlong() ); break; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3649 |
case T_FLOAT: constant_addr = _masm.float_constant( con.get_jfloat() ); break; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3650 |
case T_DOUBLE: constant_addr = _masm.double_constant(con.get_jdouble()); break; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3651 |
case T_OBJECT: { |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3652 |
jobject obj = con.get_jobject(); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3653 |
int oop_index = _masm.oop_recorder()->find_index(obj); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3654 |
constant_addr = _masm.address_constant((address) obj, oop_Relocation::spec(oop_index)); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3655 |
break; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3656 |
} |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3657 |
case T_ADDRESS: { |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3658 |
address addr = (address) con.get_jobject(); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3659 |
constant_addr = _masm.address_constant(addr); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3660 |
break; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3661 |
} |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3662 |
// We use T_VOID as marker for jump-table entries (labels) which |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3663 |
// need an internal word relocation. |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3664 |
case T_VOID: { |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3665 |
MachConstantNode* n = (MachConstantNode*) con.get_jobject(); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3666 |
// Fill the jump-table with a dummy word. The real value is |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3667 |
// filled in later in fill_jump_table. |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3668 |
address dummy = (address) n; |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3669 |
constant_addr = _masm.address_constant(dummy); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3670 |
// Expand jump-table |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3671 |
for (uint i = 1; i < n->outcnt(); i++) { |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3672 |
address temp_addr = _masm.address_constant(dummy + i); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3673 |
assert(temp_addr, "consts section too small"); |
7433 | 3674 |
} |
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3675 |
break; |
7433 | 3676 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3677 |
case T_METADATA: { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3678 |
Metadata* obj = con.get_metadata(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3679 |
int metadata_index = _masm.oop_recorder()->find_index(obj); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3680 |
constant_addr = _masm.address_constant((address) obj, metadata_Relocation::spec(metadata_index)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3681 |
break; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3682 |
} |
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3683 |
default: ShouldNotReachHere(); |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3684 |
} |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3685 |
assert(constant_addr, "consts section too small"); |
13393
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
13104
diff
changeset
|
3686 |
assert((constant_addr - _masm.code()->consts()->start()) == con.offset(), err_msg_res("must be: %d == %d", constant_addr - _masm.code()->consts()->start(), con.offset())); |
7433 | 3687 |
} |
3688 |
} |
|
3689 |
||
3690 |
int Compile::ConstantTable::find_offset(Constant& con) const { |
|
3691 |
int idx = _constants.find(con); |
|
3692 |
assert(idx != -1, "constant must be in constant table"); |
|
3693 |
int offset = _constants.at(idx).offset(); |
|
3694 |
assert(offset != -1, "constant table not emitted yet?"); |
|
3695 |
return offset; |
|
3696 |
} |
|
3697 |
||
3698 |
void Compile::ConstantTable::add(Constant& con) { |
|
3699 |
if (con.can_be_reused()) { |
|
3700 |
int idx = _constants.find(con); |
|
3701 |
if (idx != -1 && _constants.at(idx).can_be_reused()) { |
|
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3702 |
_constants.adr_at(idx)->inc_freq(con.freq()); // increase the frequency by the current value |
7433 | 3703 |
return; |
3704 |
} |
|
3705 |
} |
|
3706 |
(void) _constants.append(con); |
|
3707 |
} |
|
3708 |
||
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3709 |
Compile::Constant Compile::ConstantTable::add(MachConstantNode* n, BasicType type, jvalue value) { |
19279
4be3c2e6663c
8022284: Hide internal data structure in PhaseCFG
adlertz
parents:
18025
diff
changeset
|
3710 |
Block* b = Compile::current()->cfg()->get_block_for_node(n); |
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3711 |
Constant con(type, value, b->_freq); |
7433 | 3712 |
add(con); |
3713 |
return con; |
|
3714 |
} |
|
3715 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3716 |
Compile::Constant Compile::ConstantTable::add(Metadata* metadata) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3717 |
Constant con(metadata); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3718 |
add(con); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3719 |
return con; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3720 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3721 |
|
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3722 |
Compile::Constant Compile::ConstantTable::add(MachConstantNode* n, MachOper* oper) { |
7433 | 3723 |
jvalue value; |
3724 |
BasicType type = oper->type()->basic_type(); |
|
3725 |
switch (type) { |
|
3726 |
case T_LONG: value.j = oper->constantL(); break; |
|
3727 |
case T_FLOAT: value.f = oper->constantF(); break; |
|
3728 |
case T_DOUBLE: value.d = oper->constantD(); break; |
|
3729 |
case T_OBJECT: |
|
3730 |
case T_ADDRESS: value.l = (jobject) oper->constant(); break; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3731 |
case T_METADATA: return add((Metadata*)oper->constant()); break; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13490
diff
changeset
|
3732 |
default: guarantee(false, err_msg_res("unhandled type: %s", type2name(type))); |
7433 | 3733 |
} |
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3734 |
return add(n, type, value); |
7433 | 3735 |
} |
3736 |
||
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3737 |
Compile::Constant Compile::ConstantTable::add_jump_table(MachConstantNode* n) { |
7433 | 3738 |
jvalue value; |
3739 |
// We can use the node pointer here to identify the right jump-table |
|
3740 |
// as this method is called from Compile::Fill_buffer right before |
|
3741 |
// the MachNodes are emitted and the jump-table is filled (means the |
|
3742 |
// MachNode pointers do not change anymore). |
|
3743 |
value.l = (jobject) n; |
|
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3744 |
Constant con(T_VOID, value, next_jump_table_freq(), false); // Labels of a jump-table cannot be reused. |
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3745 |
add(con); |
7433 | 3746 |
return con; |
3747 |
} |
|
3748 |
||
3749 |
void Compile::ConstantTable::fill_jump_table(CodeBuffer& cb, MachConstantNode* n, GrowableArray<Label*> labels) const { |
|
3750 |
// If called from Compile::scratch_emit_size do nothing. |
|
3751 |
if (Compile::current()->in_scratch_emit_size()) return; |
|
3752 |
||
3753 |
assert(labels.is_nonempty(), "must be"); |
|
13393
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
13104
diff
changeset
|
3754 |
assert((uint) labels.length() == n->outcnt(), err_msg_res("must be equal: %d == %d", labels.length(), n->outcnt())); |
7433 | 3755 |
|
3756 |
// Since MachConstantNode::constant_offset() also contains |
|
3757 |
// table_base_offset() we need to subtract the table_base_offset() |
|
3758 |
// to get the plain offset into the constant table. |
|
3759 |
int offset = n->constant_offset() - table_base_offset(); |
|
3760 |
||
3761 |
MacroAssembler _masm(&cb); |
|
3762 |
address* jump_table_base = (address*) (_masm.code()->consts()->start() + offset); |
|
3763 |
||
11190
d561d41f241a
7003454: order constants in constant table by number of references in code
twisti
parents:
10988
diff
changeset
|
3764 |
for (uint i = 0; i < n->outcnt(); i++) { |
7433 | 3765 |
address* constant_addr = &jump_table_base[i]; |
13393
f0344cc50a90
7187454: stack overflow in C2 compiler thread on Solaris x86
kvn
parents:
13104
diff
changeset
|
3766 |
assert(*constant_addr == (((address) n) + i), err_msg_res("all jump-table entries must contain adjusted node pointer: " INTPTR_FORMAT " == " INTPTR_FORMAT, *constant_addr, (((address) n) + i))); |
7433 | 3767 |
*constant_addr = cb.consts()->target(*labels.at(i), (address) constant_addr); |
3768 |
cb.consts()->relocate((address) constant_addr, relocInfo::internal_word_type); |
|
3769 |
} |
|
3770 |
} |
|
14828
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
3771 |
|
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
3772 |
void Compile::dump_inlining() { |
20073 | 3773 |
if (print_inlining() || print_intrinsics()) { |
15113 | 3774 |
// Print inlining message for candidates that we couldn't inline |
3775 |
// for lack of space or non constant receiver |
|
3776 |
for (int i = 0; i < _late_inlines.length(); i++) { |
|
3777 |
CallGenerator* cg = _late_inlines.at(i); |
|
3778 |
cg->print_inlining_late("live nodes > LiveNodeCountInliningCutoff"); |
|
3779 |
} |
|
3780 |
Unique_Node_List useful; |
|
3781 |
useful.push(root()); |
|
3782 |
for (uint next = 0; next < useful.size(); ++next) { |
|
3783 |
Node* n = useful.at(next); |
|
3784 |
if (n->is_Call() && n->as_Call()->generator() != NULL && n->as_Call()->generator()->call_node() == n) { |
|
3785 |
CallNode* call = n->as_Call(); |
|
3786 |
CallGenerator* cg = call->generator(); |
|
3787 |
cg->print_inlining_late("receiver not constant"); |
|
3788 |
} |
|
3789 |
uint max = n->len(); |
|
3790 |
for ( uint i = 0; i < max; ++i ) { |
|
3791 |
Node *m = n->in(i); |
|
3792 |
if ( m == NULL ) continue; |
|
3793 |
useful.push(m); |
|
3794 |
} |
|
3795 |
} |
|
14828
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
3796 |
for (int i = 0; i < _print_inlining_list->length(); i++) { |
20073 | 3797 |
tty->print(_print_inlining_list->adr_at(i)->ss()->as_string()); |
14828
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
3798 |
} |
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
3799 |
} |
bb9dffedf46c
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
14626
diff
changeset
|
3800 |
} |
15618
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3801 |
|
22243 | 3802 |
// Dump inlining replay data to the stream. |
3803 |
// Don't change thread state and acquire any locks. |
|
3804 |
void Compile::dump_inline_data(outputStream* out) { |
|
3805 |
InlineTree* inl_tree = ilt(); |
|
3806 |
if (inl_tree != NULL) { |
|
3807 |
out->print(" inline %d", inl_tree->count()); |
|
3808 |
inl_tree->dump_replay_data(out); |
|
3809 |
} |
|
3810 |
} |
|
3811 |
||
15618
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3812 |
int Compile::cmp_expensive_nodes(Node* n1, Node* n2) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3813 |
if (n1->Opcode() < n2->Opcode()) return -1; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3814 |
else if (n1->Opcode() > n2->Opcode()) return 1; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3815 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3816 |
assert(n1->req() == n2->req(), err_msg_res("can't compare %s nodes: n1->req() = %d, n2->req() = %d", NodeClassNames[n1->Opcode()], n1->req(), n2->req())); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3817 |
for (uint i = 1; i < n1->req(); i++) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3818 |
if (n1->in(i) < n2->in(i)) return -1; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3819 |
else if (n1->in(i) > n2->in(i)) return 1; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3820 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3821 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3822 |
return 0; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3823 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3824 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3825 |
int Compile::cmp_expensive_nodes(Node** n1p, Node** n2p) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3826 |
Node* n1 = *n1p; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3827 |
Node* n2 = *n2p; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3828 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3829 |
return cmp_expensive_nodes(n1, n2); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3830 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3831 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3832 |
void Compile::sort_expensive_nodes() { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3833 |
if (!expensive_nodes_sorted()) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3834 |
_expensive_nodes->sort(cmp_expensive_nodes); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3835 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3836 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3837 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3838 |
bool Compile::expensive_nodes_sorted() const { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3839 |
for (int i = 1; i < _expensive_nodes->length(); i++) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3840 |
if (cmp_expensive_nodes(_expensive_nodes->adr_at(i), _expensive_nodes->adr_at(i-1)) < 0) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3841 |
return false; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3842 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3843 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3844 |
return true; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3845 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3846 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3847 |
bool Compile::should_optimize_expensive_nodes(PhaseIterGVN &igvn) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3848 |
if (_expensive_nodes->length() == 0) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3849 |
return false; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3850 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3851 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3852 |
assert(OptimizeExpensiveOps, "optimization off?"); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3853 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3854 |
// Take this opportunity to remove dead nodes from the list |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3855 |
int j = 0; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3856 |
for (int i = 0; i < _expensive_nodes->length(); i++) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3857 |
Node* n = _expensive_nodes->at(i); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3858 |
if (!n->is_unreachable(igvn)) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3859 |
assert(n->is_expensive(), "should be expensive"); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3860 |
_expensive_nodes->at_put(j, n); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3861 |
j++; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3862 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3863 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3864 |
_expensive_nodes->trunc_to(j); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3865 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3866 |
// Then sort the list so that similar nodes are next to each other |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3867 |
// and check for at least two nodes of identical kind with same data |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3868 |
// inputs. |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3869 |
sort_expensive_nodes(); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3870 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3871 |
for (int i = 0; i < _expensive_nodes->length()-1; i++) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3872 |
if (cmp_expensive_nodes(_expensive_nodes->adr_at(i), _expensive_nodes->adr_at(i+1)) == 0) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3873 |
return true; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3874 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3875 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3876 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3877 |
return false; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3878 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3879 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3880 |
void Compile::cleanup_expensive_nodes(PhaseIterGVN &igvn) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3881 |
if (_expensive_nodes->length() == 0) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3882 |
return; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3883 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3884 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3885 |
assert(OptimizeExpensiveOps, "optimization off?"); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3886 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3887 |
// Sort to bring similar nodes next to each other and clear the |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3888 |
// control input of nodes for which there's only a single copy. |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3889 |
sort_expensive_nodes(); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3890 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3891 |
int j = 0; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3892 |
int identical = 0; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3893 |
int i = 0; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3894 |
for (; i < _expensive_nodes->length()-1; i++) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3895 |
assert(j <= i, "can't write beyond current index"); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3896 |
if (_expensive_nodes->at(i)->Opcode() == _expensive_nodes->at(i+1)->Opcode()) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3897 |
identical++; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3898 |
_expensive_nodes->at_put(j++, _expensive_nodes->at(i)); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3899 |
continue; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3900 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3901 |
if (identical > 0) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3902 |
_expensive_nodes->at_put(j++, _expensive_nodes->at(i)); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3903 |
identical = 0; |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3904 |
} else { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3905 |
Node* n = _expensive_nodes->at(i); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3906 |
igvn.hash_delete(n); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3907 |
n->set_req(0, NULL); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3908 |
igvn.hash_insert(n); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3909 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3910 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3911 |
if (identical > 0) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3912 |
_expensive_nodes->at_put(j++, _expensive_nodes->at(i)); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3913 |
} else if (_expensive_nodes->length() >= 1) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3914 |
Node* n = _expensive_nodes->at(i); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3915 |
igvn.hash_delete(n); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3916 |
n->set_req(0, NULL); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3917 |
igvn.hash_insert(n); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3918 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3919 |
_expensive_nodes->trunc_to(j); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3920 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3921 |
|
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3922 |
void Compile::add_expensive_node(Node * n) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3923 |
assert(!_expensive_nodes->contains(n), "duplicate entry in expensive list"); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3924 |
assert(n->is_expensive(), "expensive nodes with non-null control here only"); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3925 |
assert(!n->is_CFG() && !n->is_Mem(), "no cfg or memory nodes here"); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3926 |
if (OptimizeExpensiveOps) { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3927 |
_expensive_nodes->append(n); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3928 |
} else { |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3929 |
// Clear control input and let IGVN optimize expensive nodes if |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3930 |
// OptimizeExpensiveOps is off. |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3931 |
n->set_req(0, NULL); |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3932 |
} |
3eb521896836
7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents:
15211
diff
changeset
|
3933 |
} |
15871
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
3934 |
|
21099 | 3935 |
/** |
3936 |
* Remove the speculative part of types and clean up the graph |
|
3937 |
*/ |
|
3938 |
void Compile::remove_speculative_types(PhaseIterGVN &igvn) { |
|
3939 |
if (UseTypeSpeculation) { |
|
3940 |
Unique_Node_List worklist; |
|
3941 |
worklist.push(root()); |
|
3942 |
int modified = 0; |
|
3943 |
// Go over all type nodes that carry a speculative type, drop the |
|
3944 |
// speculative part of the type and enqueue the node for an igvn |
|
3945 |
// which may optimize it out. |
|
3946 |
for (uint next = 0; next < worklist.size(); ++next) { |
|
3947 |
Node *n = worklist.at(next); |
|
22799
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3948 |
if (n->is_Type()) { |
21099 | 3949 |
TypeNode* tn = n->as_Type(); |
22799
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3950 |
const Type* t = tn->type(); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3951 |
const Type* t_no_spec = t->remove_speculative(); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3952 |
if (t_no_spec != t) { |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3953 |
bool in_hash = igvn.hash_delete(n); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3954 |
assert(in_hash, "node should be in igvn hash table"); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3955 |
tn->set_type(t_no_spec); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3956 |
igvn.hash_insert(n); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3957 |
igvn._worklist.push(n); // give it a chance to go away |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3958 |
modified++; |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3959 |
} |
21099 | 3960 |
} |
3961 |
uint max = n->len(); |
|
3962 |
for( uint i = 0; i < max; ++i ) { |
|
3963 |
Node *m = n->in(i); |
|
3964 |
if (not_a_node(m)) continue; |
|
3965 |
worklist.push(m); |
|
3966 |
} |
|
3967 |
} |
|
3968 |
// Drop the speculative part of all types in the igvn's type table |
|
3969 |
igvn.remove_speculative_types(); |
|
3970 |
if (modified > 0) { |
|
3971 |
igvn.optimize(); |
|
3972 |
} |
|
22799
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3973 |
#ifdef ASSERT |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3974 |
// Verify that after the IGVN is over no speculative type has resurfaced |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3975 |
worklist.clear(); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3976 |
worklist.push(root()); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3977 |
for (uint next = 0; next < worklist.size(); ++next) { |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3978 |
Node *n = worklist.at(next); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3979 |
const Type* t = igvn.type(n); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3980 |
assert(t == t->remove_speculative(), "no more speculative types"); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3981 |
if (n->is_Type()) { |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3982 |
t = n->as_Type()->type(); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3983 |
assert(t == t->remove_speculative(), "no more speculative types"); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3984 |
} |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3985 |
uint max = n->len(); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3986 |
for( uint i = 0; i < max; ++i ) { |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3987 |
Node *m = n->in(i); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3988 |
if (not_a_node(m)) continue; |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3989 |
worklist.push(m); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3990 |
} |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3991 |
} |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3992 |
igvn.check_no_speculative_types(); |
83e58bac7980
8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents:
22243
diff
changeset
|
3993 |
#endif |
21099 | 3994 |
} |
3995 |
} |
|
3996 |
||
15871
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
3997 |
// Auxiliary method to support randomized stressing/fuzzing. |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
3998 |
// |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
3999 |
// This method can be called the arbitrary number of times, with current count |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4000 |
// as the argument. The logic allows selecting a single candidate from the |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4001 |
// running list of candidates as follows: |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4002 |
// int count = 0; |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4003 |
// Cand* selected = null; |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4004 |
// while(cand = cand->next()) { |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4005 |
// if (randomized_select(++count)) { |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4006 |
// selected = cand; |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4007 |
// } |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4008 |
// } |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4009 |
// |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4010 |
// Including count equalizes the chances any candidate is "selected". |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4011 |
// This is useful when we don't have the complete list of candidates to choose |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4012 |
// from uniformly. In this case, we need to adjust the randomicity of the |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4013 |
// selection, or else we will end up biasing the selection towards the latter |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4014 |
// candidates. |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4015 |
// |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4016 |
// Quick back-envelope calculation shows that for the list of n candidates |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4017 |
// the equal probability for the candidate to persist as "best" can be |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4018 |
// achieved by replacing it with "next" k-th candidate with the probability |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4019 |
// of 1/k. It can be easily shown that by the end of the run, the |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4020 |
// probability for any candidate is converged to 1/n, thus giving the |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4021 |
// uniform distribution among all the candidates. |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4022 |
// |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4023 |
// We don't care about the domain size as long as (RANDOMIZED_DOMAIN / count) is large. |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4024 |
#define RANDOMIZED_DOMAIN_POW 29 |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4025 |
#define RANDOMIZED_DOMAIN (1 << RANDOMIZED_DOMAIN_POW) |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4026 |
#define RANDOMIZED_DOMAIN_MASK ((1 << (RANDOMIZED_DOMAIN_POW + 1)) - 1) |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4027 |
bool Compile::randomized_select(int count) { |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4028 |
assert(count > 0, "only positive"); |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4029 |
return (os::random() & RANDOMIZED_DOMAIN_MASK) < (RANDOMIZED_DOMAIN / count); |
b04dd94da4e6
8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents:
15618
diff
changeset
|
4030 |
} |