Mercurial > hg > truffle
annotate src/share/vm/opto/parse2.cpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
| author | tonyp |
|---|---|
| date | Fri, 16 Dec 2011 02:14:27 -0500 |
| parents | c124e2e7463e |
| children | 8f6ce6f1049b |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2383
diff
changeset
|
2 * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1213
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1213
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1213
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "ci/ciMethodData.hpp" | |
| 27 #include "classfile/systemDictionary.hpp" | |
| 28 #include "classfile/vmSymbols.hpp" | |
| 29 #include "compiler/compileLog.hpp" | |
| 30 #include "interpreter/linkResolver.hpp" | |
| 31 #include "memory/universe.inline.hpp" | |
| 32 #include "opto/addnode.hpp" | |
| 33 #include "opto/divnode.hpp" | |
| 34 #include "opto/idealGraphPrinter.hpp" | |
| 35 #include "opto/matcher.hpp" | |
| 36 #include "opto/memnode.hpp" | |
| 37 #include "opto/mulnode.hpp" | |
| 38 #include "opto/parse.hpp" | |
| 39 #include "opto/runtime.hpp" | |
| 40 #include "runtime/deoptimization.hpp" | |
| 41 #include "runtime/sharedRuntime.hpp" | |
| 0 | 42 |
| 43 extern int explicit_null_checks_inserted, | |
| 44 explicit_null_checks_elided; | |
| 45 | |
| 46 //---------------------------------array_load---------------------------------- | |
| 47 void Parse::array_load(BasicType elem_type) { | |
| 48 const Type* elem = Type::TOP; | |
| 49 Node* adr = array_addressing(elem_type, 0, &elem); | |
| 605 | 50 if (stopped()) return; // guaranteed null or range check |
| 0 | 51 _sp -= 2; // Pop array and index |
| 52 const TypeAryPtr* adr_type = TypeAryPtr::get_array_body_type(elem_type); | |
| 53 Node* ld = make_load(control(), adr, elem, elem_type, adr_type); | |
| 54 push(ld); | |
| 55 } | |
| 56 | |
| 57 | |
| 58 //--------------------------------array_store---------------------------------- | |
| 59 void Parse::array_store(BasicType elem_type) { | |
| 60 Node* adr = array_addressing(elem_type, 1); | |
| 605 | 61 if (stopped()) return; // guaranteed null or range check |
| 0 | 62 Node* val = pop(); |
| 63 _sp -= 2; // Pop array and index | |
| 64 const TypeAryPtr* adr_type = TypeAryPtr::get_array_body_type(elem_type); | |
| 65 store_to_memory(control(), adr, val, elem_type, adr_type); | |
| 66 } | |
| 67 | |
| 68 | |
| 69 //------------------------------array_addressing------------------------------- | |
| 70 // Pull array and index from the stack. Compute pointer-to-element. | |
| 71 Node* Parse::array_addressing(BasicType type, int vals, const Type* *result2) { | |
| 72 Node *idx = peek(0+vals); // Get from stack without popping | |
| 73 Node *ary = peek(1+vals); // in case of exception | |
| 74 | |
| 75 // Null check the array base, with correct stack contents | |
| 76 ary = do_null_check(ary, T_ARRAY); | |
| 77 // Compile-time detect of null-exception? | |
| 78 if (stopped()) return top(); | |
| 79 | |
| 80 const TypeAryPtr* arytype = _gvn.type(ary)->is_aryptr(); | |
| 81 const TypeInt* sizetype = arytype->size(); | |
| 82 const Type* elemtype = arytype->elem(); | |
| 83 | |
| 84 if (UseUniqueSubclasses && result2 != NULL) { | |
|
221
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
129
diff
changeset
|
85 const Type* el = elemtype->make_ptr(); |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
129
diff
changeset
|
86 if (el && el->isa_instptr()) { |
|
1e026f8da827
6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents:
129
diff
changeset
|
87 const TypeInstPtr* toop = el->is_instptr(); |
| 0 | 88 if (toop->klass()->as_instance_klass()->unique_concrete_subklass()) { |
| 89 // If we load from "AbstractClass[]" we must see "ConcreteSubClass". | |
| 90 const Type* subklass = Type::get_const_type(toop->klass()); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
37
diff
changeset
|
91 elemtype = subklass->join(el); |
| 0 | 92 } |
| 93 } | |
| 94 } | |
| 95 | |
| 96 // Check for big class initializers with all constant offsets | |
| 97 // feeding into a known-size array. | |
| 98 const TypeInt* idxtype = _gvn.type(idx)->is_int(); | |
| 99 // See if the highest idx value is less than the lowest array bound, | |
| 100 // and if the idx value cannot be negative: | |
| 101 bool need_range_check = true; | |
| 102 if (idxtype->_hi < sizetype->_lo && idxtype->_lo >= 0) { | |
| 103 need_range_check = false; | |
| 104 if (C->log() != NULL) C->log()->elem("observe that='!need_range_check'"); | |
| 105 } | |
| 106 | |
| 107 if (!arytype->klass()->is_loaded()) { | |
| 108 // Only fails for some -Xcomp runs | |
| 109 // The class is unloaded. We have to run this bytecode in the interpreter. | |
| 110 uncommon_trap(Deoptimization::Reason_unloaded, | |
| 111 Deoptimization::Action_reinterpret, | |
| 112 arytype->klass(), "!loaded array"); | |
| 113 return top(); | |
| 114 } | |
| 115 | |
| 116 // Do the range check | |
| 117 if (GenerateRangeChecks && need_range_check) { | |
|
129
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
118 Node* tst; |
|
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
119 if (sizetype->_hi <= 0) { |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
254
diff
changeset
|
120 // The greatest array bound is negative, so we can conclude that we're |
|
129
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
121 // compiling unreachable code, but the unsigned compare trick used below |
|
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
122 // only works with non-negative lengths. Instead, hack "tst" to be zero so |
|
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
123 // the uncommon_trap path will always be taken. |
|
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
124 tst = _gvn.intcon(0); |
|
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
125 } else { |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
254
diff
changeset
|
126 // Range is constant in array-oop, so we can use the original state of mem |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
254
diff
changeset
|
127 Node* len = load_array_length(ary); |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
254
diff
changeset
|
128 |
|
129
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
129 // Test length vs index (standard trick using unsigned compare) |
|
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
130 Node* chk = _gvn.transform( new (C, 3) CmpUNode(idx, len) ); |
|
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
131 BoolTest::mask btest = BoolTest::lt; |
|
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
132 tst = _gvn.transform( new (C, 2) BoolNode(chk, btest) ); |
|
c0939256690b
6646019: array subscript expressions become top() with -d64
rasbold
parents:
113
diff
changeset
|
133 } |
| 0 | 134 // Branch to failure if out of bounds |
| 135 { BuildCutout unless(this, tst, PROB_MAX); | |
| 136 if (C->allow_range_check_smearing()) { | |
| 137 // Do not use builtin_throw, since range checks are sometimes | |
| 138 // made more stringent by an optimistic transformation. | |
| 139 // This creates "tentative" range checks at this point, | |
| 140 // which are not guaranteed to throw exceptions. | |
| 141 // See IfNode::Ideal, is_range_check, adjust_check. | |
| 142 uncommon_trap(Deoptimization::Reason_range_check, | |
| 143 Deoptimization::Action_make_not_entrant, | |
| 144 NULL, "range_check"); | |
| 145 } else { | |
| 146 // If we have already recompiled with the range-check-widening | |
| 147 // heroic optimization turned off, then we must really be throwing | |
| 148 // range check exceptions. | |
| 149 builtin_throw(Deoptimization::Reason_range_check, idx); | |
| 150 } | |
| 151 } | |
| 152 } | |
| 153 // Check for always knowing you are throwing a range-check exception | |
| 154 if (stopped()) return top(); | |
| 155 | |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
254
diff
changeset
|
156 Node* ptr = array_element_address(ary, idx, type, sizetype); |
| 0 | 157 |
| 158 if (result2 != NULL) *result2 = elemtype; | |
|
366
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
254
diff
changeset
|
159 |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
254
diff
changeset
|
160 assert(ptr != top(), "top should go hand-in-hand with stopped"); |
|
8261ee795323
6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents:
254
diff
changeset
|
161 |
| 0 | 162 return ptr; |
| 163 } | |
| 164 | |
| 165 | |
| 166 // returns IfNode | |
| 167 IfNode* Parse::jump_if_fork_int(Node* a, Node* b, BoolTest::mask mask) { | |
| 168 Node *cmp = _gvn.transform( new (C, 3) CmpINode( a, b)); // two cases: shiftcount > 32 and shiftcount <= 32 | |
| 169 Node *tst = _gvn.transform( new (C, 2) BoolNode( cmp, mask)); | |
| 170 IfNode *iff = create_and_map_if( control(), tst, ((mask == BoolTest::eq) ? PROB_STATIC_INFREQUENT : PROB_FAIR), COUNT_UNKNOWN ); | |
| 171 return iff; | |
| 172 } | |
| 173 | |
| 174 // return Region node | |
| 175 Node* Parse::jump_if_join(Node* iffalse, Node* iftrue) { | |
| 176 Node *region = new (C, 3) RegionNode(3); // 2 results | |
| 177 record_for_igvn(region); | |
| 178 region->init_req(1, iffalse); | |
| 179 region->init_req(2, iftrue ); | |
| 180 _gvn.set_type(region, Type::CONTROL); | |
| 181 region = _gvn.transform(region); | |
| 182 set_control (region); | |
| 183 return region; | |
| 184 } | |
| 185 | |
| 186 | |
| 187 //------------------------------helper for tableswitch------------------------- | |
| 188 void Parse::jump_if_true_fork(IfNode *iff, int dest_bci_if_true, int prof_table_index) { | |
| 189 // True branch, use existing map info | |
| 190 { PreserveJVMState pjvms(this); | |
| 191 Node *iftrue = _gvn.transform( new (C, 1) IfTrueNode (iff) ); | |
| 192 set_control( iftrue ); | |
| 193 profile_switch_case(prof_table_index); | |
| 194 merge_new_path(dest_bci_if_true); | |
| 195 } | |
| 196 | |
| 197 // False branch | |
| 198 Node *iffalse = _gvn.transform( new (C, 1) IfFalseNode(iff) ); | |
| 199 set_control( iffalse ); | |
| 200 } | |
| 201 | |
| 202 void Parse::jump_if_false_fork(IfNode *iff, int dest_bci_if_true, int prof_table_index) { | |
| 203 // True branch, use existing map info | |
| 204 { PreserveJVMState pjvms(this); | |
| 205 Node *iffalse = _gvn.transform( new (C, 1) IfFalseNode (iff) ); | |
| 206 set_control( iffalse ); | |
| 207 profile_switch_case(prof_table_index); | |
| 208 merge_new_path(dest_bci_if_true); | |
| 209 } | |
| 210 | |
| 211 // False branch | |
| 212 Node *iftrue = _gvn.transform( new (C, 1) IfTrueNode(iff) ); | |
| 213 set_control( iftrue ); | |
| 214 } | |
| 215 | |
| 216 void Parse::jump_if_always_fork(int dest_bci, int prof_table_index) { | |
| 217 // False branch, use existing map and control() | |
| 218 profile_switch_case(prof_table_index); | |
| 219 merge_new_path(dest_bci); | |
| 220 } | |
| 221 | |
| 222 | |
| 223 extern "C" { | |
| 224 static int jint_cmp(const void *i, const void *j) { | |
| 225 int a = *(jint *)i; | |
| 226 int b = *(jint *)j; | |
| 227 return a > b ? 1 : a < b ? -1 : 0; | |
| 228 } | |
| 229 } | |
| 230 | |
| 231 | |
| 232 // Default value for methodData switch indexing. Must be a negative value to avoid | |
| 233 // conflict with any legal switch index. | |
| 234 #define NullTableIndex -1 | |
| 235 | |
| 236 class SwitchRange : public StackObj { | |
| 237 // a range of integers coupled with a bci destination | |
| 238 jint _lo; // inclusive lower limit | |
| 239 jint _hi; // inclusive upper limit | |
| 240 int _dest; | |
| 241 int _table_index; // index into method data table | |
| 242 | |
| 243 public: | |
| 244 jint lo() const { return _lo; } | |
| 245 jint hi() const { return _hi; } | |
| 246 int dest() const { return _dest; } | |
| 247 int table_index() const { return _table_index; } | |
| 248 bool is_singleton() const { return _lo == _hi; } | |
| 249 | |
| 250 void setRange(jint lo, jint hi, int dest, int table_index) { | |
| 251 assert(lo <= hi, "must be a non-empty range"); | |
| 252 _lo = lo, _hi = hi; _dest = dest; _table_index = table_index; | |
| 253 } | |
| 254 bool adjoinRange(jint lo, jint hi, int dest, int table_index) { | |
| 255 assert(lo <= hi, "must be a non-empty range"); | |
| 256 if (lo == _hi+1 && dest == _dest && table_index == _table_index) { | |
| 257 _hi = hi; | |
| 258 return true; | |
| 259 } | |
| 260 return false; | |
| 261 } | |
| 262 | |
| 263 void set (jint value, int dest, int table_index) { | |
| 264 setRange(value, value, dest, table_index); | |
| 265 } | |
| 266 bool adjoin(jint value, int dest, int table_index) { | |
| 267 return adjoinRange(value, value, dest, table_index); | |
| 268 } | |
| 269 | |
| 270 void print(ciEnv* env) { | |
| 271 if (is_singleton()) | |
| 272 tty->print(" {%d}=>%d", lo(), dest()); | |
| 273 else if (lo() == min_jint) | |
| 274 tty->print(" {..%d}=>%d", hi(), dest()); | |
| 275 else if (hi() == max_jint) | |
| 276 tty->print(" {%d..}=>%d", lo(), dest()); | |
| 277 else | |
| 278 tty->print(" {%d..%d}=>%d", lo(), hi(), dest()); | |
| 279 } | |
| 280 }; | |
| 281 | |
| 282 | |
| 283 //-------------------------------do_tableswitch-------------------------------- | |
| 284 void Parse::do_tableswitch() { | |
| 285 Node* lookup = pop(); | |
| 286 | |
| 287 // Get information about tableswitch | |
| 288 int default_dest = iter().get_dest_table(0); | |
| 289 int lo_index = iter().get_int_table(1); | |
| 290 int hi_index = iter().get_int_table(2); | |
| 291 int len = hi_index - lo_index + 1; | |
| 292 | |
| 293 if (len < 1) { | |
| 294 // If this is a backward branch, add safepoint | |
| 295 maybe_add_safepoint(default_dest); | |
| 296 merge(default_dest); | |
| 297 return; | |
| 298 } | |
| 299 | |
| 300 // generate decision tree, using trichotomy when possible | |
| 301 int rnum = len+2; | |
| 302 bool makes_backward_branch = false; | |
| 303 SwitchRange* ranges = NEW_RESOURCE_ARRAY(SwitchRange, rnum); | |
| 304 int rp = -1; | |
| 305 if (lo_index != min_jint) { | |
| 306 ranges[++rp].setRange(min_jint, lo_index-1, default_dest, NullTableIndex); | |
| 307 } | |
| 308 for (int j = 0; j < len; j++) { | |
| 309 jint match_int = lo_index+j; | |
| 310 int dest = iter().get_dest_table(j+3); | |
| 311 makes_backward_branch |= (dest <= bci()); | |
| 312 int table_index = method_data_update() ? j : NullTableIndex; | |
| 313 if (rp < 0 || !ranges[rp].adjoin(match_int, dest, table_index)) { | |
| 314 ranges[++rp].set(match_int, dest, table_index); | |
| 315 } | |
| 316 } | |
| 317 jint highest = lo_index+(len-1); | |
| 318 assert(ranges[rp].hi() == highest, ""); | |
| 319 if (highest != max_jint | |
| 320 && !ranges[rp].adjoinRange(highest+1, max_jint, default_dest, NullTableIndex)) { | |
| 321 ranges[++rp].setRange(highest+1, max_jint, default_dest, NullTableIndex); | |
| 322 } | |
| 323 assert(rp < len+2, "not too many ranges"); | |
| 324 | |
| 325 // Safepoint in case if backward branch observed | |
| 326 if( makes_backward_branch && UseLoopSafepoints ) | |
| 327 add_safepoint(); | |
| 328 | |
| 329 jump_switch_ranges(lookup, &ranges[0], &ranges[rp]); | |
| 330 } | |
| 331 | |
| 332 | |
| 333 //------------------------------do_lookupswitch-------------------------------- | |
| 334 void Parse::do_lookupswitch() { | |
| 335 Node *lookup = pop(); // lookup value | |
| 336 // Get information about lookupswitch | |
| 337 int default_dest = iter().get_dest_table(0); | |
| 338 int len = iter().get_int_table(1); | |
| 339 | |
| 340 if (len < 1) { // If this is a backward branch, add safepoint | |
| 341 maybe_add_safepoint(default_dest); | |
| 342 merge(default_dest); | |
| 343 return; | |
| 344 } | |
| 345 | |
| 346 // generate decision tree, using trichotomy when possible | |
| 347 jint* table = NEW_RESOURCE_ARRAY(jint, len*2); | |
| 348 { | |
| 349 for( int j = 0; j < len; j++ ) { | |
| 350 table[j+j+0] = iter().get_int_table(2+j+j); | |
| 351 table[j+j+1] = iter().get_dest_table(2+j+j+1); | |
| 352 } | |
| 353 qsort( table, len, 2*sizeof(table[0]), jint_cmp ); | |
| 354 } | |
| 355 | |
| 356 int rnum = len*2+1; | |
| 357 bool makes_backward_branch = false; | |
| 358 SwitchRange* ranges = NEW_RESOURCE_ARRAY(SwitchRange, rnum); | |
| 359 int rp = -1; | |
| 360 for( int j = 0; j < len; j++ ) { | |
| 361 jint match_int = table[j+j+0]; | |
| 362 int dest = table[j+j+1]; | |
| 363 int next_lo = rp < 0 ? min_jint : ranges[rp].hi()+1; | |
| 364 int table_index = method_data_update() ? j : NullTableIndex; | |
| 365 makes_backward_branch |= (dest <= bci()); | |
| 366 if( match_int != next_lo ) { | |
| 367 ranges[++rp].setRange(next_lo, match_int-1, default_dest, NullTableIndex); | |
| 368 } | |
| 369 if( rp < 0 || !ranges[rp].adjoin(match_int, dest, table_index) ) { | |
| 370 ranges[++rp].set(match_int, dest, table_index); | |
| 371 } | |
| 372 } | |
| 373 jint highest = table[2*(len-1)]; | |
| 374 assert(ranges[rp].hi() == highest, ""); | |
| 375 if( highest != max_jint | |
| 376 && !ranges[rp].adjoinRange(highest+1, max_jint, default_dest, NullTableIndex) ) { | |
| 377 ranges[++rp].setRange(highest+1, max_jint, default_dest, NullTableIndex); | |
| 378 } | |
| 379 assert(rp < rnum, "not too many ranges"); | |
| 380 | |
| 381 // Safepoint in case backward branch observed | |
| 382 if( makes_backward_branch && UseLoopSafepoints ) | |
| 383 add_safepoint(); | |
| 384 | |
| 385 jump_switch_ranges(lookup, &ranges[0], &ranges[rp]); | |
| 386 } | |
| 387 | |
| 388 //----------------------------create_jump_tables------------------------------- | |
| 389 bool Parse::create_jump_tables(Node* key_val, SwitchRange* lo, SwitchRange* hi) { | |
| 390 // Are jumptables enabled | |
| 391 if (!UseJumpTables) return false; | |
| 392 | |
| 393 // Are jumptables supported | |
| 394 if (!Matcher::has_match_rule(Op_Jump)) return false; | |
| 395 | |
| 396 // Don't make jump table if profiling | |
| 397 if (method_data_update()) return false; | |
| 398 | |
| 399 // Decide if a guard is needed to lop off big ranges at either (or | |
| 400 // both) end(s) of the input set. We'll call this the default target | |
| 401 // even though we can't be sure that it is the true "default". | |
| 402 | |
| 403 bool needs_guard = false; | |
| 404 int default_dest; | |
| 405 int64 total_outlier_size = 0; | |
| 406 int64 hi_size = ((int64)hi->hi()) - ((int64)hi->lo()) + 1; | |
| 407 int64 lo_size = ((int64)lo->hi()) - ((int64)lo->lo()) + 1; | |
| 408 | |
| 409 if (lo->dest() == hi->dest()) { | |
| 410 total_outlier_size = hi_size + lo_size; | |
| 411 default_dest = lo->dest(); | |
| 412 } else if (lo_size > hi_size) { | |
| 413 total_outlier_size = lo_size; | |
| 414 default_dest = lo->dest(); | |
| 415 } else { | |
| 416 total_outlier_size = hi_size; | |
| 417 default_dest = hi->dest(); | |
| 418 } | |
| 419 | |
| 420 // If a guard test will eliminate very sparse end ranges, then | |
| 421 // it is worth the cost of an extra jump. | |
| 422 if (total_outlier_size > (MaxJumpTableSparseness * 4)) { | |
| 423 needs_guard = true; | |
| 424 if (default_dest == lo->dest()) lo++; | |
| 425 if (default_dest == hi->dest()) hi--; | |
| 426 } | |
| 427 | |
| 428 // Find the total number of cases and ranges | |
| 429 int64 num_cases = ((int64)hi->hi()) - ((int64)lo->lo()) + 1; | |
| 430 int num_range = hi - lo + 1; | |
| 431 | |
| 432 // Don't create table if: too large, too small, or too sparse. | |
| 433 if (num_cases < MinJumpTableSize || num_cases > MaxJumpTableSize) | |
| 434 return false; | |
| 435 if (num_cases > (MaxJumpTableSparseness * num_range)) | |
| 436 return false; | |
| 437 | |
| 438 // Normalize table lookups to zero | |
| 439 int lowval = lo->lo(); | |
| 440 key_val = _gvn.transform( new (C, 3) SubINode(key_val, _gvn.intcon(lowval)) ); | |
| 441 | |
| 442 // Generate a guard to protect against input keyvals that aren't | |
| 443 // in the switch domain. | |
| 444 if (needs_guard) { | |
| 445 Node* size = _gvn.intcon(num_cases); | |
| 446 Node* cmp = _gvn.transform( new (C, 3) CmpUNode(key_val, size) ); | |
| 447 Node* tst = _gvn.transform( new (C, 2) BoolNode(cmp, BoolTest::ge) ); | |
| 448 IfNode* iff = create_and_map_if( control(), tst, PROB_FAIR, COUNT_UNKNOWN); | |
| 449 jump_if_true_fork(iff, default_dest, NullTableIndex); | |
| 450 } | |
| 451 | |
| 452 // Create an ideal node JumpTable that has projections | |
| 453 // of all possible ranges for a switch statement | |
| 454 // The key_val input must be converted to a pointer offset and scaled. | |
| 455 // Compare Parse::array_addressing above. | |
| 456 #ifdef _LP64 | |
| 457 // Clean the 32-bit int into a real 64-bit offset. | |
| 458 // Otherwise, the jint value 0 might turn into an offset of 0x0800000000. | |
| 459 const TypeLong* lkeytype = TypeLong::make(CONST64(0), num_cases-1, Type::WidenMin); | |
| 460 key_val = _gvn.transform( new (C, 2) ConvI2LNode(key_val, lkeytype) ); | |
| 461 #endif | |
| 462 // Shift the value by wordsize so we have an index into the table, rather | |
| 463 // than a switch value | |
| 464 Node *shiftWord = _gvn.MakeConX(wordSize); | |
| 465 key_val = _gvn.transform( new (C, 3) MulXNode( key_val, shiftWord)); | |
| 466 | |
| 467 // Create the JumpNode | |
| 468 Node* jtn = _gvn.transform( new (C, 2) JumpNode(control(), key_val, num_cases) ); | |
| 469 | |
| 470 // These are the switch destinations hanging off the jumpnode | |
| 471 int i = 0; | |
| 472 for (SwitchRange* r = lo; r <= hi; r++) { | |
| 473 for (int j = r->lo(); j <= r->hi(); j++, i++) { | |
| 474 Node* input = _gvn.transform(new (C, 1) JumpProjNode(jtn, i, r->dest(), j - lowval)); | |
| 475 { | |
| 476 PreserveJVMState pjvms(this); | |
| 477 set_control(input); | |
| 478 jump_if_always_fork(r->dest(), r->table_index()); | |
| 479 } | |
| 480 } | |
| 481 } | |
| 482 assert(i == num_cases, "miscount of cases"); | |
| 483 stop_and_kill_map(); // no more uses for this JVMS | |
| 484 return true; | |
| 485 } | |
| 486 | |
| 487 //----------------------------jump_switch_ranges------------------------------- | |
| 488 void Parse::jump_switch_ranges(Node* key_val, SwitchRange *lo, SwitchRange *hi, int switch_depth) { | |
| 489 Block* switch_block = block(); | |
| 490 | |
| 491 if (switch_depth == 0) { | |
| 492 // Do special processing for the top-level call. | |
| 493 assert(lo->lo() == min_jint, "initial range must exhaust Type::INT"); | |
| 494 assert(hi->hi() == max_jint, "initial range must exhaust Type::INT"); | |
| 495 | |
| 496 // Decrement pred-numbers for the unique set of nodes. | |
| 497 #ifdef ASSERT | |
| 498 // Ensure that the block's successors are a (duplicate-free) set. | |
| 499 int successors_counted = 0; // block occurrences in [hi..lo] | |
| 500 int unique_successors = switch_block->num_successors(); | |
| 501 for (int i = 0; i < unique_successors; i++) { | |
| 502 Block* target = switch_block->successor_at(i); | |
| 503 | |
| 504 // Check that the set of successors is the same in both places. | |
| 505 int successors_found = 0; | |
| 506 for (SwitchRange* p = lo; p <= hi; p++) { | |
| 507 if (p->dest() == target->start()) successors_found++; | |
| 508 } | |
| 509 assert(successors_found > 0, "successor must be known"); | |
| 510 successors_counted += successors_found; | |
| 511 } | |
| 512 assert(successors_counted == (hi-lo)+1, "no unexpected successors"); | |
| 513 #endif | |
| 514 | |
| 515 // Maybe prune the inputs, based on the type of key_val. | |
| 516 jint min_val = min_jint; | |
| 517 jint max_val = max_jint; | |
| 518 const TypeInt* ti = key_val->bottom_type()->isa_int(); | |
| 519 if (ti != NULL) { | |
| 520 min_val = ti->_lo; | |
| 521 max_val = ti->_hi; | |
| 522 assert(min_val <= max_val, "invalid int type"); | |
| 523 } | |
| 524 while (lo->hi() < min_val) lo++; | |
| 525 if (lo->lo() < min_val) lo->setRange(min_val, lo->hi(), lo->dest(), lo->table_index()); | |
| 526 while (hi->lo() > max_val) hi--; | |
| 527 if (hi->hi() > max_val) hi->setRange(hi->lo(), max_val, hi->dest(), hi->table_index()); | |
| 528 } | |
| 529 | |
| 530 #ifndef PRODUCT | |
| 531 if (switch_depth == 0) { | |
| 532 _max_switch_depth = 0; | |
| 533 _est_switch_depth = log2_intptr((hi-lo+1)-1)+1; | |
| 534 } | |
| 535 #endif | |
| 536 | |
| 537 assert(lo <= hi, "must be a non-empty set of ranges"); | |
| 538 if (lo == hi) { | |
| 539 jump_if_always_fork(lo->dest(), lo->table_index()); | |
| 540 } else { | |
| 541 assert(lo->hi() == (lo+1)->lo()-1, "contiguous ranges"); | |
| 542 assert(hi->lo() == (hi-1)->hi()+1, "contiguous ranges"); | |
| 543 | |
| 544 if (create_jump_tables(key_val, lo, hi)) return; | |
| 545 | |
| 546 int nr = hi - lo + 1; | |
| 547 | |
| 548 SwitchRange* mid = lo + nr/2; | |
| 549 // if there is an easy choice, pivot at a singleton: | |
| 550 if (nr > 3 && !mid->is_singleton() && (mid-1)->is_singleton()) mid--; | |
| 551 | |
| 552 assert(lo < mid && mid <= hi, "good pivot choice"); | |
| 553 assert(nr != 2 || mid == hi, "should pick higher of 2"); | |
| 554 assert(nr != 3 || mid == hi-1, "should pick middle of 3"); | |
| 555 | |
| 556 Node *test_val = _gvn.intcon(mid->lo()); | |
| 557 | |
| 558 if (mid->is_singleton()) { | |
| 559 IfNode *iff_ne = jump_if_fork_int(key_val, test_val, BoolTest::ne); | |
| 560 jump_if_false_fork(iff_ne, mid->dest(), mid->table_index()); | |
| 561 | |
| 562 // Special Case: If there are exactly three ranges, and the high | |
| 563 // and low range each go to the same place, omit the "gt" test, | |
| 564 // since it will not discriminate anything. | |
| 565 bool eq_test_only = (hi == lo+2 && hi->dest() == lo->dest()); | |
| 566 if (eq_test_only) { | |
| 567 assert(mid == hi-1, ""); | |
| 568 } | |
| 569 | |
| 570 // if there is a higher range, test for it and process it: | |
| 571 if (mid < hi && !eq_test_only) { | |
| 572 // two comparisons of same values--should enable 1 test for 2 branches | |
| 573 // Use BoolTest::le instead of BoolTest::gt | |
| 574 IfNode *iff_le = jump_if_fork_int(key_val, test_val, BoolTest::le); | |
| 575 Node *iftrue = _gvn.transform( new (C, 1) IfTrueNode(iff_le) ); | |
| 576 Node *iffalse = _gvn.transform( new (C, 1) IfFalseNode(iff_le) ); | |
| 577 { PreserveJVMState pjvms(this); | |
| 578 set_control(iffalse); | |
| 579 jump_switch_ranges(key_val, mid+1, hi, switch_depth+1); | |
| 580 } | |
| 581 set_control(iftrue); | |
| 582 } | |
| 583 | |
| 584 } else { | |
| 585 // mid is a range, not a singleton, so treat mid..hi as a unit | |
| 586 IfNode *iff_ge = jump_if_fork_int(key_val, test_val, BoolTest::ge); | |
| 587 | |
| 588 // if there is a higher range, test for it and process it: | |
| 589 if (mid == hi) { | |
| 590 jump_if_true_fork(iff_ge, mid->dest(), mid->table_index()); | |
| 591 } else { | |
| 592 Node *iftrue = _gvn.transform( new (C, 1) IfTrueNode(iff_ge) ); | |
| 593 Node *iffalse = _gvn.transform( new (C, 1) IfFalseNode(iff_ge) ); | |
| 594 { PreserveJVMState pjvms(this); | |
| 595 set_control(iftrue); | |
| 596 jump_switch_ranges(key_val, mid, hi, switch_depth+1); | |
| 597 } | |
| 598 set_control(iffalse); | |
| 599 } | |
| 600 } | |
| 601 | |
| 602 // in any case, process the lower range | |
| 603 jump_switch_ranges(key_val, lo, mid-1, switch_depth+1); | |
| 604 } | |
| 605 | |
| 606 // Decrease pred_count for each successor after all is done. | |
| 607 if (switch_depth == 0) { | |
| 608 int unique_successors = switch_block->num_successors(); | |
| 609 for (int i = 0; i < unique_successors; i++) { | |
| 610 Block* target = switch_block->successor_at(i); | |
| 611 // Throw away the pre-allocated path for each unique successor. | |
| 612 target->next_path_num(); | |
| 613 } | |
| 614 } | |
| 615 | |
| 616 #ifndef PRODUCT | |
| 617 _max_switch_depth = MAX2(switch_depth, _max_switch_depth); | |
| 618 if (TraceOptoParse && Verbose && WizardMode && switch_depth == 0) { | |
| 619 SwitchRange* r; | |
| 620 int nsing = 0; | |
| 621 for( r = lo; r <= hi; r++ ) { | |
| 622 if( r->is_singleton() ) nsing++; | |
| 623 } | |
| 624 tty->print(">>> "); | |
| 625 _method->print_short_name(); | |
| 626 tty->print_cr(" switch decision tree"); | |
| 627 tty->print_cr(" %d ranges (%d singletons), max_depth=%d, est_depth=%d", | |
| 628 hi-lo+1, nsing, _max_switch_depth, _est_switch_depth); | |
| 629 if (_max_switch_depth > _est_switch_depth) { | |
| 630 tty->print_cr("******** BAD SWITCH DEPTH ********"); | |
| 631 } | |
| 632 tty->print(" "); | |
| 633 for( r = lo; r <= hi; r++ ) { | |
| 634 r->print(env()); | |
| 635 } | |
| 636 tty->print_cr(""); | |
| 637 } | |
| 638 #endif | |
| 639 } | |
| 640 | |
| 641 void Parse::modf() { | |
| 642 Node *f2 = pop(); | |
| 643 Node *f1 = pop(); | |
| 644 Node* c = make_runtime_call(RC_LEAF, OptoRuntime::modf_Type(), | |
| 645 CAST_FROM_FN_PTR(address, SharedRuntime::frem), | |
| 646 "frem", NULL, //no memory effects | |
| 647 f1, f2); | |
| 648 Node* res = _gvn.transform(new (C, 1) ProjNode(c, TypeFunc::Parms + 0)); | |
| 649 | |
| 650 push(res); | |
| 651 } | |
| 652 | |
| 653 void Parse::modd() { | |
| 654 Node *d2 = pop_pair(); | |
| 655 Node *d1 = pop_pair(); | |
| 656 Node* c = make_runtime_call(RC_LEAF, OptoRuntime::Math_DD_D_Type(), | |
| 657 CAST_FROM_FN_PTR(address, SharedRuntime::drem), | |
| 658 "drem", NULL, //no memory effects | |
| 659 d1, top(), d2, top()); | |
| 660 Node* res_d = _gvn.transform(new (C, 1) ProjNode(c, TypeFunc::Parms + 0)); | |
| 661 | |
| 662 #ifdef ASSERT | |
| 663 Node* res_top = _gvn.transform(new (C, 1) ProjNode(c, TypeFunc::Parms + 1)); | |
| 664 assert(res_top == top(), "second value must be top"); | |
| 665 #endif | |
| 666 | |
| 667 push_pair(res_d); | |
| 668 } | |
| 669 | |
| 670 void Parse::l2f() { | |
| 671 Node* f2 = pop(); | |
| 672 Node* f1 = pop(); | |
| 673 Node* c = make_runtime_call(RC_LEAF, OptoRuntime::l2f_Type(), | |
| 674 CAST_FROM_FN_PTR(address, SharedRuntime::l2f), | |
| 675 "l2f", NULL, //no memory effects | |
| 676 f1, f2); | |
| 677 Node* res = _gvn.transform(new (C, 1) ProjNode(c, TypeFunc::Parms + 0)); | |
| 678 | |
| 679 push(res); | |
| 680 } | |
| 681 | |
| 682 void Parse::do_irem() { | |
| 683 // Must keep both values on the expression-stack during null-check | |
| 684 do_null_check(peek(), T_INT); | |
| 685 // Compile-time detect of null-exception? | |
| 686 if (stopped()) return; | |
| 687 | |
| 688 Node* b = pop(); | |
| 689 Node* a = pop(); | |
| 690 | |
| 691 const Type *t = _gvn.type(b); | |
| 692 if (t != Type::TOP) { | |
| 693 const TypeInt *ti = t->is_int(); | |
| 694 if (ti->is_con()) { | |
| 695 int divisor = ti->get_con(); | |
| 696 // check for positive power of 2 | |
| 697 if (divisor > 0 && | |
| 698 (divisor & ~(divisor-1)) == divisor) { | |
| 699 // yes ! | |
| 700 Node *mask = _gvn.intcon((divisor - 1)); | |
| 701 // Sigh, must handle negative dividends | |
| 702 Node *zero = _gvn.intcon(0); | |
| 703 IfNode *ifff = jump_if_fork_int(a, zero, BoolTest::lt); | |
| 704 Node *iff = _gvn.transform( new (C, 1) IfFalseNode(ifff) ); | |
| 705 Node *ift = _gvn.transform( new (C, 1) IfTrueNode (ifff) ); | |
| 706 Node *reg = jump_if_join(ift, iff); | |
| 707 Node *phi = PhiNode::make(reg, NULL, TypeInt::INT); | |
| 708 // Negative path; negate/and/negate | |
| 709 Node *neg = _gvn.transform( new (C, 3) SubINode(zero, a) ); | |
| 710 Node *andn= _gvn.transform( new (C, 3) AndINode(neg, mask) ); | |
| 711 Node *negn= _gvn.transform( new (C, 3) SubINode(zero, andn) ); | |
| 712 phi->init_req(1, negn); | |
| 713 // Fast positive case | |
| 714 Node *andx = _gvn.transform( new (C, 3) AndINode(a, mask) ); | |
| 715 phi->init_req(2, andx); | |
| 716 // Push the merge | |
| 717 push( _gvn.transform(phi) ); | |
| 718 return; | |
| 719 } | |
| 720 } | |
| 721 } | |
| 722 // Default case | |
| 723 push( _gvn.transform( new (C, 3) ModINode(control(),a,b) ) ); | |
| 724 } | |
| 725 | |
| 726 // Handle jsr and jsr_w bytecode | |
| 727 void Parse::do_jsr() { | |
| 728 assert(bc() == Bytecodes::_jsr || bc() == Bytecodes::_jsr_w, "wrong bytecode"); | |
| 729 | |
| 730 // Store information about current state, tagged with new _jsr_bci | |
| 731 int return_bci = iter().next_bci(); | |
| 732 int jsr_bci = (bc() == Bytecodes::_jsr) ? iter().get_dest() : iter().get_far_dest(); | |
| 733 | |
| 734 // Update method data | |
| 735 profile_taken_branch(jsr_bci); | |
| 736 | |
| 737 // The way we do things now, there is only one successor block | |
| 738 // for the jsr, because the target code is cloned by ciTypeFlow. | |
| 739 Block* target = successor_for_bci(jsr_bci); | |
| 740 | |
| 741 // What got pushed? | |
| 742 const Type* ret_addr = target->peek(); | |
| 743 assert(ret_addr->singleton(), "must be a constant (cloned jsr body)"); | |
| 744 | |
| 745 // Effect on jsr on stack | |
| 746 push(_gvn.makecon(ret_addr)); | |
| 747 | |
| 748 // Flow to the jsr. | |
| 749 merge(jsr_bci); | |
| 750 } | |
| 751 | |
| 752 // Handle ret bytecode | |
| 753 void Parse::do_ret() { | |
| 754 // Find to whom we return. | |
| 755 assert(block()->num_successors() == 1, "a ret can only go one place now"); | |
| 756 Block* target = block()->successor_at(0); | |
| 757 assert(!target->is_ready(), "our arrival must be expected"); | |
| 758 profile_ret(target->flow()->start()); | |
| 759 int pnum = target->next_path_num(); | |
| 760 merge_common(target, pnum); | |
| 761 } | |
| 762 | |
| 763 //--------------------------dynamic_branch_prediction-------------------------- | |
| 764 // Try to gather dynamic branch prediction behavior. Return a probability | |
| 765 // of the branch being taken and set the "cnt" field. Returns a -1.0 | |
| 766 // if we need to use static prediction for some reason. | |
| 767 float Parse::dynamic_branch_prediction(float &cnt) { | |
| 768 ResourceMark rm; | |
| 769 | |
| 770 cnt = COUNT_UNKNOWN; | |
| 771 | |
| 772 // Use MethodData information if it is available | |
| 773 // FIXME: free the ProfileData structure | |
| 774 ciMethodData* methodData = method()->method_data(); | |
| 775 if (!methodData->is_mature()) return PROB_UNKNOWN; | |
| 776 ciProfileData* data = methodData->bci_to_data(bci()); | |
| 777 if (!data->is_JumpData()) return PROB_UNKNOWN; | |
| 778 | |
| 779 // get taken and not taken values | |
| 780 int taken = data->as_JumpData()->taken(); | |
| 781 int not_taken = 0; | |
| 782 if (data->is_BranchData()) { | |
| 783 not_taken = data->as_BranchData()->not_taken(); | |
| 784 } | |
| 785 | |
| 786 // scale the counts to be commensurate with invocation counts: | |
| 787 taken = method()->scale_count(taken); | |
| 788 not_taken = method()->scale_count(not_taken); | |
| 789 | |
|
2481
3a808be061ff
6988308: assert((cnt > 0.0f) && (prob > 0.0f)) failed: Bad frequency assignment in if
iveresov
parents:
2426
diff
changeset
|
790 // Give up if too few (or too many, in which case the sum will overflow) counts to be meaningful. |
|
3a808be061ff
6988308: assert((cnt > 0.0f) && (prob > 0.0f)) failed: Bad frequency assignment in if
iveresov
parents:
2426
diff
changeset
|
791 // We also check that individual counters are positive first, overwise the sum can become positive. |
|
3a808be061ff
6988308: assert((cnt > 0.0f) && (prob > 0.0f)) failed: Bad frequency assignment in if
iveresov
parents:
2426
diff
changeset
|
792 if (taken < 0 || not_taken < 0 || taken + not_taken < 40) { |
| 0 | 793 if (C->log() != NULL) { |
| 794 C->log()->elem("branch target_bci='%d' taken='%d' not_taken='%d'", iter().get_dest(), taken, not_taken); | |
| 795 } | |
| 796 return PROB_UNKNOWN; | |
| 797 } | |
| 798 | |
| 799 // Compute frequency that we arrive here | |
|
2481
3a808be061ff
6988308: assert((cnt > 0.0f) && (prob > 0.0f)) failed: Bad frequency assignment in if
iveresov
parents:
2426
diff
changeset
|
800 float sum = taken + not_taken; |
| 0 | 801 // Adjust, if this block is a cloned private block but the |
| 802 // Jump counts are shared. Taken the private counts for | |
| 803 // just this path instead of the shared counts. | |
| 804 if( block()->count() > 0 ) | |
| 805 sum = block()->count(); | |
|
2481
3a808be061ff
6988308: assert((cnt > 0.0f) && (prob > 0.0f)) failed: Bad frequency assignment in if
iveresov
parents:
2426
diff
changeset
|
806 cnt = sum / FreqCountInvocations; |
| 0 | 807 |
| 808 // Pin probability to sane limits | |
| 809 float prob; | |
| 810 if( !taken ) | |
| 811 prob = (0+PROB_MIN) / 2; | |
| 812 else if( !not_taken ) | |
| 813 prob = (1+PROB_MAX) / 2; | |
| 814 else { // Compute probability of true path | |
| 815 prob = (float)taken / (float)(taken + not_taken); | |
| 816 if (prob > PROB_MAX) prob = PROB_MAX; | |
| 817 if (prob < PROB_MIN) prob = PROB_MIN; | |
| 818 } | |
| 819 | |
| 820 assert((cnt > 0.0f) && (prob > 0.0f), | |
| 821 "Bad frequency assignment in if"); | |
| 822 | |
| 823 if (C->log() != NULL) { | |
| 824 const char* prob_str = NULL; | |
| 825 if (prob >= PROB_MAX) prob_str = (prob == PROB_MAX) ? "max" : "always"; | |
| 826 if (prob <= PROB_MIN) prob_str = (prob == PROB_MIN) ? "min" : "never"; | |
| 827 char prob_str_buf[30]; | |
| 828 if (prob_str == NULL) { | |
| 829 sprintf(prob_str_buf, "%g", prob); | |
| 830 prob_str = prob_str_buf; | |
| 831 } | |
| 832 C->log()->elem("branch target_bci='%d' taken='%d' not_taken='%d' cnt='%g' prob='%s'", | |
| 833 iter().get_dest(), taken, not_taken, cnt, prob_str); | |
| 834 } | |
| 835 return prob; | |
| 836 } | |
| 837 | |
| 838 //-----------------------------branch_prediction------------------------------- | |
| 839 float Parse::branch_prediction(float& cnt, | |
| 840 BoolTest::mask btest, | |
| 841 int target_bci) { | |
| 842 float prob = dynamic_branch_prediction(cnt); | |
| 843 // If prob is unknown, switch to static prediction | |
| 844 if (prob != PROB_UNKNOWN) return prob; | |
| 845 | |
| 846 prob = PROB_FAIR; // Set default value | |
| 847 if (btest == BoolTest::eq) // Exactly equal test? | |
| 848 prob = PROB_STATIC_INFREQUENT; // Assume its relatively infrequent | |
| 849 else if (btest == BoolTest::ne) | |
| 850 prob = PROB_STATIC_FREQUENT; // Assume its relatively frequent | |
| 851 | |
| 852 // If this is a conditional test guarding a backwards branch, | |
| 853 // assume its a loop-back edge. Make it a likely taken branch. | |
| 854 if (target_bci < bci()) { | |
| 855 if (is_osr_parse()) { // Could be a hot OSR'd loop; force deopt | |
| 856 // Since it's an OSR, we probably have profile data, but since | |
| 857 // branch_prediction returned PROB_UNKNOWN, the counts are too small. | |
| 858 // Let's make a special check here for completely zero counts. | |
| 859 ciMethodData* methodData = method()->method_data(); | |
| 860 if (!methodData->is_empty()) { | |
| 861 ciProfileData* data = methodData->bci_to_data(bci()); | |
| 862 // Only stop for truly zero counts, which mean an unknown part | |
| 863 // of the OSR-ed method, and we want to deopt to gather more stats. | |
| 864 // If you have ANY counts, then this loop is simply 'cold' relative | |
| 865 // to the OSR loop. | |
| 866 if (data->as_BranchData()->taken() + | |
| 867 data->as_BranchData()->not_taken() == 0 ) { | |
| 868 // This is the only way to return PROB_UNKNOWN: | |
| 869 return PROB_UNKNOWN; | |
| 870 } | |
| 871 } | |
| 872 } | |
| 873 prob = PROB_STATIC_FREQUENT; // Likely to take backwards branch | |
| 874 } | |
| 875 | |
| 876 assert(prob != PROB_UNKNOWN, "must have some guess at this point"); | |
| 877 return prob; | |
| 878 } | |
| 879 | |
| 880 // The magic constants are chosen so as to match the output of | |
| 881 // branch_prediction() when the profile reports a zero taken count. | |
| 882 // It is important to distinguish zero counts unambiguously, because | |
| 883 // some branches (e.g., _213_javac.Assembler.eliminate) validly produce | |
| 884 // very small but nonzero probabilities, which if confused with zero | |
| 885 // counts would keep the program recompiling indefinitely. | |
| 886 bool Parse::seems_never_taken(float prob) { | |
| 887 return prob < PROB_MIN; | |
| 888 } | |
| 889 | |
|
1746
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
890 // True if the comparison seems to be the kind that will not change its |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
891 // statistics from true to false. See comments in adjust_map_after_if. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
892 // This question is only asked along paths which are already |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
893 // classifed as untaken (by seems_never_taken), so really, |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
894 // if a path is never taken, its controlling comparison is |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
895 // already acting in a stable fashion. If the comparison |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
896 // seems stable, we will put an expensive uncommon trap |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
897 // on the untaken path. To be conservative, and to allow |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
898 // partially executed counted loops to be compiled fully, |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
899 // we will plant uncommon traps only after pointer comparisons. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
900 bool Parse::seems_stable_comparison(BoolTest::mask btest, Node* cmp) { |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
901 for (int depth = 4; depth > 0; depth--) { |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
902 // The following switch can find CmpP here over half the time for |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
903 // dynamic language code rich with type tests. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
904 // Code using counted loops or array manipulations (typical |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
905 // of benchmarks) will have many (>80%) CmpI instructions. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
906 switch (cmp->Opcode()) { |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
907 case Op_CmpP: |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
908 // A never-taken null check looks like CmpP/BoolTest::eq. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
909 // These certainly should be closed off as uncommon traps. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
910 if (btest == BoolTest::eq) |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
911 return true; |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
912 // A never-failed type check looks like CmpP/BoolTest::ne. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
913 // Let's put traps on those, too, so that we don't have to compile |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
914 // unused paths with indeterminate dynamic type information. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
915 if (ProfileDynamicTypes) |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
916 return true; |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
917 return false; |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
918 |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
919 case Op_CmpI: |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
920 // A small minority (< 10%) of CmpP are masked as CmpI, |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
921 // as if by boolean conversion ((p == q? 1: 0) != 0). |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
922 // Detect that here, even if it hasn't optimized away yet. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
923 // Specifically, this covers the 'instanceof' operator. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
924 if (btest == BoolTest::ne || btest == BoolTest::eq) { |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
925 if (_gvn.type(cmp->in(2))->singleton() && |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
926 cmp->in(1)->is_Phi()) { |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
927 PhiNode* phi = cmp->in(1)->as_Phi(); |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
928 int true_path = phi->is_diamond_phi(); |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
929 if (true_path > 0 && |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
930 _gvn.type(phi->in(1))->singleton() && |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
931 _gvn.type(phi->in(2))->singleton()) { |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
932 // phi->region->if_proj->ifnode->bool->cmp |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
933 BoolNode* bol = phi->in(0)->in(1)->in(0)->in(1)->as_Bool(); |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
934 btest = bol->_test._test; |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
935 cmp = bol->in(1); |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
936 continue; |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
937 } |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
938 } |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
939 } |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
940 return false; |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
941 } |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
942 } |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
943 return false; |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
944 } |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
945 |
|
246
9b66e6287f4a
6707044: uncommon_trap of ifnull bytecode leaves garbage on expression stack
rasbold
parents:
235
diff
changeset
|
946 //-------------------------------repush_if_args-------------------------------- |
|
9b66e6287f4a
6707044: uncommon_trap of ifnull bytecode leaves garbage on expression stack
rasbold
parents:
235
diff
changeset
|
947 // Push arguments of an "if" bytecode back onto the stack by adjusting _sp. |
| 1172 | 948 inline int Parse::repush_if_args() { |
| 0 | 949 #ifndef PRODUCT |
| 950 if (PrintOpto && WizardMode) { | |
| 951 tty->print("defending against excessive implicit null exceptions on %s @%d in ", | |
| 952 Bytecodes::name(iter().cur_bc()), iter().cur_bci()); | |
| 953 method()->print_name(); tty->cr(); | |
| 954 } | |
| 955 #endif | |
| 956 int bc_depth = - Bytecodes::depth(iter().cur_bc()); | |
| 957 assert(bc_depth == 1 || bc_depth == 2, "only two kinds of branches"); | |
| 958 DEBUG_ONLY(sync_jvms()); // argument(n) requires a synced jvms | |
| 959 assert(argument(0) != NULL, "must exist"); | |
| 960 assert(bc_depth == 1 || argument(1) != NULL, "two must exist"); | |
| 961 _sp += bc_depth; | |
| 1172 | 962 return bc_depth; |
| 0 | 963 } |
| 964 | |
| 965 //----------------------------------do_ifnull---------------------------------- | |
|
248
18aab3cdd513
6726504: handle do_ifxxx calls in parser more uniformly
rasbold
parents:
246
diff
changeset
|
966 void Parse::do_ifnull(BoolTest::mask btest, Node *c) { |
| 0 | 967 int target_bci = iter().get_dest(); |
| 968 | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
969 Block* branch_block = successor_for_bci(target_bci); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
970 Block* next_block = successor_for_bci(iter().next_bci()); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
971 |
| 0 | 972 float cnt; |
| 973 float prob = branch_prediction(cnt, btest, target_bci); | |
| 974 if (prob == PROB_UNKNOWN) { | |
| 975 // (An earlier version of do_ifnull omitted this trap for OSR methods.) | |
| 976 #ifndef PRODUCT | |
| 977 if (PrintOpto && Verbose) | |
|
248
18aab3cdd513
6726504: handle do_ifxxx calls in parser more uniformly
rasbold
parents:
246
diff
changeset
|
978 tty->print_cr("Never-taken edge stops compilation at bci %d",bci()); |
| 0 | 979 #endif |
|
248
18aab3cdd513
6726504: handle do_ifxxx calls in parser more uniformly
rasbold
parents:
246
diff
changeset
|
980 repush_if_args(); // to gather stats on loop |
| 0 | 981 // We need to mark this branch as taken so that if we recompile we will |
| 982 // see that it is possible. In the tiered system the interpreter doesn't | |
| 983 // do profiling and by the time we get to the lower tier from the interpreter | |
| 984 // the path may be cold again. Make sure it doesn't look untaken | |
| 985 profile_taken_branch(target_bci, !ProfileInterpreter); | |
| 986 uncommon_trap(Deoptimization::Reason_unreached, | |
| 987 Deoptimization::Action_reinterpret, | |
| 988 NULL, "cold"); | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
989 if (EliminateAutoBox) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
990 // Mark the successor blocks as parsed |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
991 branch_block->next_path_num(); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
992 next_block->next_path_num(); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
993 } |
| 0 | 994 return; |
| 995 } | |
| 996 | |
| 997 explicit_null_checks_inserted++; | |
| 998 | |
| 999 // Generate real control flow | |
| 1000 Node *tst = _gvn.transform( new (C, 2) BoolNode( c, btest ) ); | |
| 1001 | |
| 1002 // Sanity check the probability value | |
| 1003 assert(prob > 0.0f,"Bad probability in Parser"); | |
| 1004 // Need xform to put node in hash table | |
| 1005 IfNode *iff = create_and_xform_if( control(), tst, prob, cnt ); | |
| 1006 assert(iff->_prob > 0.0f,"Optimizer made bad probability in parser"); | |
| 1007 // True branch | |
| 1008 { PreserveJVMState pjvms(this); | |
| 1009 Node* iftrue = _gvn.transform( new (C, 1) IfTrueNode (iff) ); | |
| 1010 set_control(iftrue); | |
| 1011 | |
| 1012 if (stopped()) { // Path is dead? | |
| 1013 explicit_null_checks_elided++; | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1014 if (EliminateAutoBox) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1015 // Mark the successor block as parsed |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1016 branch_block->next_path_num(); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1017 } |
| 0 | 1018 } else { // Path is live. |
| 1019 // Update method data | |
| 1020 profile_taken_branch(target_bci); | |
| 1021 adjust_map_after_if(btest, c, prob, branch_block, next_block); | |
| 1172 | 1022 if (!stopped()) { |
| 0 | 1023 merge(target_bci); |
| 1172 | 1024 } |
| 0 | 1025 } |
| 1026 } | |
| 1027 | |
| 1028 // False branch | |
| 1029 Node* iffalse = _gvn.transform( new (C, 1) IfFalseNode(iff) ); | |
| 1030 set_control(iffalse); | |
| 1031 | |
| 1032 if (stopped()) { // Path is dead? | |
| 1033 explicit_null_checks_elided++; | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1034 if (EliminateAutoBox) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1035 // Mark the successor block as parsed |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1036 next_block->next_path_num(); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1037 } |
| 0 | 1038 } else { // Path is live. |
| 1039 // Update method data | |
| 1040 profile_not_taken_branch(); | |
| 1041 adjust_map_after_if(BoolTest(btest).negate(), c, 1.0-prob, | |
| 1042 next_block, branch_block); | |
| 1043 } | |
| 1044 } | |
| 1045 | |
| 1046 //------------------------------------do_if------------------------------------ | |
| 1047 void Parse::do_if(BoolTest::mask btest, Node* c) { | |
| 1048 int target_bci = iter().get_dest(); | |
| 1049 | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1050 Block* branch_block = successor_for_bci(target_bci); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1051 Block* next_block = successor_for_bci(iter().next_bci()); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1052 |
| 0 | 1053 float cnt; |
| 1054 float prob = branch_prediction(cnt, btest, target_bci); | |
| 1055 float untaken_prob = 1.0 - prob; | |
| 1056 | |
| 1057 if (prob == PROB_UNKNOWN) { | |
| 1058 #ifndef PRODUCT | |
| 1059 if (PrintOpto && Verbose) | |
|
248
18aab3cdd513
6726504: handle do_ifxxx calls in parser more uniformly
rasbold
parents:
246
diff
changeset
|
1060 tty->print_cr("Never-taken edge stops compilation at bci %d",bci()); |
| 0 | 1061 #endif |
| 1062 repush_if_args(); // to gather stats on loop | |
| 1063 // We need to mark this branch as taken so that if we recompile we will | |
| 1064 // see that it is possible. In the tiered system the interpreter doesn't | |
| 1065 // do profiling and by the time we get to the lower tier from the interpreter | |
| 1066 // the path may be cold again. Make sure it doesn't look untaken | |
| 1067 profile_taken_branch(target_bci, !ProfileInterpreter); | |
| 1068 uncommon_trap(Deoptimization::Reason_unreached, | |
| 1069 Deoptimization::Action_reinterpret, | |
| 1070 NULL, "cold"); | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1071 if (EliminateAutoBox) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1072 // Mark the successor blocks as parsed |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1073 branch_block->next_path_num(); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1074 next_block->next_path_num(); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1075 } |
| 0 | 1076 return; |
| 1077 } | |
| 1078 | |
| 1079 // Sanity check the probability value | |
| 1080 assert(0.0f < prob && prob < 1.0f,"Bad probability in Parser"); | |
| 1081 | |
| 1082 bool taken_if_true = true; | |
| 1083 // Convert BoolTest to canonical form: | |
| 1084 if (!BoolTest(btest).is_canonical()) { | |
| 1085 btest = BoolTest(btest).negate(); | |
| 1086 taken_if_true = false; | |
| 1087 // prob is NOT updated here; it remains the probability of the taken | |
| 1088 // path (as opposed to the prob of the path guarded by an 'IfTrueNode'). | |
| 1089 } | |
| 1090 assert(btest != BoolTest::eq, "!= is the only canonical exact test"); | |
| 1091 | |
| 1092 Node* tst0 = new (C, 2) BoolNode(c, btest); | |
| 1093 Node* tst = _gvn.transform(tst0); | |
| 1094 BoolTest::mask taken_btest = BoolTest::illegal; | |
| 1095 BoolTest::mask untaken_btest = BoolTest::illegal; | |
|
37
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1096 |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1097 if (tst->is_Bool()) { |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1098 // Refresh c from the transformed bool node, since it may be |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1099 // simpler than the original c. Also re-canonicalize btest. |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1100 // This wins when (Bool ne (Conv2B p) 0) => (Bool ne (CmpP p NULL)). |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1101 // That can arise from statements like: if (x instanceof C) ... |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1102 if (tst != tst0) { |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1103 // Canonicalize one more time since transform can change it. |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1104 btest = tst->as_Bool()->_test._test; |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1105 if (!BoolTest(btest).is_canonical()) { |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1106 // Reverse edges one more time... |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1107 tst = _gvn.transform( tst->as_Bool()->negate(&_gvn) ); |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1108 btest = tst->as_Bool()->_test._test; |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1109 assert(BoolTest(btest).is_canonical(), "sanity"); |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1110 taken_if_true = !taken_if_true; |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1111 } |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1112 c = tst->in(1); |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1113 } |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1114 BoolTest::mask neg_btest = BoolTest(btest).negate(); |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1115 taken_btest = taken_if_true ? btest : neg_btest; |
|
73970d8c0b27
6671250: In Parse::do_if() old Cmp node 'c' should be replaced with new one after BoolNode transformation
kvn
parents:
17
diff
changeset
|
1116 untaken_btest = taken_if_true ? neg_btest : btest; |
| 0 | 1117 } |
| 1118 | |
| 1119 // Generate real control flow | |
| 1120 float true_prob = (taken_if_true ? prob : untaken_prob); | |
| 1121 IfNode* iff = create_and_map_if(control(), tst, true_prob, cnt); | |
| 1122 assert(iff->_prob > 0.0f,"Optimizer made bad probability in parser"); | |
| 1123 Node* taken_branch = new (C, 1) IfTrueNode(iff); | |
| 1124 Node* untaken_branch = new (C, 1) IfFalseNode(iff); | |
| 1125 if (!taken_if_true) { // Finish conversion to canonical form | |
| 1126 Node* tmp = taken_branch; | |
| 1127 taken_branch = untaken_branch; | |
| 1128 untaken_branch = tmp; | |
| 1129 } | |
| 1130 | |
| 1131 // Branch is taken: | |
| 1132 { PreserveJVMState pjvms(this); | |
| 1133 taken_branch = _gvn.transform(taken_branch); | |
| 1134 set_control(taken_branch); | |
| 1135 | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1136 if (stopped()) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1137 if (EliminateAutoBox) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1138 // Mark the successor block as parsed |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1139 branch_block->next_path_num(); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1140 } |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1141 } else { |
| 0 | 1142 // Update method data |
| 1143 profile_taken_branch(target_bci); | |
| 1144 adjust_map_after_if(taken_btest, c, prob, branch_block, next_block); | |
| 1172 | 1145 if (!stopped()) { |
| 0 | 1146 merge(target_bci); |
| 1172 | 1147 } |
| 0 | 1148 } |
| 1149 } | |
| 1150 | |
| 1151 untaken_branch = _gvn.transform(untaken_branch); | |
| 1152 set_control(untaken_branch); | |
| 1153 | |
| 1154 // Branch not taken. | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1155 if (stopped()) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1156 if (EliminateAutoBox) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1157 // Mark the successor block as parsed |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1158 next_block->next_path_num(); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1159 } |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
1160 } else { |
| 0 | 1161 // Update method data |
| 1162 profile_not_taken_branch(); | |
| 1163 adjust_map_after_if(untaken_btest, c, untaken_prob, | |
| 1164 next_block, branch_block); | |
| 1165 } | |
| 1166 } | |
| 1167 | |
| 1168 //----------------------------adjust_map_after_if------------------------------ | |
| 1169 // Adjust the JVM state to reflect the result of taking this path. | |
| 1170 // Basically, it means inspecting the CmpNode controlling this | |
| 1171 // branch, seeing how it constrains a tested value, and then | |
| 1172 // deciding if it's worth our while to encode this constraint | |
| 1173 // as graph nodes in the current abstract interpretation map. | |
| 1174 void Parse::adjust_map_after_if(BoolTest::mask btest, Node* c, float prob, | |
| 1175 Block* path, Block* other_path) { | |
| 1176 if (stopped() || !c->is_Cmp() || btest == BoolTest::illegal) | |
| 1177 return; // nothing to do | |
| 1178 | |
| 1179 bool is_fallthrough = (path == successor_for_bci(iter().next_bci())); | |
| 1180 | |
|
1746
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
1181 if (seems_never_taken(prob) && seems_stable_comparison(btest, c)) { |
| 0 | 1182 // If this might possibly turn into an implicit null check, |
| 1183 // and the null has never yet been seen, we need to generate | |
| 1184 // an uncommon trap, so as to recompile instead of suffering | |
| 1185 // with very slow branches. (We'll get the slow branches if | |
| 1186 // the program ever changes phase and starts seeing nulls here.) | |
| 1187 // | |
|
1746
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
1188 // We do not inspect for a null constant, since a node may |
| 0 | 1189 // optimize to 'null' later on. |
|
1746
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
1190 // |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
1191 // Null checks, and other tests which expect inequality, |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
1192 // show btest == BoolTest::eq along the non-taken branch. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
1193 // On the other hand, type tests, must-be-null tests, |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
1194 // and other tests which expect pointer equality, |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
1195 // show btest == BoolTest::ne along the non-taken branch. |
|
4b29a725c43c
6912064: type profiles need to be exploited more for dynamic language support
jrose
parents:
1602
diff
changeset
|
1196 // We prune both types of branches if they look unused. |
| 0 | 1197 repush_if_args(); |
| 1198 // We need to mark this branch as taken so that if we recompile we will | |
| 1199 // see that it is possible. In the tiered system the interpreter doesn't | |
| 1200 // do profiling and by the time we get to the lower tier from the interpreter | |
| 1201 // the path may be cold again. Make sure it doesn't look untaken | |
| 1202 if (is_fallthrough) { | |
| 1203 profile_not_taken_branch(!ProfileInterpreter); | |
| 1204 } else { | |
| 1205 profile_taken_branch(iter().get_dest(), !ProfileInterpreter); | |
| 1206 } | |
| 1207 uncommon_trap(Deoptimization::Reason_unreached, | |
| 1208 Deoptimization::Action_reinterpret, | |
| 1209 NULL, | |
| 1210 (is_fallthrough ? "taken always" : "taken never")); | |
| 1211 return; | |
| 1212 } | |
| 1213 | |
| 1214 Node* val = c->in(1); | |
| 1215 Node* con = c->in(2); | |
| 1216 const Type* tcon = _gvn.type(con); | |
| 1217 const Type* tval = _gvn.type(val); | |
| 1218 bool have_con = tcon->singleton(); | |
| 1219 if (tval->singleton()) { | |
| 1220 if (!have_con) { | |
| 1221 // Swap, so constant is in con. | |
| 1222 con = val; | |
| 1223 tcon = tval; | |
| 1224 val = c->in(2); | |
| 1225 tval = _gvn.type(val); | |
| 1226 btest = BoolTest(btest).commute(); | |
| 1227 have_con = true; | |
| 1228 } else { | |
| 1229 // Do we have two constants? Then leave well enough alone. | |
| 1230 have_con = false; | |
| 1231 } | |
| 1232 } | |
| 1233 if (!have_con) // remaining adjustments need a con | |
| 1234 return; | |
| 1235 | |
| 1236 | |
| 1237 int val_in_map = map()->find_edge(val); | |
| 1238 if (val_in_map < 0) return; // replace_in_map would be useless | |
| 1239 { | |
| 1240 JVMState* jvms = this->jvms(); | |
| 1241 if (!(jvms->is_loc(val_in_map) || | |
| 1242 jvms->is_stk(val_in_map))) | |
| 1243 return; // again, it would be useless | |
| 1244 } | |
| 1245 | |
| 1246 // Check for a comparison to a constant, and "know" that the compared | |
| 1247 // value is constrained on this path. | |
| 1248 assert(tcon->singleton(), ""); | |
| 1249 ConstraintCastNode* ccast = NULL; | |
| 1250 Node* cast = NULL; | |
| 1251 | |
| 1252 switch (btest) { | |
| 1253 case BoolTest::eq: // Constant test? | |
| 1254 { | |
| 1255 const Type* tboth = tcon->join(tval); | |
| 1256 if (tboth == tval) break; // Nothing to gain. | |
| 1257 if (tcon->isa_int()) { | |
| 1258 ccast = new (C, 2) CastIINode(val, tboth); | |
| 1259 } else if (tcon == TypePtr::NULL_PTR) { | |
| 1260 // Cast to null, but keep the pointer identity temporarily live. | |
| 1261 ccast = new (C, 2) CastPPNode(val, tboth); | |
| 1262 } else { | |
| 1263 const TypeF* tf = tcon->isa_float_constant(); | |
| 1264 const TypeD* td = tcon->isa_double_constant(); | |
| 1265 // Exclude tests vs float/double 0 as these could be | |
| 1266 // either +0 or -0. Just because you are equal to +0 | |
| 1267 // doesn't mean you ARE +0! | |
| 1268 if ((!tf || tf->_f != 0.0) && | |
| 1269 (!td || td->_d != 0.0)) | |
| 1270 cast = con; // Replace non-constant val by con. | |
| 1271 } | |
| 1272 } | |
| 1273 break; | |
| 1274 | |
| 1275 case BoolTest::ne: | |
| 1276 if (tcon == TypePtr::NULL_PTR) { | |
| 1277 cast = cast_not_null(val, false); | |
| 1278 } | |
| 1279 break; | |
| 1280 | |
| 1281 default: | |
| 1282 // (At this point we could record int range types with CastII.) | |
| 1283 break; | |
| 1284 } | |
| 1285 | |
| 1286 if (ccast != NULL) { | |
| 1287 const Type* tcc = ccast->as_Type()->type(); | |
| 1288 assert(tcc != tval && tcc->higher_equal(tval), "must improve"); | |
| 1289 // Delay transform() call to allow recovery of pre-cast value | |
| 1290 // at the control merge. | |
| 1291 ccast->set_req(0, control()); | |
| 1292 _gvn.set_type_bottom(ccast); | |
| 1293 record_for_igvn(ccast); | |
| 1294 cast = ccast; | |
| 1295 } | |
| 1296 | |
| 1297 if (cast != NULL) { // Here's the payoff. | |
| 1298 replace_in_map(val, cast); | |
| 1299 } | |
| 1300 } | |
| 1301 | |
| 1302 | |
| 1303 //------------------------------do_one_bytecode-------------------------------- | |
| 1304 // Parse this bytecode, and alter the Parsers JVM->Node mapping | |
| 1305 void Parse::do_one_bytecode() { | |
| 1306 Node *a, *b, *c, *d; // Handy temps | |
| 1307 BoolTest::mask btest; | |
| 1308 int i; | |
| 1309 | |
| 1310 assert(!has_exceptions(), "bytecode entry state must be clear of throws"); | |
| 1311 | |
| 1312 if (C->check_node_count(NodeLimitFudgeFactor * 5, | |
| 1313 "out of nodes parsing method")) { | |
| 1314 return; | |
| 1315 } | |
| 1316 | |
| 1317 #ifdef ASSERT | |
| 1318 // for setting breakpoints | |
| 1319 if (TraceOptoParse) { | |
| 1320 tty->print(" @"); | |
| 1321 dump_bci(bci()); | |
| 1322 } | |
| 1323 #endif | |
| 1324 | |
| 1325 switch (bc()) { | |
| 1326 case Bytecodes::_nop: | |
| 1327 // do nothing | |
| 1328 break; | |
| 1329 case Bytecodes::_lconst_0: | |
| 1330 push_pair(longcon(0)); | |
| 1331 break; | |
| 1332 | |
| 1333 case Bytecodes::_lconst_1: | |
| 1334 push_pair(longcon(1)); | |
| 1335 break; | |
| 1336 | |
| 1337 case Bytecodes::_fconst_0: | |
| 1338 push(zerocon(T_FLOAT)); | |
| 1339 break; | |
| 1340 | |
| 1341 case Bytecodes::_fconst_1: | |
| 1342 push(makecon(TypeF::ONE)); | |
| 1343 break; | |
| 1344 | |
| 1345 case Bytecodes::_fconst_2: | |
| 1346 push(makecon(TypeF::make(2.0f))); | |
| 1347 break; | |
| 1348 | |
| 1349 case Bytecodes::_dconst_0: | |
| 1350 push_pair(zerocon(T_DOUBLE)); | |
| 1351 break; | |
| 1352 | |
| 1353 case Bytecodes::_dconst_1: | |
| 1354 push_pair(makecon(TypeD::ONE)); | |
| 1355 break; | |
| 1356 | |
| 1357 case Bytecodes::_iconst_m1:push(intcon(-1)); break; | |
| 1358 case Bytecodes::_iconst_0: push(intcon( 0)); break; | |
| 1359 case Bytecodes::_iconst_1: push(intcon( 1)); break; | |
| 1360 case Bytecodes::_iconst_2: push(intcon( 2)); break; | |
| 1361 case Bytecodes::_iconst_3: push(intcon( 3)); break; | |
| 1362 case Bytecodes::_iconst_4: push(intcon( 4)); break; | |
| 1363 case Bytecodes::_iconst_5: push(intcon( 5)); break; | |
| 1565 | 1364 case Bytecodes::_bipush: push(intcon(iter().get_constant_u1())); break; |
| 1365 case Bytecodes::_sipush: push(intcon(iter().get_constant_u2())); break; | |
| 0 | 1366 case Bytecodes::_aconst_null: push(null()); break; |
| 1367 case Bytecodes::_ldc: | |
| 1368 case Bytecodes::_ldc_w: | |
| 1369 case Bytecodes::_ldc2_w: | |
| 1370 // If the constant is unresolved, run this BC once in the interpreter. | |
| 1602 | 1371 { |
| 0 | 1372 ciConstant constant = iter().get_constant(); |
| 1602 | 1373 if (constant.basic_type() == T_OBJECT && |
| 1374 !constant.as_object()->is_loaded()) { | |
| 1375 int index = iter().get_constant_pool_index(); | |
| 1376 constantTag tag = iter().get_constant_pool_tag(index); | |
| 1377 uncommon_trap(Deoptimization::make_trap_request | |
| 1378 (Deoptimization::Reason_unloaded, | |
| 1379 Deoptimization::Action_reinterpret, | |
| 1380 index), | |
| 1381 NULL, tag.internal_name()); | |
| 1382 break; | |
| 0 | 1383 } |
| 1602 | 1384 assert(constant.basic_type() != T_OBJECT || !constant.as_object()->is_klass(), |
| 1385 "must be java_mirror of klass"); | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
1386 bool pushed = push_constant(constant, true); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
1387 guarantee(pushed, "must be possible to push this constant"); |
| 0 | 1388 } |
| 1389 | |
| 1390 break; | |
| 1391 | |
| 1392 case Bytecodes::_aload_0: | |
| 1393 push( local(0) ); | |
| 1394 break; | |
| 1395 case Bytecodes::_aload_1: | |
| 1396 push( local(1) ); | |
| 1397 break; | |
| 1398 case Bytecodes::_aload_2: | |
| 1399 push( local(2) ); | |
| 1400 break; | |
| 1401 case Bytecodes::_aload_3: | |
| 1402 push( local(3) ); | |
| 1403 break; | |
| 1404 case Bytecodes::_aload: | |
| 1405 push( local(iter().get_index()) ); | |
| 1406 break; | |
| 1407 | |
| 1408 case Bytecodes::_fload_0: | |
| 1409 case Bytecodes::_iload_0: | |
| 1410 push( local(0) ); | |
| 1411 break; | |
| 1412 case Bytecodes::_fload_1: | |
| 1413 case Bytecodes::_iload_1: | |
| 1414 push( local(1) ); | |
| 1415 break; | |
| 1416 case Bytecodes::_fload_2: | |
| 1417 case Bytecodes::_iload_2: | |
| 1418 push( local(2) ); | |
| 1419 break; | |
| 1420 case Bytecodes::_fload_3: | |
| 1421 case Bytecodes::_iload_3: | |
| 1422 push( local(3) ); | |
| 1423 break; | |
| 1424 case Bytecodes::_fload: | |
| 1425 case Bytecodes::_iload: | |
| 1426 push( local(iter().get_index()) ); | |
| 1427 break; | |
| 1428 case Bytecodes::_lload_0: | |
| 1429 push_pair_local( 0 ); | |
| 1430 break; | |
| 1431 case Bytecodes::_lload_1: | |
| 1432 push_pair_local( 1 ); | |
| 1433 break; | |
| 1434 case Bytecodes::_lload_2: | |
| 1435 push_pair_local( 2 ); | |
| 1436 break; | |
| 1437 case Bytecodes::_lload_3: | |
| 1438 push_pair_local( 3 ); | |
| 1439 break; | |
| 1440 case Bytecodes::_lload: | |
| 1441 push_pair_local( iter().get_index() ); | |
| 1442 break; | |
| 1443 | |
| 1444 case Bytecodes::_dload_0: | |
| 1445 push_pair_local(0); | |
| 1446 break; | |
| 1447 case Bytecodes::_dload_1: | |
| 1448 push_pair_local(1); | |
| 1449 break; | |
| 1450 case Bytecodes::_dload_2: | |
| 1451 push_pair_local(2); | |
| 1452 break; | |
| 1453 case Bytecodes::_dload_3: | |
| 1454 push_pair_local(3); | |
| 1455 break; | |
| 1456 case Bytecodes::_dload: | |
| 1457 push_pair_local(iter().get_index()); | |
| 1458 break; | |
| 1459 case Bytecodes::_fstore_0: | |
| 1460 case Bytecodes::_istore_0: | |
| 1461 case Bytecodes::_astore_0: | |
| 1462 set_local( 0, pop() ); | |
| 1463 break; | |
| 1464 case Bytecodes::_fstore_1: | |
| 1465 case Bytecodes::_istore_1: | |
| 1466 case Bytecodes::_astore_1: | |
| 1467 set_local( 1, pop() ); | |
| 1468 break; | |
| 1469 case Bytecodes::_fstore_2: | |
| 1470 case Bytecodes::_istore_2: | |
| 1471 case Bytecodes::_astore_2: | |
| 1472 set_local( 2, pop() ); | |
| 1473 break; | |
| 1474 case Bytecodes::_fstore_3: | |
| 1475 case Bytecodes::_istore_3: | |
| 1476 case Bytecodes::_astore_3: | |
| 1477 set_local( 3, pop() ); | |
| 1478 break; | |
| 1479 case Bytecodes::_fstore: | |
| 1480 case Bytecodes::_istore: | |
| 1481 case Bytecodes::_astore: | |
| 1482 set_local( iter().get_index(), pop() ); | |
| 1483 break; | |
| 1484 // long stores | |
| 1485 case Bytecodes::_lstore_0: | |
| 1486 set_pair_local( 0, pop_pair() ); | |
| 1487 break; | |
| 1488 case Bytecodes::_lstore_1: | |
| 1489 set_pair_local( 1, pop_pair() ); | |
| 1490 break; | |
| 1491 case Bytecodes::_lstore_2: | |
| 1492 set_pair_local( 2, pop_pair() ); | |
| 1493 break; | |
| 1494 case Bytecodes::_lstore_3: | |
| 1495 set_pair_local( 3, pop_pair() ); | |
| 1496 break; | |
| 1497 case Bytecodes::_lstore: | |
| 1498 set_pair_local( iter().get_index(), pop_pair() ); | |
| 1499 break; | |
| 1500 | |
| 1501 // double stores | |
| 1502 case Bytecodes::_dstore_0: | |
| 1503 set_pair_local( 0, dstore_rounding(pop_pair()) ); | |
| 1504 break; | |
| 1505 case Bytecodes::_dstore_1: | |
| 1506 set_pair_local( 1, dstore_rounding(pop_pair()) ); | |
| 1507 break; | |
| 1508 case Bytecodes::_dstore_2: | |
| 1509 set_pair_local( 2, dstore_rounding(pop_pair()) ); | |
| 1510 break; | |
| 1511 case Bytecodes::_dstore_3: | |
| 1512 set_pair_local( 3, dstore_rounding(pop_pair()) ); | |
| 1513 break; | |
| 1514 case Bytecodes::_dstore: | |
| 1515 set_pair_local( iter().get_index(), dstore_rounding(pop_pair()) ); | |
| 1516 break; | |
| 1517 | |
| 1518 case Bytecodes::_pop: _sp -= 1; break; | |
| 1519 case Bytecodes::_pop2: _sp -= 2; break; | |
| 1520 case Bytecodes::_swap: | |
| 1521 a = pop(); | |
| 1522 b = pop(); | |
| 1523 push(a); | |
| 1524 push(b); | |
| 1525 break; | |
| 1526 case Bytecodes::_dup: | |
| 1527 a = pop(); | |
| 1528 push(a); | |
| 1529 push(a); | |
| 1530 break; | |
| 1531 case Bytecodes::_dup_x1: | |
| 1532 a = pop(); | |
| 1533 b = pop(); | |
| 1534 push( a ); | |
| 1535 push( b ); | |
| 1536 push( a ); | |
| 1537 break; | |
| 1538 case Bytecodes::_dup_x2: | |
| 1539 a = pop(); | |
| 1540 b = pop(); | |
| 1541 c = pop(); | |
| 1542 push( a ); | |
| 1543 push( c ); | |
| 1544 push( b ); | |
| 1545 push( a ); | |
| 1546 break; | |
| 1547 case Bytecodes::_dup2: | |
| 1548 a = pop(); | |
| 1549 b = pop(); | |
| 1550 push( b ); | |
| 1551 push( a ); | |
| 1552 push( b ); | |
| 1553 push( a ); | |
| 1554 break; | |
| 1555 | |
| 1556 case Bytecodes::_dup2_x1: | |
| 1557 // before: .. c, b, a | |
| 1558 // after: .. b, a, c, b, a | |
| 1559 // not tested | |
| 1560 a = pop(); | |
| 1561 b = pop(); | |
| 1562 c = pop(); | |
| 1563 push( b ); | |
| 1564 push( a ); | |
| 1565 push( c ); | |
| 1566 push( b ); | |
| 1567 push( a ); | |
| 1568 break; | |
| 1569 case Bytecodes::_dup2_x2: | |
| 1570 // before: .. d, c, b, a | |
| 1571 // after: .. b, a, d, c, b, a | |
| 1572 // not tested | |
| 1573 a = pop(); | |
| 1574 b = pop(); | |
| 1575 c = pop(); | |
| 1576 d = pop(); | |
| 1577 push( b ); | |
| 1578 push( a ); | |
| 1579 push( d ); | |
| 1580 push( c ); | |
| 1581 push( b ); | |
| 1582 push( a ); | |
| 1583 break; | |
| 1584 | |
| 1585 case Bytecodes::_arraylength: { | |
| 1586 // Must do null-check with value on expression stack | |
| 1587 Node *ary = do_null_check(peek(), T_ARRAY); | |
| 1588 // Compile-time detect of null-exception? | |
| 1589 if (stopped()) return; | |
| 1590 a = pop(); | |
| 1591 push(load_array_length(a)); | |
| 1592 break; | |
| 1593 } | |
| 1594 | |
| 1595 case Bytecodes::_baload: array_load(T_BYTE); break; | |
| 1596 case Bytecodes::_caload: array_load(T_CHAR); break; | |
| 1597 case Bytecodes::_iaload: array_load(T_INT); break; | |
| 1598 case Bytecodes::_saload: array_load(T_SHORT); break; | |
| 1599 case Bytecodes::_faload: array_load(T_FLOAT); break; | |
| 1600 case Bytecodes::_aaload: array_load(T_OBJECT); break; | |
| 1601 case Bytecodes::_laload: { | |
| 1602 a = array_addressing(T_LONG, 0); | |
| 605 | 1603 if (stopped()) return; // guaranteed null or range check |
| 0 | 1604 _sp -= 2; // Pop array and index |
| 1605 push_pair( make_load(control(), a, TypeLong::LONG, T_LONG, TypeAryPtr::LONGS)); | |
| 1606 break; | |
| 1607 } | |
| 1608 case Bytecodes::_daload: { | |
| 1609 a = array_addressing(T_DOUBLE, 0); | |
| 605 | 1610 if (stopped()) return; // guaranteed null or range check |
| 0 | 1611 _sp -= 2; // Pop array and index |
| 1612 push_pair( make_load(control(), a, Type::DOUBLE, T_DOUBLE, TypeAryPtr::DOUBLES)); | |
| 1613 break; | |
| 1614 } | |
| 1615 case Bytecodes::_bastore: array_store(T_BYTE); break; | |
| 1616 case Bytecodes::_castore: array_store(T_CHAR); break; | |
| 1617 case Bytecodes::_iastore: array_store(T_INT); break; | |
| 1618 case Bytecodes::_sastore: array_store(T_SHORT); break; | |
| 1619 case Bytecodes::_fastore: array_store(T_FLOAT); break; | |
| 1620 case Bytecodes::_aastore: { | |
| 1621 d = array_addressing(T_OBJECT, 1); | |
| 605 | 1622 if (stopped()) return; // guaranteed null or range check |
| 0 | 1623 array_store_check(); |
| 1624 c = pop(); // Oop to store | |
| 1625 b = pop(); // index (already used) | |
| 1626 a = pop(); // the array itself | |
|
827
bf3489cc0aa0
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
825
diff
changeset
|
1627 const TypeOopPtr* elemtype = _gvn.type(a)->is_aryptr()->elem()->make_oopptr(); |
| 0 | 1628 const TypeAryPtr* adr_type = TypeAryPtr::OOPS; |
| 1629 Node* store = store_oop_to_array(control(), a, d, adr_type, c, elemtype, T_OBJECT); | |
| 1630 break; | |
| 1631 } | |
| 1632 case Bytecodes::_lastore: { | |
| 1633 a = array_addressing(T_LONG, 2); | |
| 605 | 1634 if (stopped()) return; // guaranteed null or range check |
| 0 | 1635 c = pop_pair(); |
| 1636 _sp -= 2; // Pop array and index | |
| 1637 store_to_memory(control(), a, c, T_LONG, TypeAryPtr::LONGS); | |
| 1638 break; | |
| 1639 } | |
| 1640 case Bytecodes::_dastore: { | |
| 1641 a = array_addressing(T_DOUBLE, 2); | |
| 605 | 1642 if (stopped()) return; // guaranteed null or range check |
| 0 | 1643 c = pop_pair(); |
| 1644 _sp -= 2; // Pop array and index | |
| 1645 c = dstore_rounding(c); | |
| 1646 store_to_memory(control(), a, c, T_DOUBLE, TypeAryPtr::DOUBLES); | |
| 1647 break; | |
| 1648 } | |
| 1649 case Bytecodes::_getfield: | |
| 1650 do_getfield(); | |
| 1651 break; | |
| 1652 | |
| 1653 case Bytecodes::_getstatic: | |
| 1654 do_getstatic(); | |
| 1655 break; | |
| 1656 | |
| 1657 case Bytecodes::_putfield: | |
| 1658 do_putfield(); | |
| 1659 break; | |
| 1660 | |
| 1661 case Bytecodes::_putstatic: | |
| 1662 do_putstatic(); | |
| 1663 break; | |
| 1664 | |
| 1665 case Bytecodes::_irem: | |
| 1666 do_irem(); | |
| 1667 break; | |
| 1668 case Bytecodes::_idiv: | |
| 1669 // Must keep both values on the expression-stack during null-check | |
| 1670 do_null_check(peek(), T_INT); | |
| 1671 // Compile-time detect of null-exception? | |
| 1672 if (stopped()) return; | |
| 1673 b = pop(); | |
| 1674 a = pop(); | |
| 1675 push( _gvn.transform( new (C, 3) DivINode(control(),a,b) ) ); | |
| 1676 break; | |
| 1677 case Bytecodes::_imul: | |
| 1678 b = pop(); a = pop(); | |
| 1679 push( _gvn.transform( new (C, 3) MulINode(a,b) ) ); | |
| 1680 break; | |
| 1681 case Bytecodes::_iadd: | |
| 1682 b = pop(); a = pop(); | |
| 1683 push( _gvn.transform( new (C, 3) AddINode(a,b) ) ); | |
| 1684 break; | |
| 1685 case Bytecodes::_ineg: | |
| 1686 a = pop(); | |
| 1687 push( _gvn.transform( new (C, 3) SubINode(_gvn.intcon(0),a)) ); | |
| 1688 break; | |
| 1689 case Bytecodes::_isub: | |
| 1690 b = pop(); a = pop(); | |
| 1691 push( _gvn.transform( new (C, 3) SubINode(a,b) ) ); | |
| 1692 break; | |
| 1693 case Bytecodes::_iand: | |
| 1694 b = pop(); a = pop(); | |
| 1695 push( _gvn.transform( new (C, 3) AndINode(a,b) ) ); | |
| 1696 break; | |
| 1697 case Bytecodes::_ior: | |
| 1698 b = pop(); a = pop(); | |
| 1699 push( _gvn.transform( new (C, 3) OrINode(a,b) ) ); | |
| 1700 break; | |
| 1701 case Bytecodes::_ixor: | |
| 1702 b = pop(); a = pop(); | |
| 1703 push( _gvn.transform( new (C, 3) XorINode(a,b) ) ); | |
| 1704 break; | |
| 1705 case Bytecodes::_ishl: | |
| 1706 b = pop(); a = pop(); | |
| 1707 push( _gvn.transform( new (C, 3) LShiftINode(a,b) ) ); | |
| 1708 break; | |
| 1709 case Bytecodes::_ishr: | |
| 1710 b = pop(); a = pop(); | |
| 1711 push( _gvn.transform( new (C, 3) RShiftINode(a,b) ) ); | |
| 1712 break; | |
| 1713 case Bytecodes::_iushr: | |
| 1714 b = pop(); a = pop(); | |
| 1715 push( _gvn.transform( new (C, 3) URShiftINode(a,b) ) ); | |
| 1716 break; | |
| 1717 | |
| 1718 case Bytecodes::_fneg: | |
| 1719 a = pop(); | |
| 1720 b = _gvn.transform(new (C, 2) NegFNode (a)); | |
| 1721 push(b); | |
| 1722 break; | |
| 1723 | |
| 1724 case Bytecodes::_fsub: | |
| 1725 b = pop(); | |
| 1726 a = pop(); | |
| 1727 c = _gvn.transform( new (C, 3) SubFNode(a,b) ); | |
| 1728 d = precision_rounding(c); | |
| 1729 push( d ); | |
| 1730 break; | |
| 1731 | |
| 1732 case Bytecodes::_fadd: | |
| 1733 b = pop(); | |
| 1734 a = pop(); | |
| 1735 c = _gvn.transform( new (C, 3) AddFNode(a,b) ); | |
| 1736 d = precision_rounding(c); | |
| 1737 push( d ); | |
| 1738 break; | |
| 1739 | |
| 1740 case Bytecodes::_fmul: | |
| 1741 b = pop(); | |
| 1742 a = pop(); | |
| 1743 c = _gvn.transform( new (C, 3) MulFNode(a,b) ); | |
| 1744 d = precision_rounding(c); | |
| 1745 push( d ); | |
| 1746 break; | |
| 1747 | |
| 1748 case Bytecodes::_fdiv: | |
| 1749 b = pop(); | |
| 1750 a = pop(); | |
| 1751 c = _gvn.transform( new (C, 3) DivFNode(0,a,b) ); | |
| 1752 d = precision_rounding(c); | |
| 1753 push( d ); | |
| 1754 break; | |
| 1755 | |
| 1756 case Bytecodes::_frem: | |
| 1757 if (Matcher::has_match_rule(Op_ModF)) { | |
| 1758 // Generate a ModF node. | |
| 1759 b = pop(); | |
| 1760 a = pop(); | |
| 1761 c = _gvn.transform( new (C, 3) ModFNode(0,a,b) ); | |
| 1762 d = precision_rounding(c); | |
| 1763 push( d ); | |
| 1764 } | |
| 1765 else { | |
| 1766 // Generate a call. | |
| 1767 modf(); | |
| 1768 } | |
| 1769 break; | |
| 1770 | |
| 1771 case Bytecodes::_fcmpl: | |
| 1772 b = pop(); | |
| 1773 a = pop(); | |
| 1774 c = _gvn.transform( new (C, 3) CmpF3Node( a, b)); | |
| 1775 push(c); | |
| 1776 break; | |
| 1777 case Bytecodes::_fcmpg: | |
| 1778 b = pop(); | |
| 1779 a = pop(); | |
| 1780 | |
| 1781 // Same as fcmpl but need to flip the unordered case. Swap the inputs, | |
| 1782 // which negates the result sign except for unordered. Flip the unordered | |
| 1783 // as well by using CmpF3 which implements unordered-lesser instead of | |
| 1784 // unordered-greater semantics. Finally, commute the result bits. Result | |
| 1785 // is same as using a CmpF3Greater except we did it with CmpF3 alone. | |
| 1786 c = _gvn.transform( new (C, 3) CmpF3Node( b, a)); | |
| 1787 c = _gvn.transform( new (C, 3) SubINode(_gvn.intcon(0),c) ); | |
| 1788 push(c); | |
| 1789 break; | |
| 1790 | |
| 1791 case Bytecodes::_f2i: | |
| 1792 a = pop(); | |
| 1793 push(_gvn.transform(new (C, 2) ConvF2INode(a))); | |
| 1794 break; | |
| 1795 | |
| 1796 case Bytecodes::_d2i: | |
| 1797 a = pop_pair(); | |
| 1798 b = _gvn.transform(new (C, 2) ConvD2INode(a)); | |
| 1799 push( b ); | |
| 1800 break; | |
| 1801 | |
| 1802 case Bytecodes::_f2d: | |
| 1803 a = pop(); | |
| 1804 b = _gvn.transform( new (C, 2) ConvF2DNode(a)); | |
| 1805 push_pair( b ); | |
| 1806 break; | |
| 1807 | |
| 1808 case Bytecodes::_d2f: | |
| 1809 a = pop_pair(); | |
| 1810 b = _gvn.transform( new (C, 2) ConvD2FNode(a)); | |
| 1811 // This breaks _227_mtrt (speed & correctness) and _222_mpegaudio (speed) | |
| 1812 //b = _gvn.transform(new (C, 2) RoundFloatNode(0, b) ); | |
| 1813 push( b ); | |
| 1814 break; | |
| 1815 | |
| 1816 case Bytecodes::_l2f: | |
| 1817 if (Matcher::convL2FSupported()) { | |
| 1818 a = pop_pair(); | |
| 1819 b = _gvn.transform( new (C, 2) ConvL2FNode(a)); | |
| 1820 // For i486.ad, FILD doesn't restrict precision to 24 or 53 bits. | |
| 1821 // Rather than storing the result into an FP register then pushing | |
| 1822 // out to memory to round, the machine instruction that implements | |
| 1823 // ConvL2D is responsible for rounding. | |
| 1824 // c = precision_rounding(b); | |
| 1825 c = _gvn.transform(b); | |
| 1826 push(c); | |
| 1827 } else { | |
| 1828 l2f(); | |
| 1829 } | |
| 1830 break; | |
| 1831 | |
| 1832 case Bytecodes::_l2d: | |
| 1833 a = pop_pair(); | |
| 1834 b = _gvn.transform( new (C, 2) ConvL2DNode(a)); | |
| 1835 // For i486.ad, rounding is always necessary (see _l2f above). | |
| 1836 // c = dprecision_rounding(b); | |
| 1837 c = _gvn.transform(b); | |
| 1838 push_pair(c); | |
| 1839 break; | |
| 1840 | |
| 1841 case Bytecodes::_f2l: | |
| 1842 a = pop(); | |
| 1843 b = _gvn.transform( new (C, 2) ConvF2LNode(a)); | |
| 1844 push_pair(b); | |
| 1845 break; | |
| 1846 | |
| 1847 case Bytecodes::_d2l: | |
| 1848 a = pop_pair(); | |
| 1849 b = _gvn.transform( new (C, 2) ConvD2LNode(a)); | |
| 1850 push_pair(b); | |
| 1851 break; | |
| 1852 | |
| 1853 case Bytecodes::_dsub: | |
| 1854 b = pop_pair(); | |
| 1855 a = pop_pair(); | |
| 1856 c = _gvn.transform( new (C, 3) SubDNode(a,b) ); | |
| 1857 d = dprecision_rounding(c); | |
| 1858 push_pair( d ); | |
| 1859 break; | |
| 1860 | |
| 1861 case Bytecodes::_dadd: | |
| 1862 b = pop_pair(); | |
| 1863 a = pop_pair(); | |
| 1864 c = _gvn.transform( new (C, 3) AddDNode(a,b) ); | |
| 1865 d = dprecision_rounding(c); | |
| 1866 push_pair( d ); | |
| 1867 break; | |
| 1868 | |
| 1869 case Bytecodes::_dmul: | |
| 1870 b = pop_pair(); | |
| 1871 a = pop_pair(); | |
| 1872 c = _gvn.transform( new (C, 3) MulDNode(a,b) ); | |
| 1873 d = dprecision_rounding(c); | |
| 1874 push_pair( d ); | |
| 1875 break; | |
| 1876 | |
| 1877 case Bytecodes::_ddiv: | |
| 1878 b = pop_pair(); | |
| 1879 a = pop_pair(); | |
| 1880 c = _gvn.transform( new (C, 3) DivDNode(0,a,b) ); | |
| 1881 d = dprecision_rounding(c); | |
| 1882 push_pair( d ); | |
| 1883 break; | |
| 1884 | |
| 1885 case Bytecodes::_dneg: | |
| 1886 a = pop_pair(); | |
| 1887 b = _gvn.transform(new (C, 2) NegDNode (a)); | |
| 1888 push_pair(b); | |
| 1889 break; | |
| 1890 | |
| 1891 case Bytecodes::_drem: | |
| 1892 if (Matcher::has_match_rule(Op_ModD)) { | |
| 1893 // Generate a ModD node. | |
| 1894 b = pop_pair(); | |
| 1895 a = pop_pair(); | |
| 1896 // a % b | |
| 1897 | |
| 1898 c = _gvn.transform( new (C, 3) ModDNode(0,a,b) ); | |
| 1899 d = dprecision_rounding(c); | |
| 1900 push_pair( d ); | |
| 1901 } | |
| 1902 else { | |
| 1903 // Generate a call. | |
| 1904 modd(); | |
| 1905 } | |
| 1906 break; | |
| 1907 | |
| 1908 case Bytecodes::_dcmpl: | |
| 1909 b = pop_pair(); | |
| 1910 a = pop_pair(); | |
| 1911 c = _gvn.transform( new (C, 3) CmpD3Node( a, b)); | |
| 1912 push(c); | |
| 1913 break; | |
| 1914 | |
| 1915 case Bytecodes::_dcmpg: | |
| 1916 b = pop_pair(); | |
| 1917 a = pop_pair(); | |
| 1918 // Same as dcmpl but need to flip the unordered case. | |
| 1919 // Commute the inputs, which negates the result sign except for unordered. | |
| 1920 // Flip the unordered as well by using CmpD3 which implements | |
| 1921 // unordered-lesser instead of unordered-greater semantics. | |
| 1922 // Finally, negate the result bits. Result is same as using a | |
| 1923 // CmpD3Greater except we did it with CmpD3 alone. | |
| 1924 c = _gvn.transform( new (C, 3) CmpD3Node( b, a)); | |
| 1925 c = _gvn.transform( new (C, 3) SubINode(_gvn.intcon(0),c) ); | |
| 1926 push(c); | |
| 1927 break; | |
| 1928 | |
| 1929 | |
| 1930 // Note for longs -> lo word is on TOS, hi word is on TOS - 1 | |
| 1931 case Bytecodes::_land: | |
| 1932 b = pop_pair(); | |
| 1933 a = pop_pair(); | |
| 1934 c = _gvn.transform( new (C, 3) AndLNode(a,b) ); | |
| 1935 push_pair(c); | |
| 1936 break; | |
| 1937 case Bytecodes::_lor: | |
| 1938 b = pop_pair(); | |
| 1939 a = pop_pair(); | |
| 1940 c = _gvn.transform( new (C, 3) OrLNode(a,b) ); | |
| 1941 push_pair(c); | |
| 1942 break; | |
| 1943 case Bytecodes::_lxor: | |
| 1944 b = pop_pair(); | |
| 1945 a = pop_pair(); | |
| 1946 c = _gvn.transform( new (C, 3) XorLNode(a,b) ); | |
| 1947 push_pair(c); | |
| 1948 break; | |
| 1949 | |
| 1950 case Bytecodes::_lshl: | |
| 1951 b = pop(); // the shift count | |
| 1952 a = pop_pair(); // value to be shifted | |
| 1953 c = _gvn.transform( new (C, 3) LShiftLNode(a,b) ); | |
| 1954 push_pair(c); | |
| 1955 break; | |
| 1956 case Bytecodes::_lshr: | |
| 1957 b = pop(); // the shift count | |
| 1958 a = pop_pair(); // value to be shifted | |
| 1959 c = _gvn.transform( new (C, 3) RShiftLNode(a,b) ); | |
| 1960 push_pair(c); | |
| 1961 break; | |
| 1962 case Bytecodes::_lushr: | |
| 1963 b = pop(); // the shift count | |
| 1964 a = pop_pair(); // value to be shifted | |
| 1965 c = _gvn.transform( new (C, 3) URShiftLNode(a,b) ); | |
| 1966 push_pair(c); | |
| 1967 break; | |
| 1968 case Bytecodes::_lmul: | |
| 1969 b = pop_pair(); | |
| 1970 a = pop_pair(); | |
| 1971 c = _gvn.transform( new (C, 3) MulLNode(a,b) ); | |
| 1972 push_pair(c); | |
| 1973 break; | |
| 1974 | |
| 1975 case Bytecodes::_lrem: | |
| 1976 // Must keep both values on the expression-stack during null-check | |
| 1977 assert(peek(0) == top(), "long word order"); | |
| 1978 do_null_check(peek(1), T_LONG); | |
| 1979 // Compile-time detect of null-exception? | |
| 1980 if (stopped()) return; | |
| 1981 b = pop_pair(); | |
| 1982 a = pop_pair(); | |
| 1983 c = _gvn.transform( new (C, 3) ModLNode(control(),a,b) ); | |
| 1984 push_pair(c); | |
| 1985 break; | |
| 1986 | |
| 1987 case Bytecodes::_ldiv: | |
| 1988 // Must keep both values on the expression-stack during null-check | |
| 1989 assert(peek(0) == top(), "long word order"); | |
| 1990 do_null_check(peek(1), T_LONG); | |
| 1991 // Compile-time detect of null-exception? | |
| 1992 if (stopped()) return; | |
| 1993 b = pop_pair(); | |
| 1994 a = pop_pair(); | |
| 1995 c = _gvn.transform( new (C, 3) DivLNode(control(),a,b) ); | |
| 1996 push_pair(c); | |
| 1997 break; | |
| 1998 | |
| 1999 case Bytecodes::_ladd: | |
| 2000 b = pop_pair(); | |
| 2001 a = pop_pair(); | |
| 2002 c = _gvn.transform( new (C, 3) AddLNode(a,b) ); | |
| 2003 push_pair(c); | |
| 2004 break; | |
| 2005 case Bytecodes::_lsub: | |
| 2006 b = pop_pair(); | |
| 2007 a = pop_pair(); | |
| 2008 c = _gvn.transform( new (C, 3) SubLNode(a,b) ); | |
| 2009 push_pair(c); | |
| 2010 break; | |
| 2011 case Bytecodes::_lcmp: | |
| 2012 // Safepoints are now inserted _before_ branches. The long-compare | |
| 2013 // bytecode painfully produces a 3-way value (-1,0,+1) which requires a | |
| 2014 // slew of control flow. These are usually followed by a CmpI vs zero and | |
| 2015 // a branch; this pattern then optimizes to the obvious long-compare and | |
| 2016 // branch. However, if the branch is backwards there's a Safepoint | |
| 2017 // inserted. The inserted Safepoint captures the JVM state at the | |
| 2018 // pre-branch point, i.e. it captures the 3-way value. Thus if a | |
| 2019 // long-compare is used to control a loop the debug info will force | |
| 2020 // computation of the 3-way value, even though the generated code uses a | |
| 2021 // long-compare and branch. We try to rectify the situation by inserting | |
| 2022 // a SafePoint here and have it dominate and kill the safepoint added at a | |
| 2023 // following backwards branch. At this point the JVM state merely holds 2 | |
| 2024 // longs but not the 3-way value. | |
| 2025 if( UseLoopSafepoints ) { | |
| 2026 switch( iter().next_bc() ) { | |
| 2027 case Bytecodes::_ifgt: | |
| 2028 case Bytecodes::_iflt: | |
| 2029 case Bytecodes::_ifge: | |
| 2030 case Bytecodes::_ifle: | |
| 2031 case Bytecodes::_ifne: | |
| 2032 case Bytecodes::_ifeq: | |
| 2033 // If this is a backwards branch in the bytecodes, add Safepoint | |
| 2034 maybe_add_safepoint(iter().next_get_dest()); | |
| 2035 } | |
| 2036 } | |
| 2037 b = pop_pair(); | |
| 2038 a = pop_pair(); | |
| 2039 c = _gvn.transform( new (C, 3) CmpL3Node( a, b )); | |
| 2040 push(c); | |
| 2041 break; | |
| 2042 | |
| 2043 case Bytecodes::_lneg: | |
| 2044 a = pop_pair(); | |
| 2045 b = _gvn.transform( new (C, 3) SubLNode(longcon(0),a)); | |
| 2046 push_pair(b); | |
| 2047 break; | |
| 2048 case Bytecodes::_l2i: | |
| 2049 a = pop_pair(); | |
| 2050 push( _gvn.transform( new (C, 2) ConvL2INode(a))); | |
| 2051 break; | |
| 2052 case Bytecodes::_i2l: | |
| 2053 a = pop(); | |
| 2054 b = _gvn.transform( new (C, 2) ConvI2LNode(a)); | |
| 2055 push_pair(b); | |
| 2056 break; | |
| 2057 case Bytecodes::_i2b: | |
| 2058 // Sign extend | |
| 2059 a = pop(); | |
| 2060 a = _gvn.transform( new (C, 3) LShiftINode(a,_gvn.intcon(24)) ); | |
| 2061 a = _gvn.transform( new (C, 3) RShiftINode(a,_gvn.intcon(24)) ); | |
| 2062 push( a ); | |
| 2063 break; | |
| 2064 case Bytecodes::_i2s: | |
| 2065 a = pop(); | |
| 2066 a = _gvn.transform( new (C, 3) LShiftINode(a,_gvn.intcon(16)) ); | |
| 2067 a = _gvn.transform( new (C, 3) RShiftINode(a,_gvn.intcon(16)) ); | |
| 2068 push( a ); | |
| 2069 break; | |
| 2070 case Bytecodes::_i2c: | |
| 2071 a = pop(); | |
| 2072 push( _gvn.transform( new (C, 3) AndINode(a,_gvn.intcon(0xFFFF)) ) ); | |
| 2073 break; | |
| 2074 | |
| 2075 case Bytecodes::_i2f: | |
| 2076 a = pop(); | |
| 2077 b = _gvn.transform( new (C, 2) ConvI2FNode(a) ) ; | |
| 2078 c = precision_rounding(b); | |
| 2079 push (b); | |
| 2080 break; | |
| 2081 | |
| 2082 case Bytecodes::_i2d: | |
| 2083 a = pop(); | |
| 2084 b = _gvn.transform( new (C, 2) ConvI2DNode(a)); | |
| 2085 push_pair(b); | |
| 2086 break; | |
| 2087 | |
| 2088 case Bytecodes::_iinc: // Increment local | |
| 2089 i = iter().get_index(); // Get local index | |
| 2090 set_local( i, _gvn.transform( new (C, 3) AddINode( _gvn.intcon(iter().get_iinc_con()), local(i) ) ) ); | |
| 2091 break; | |
| 2092 | |
| 2093 // Exit points of synchronized methods must have an unlock node | |
| 2094 case Bytecodes::_return: | |
| 2095 return_current(NULL); | |
| 2096 break; | |
| 2097 | |
| 2098 case Bytecodes::_ireturn: | |
| 2099 case Bytecodes::_areturn: | |
| 2100 case Bytecodes::_freturn: | |
| 2101 return_current(pop()); | |
| 2102 break; | |
| 2103 case Bytecodes::_lreturn: | |
| 2104 return_current(pop_pair()); | |
| 2105 break; | |
| 2106 case Bytecodes::_dreturn: | |
| 2107 return_current(pop_pair()); | |
| 2108 break; | |
| 2109 | |
| 2110 case Bytecodes::_athrow: | |
| 2111 // null exception oop throws NULL pointer exception | |
| 2112 do_null_check(peek(), T_OBJECT); | |
| 2113 if (stopped()) return; | |
| 2114 // Hook the thrown exception directly to subsequent handlers. | |
| 2115 if (BailoutToInterpreterForThrows) { | |
| 2116 // Keep method interpreted from now on. | |
| 2117 uncommon_trap(Deoptimization::Reason_unhandled, | |
| 2118 Deoptimization::Action_make_not_compilable); | |
| 2119 return; | |
| 2120 } | |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1172
diff
changeset
|
2121 if (env()->jvmti_can_post_on_exceptions()) { |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1172
diff
changeset
|
2122 // check if we must post exception events, take uncommon trap if so (with must_throw = false) |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1172
diff
changeset
|
2123 uncommon_trap_if_should_post_on_exceptions(Deoptimization::Reason_unhandled, false); |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1172
diff
changeset
|
2124 } |
|
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1172
diff
changeset
|
2125 // Here if either can_post_on_exceptions or should_post_on_exceptions is false |
| 0 | 2126 add_exception_state(make_exception_state(peek())); |
| 2127 break; | |
| 2128 | |
| 2129 case Bytecodes::_goto: // fall through | |
| 2130 case Bytecodes::_goto_w: { | |
| 2131 int target_bci = (bc() == Bytecodes::_goto) ? iter().get_dest() : iter().get_far_dest(); | |
| 2132 | |
| 2133 // If this is a backwards branch in the bytecodes, add Safepoint | |
| 2134 maybe_add_safepoint(target_bci); | |
| 2135 | |
| 2136 // Update method data | |
| 2137 profile_taken_branch(target_bci); | |
| 2138 | |
| 2139 // Merge the current control into the target basic block | |
| 2140 merge(target_bci); | |
| 2141 | |
| 2142 // See if we can get some profile data and hand it off to the next block | |
| 2143 Block *target_block = block()->successor_for_bci(target_bci); | |
| 2144 if (target_block->pred_count() != 1) break; | |
| 2145 ciMethodData* methodData = method()->method_data(); | |
| 2146 if (!methodData->is_mature()) break; | |
| 2147 ciProfileData* data = methodData->bci_to_data(bci()); | |
| 2148 assert( data->is_JumpData(), "" ); | |
| 2149 int taken = ((ciJumpData*)data)->taken(); | |
| 2150 taken = method()->scale_count(taken); | |
| 2151 target_block->set_count(taken); | |
| 2152 break; | |
| 2153 } | |
| 2154 | |
|
248
18aab3cdd513
6726504: handle do_ifxxx calls in parser more uniformly
rasbold
parents:
246
diff
changeset
|
2155 case Bytecodes::_ifnull: btest = BoolTest::eq; goto handle_if_null; |
|
18aab3cdd513
6726504: handle do_ifxxx calls in parser more uniformly
rasbold
parents:
246
diff
changeset
|
2156 case Bytecodes::_ifnonnull: btest = BoolTest::ne; goto handle_if_null; |
|
18aab3cdd513
6726504: handle do_ifxxx calls in parser more uniformly
rasbold
parents:
246
diff
changeset
|
2157 handle_if_null: |
|
254
3e333d6f35dd
6730192: expression stack wrong at deoptimization point
rasbold
parents:
248
diff
changeset
|
2158 // If this is a backwards branch in the bytecodes, add Safepoint |
|
3e333d6f35dd
6730192: expression stack wrong at deoptimization point
rasbold
parents:
248
diff
changeset
|
2159 maybe_add_safepoint(iter().get_dest()); |
|
248
18aab3cdd513
6726504: handle do_ifxxx calls in parser more uniformly
rasbold
parents:
246
diff
changeset
|
2160 a = null(); |
|
18aab3cdd513
6726504: handle do_ifxxx calls in parser more uniformly
rasbold
parents:
246
diff
changeset
|
2161 b = pop(); |
|
18aab3cdd513
6726504: handle do_ifxxx calls in parser more uniformly
rasbold
parents:
246
diff
changeset
|
2162 c = _gvn.transform( new (C, 3) CmpPNode(b, a) ); |
|
18aab3cdd513
6726504: handle do_ifxxx calls in parser more uniformly
rasbold
parents:
246
diff
changeset
|
2163 do_ifnull(btest, c); |
| 0 | 2164 break; |
| 2165 | |
| 2166 case Bytecodes::_if_acmpeq: btest = BoolTest::eq; goto handle_if_acmp; | |
| 2167 case Bytecodes::_if_acmpne: btest = BoolTest::ne; goto handle_if_acmp; | |
| 2168 handle_if_acmp: | |
|
254
3e333d6f35dd
6730192: expression stack wrong at deoptimization point
rasbold
parents:
248
diff
changeset
|
2169 // If this is a backwards branch in the bytecodes, add Safepoint |
|
3e333d6f35dd
6730192: expression stack wrong at deoptimization point
rasbold
parents:
248
diff
changeset
|
2170 maybe_add_safepoint(iter().get_dest()); |
| 0 | 2171 a = pop(); |
| 2172 b = pop(); | |
| 2173 c = _gvn.transform( new (C, 3) CmpPNode(b, a) ); | |
| 2174 do_if(btest, c); | |
| 2175 break; | |
| 2176 | |
| 2177 case Bytecodes::_ifeq: btest = BoolTest::eq; goto handle_ifxx; | |
| 2178 case Bytecodes::_ifne: btest = BoolTest::ne; goto handle_ifxx; | |
| 2179 case Bytecodes::_iflt: btest = BoolTest::lt; goto handle_ifxx; | |
| 2180 case Bytecodes::_ifle: btest = BoolTest::le; goto handle_ifxx; | |
| 2181 case Bytecodes::_ifgt: btest = BoolTest::gt; goto handle_ifxx; | |
| 2182 case Bytecodes::_ifge: btest = BoolTest::ge; goto handle_ifxx; | |
| 2183 handle_ifxx: | |
|
254
3e333d6f35dd
6730192: expression stack wrong at deoptimization point
rasbold
parents:
248
diff
changeset
|
2184 // If this is a backwards branch in the bytecodes, add Safepoint |
|
3e333d6f35dd
6730192: expression stack wrong at deoptimization point
rasbold
parents:
248
diff
changeset
|
2185 maybe_add_safepoint(iter().get_dest()); |
| 0 | 2186 a = _gvn.intcon(0); |
| 2187 b = pop(); | |
| 2188 c = _gvn.transform( new (C, 3) CmpINode(b, a) ); | |
| 2189 do_if(btest, c); | |
| 2190 break; | |
| 2191 | |
| 2192 case Bytecodes::_if_icmpeq: btest = BoolTest::eq; goto handle_if_icmp; | |
| 2193 case Bytecodes::_if_icmpne: btest = BoolTest::ne; goto handle_if_icmp; | |
| 2194 case Bytecodes::_if_icmplt: btest = BoolTest::lt; goto handle_if_icmp; | |
| 2195 case Bytecodes::_if_icmple: btest = BoolTest::le; goto handle_if_icmp; | |
| 2196 case Bytecodes::_if_icmpgt: btest = BoolTest::gt; goto handle_if_icmp; | |
| 2197 case Bytecodes::_if_icmpge: btest = BoolTest::ge; goto handle_if_icmp; | |
| 2198 handle_if_icmp: | |
|
254
3e333d6f35dd
6730192: expression stack wrong at deoptimization point
rasbold
parents:
248
diff
changeset
|
2199 // If this is a backwards branch in the bytecodes, add Safepoint |
|
3e333d6f35dd
6730192: expression stack wrong at deoptimization point
rasbold
parents:
248
diff
changeset
|
2200 maybe_add_safepoint(iter().get_dest()); |
| 0 | 2201 a = pop(); |
| 2202 b = pop(); | |
| 2203 c = _gvn.transform( new (C, 3) CmpINode( b, a ) ); | |
| 2204 do_if(btest, c); | |
| 2205 break; | |
| 2206 | |
| 2207 case Bytecodes::_tableswitch: | |
| 2208 do_tableswitch(); | |
| 2209 break; | |
| 2210 | |
| 2211 case Bytecodes::_lookupswitch: | |
| 2212 do_lookupswitch(); | |
| 2213 break; | |
| 2214 | |
| 2215 case Bytecodes::_invokestatic: | |
|
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
605
diff
changeset
|
2216 case Bytecodes::_invokedynamic: |
| 0 | 2217 case Bytecodes::_invokespecial: |
| 2218 case Bytecodes::_invokevirtual: | |
| 2219 case Bytecodes::_invokeinterface: | |
| 2220 do_call(); | |
| 2221 break; | |
| 2222 case Bytecodes::_checkcast: | |
| 2223 do_checkcast(); | |
| 2224 break; | |
| 2225 case Bytecodes::_instanceof: | |
| 2226 do_instanceof(); | |
| 2227 break; | |
| 2228 case Bytecodes::_anewarray: | |
| 2229 do_anewarray(); | |
| 2230 break; | |
| 2231 case Bytecodes::_newarray: | |
| 2232 do_newarray((BasicType)iter().get_index()); | |
| 2233 break; | |
| 2234 case Bytecodes::_multianewarray: | |
| 2235 do_multianewarray(); | |
| 2236 break; | |
| 2237 case Bytecodes::_new: | |
| 2238 do_new(); | |
| 2239 break; | |
| 2240 | |
| 2241 case Bytecodes::_jsr: | |
| 2242 case Bytecodes::_jsr_w: | |
| 2243 do_jsr(); | |
| 2244 break; | |
| 2245 | |
| 2246 case Bytecodes::_ret: | |
| 2247 do_ret(); | |
| 2248 break; | |
| 2249 | |
| 2250 | |
| 2251 case Bytecodes::_monitorenter: | |
| 2252 do_monitor_enter(); | |
| 2253 break; | |
| 2254 | |
| 2255 case Bytecodes::_monitorexit: | |
| 2256 do_monitor_exit(); | |
| 2257 break; | |
| 2258 | |
| 2259 case Bytecodes::_breakpoint: | |
| 2260 // Breakpoint set concurrently to compile | |
| 2261 // %%% use an uncommon trap? | |
| 2262 C->record_failure("breakpoint in method"); | |
| 2263 return; | |
| 2264 | |
| 2265 default: | |
| 2266 #ifndef PRODUCT | |
| 2267 map()->dump(99); | |
| 2268 #endif | |
| 2269 tty->print("\nUnhandled bytecode %s\n", Bytecodes::name(bc()) ); | |
| 2270 ShouldNotReachHere(); | |
| 2271 } | |
| 2272 | |
| 2273 #ifndef PRODUCT | |
| 2274 IdealGraphPrinter *printer = IdealGraphPrinter::printer(); | |
| 2275 if(printer) { | |
| 2276 char buffer[256]; | |
| 2277 sprintf(buffer, "Bytecode %d: %s", bci(), Bytecodes::name(bc())); | |
| 2278 bool old = printer->traverse_outs(); | |
| 2279 printer->set_traverse_outs(true); | |
| 222 | 2280 printer->print_method(C, buffer, 4); |
| 0 | 2281 printer->set_traverse_outs(old); |
| 2282 } | |
| 2283 #endif | |
| 2284 } |