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