Loading...

XML

Word

Printable

Details

Type: Bug
Resolution: Fixed
Priority: P3
Fix Version/s: 21
Affects Version/s: 21
Component/s: hotspot
Labels:

Subcomponent:
compiler
Resolved In Build:
b14
CPU:

x86
OS:

linux

Description

Reported by Eirik Bjørsnøs <eirbjo@gmail.com>: https://mail.openjdk.org/pipermail/hotspot-compiler-dev/2023-February/062905.html

After ~~JDK-8302668~~ fixed the SSE rules, LoopRangeStrideTest.countDownLoopWithNegScale and LoopRangeStrideTest.countupLoopWithNegScale fail IR verification on Linux x86:

Run Test VM - [-XX:-OptimizeFill]:
Command line: [/home/runner/work/jdk/jdk/bundles/jdk/jdk-21/fastdebug/bin/java -cp /home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes/compiler/vectorization/runner/LoopRangeStrideTest.d:/home/runner/work/jdk/jdk/test/hotspot/jtreg/compiler/vectorization/runner:/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes/test/lib:/home/runner/work/jdk/jdk/test/lib:/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes:/home/runner/work/jdk/jdk/test/hotspot/jtreg:/home/runner/work/jdk/jdk/jtreg/installed/lib/javatest.jar:/home/runner/work/jdk/jdk/jtreg/installed/lib/jtreg.jar -Djava.library.path=/home/runner/work/jdk/jdk/bundles/tests/hotspot/jtreg/native -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:MaxRAMPercentage=25 -Dtest.boot.jdk=bootjdk/jdk -Djava.io.tmpdir=/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/tmp -XX:-CreateCoredumpOnCrash -Dir.framework.server.port=36331 -XX:-OptimizeFill -XX:+PrintCompilation -XX:+UnlockDiagnosticVMOptions -XX:+LogCompilation -XX:CompilerDirectivesFile=test-vm-compile-commands-pid-58826.log -XX:CompilerDirectivesLimit=91 -XX:-OmitStackTraceInFastThrow -DShouldDoIRVerification=true -XX:-BackgroundCompilation -XX:CompileCommand=quiet compiler.lib.ir_framework.test.TestVM compiler.vectorization.runner.LoopRangeStrideTest ]
[2023-02-22T18:31:21.995946498Z] Gathering output for process 58848
[2023-02-22T18:31:24.404010607Z] Waiting for completion for process 58848
[2023-02-22T18:31:24.404257105Z] Waiting for completion finished for process 58848
Output and diagnostic info for process 58848 was saved into 'pid-58848-output.log'
[2023-02-22T18:31:24.429929695Z] Waiting for completion for process 58848
[2023-02-22T18:31:24.430105294Z] Waiting for completion finished for process 58848

Compilations (2) of Failed Methods (2)
--------------------------------------
1) Compilation of "public int[] compiler.vectorization.runner.LoopRangeStrideTest.countDownLoopWithNegScale()":
> Phase "PrintIdeal":
AFTER: print_ideal
    0 Root === 0 82 614 625 243 242 508 1114 529 1103 550 1093 571 604 593 [[ 0 1 3 22 23 228 26 28 1324 30 170 813 774 37 39 148 63 77 90 103 129 133 731 719 386 376 365 820 866 870 896 939 1002 1004 1007 1009 1011 1017 1072 1115 1197 1198 1199 1200 1204 1245 1247 1248 1249 1250 1251 1252 1253 1254 1287 1292 1293 1295 1300 1302 1304 1305 1313 1316 1317 1319 1360 1361 1363 1373 1376 1379 1409 ]]
    1 Con === 0 [[ ]] #top
    3 Start === 3 0 [[ 3 5 6 7 8 9 10 ]] #{0:control, 1:abIO, 2:memory, 3:rawptr:BotPTR, 4:return_address, 5:compiler/vectorization/runner/LoopRangeStrideTest:NotNull *}
    5 Parm === 3 [[ 1404 1365 1366 ]] Control !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:-1 (line 214)
    6 Parm === 3 [[ 1375 1358 ]] I_O !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:-1 (line 214)
    7 Parm === 3 [[ 317 150 131 172 16 1400 50 59 75 1365 1366 1382 ]] Memory Memory: @BotPTR *+bot, idx=Bot; !orig=[112],[120] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:-1 (line 214)
    8 Parm === 3 [[ 243 242 593 614 1400 78 604 625 82 508 529 550 571 1093 1114 1103 ]] FramePtr !orig=[507] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:-1 (line 214)
    9 Parm === 3 [[ 243 242 78 ]] ReturnAdr !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:-1 (line 214)
   10 Parm === 3 [[ 130 130 78 1400 171 171 ]] Parm0: compiler/vectorization/runner/LoopRangeStrideTest:NotNull * Oop:compiler/vectorization/runner/LoopRangeStrideTest:NotNull * !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:-1 (line 214)
   16 MergeMem === _ 1 7 1399 1399 1399 432 [[ 242 ]] { N1399:rawptr:BotPTR N1399:java/lang/Object * N1399:java/lang/Object+4 * N432:int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any * } Memory: @BotPTR *+bot, idx=Bot;
   22 ConI === 0 [[ 1400 727 1387 ]] #int:543
   23 ConP === 0 [[ 1385 ]] #precise [int (java/lang/Cloneable,java/io/Serializable): :Constant:exact *
   26 ConI === 0 [[ 431 ]] #int:-1
   28 ConI === 0 [[ 1389 1164 430 443 ]] #int:0
   30 ConI === 0 [[ 1163 442 ]] #int:2
   37 ConI === 0 [[ 1367 1158 1147 1152 435 437 440 ]] #int:2184
   39 ConI === 0 [[ 1383 ]] #int:1
   44 Proj === 1400 [[ 47 ]] #0 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
   47 Catch === 44 54 [[ 1401 49 ]] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
   49 CatchProj === 47 [[ 243 52 ]] #1@bci -1 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
   50 MergeMem === _ 1 7 53 [[ 243 ]] { N53:rawptr:BotPTR } Memory: @BotPTR *+bot, idx=Bot; !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
   52 CreateEx === 49 54 [[ 243 ]] #java/lang/Throwable (java/io/Serializable):NotNull * Oop:java/lang/Throwable (java/io/Serializable):NotNull * !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
   53 Proj === 1400 [[ 50 1357 ]] #2 Memory: @BotPTR *+bot, idx=Bot; !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
   54 Proj === 1400 [[ 47 52 243 ]] #1 !orig=[111] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
   56 Initialize === 1356 1 59 1 1 1 1357 [[ 1397 1396 ]] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
   59 MergeMem === _ 1 1357 1 1 1 7 [[ 56 ]] { - - - N7:int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any * } Memory: @BotPTR *+bot, idx=Bot; !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
   60 CheckCastPP === 1398 1359 [[ 242 957 78 1155 1156 1170 1153 221 437 438 438 469 1154 469 679 973 980 784 1172 1171 793 1156 966 1173 1152 ]] #int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact * !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
   63 ConI === 0 [[ 78 78 1408 ]] #int:271
   75 MergeMem === _ 1 7 1399 1399 1399 1399 [[ 78 ]] { N1399:rawptr:BotPTR N1399:java/lang/Object * N1399:java/lang/Object+4 * N1399:int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any * } Memory: @BotPTR *+bot, idx=Bot; !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
   77 ConI === 0 [[ 78 ]] #int:-138
   78 CallStaticJava === 266 1358 75 8 9 (77 10 60 63 63 ) [[ 79 ]] # Static uncommon_trap(reason='predicate' action='maybe_recompile') void ( int ) C=0.000100 LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215) reexecute !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
   79 Proj === 78 [[ 82 ]] #0 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
   82 Halt === 79 1 1 8 1 [[ 0 ]] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  129 ConI === 0 [[ 130 1393 ]] #int:16
  130 AddP === _ 10 10 129 [[ 131 ]] Oop:compiler/vectorization/runner/LoopRangeStrideTest:NotNull+16 * !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:21 (line 216)
  131 LoadP === _ 7 130 [[ 167 134 1161 1160 1159 1158 1178 960 968 795 1176 1177 787 975 982 682 472 472 1162 1162 441 441 440 1175 149 149 ]] @compiler/vectorization/runner/LoopRangeStrideTest+16 *, name=a, idx=7; #int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact * !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:21 (line 216)
  133 ConP === 0 [[ 134 174 ]] #NULL
  134 CmpP === _ 131 133 [[ 135 ]] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  135 Bool === _ 134 [[ 268 ]] [ne] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  148 ConI === 0 [[ 149 316 1386 ]] #int:8
  149 AddP === _ 131 131 148 [[ 150 ]] !orig=[271],... !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  150 LoadRange === 269 7 149 [[ 366 597 294 377 1314 1311 ]] @bottom[int:>=0] (java/lang/Cloneable,java/io/Serializable)+8 *, idx=8; #int:>=0 !orig=[272],... !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  167 AddP === _ 131 1162 1253 [[ 169 ]] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  169 LoadI === 420 674 167 |269 [[ 206 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  170 ConI === 0 [[ 171 ]] #int:20
  171 AddP === _ 10 10 170 [[ 172 ]] Oop:compiler/vectorization/runner/LoopRangeStrideTest:NotNull+20 * !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:31 (line 216)
  172 LoadP === _ 7 171 [[ 316 174 1150 1149 1148 1147 1168 1151 1151 791 1166 1167 782 964 971 677 467 467 1165 436 436 435 978 203 955 316 ]] @compiler/vectorization/runner/LoopRangeStrideTest+20 *, name=b, idx=9; #int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact * !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:31 (line 216)
  174 CmpP === _ 172 133 [[ 175 ]] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  175 Bool === _ 174 [[ 313 ]] [ne] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  203 AddP === _ 172 1151 1253 [[ 205 ]] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  205 LoadI === 420 674 203 |314 [[ 206 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  206 MulI === _ 169 205 [[ 223 ]] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
  221 AddP === _ 60 1156 1253 [[ 223 ]] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  223 StoreI === 1185 674 221 206 [[ 1188 446 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  224 AddI === _ 1189 1072 [[ 1189 246 ]] !orig=[245],... !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:42 (line 215)
  242 Return === 449 1358 16 8 9 returns 60 [[ 0 ]]
  243 Rethrow === 49 54 50 8 9 exception 52 [[ 0 ]]
  246 CmpI === _ 224 1115 [[ 247 ]] !orig=[231] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  247 Bool === _ 246 [[ 248 ]] [gt] !orig=[232] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  248 CountedLoopEnd === 1185 247 [[ 249 251 ]] [gt] P=0.996332, C=68452.000000 !orig=[233] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  249 IfTrue === 248 [[ 1185 ]] #1 !orig=[235] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  251 IfFalse === 248 [[ 1325 439 434 591 ]] #0 !orig=[250],[234] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  266 Region === 266 315 270 371 382 421 428 [[ 266 78 ]] !orig=[74] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  268 If === 1398 135 [[ 269 270 ]] P=0.999999, C=-1.000000
  269 IfTrue === 268 [[ 1410 1134 169 150 1131 439 471 681 950 947 786 1126 1118 777 942 959 1123 1157 1139 1142 ]] #1
  270 IfFalse === 268 [[ 266 ]] #0
  294 ConvI2L === _ 150 [[ 586 1320 ]] #long:0..maxint
  313 If === 381 175 [[ 314 315 ]] P=0.999999, C=-1.000000
  314 IfTrue === 313 [[ 1412 1138 317 954 205 951 434 466 676 946 943 781 1122 1119 778 1130 1127 1146 1135 1143 ]] #1
  315 IfFalse === 313 [[ 266 ]] #0
  316 AddP === _ 172 172 148 [[ 317 ]] !orig=[187] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  317 LoadRange === 314 7 316 [[ 423 409 338 618 1309 1307 ]] @bottom[int:>=0] (java/lang/Cloneable,java/io/Serializable)+8 *, idx=8; #int:>=0 !orig=[188] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  338 ConvI2L === _ 317 [[ 607 1322 ]] #long:0..maxint
  365 ConI === 0 [[ 366 423 ]] #int:272
  366 CmpU === _ 150 365 [[ 368 ]] !orig=[275]
  368 Bool === _ 366 [[ 1410 ]] [le]
  370 IfFalse === 1410 [[ 1411 ]] #0 !orig=[278]
  371 IfTrue === 1410 [[ 266 ]] #1 !orig=[279]
  376 ConI === 0 [[ 377 409 ]] #int:542
  377 CmpU === _ 150 376 [[ 379 ]] !orig=[283]
  379 Bool === _ 377 [[ 1411 ]] [le]
  381 IfFalse === 1411 [[ 313 471 ]] #0 !orig=[286]
  382 IfTrue === 1411 [[ 266 ]] #1 !orig=[287]
  386 ConL === 0 [[ 585 ]] #long:543
  409 CmpU === _ 317 376 [[ 418 ]] !orig=[328]
  418 Bool === _ 409 [[ 1413 ]] [le]
  420 IfFalse === 1413 [[ 464 466 681 1146 1143 1142 1139 1138 1135 1134 1131 1130 1127 1126 1123 1122 1119 1118 959 954 951 950 947 946 943 942 786 781 778 777 169 1157 1414 205 676 ]] #0 !orig=[331] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  421 IfTrue === 1413 [[ 266 ]] #1 !orig=[332]
  423 CmpU === _ 317 365 [[ 425 ]] !orig=[320]
  425 Bool === _ 423 [[ 1412 ]] [le]
  427 IfFalse === 1412 [[ 1413 ]] #0 !orig=[323]
  428 IfTrue === 1412 [[ 266 ]] #1 !orig=[324]
  429 Bool === _ 430 [[ 447 ]] [gt] !orig=247,[232] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  430 CmpI === _ 431 28 [[ 429 ]] !orig=246,[231] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  431 AddI === _ 445 26 [[ 430 445 ]] !orig=224,... !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:42 (line 215)
  432 StoreI === 444 446 437 433 [[ 446 16 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  433 MulI === _ 434 439 [[ 432 ]] !orig=206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
  434 LoadI === 251 446 435 |314 [[ 433 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  435 AddP === _ 172 436 37 [[ 434 ]] !orig=203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  436 AddP === _ 172 172 442 [[ 435 ]] !orig=[359]
  437 AddP === _ 60 438 37 [[ 432 ]] !orig=221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  438 AddP === _ 60 60 442 [[ 437 ]] !orig=[360]
  439 LoadI === 251 446 440 |269 [[ 433 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  440 AddP === _ 131 441 37 [[ 439 ]] !orig=167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  441 AddP === _ 131 131 442 [[ 440 ]] !orig=[358]
  442 LShiftI === _ 443 30 [[ 436 438 441 ]] !orig=[262]
  443 SubI === _ 28 445 [[ 442 ]] !orig=[259]
  444 CountedLoop === 444 621 448 [[ 432 444 445 446 447 ]] inner stride: -1 post of N255 !orig=[255],[244],[118] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:14 (line 216)
  445 Phi === 444 1327 431 [[ 431 443 ]] #int:1..254:www #tripcount !orig=125 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:14 (line 216)
  446 Phi === 444 223 432 [[ 432 434 439 ]] #memory Memory: @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; !orig=124 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:14 (line 216)
  447 CountedLoopEnd === 444 429 [[ 448 449 ]] [gt] P=0.500000, C=68452.000000 !orig=248,[233] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  448 IfTrue === 447 [[ 444 ]] #1 !orig=249,[235] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  449 IfFalse === 447 [[ 242 ]] #0 !orig=251,[250],[234] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:11 (line 215)
  464 StoreI === 420 1399 469 465 [[ 1188 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact[272] *, idx=6; !orig=223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  465 MulI === _ 466 471 [[ 464 ]] !orig=206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
  466 LoadI === 420 1399 467 |314 [[ 465 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  467 AddP === _ 172 172 1316 [[ 466 ]] !orig=203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  469 AddP === _ 60 60 1316 [[ 464 ]] !orig=221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  471 LoadI === 381 1399 472 |269 [[ 465 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  472 AddP === _ 131 131 1316 [[ 471 ]] !orig=167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  508 Halt === 1355 1 1 8 1 [[ 0 ]]
  529 Halt === 1339 1 1 8 1 [[ 0 ]]
  550 Halt === 1351 1 1 8 1 [[ 0 ]]
  571 Halt === 1347 1 1 8 1 [[ 0 ]]
  584 ConvI2L === _ 1327 [[ 585 ]] #long:14..254:www !orig=[562],[289],[383]
  585 SubL === _ 386 584 [[ 586 607 ]] !orig=[563],[387],[293]
  586 CmpUL === _ 585 294 [[ 587 ]] !orig=[564],[295]
  587 Bool === _ 586 [[ 591 ]] [lt] !orig=[565],[296]
  589 IfTrue === 591 [[ 1418 ]] #1 !orig=[567],[299]
  590 IfFalse === 591 [[ 593 ]] #0 !orig=[568],[300]
  591 If === 251 587 [[ 589 590 ]] P=0.999999, C=-1.000000 !orig=[569],[298]
  593 Halt === 590 1 1 8 1 [[ 0 ]]
  597 CmpU === _ 727 150 [[ 598 ]] !orig=[543],[307]
  598 Bool === _ 597 [[ 1418 ]] [lt] !orig=[544],[308]
  600 IfTrue === 1418 [[ 612 ]] #1 !orig=[546],[311]
  601 IfFalse === 1418 [[ 604 ]] #0 !orig=[547],[312]
  604 Halt === 601 1 1 8 1 [[ 0 ]]
  607 CmpUL === _ 585 338 [[ 608 ]] !orig=[522],[339]
  608 Bool === _ 607 [[ 612 ]] [lt] !orig=[523],[340]
  610 IfTrue === 612 [[ 1419 ]] #1 !orig=[525],[343],[355]
  611 IfFalse === 612 [[ 614 ]] #0 !orig=[526],[344]
  612 If === 600 608 [[ 610 611 ]] P=0.999999, C=-1.000000 !orig=[527],[342]
  614 Halt === 611 1 1 8 1 [[ 0 ]]
  618 CmpU === _ 727 317 [[ 619 ]] !orig=[501],[351]
  619 Bool === _ 618 [[ 1419 ]] [lt] !orig=[502],[352]
  621 IfTrue === 1419 [[ 444 ]] #1 !orig=[504],[355]
  622 IfFalse === 1419 [[ 625 ]] #0 !orig=[505],[356]
  625 Halt === 622 1 1 8 1 [[ 0 ]]
  674 StoreI === 1185 775 679 675 [[ 169 223 205 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  675 MulI === _ 676 681 [[ 674 ]] !orig=206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
  676 LoadI === 420 775 677 |314 [[ 675 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  677 AddP === _ 172 1151 1251 [[ 676 ]] !orig=203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  679 AddP === _ 60 1156 1251 [[ 674 ]] !orig=221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  681 LoadI === 420 775 682 |269 [[ 675 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  682 AddP === _ 131 1162 1251 [[ 681 ]] !orig=167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  719 ConI === 0 [[ 1189 ]] #int:270
  727 SubI === _ 22 1327 [[ 618 597 ]] !orig=[617],[500],[422],[407],[350]
  775 StoreI === 1185 779 793 776 [[ 674 676 681 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  776 MulI === _ 777 778 [[ 775 ]] !orig=206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
  777 LoadI === 420 779 795 |269 [[ 776 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  778 LoadI === 420 779 791 |314 [[ 776 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  779 StoreI === 1185 940 784 780 [[ 775 777 778 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=674,223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  780 MulI === _ 781 786 [[ 779 ]] !orig=675,206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
  781 LoadI === 420 940 782 |314 [[ 780 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=676,205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  782 AddP === _ 172 1151 1252 [[ 781 ]] !orig=677,203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  784 AddP === _ 60 1156 1252 [[ 779 ]] !orig=679,221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  786 LoadI === 420 940 787 |269 [[ 780 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=681,169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  787 AddP === _ 131 1162 1252 [[ 786 ]] !orig=682,167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  791 AddP === _ 172 1151 1254 [[ 778 ]] !orig=203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  793 AddP === _ 60 1156 1254 [[ 775 ]] !orig=221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  795 AddP === _ 131 1162 1254 [[ 777 ]] !orig=167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  940 StoreI === 1185 944 966 941 [[ 779 781 786 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  941 MulI === _ 942 943 [[ 940 ]] !orig=206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
  942 LoadI === 420 944 968 |269 [[ 941 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  943 LoadI === 420 944 964 |314 [[ 941 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  944 StoreI === 1185 948 973 945 [[ 940 942 943 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=674,223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  945 MulI === _ 946 947 [[ 944 ]] !orig=675,206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
  946 LoadI === 420 948 971 |314 [[ 945 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=676,205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  947 LoadI === 420 948 975 |269 [[ 945 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=681,169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  948 StoreI === 1185 952 980 949 [[ 944 946 947 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=775,223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  949 MulI === _ 950 951 [[ 948 ]] !orig=776,206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
  950 LoadI === 420 952 982 |269 [[ 949 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=777,169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  951 LoadI === 420 952 978 |314 [[ 949 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=778,205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  952 StoreI === 1185 1116 957 953 [[ 948 950 951 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=779,674,223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  953 MulI === _ 954 959 [[ 952 ]] !orig=780,675,206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
  954 LoadI === 420 1116 955 |314 [[ 953 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=781,676,205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  955 AddP === _ 172 1151 1247 [[ 954 ]] !orig=782,677,203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  957 AddP === _ 60 1156 1247 [[ 952 ]] !orig=784,679,221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  959 LoadI === 420 1116 960 |269 [[ 953 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=786,681,169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  960 AddP === _ 131 1162 1247 [[ 959 ]] !orig=787,682,167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  964 AddP === _ 172 1151 1250 [[ 943 ]] !orig=203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  966 AddP === _ 60 1156 1250 [[ 940 ]] !orig=221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  968 AddP === _ 131 1162 1250 [[ 942 ]] !orig=167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  971 AddP === _ 172 1151 1248 [[ 946 ]] !orig=677,203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  973 AddP === _ 60 1156 1248 [[ 944 ]] !orig=679,221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  975 AddP === _ 131 1162 1248 [[ 947 ]] !orig=682,167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
  978 AddP === _ 172 1151 1249 [[ 951 ]] !orig=791,203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
  980 AddP === _ 60 1156 1249 [[ 948 ]] !orig=793,221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
  982 AddP === _ 131 1162 1249 [[ 950 ]] !orig=795,167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1002 ConI === 0 [[ 1384 ]] #int:4
1004 ConI === 0 [[ 1160 1154 1149 ]] #int:2188
1007 ConI === 0 [[ 1159 1155 1150 ]] #int:2192
1009 ConI === 0 [[ 1388 ]] #int:12
1011 ConI === 0 [[ 1161 1153 1148 ]] #int:2196
1072 ConI === 0 [[ 224 1327 ]] #int:-16
1093 Halt === 1343 1 1 8 1 [[ 0 ]]
1103 Halt === 1335 1 1 8 1 [[ 0 ]]
1114 Halt === 1331 1 1 8 1 [[ 0 ]]
1115 ConI === 0 [[ 246 ]] #int:15
1116 StoreI === 1185 1120 1171 1117 [[ 952 954 959 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1117 MulI === _ 1118 1119 [[ 1116 ]] !orig=206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
1118 LoadI === 420 1120 1176 |269 [[ 1117 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1119 LoadI === 420 1120 1166 |314 [[ 1117 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1120 StoreI === 1185 1124 1173 1121 [[ 1116 1118 1119 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=674,223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1121 MulI === _ 1122 1123 [[ 1120 ]] !orig=675,206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
1122 LoadI === 420 1124 1167 |314 [[ 1121 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=676,205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1123 LoadI === 420 1124 1178 |269 [[ 1121 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=681,169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1124 StoreI === 1185 1128 1172 1125 [[ 1120 1122 1123 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=775,223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1125 MulI === _ 1126 1127 [[ 1124 ]] !orig=776,206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
1126 LoadI === 420 1128 1177 |269 [[ 1125 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=777,169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1127 LoadI === 420 1128 1168 |314 [[ 1125 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=778,205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1128 StoreI === 1185 1132 1170 1129 [[ 1124 1126 1127 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=779,674,223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1129 MulI === _ 1130 1131 [[ 1128 ]] !orig=780,675,206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
1130 LoadI === 420 1132 1165 |314 [[ 1129 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=781,676,205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1131 LoadI === 420 1132 1175 |269 [[ 1129 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=786,681,169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1132 StoreI === 1185 1136 1153 1133 [[ 1128 1130 1131 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=940,223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1133 MulI === _ 1134 1135 [[ 1132 ]] !orig=941,206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
1134 LoadI === 420 1136 1161 |269 [[ 1133 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=942,169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1135 LoadI === 420 1136 1148 |314 [[ 1133 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=943,205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1136 StoreI === 1185 1140 1155 1137 [[ 1132 1134 1135 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=944,674,223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1137 MulI === _ 1138 1139 [[ 1136 ]] !orig=945,675,206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
1138 LoadI === 420 1140 1150 |314 [[ 1137 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=946,676,205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1139 LoadI === 420 1140 1159 |269 [[ 1137 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=947,681,169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1140 StoreI === 1185 1144 1154 1141 [[ 1136 1138 1139 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=948,775,223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1141 MulI === _ 1142 1143 [[ 1140 ]] !orig=949,776,206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
1142 LoadI === 420 1144 1160 |269 [[ 1141 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=950,777,169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1143 LoadI === 420 1144 1149 |314 [[ 1141 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=951,778,205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1144 StoreI === 1185 1188 1152 1145 [[ 1140 1142 1143 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=952,779,674,223,695 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1145 MulI === _ 1146 1157 [[ 1144 ]] !orig=953,780,675,206 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:40 (line 216)
1146 LoadI === 420 1188 1147 |314 [[ 1145 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=954,781,676,205 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1147 AddP === _ 172 1151 37 [[ 1146 ]] !orig=955,782,677,203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1148 AddP === _ 172 1151 1011 [[ 1135 ]] !orig=964,203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1149 AddP === _ 172 1151 1004 [[ 1143 ]] !orig=978,791,203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1150 AddP === _ 172 1151 1007 [[ 1138 ]] !orig=971,677,203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1151 AddP === _ 172 172 1163 [[ 1147 1148 1149 1150 1165 1168 1167 1166 971 677 203 782 955 964 978 791 ]] !orig=[956],[783],[678],[359]
1152 AddP === _ 60 1156 37 [[ 1144 ]] !orig=957,784,679,221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1153 AddP === _ 60 1156 1011 [[ 1132 ]] !orig=966,221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1154 AddP === _ 60 1156 1004 [[ 1140 ]] !orig=980,793,221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1155 AddP === _ 60 1156 1007 [[ 1136 ]] !orig=973,679,221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1156 AddP === _ 60 60 1163 [[ 1152 1153 1154 1155 1170 1173 1172 1171 793 957 966 980 973 679 784 221 ]] !orig=[958],[785],[680],[360]
1157 LoadI === 420 1188 1158 |269 [[ 1145 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=959,786,681,169 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1158 AddP === _ 131 1162 37 [[ 1157 ]] !orig=960,787,682,167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1159 AddP === _ 131 1162 1007 [[ 1139 ]] !orig=975,682,167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1160 AddP === _ 131 1162 1004 [[ 1142 ]] !orig=982,795,167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1161 AddP === _ 131 1162 1011 [[ 1134 ]] !orig=968,167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1162 AddP === _ 131 131 1163 [[ 1158 1159 1160 1161 1175 1178 1177 1176 795 960 975 982 968 682 787 167 ]] !orig=[961],[788],[683],[358]
1163 LShiftI === _ 1164 30 [[ 1151 1156 1162 ]] !orig=[962],[789],[684],[262]
1164 SubI === _ 28 1189 [[ 1163 ]] !orig=[963],[790],[685],[259]
1165 AddP === _ 172 1151 1197 [[ 1130 ]] !orig=782,677,203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1166 AddP === _ 172 1151 1198 [[ 1119 ]] !orig=203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1167 AddP === _ 172 1151 1200 [[ 1122 ]] !orig=677,203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1168 AddP === _ 172 1151 1199 [[ 1127 ]] !orig=791,203 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:39 (line 216)
1170 AddP === _ 60 1156 1197 [[ 1128 ]] !orig=784,679,221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1171 AddP === _ 60 1156 1198 [[ 1116 ]] !orig=221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1172 AddP === _ 60 1156 1199 [[ 1124 ]] !orig=793,221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1173 AddP === _ 60 1156 1200 [[ 1120 ]] !orig=679,221 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:41 (line 216)
1175 AddP === _ 131 1162 1197 [[ 1131 ]] !orig=787,682,167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1176 AddP === _ 131 1162 1198 [[ 1118 ]] !orig=167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1177 AddP === _ 131 1162 1199 [[ 1126 ]] !orig=795,167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1178 AddP === _ 131 1162 1200 [[ 1123 ]] !orig=682,167 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:29 (line 216)
1185 CountedLoop === 1185 1330 249 [[ 1116 1120 1124 1128 1132 1136 1140 1144 1185 940 1188 1189 944 948 952 248 775 779 223 674 ]] inner stride: -16 main of N1185 !orig=[992],[802],[686],[255],[244],[118] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:14 (line 216)
1188 Phi === 1185 464 223 [[ 1144 1146 1157 ]] #memory Memory: @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; !orig=[995],[805],[688],124 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:14 (line 216)
1189 Phi === 1185 719 224 [[ 1164 224 1325 ]] #int:30..270:www #tripcount !orig=[991],[806],[687],125 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:14 (line 216)
1197 ConI === 0 [[ 1165 1170 1175 ]] #int:2200
1198 ConI === 0 [[ 1166 1171 1176 ]] #int:2212
1199 ConI === 0 [[ 1168 1172 1177 ]] #int:2204
1200 ConI === 0 [[ 1167 1173 1178 ]] #int:2208
1247 ConI === 0 [[ 960 957 955 ]] #int:2216
1248 ConI === 0 [[ 975 973 971 ]] #int:2224
1249 ConI === 0 [[ 982 980 978 ]] #int:2220
1250 ConI === 0 [[ 968 966 964 ]] #int:2228
1251 ConI === 0 [[ 682 679 677 ]] #int:2240
1252 ConI === 0 [[ 787 784 782 ]] #int:2232
1253 ConI === 0 [[ 167 221 203 ]] #int:2244
1254 ConI === 0 [[ 795 793 791 ]] #int:2236
1302 ConI === 0 [[ 1309 1314 ]] #int:273
1304 ConI === 0 [[ 1307 1311 ]] #int:288
1307 CmpU === _ 317 1304 [[ 1328 ]] !orig=[1107],[501],[351]
1309 CmpU === _ 317 1302 [[ 1352 ]] !orig=[501],[351]
1311 CmpU === _ 150 1304 [[ 1340 ]] !orig=[1086],[543],[307]
1314 CmpU === _ 150 1302 [[ 1348 ]] !orig=[543],[307]
1316 ConI === 0 [[ 469 467 472 ]] #int:1100
1319 ConL === 0 [[ 1320 1322 ]] #long:273
1320 CmpUL === _ 294 1319 [[ 1344 ]] !orig=[1075],[564],[295]
1322 CmpUL === _ 338 1319 [[ 1332 ]] !orig=[1096],[522],[339]
1325 CastII === 251 1189 [[ 1327 ]] #int:30..270:www unconditional dependency
1327 AddI === _ 1325 1072 [[ 727 584 445 ]] !orig=[460],[720]
1328 Bool === _ 1307 [[ 1417 ]] [le]
1330 IfFalse === 1417 [[ 1185 ]] #0 !orig=[1110],[504],[355]
1331 IfTrue === 1417 [[ 1114 ]] #1 !orig=[1111],[505],[356]
1332 Bool === _ 1322 [[ 1333 1337 ]] [le] !orig=[1336]
1333 If === 1342 1332 [[ 1334 1335 ]] P=0.000001, C=-1.000000 !orig=[1101],[527],[342]
1334 IfFalse === 1333 [[ 1417 ]] #0 !orig=[1099],[525],[343],[355]
1335 IfTrue === 1333 [[ 1103 ]] #1 !orig=[1100],[526],[344]
1337 If === 1354 1332 [[ 1338 1339 ]] P=0.000001, C=-1.000000 !orig=[527],[342]
1338 IfFalse === 1337 [[ 1415 ]] #0 !orig=[525],[343],[355]
1339 IfTrue === 1337 [[ 529 ]] #1 !orig=[526],[344]
1340 Bool === _ 1311 [[ 1416 ]] [le]
1342 IfFalse === 1416 [[ 1333 ]] #0 !orig=[1089],[546],[311]
1343 IfTrue === 1416 [[ 1093 ]] #1 !orig=[1090],[547],[312]
1344 Bool === _ 1320 [[ 1345 ]] [le]
1345 If === 1350 1344 [[ 1346 1347 ]] P=0.000001, C=-1.000000 !orig=[569],[298]
1346 IfFalse === 1345 [[ 1416 ]] #0 !orig=[567],[299]
1347 IfTrue === 1345 [[ 571 ]] #1 !orig=[568],[300]
1348 Bool === _ 1314 [[ 1415 ]] [le]
1350 IfFalse === 1415 [[ 1345 ]] #0 !orig=[546],[311]
1351 IfTrue === 1415 [[ 550 ]] #1 !orig=[547],[312]
1352 Bool === _ 1309 [[ 1414 ]] [le]
1354 IfFalse === 1414 [[ 1337 ]] #0 !orig=[504],[355]
1355 IfTrue === 1414 [[ 508 ]] #1 !orig=[505],[356]
1356 Region === 1356 1401 1406 [[ 1356 1357 1358 1359 56 ]] !orig=[48] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
1357 Phi === 1356 53 1408 [[ 59 56 ]] #memory Memory: @rawptr:BotPTR, idx=Raw;
1358 Phi === 1356 6 1381 [[ 242 78 ]] #abIO
1359 Phi === 1356 1402 1366 [[ 60 ]] #rawptr:BotPTR !orig=[55] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
1360 ThreadLocal === 0 [[ 1362 1364 ]]
1361 ConI === 0 [[ 1362 ]] #int:216
1362 AddP === _ 1 1360 1361 [[ 1366 1382 ]]
1363 ConI === 0 [[ 1364 ]] #int:224
1364 AddP === _ 1 1360 1363 [[ 1365 ]]
1365 LoadP === 5 7 1364 [[ 1368 ]] @rawptr:BotPTR, idx=Raw; #rawptr:BotPTR (does not depend only on test, raw access)
1366 LoadP === 5 7 1362 [[ 1367 1374 1377 1380 1383 1384 1384 1386 1386 1388 1388 1393 1393 1359 ]] @rawptr:BotPTR, idx=Raw; #rawptr:BotPTR (does not depend only on test, raw access)
1367 AddP === _ 1 1366 37 [[ 1368 1374 1377 1380 1382 ]]
1368 CmpP === _ 1367 1365 [[ 1403 ]]
1373 ConI === 0 [[ 1374 ]] #int:256
1374 AddP === _ 1366 1367 1373 [[ 1375 ]]
1375 PrefetchAllocation === 1406 6 1374 [[ 1378 ]]
1376 ConI === 0 [[ 1377 ]] #int:320
1377 AddP === _ 1366 1367 1376 [[ 1378 ]]
1378 PrefetchAllocation === _ 1375 1377 [[ 1381 ]]
1379 ConI === 0 [[ 1380 ]] #int:384
1380 AddP === _ 1366 1367 1379 [[ 1381 ]]
1381 PrefetchAllocation === _ 1378 1380 [[ 1358 ]]
1382 StoreP === 1406 7 1362 1367 [[ 1383 ]] @rawptr:BotPTR, idx=Raw; Memory: @rawptr:BotPTR, idx=Raw;
1383 StoreI === 1406 1382 1366 39 [[ 1385 ]] @NULL Memory: @rawptr:BotPTR, idx=Raw;
1384 AddP === _ 1366 1366 1002 [[ 1385 ]]
1385 StoreP === 1406 1383 1384 23 [[ 1387 ]] @NULL Memory: @rawptr:BotPTR, idx=Raw;
1386 AddP === _ 1366 1366 148 [[ 1387 ]]
1387 StoreI === 1406 1385 1386 22 [[ 1389 ]] @NULL Memory: @rawptr:BotPTR, idx=Raw;
1388 AddP === _ 1366 1366 1009 [[ 1389 ]]
1389 StoreI === 1406 1387 1388 28 [[ 1408 ]] @rawptr:BotPTR, idx=Raw; Memory: @rawptr:BotPTR, idx=Raw;
1393 AddP === _ 1366 1366 129 [[ 1408 ]]
1395 MemBarStoreStore === 1396 1 1397 1 1 [[ 1398 1399 ]]
1396 Proj === 56 [[ 1395 ]] #0
1397 Proj === 56 [[ 1395 ]] #2 Memory: @rawptr:BotPTR, idx=Raw;
1398 Proj === 1395 [[ 60 268 ]] #0 !orig=[57] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
1399 Proj === 1395 [[ 75 75 75 75 466 471 16 16 16 464 ]] #2 Memory: @BotPTR *+bot, idx=Bot; !orig=[58],[116] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
1400 CallStaticJava === 1405 1 7 8 1 (1409 22 10 1 1 ) [[ 1402 54 53 44 ]] # Static _new_array_Java rawptr:NotNull ( java/lang/Object:NotNull *, int ) C=0.000100 LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214) !orig=43 !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
1401 CatchProj === 47 [[ 1356 ]] #0@bci -1 !orig=[48] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
1402 Proj === 1400 [[ 1359 ]] #5 !orig=[55] !jvms: LoopRangeStrideTest::countDownLoopWithNegScale @ bci:3 (line 214)
1403 Bool === _ 1368 [[ 1404 ]] [lt]
1404 If === 5 1403 [[ 1405 1406 ]] P=0.999900, C=-1.000000 !orig=[1370]
1405 IfFalse === 1404 [[ 1400 ]] #0 !orig=[1371]
1406 IfTrue === 1404 [[ 1356 1408 1389 1387 1385 1383 1382 1375 ]] #1 !orig=[1372]
1408 ClearArray === 1406 1389 63 1393 [[ 1357 ]] Memory: @rawptr:BotPTR, idx=Raw; !orig=[1394]
1409 ConP === 0 [[ 1400 ]] #precise [int (java/lang/Cloneable,java/io/Serializable): :Constant:exact *
1410 If === 269 368 [[ 371 370 ]] P=0.000001, C=-1.000000
1411 If === 370 379 [[ 382 381 ]] P=0.000001, C=-1.000000
1412 If === 314 425 [[ 428 427 ]] P=0.000001, C=-1.000000
1413 If === 427 418 [[ 421 420 ]] P=0.000001, C=-1.000000
1414 If === 420 1352 [[ 1355 1354 ]] P=0.000001, C=-1.000000
1415 If === 1338 1348 [[ 1351 1350 ]] P=0.000001, C=-1.000000
1416 If === 1346 1340 [[ 1343 1342 ]] P=0.000001, C=-1.000000
1417 If === 1334 1328 [[ 1331 1330 ]] P=0.000001, C=-1.000000
1418 If === 589 598 [[ 601 600 ]] P=0.999999, C=-1.000000
1419 If === 610 619 [[ 622 621 ]] P=0.999999, C=-1.000000

2) Compilation of "public int[] compiler.vectorization.runner.LoopRangeStrideTest.countupLoopWithNegScale()":
> Phase "PrintIdeal":
AFTER: print_ideal
    0 Root === 0 82 628 616 243 242 509 1110 531 1099 552 1089 573 606 595 [[ 0 1 3 22 23 228 1327 28 170 30 815 813 148 37 39 808 63 77 90 103 129 133 256 769 726 396 386 376 817 863 867 935 998 1000 1002 1004 1006 1008 1014 1111 1192 1194 1195 1196 1197 1201 1242 1244 1245 1246 1247 1248 1249 1250 1251 1288 1289 1290 1292 1293 1299 1302 1307 1309 1311 1320 1323 1361 1362 1364 1376 1379 1388 1391 1411 ]]
    1 Con === 0 [[ ]] #top
    3 Start === 3 0 [[ 3 5 6 7 8 9 10 ]] #{0:control, 1:abIO, 2:memory, 3:rawptr:BotPTR, 4:return_address, 5:compiler/vectorization/runner/LoopRangeStrideTest:NotNull *}
    5 Parm === 3 [[ 1406 1366 1367 ]] Control !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:-1 (line 203)
    6 Parm === 3 [[ 1375 1359 ]] I_O !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:-1 (line 203)
    7 Parm === 3 [[ 316 150 172 131 16 1402 50 59 75 1366 1367 1382 ]] Memory Memory: @BotPTR *+bot, idx=Bot; !orig=[112],[120] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:-1 (line 203)
    8 Parm === 3 [[ 243 242 616 595 1402 78 628 606 82 509 531 552 573 1099 1110 1089 ]] FramePtr !orig=[508] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:-1 (line 203)
    9 Parm === 3 [[ 243 242 78 ]] ReturnAdr !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:-1 (line 203)
   10 Parm === 3 [[ 130 130 78 1402 171 171 ]] Parm0: compiler/vectorization/runner/LoopRangeStrideTest:NotNull * Oop:compiler/vectorization/runner/LoopRangeStrideTest:NotNull * !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:-1 (line 203)
   16 MergeMem === _ 1 7 1401 1401 1401 431 [[ 242 ]] { N1401:rawptr:BotPTR N1401:java/lang/Object * N1401:java/lang/Object+4 * N431:int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any * } Memory: @BotPTR *+bot, idx=Bot;
   22 ConI === 0 [[ 430 78 1402 1387 ]] #int:543
   23 ConP === 0 [[ 1385 ]] #precise [int (java/lang/Cloneable,java/io/Serializable): :Constant:exact *
   28 ConI === 0 [[ 1390 442 1160 ]] #int:0
   30 ConI === 0 [[ 1159 441 ]] #int:2
   37 ConI === 0 [[ 1368 1154 1143 1148 434 436 439 ]] #int:2184
   39 ConI === 0 [[ 1383 443 366 423 ]] #int:1
   44 Proj === 1402 [[ 47 ]] #0 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
   47 Catch === 44 54 [[ 1403 49 ]] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
   49 CatchProj === 47 [[ 243 52 ]] #1@bci -1 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
   50 MergeMem === _ 1 7 53 [[ 243 ]] { N53:rawptr:BotPTR } Memory: @BotPTR *+bot, idx=Bot; !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
   52 CreateEx === 49 54 [[ 243 ]] #java/lang/Throwable (java/io/Serializable):NotNull * Oop:java/lang/Throwable (java/io/Serializable):NotNull * !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
   53 Proj === 1402 [[ 50 1358 ]] #2 Memory: @BotPTR *+bot, idx=Bot; !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
   54 Proj === 1402 [[ 47 52 243 ]] #1 !orig=[111] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
   56 Initialize === 1357 1 59 1 1 1 1358 [[ 1399 1398 ]] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
   59 MergeMem === _ 1 1358 1 1 1 7 [[ 56 ]] { - - - N7:int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any * } Memory: @BotPTR *+bot, idx=Bot; !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
   60 CheckCastPP === 1400 1360 [[ 242 953 78 1152 1151 1166 1149 221 436 437 437 468 1150 468 681 966 971 779 1168 1167 788 1152 976 1169 1148 ]] #int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact * !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
   63 ConI === 0 [[ 1300 78 78 1312 1410 ]] #int:271
   75 MergeMem === _ 1 7 1401 1401 1401 1401 [[ 78 ]] { N1401:rawptr:BotPTR N1401:java/lang/Object * N1401:java/lang/Object+4 * N1401:int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any * } Memory: @BotPTR *+bot, idx=Bot; !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
   77 ConI === 0 [[ 78 ]] #int:-138
   78 CallStaticJava === 265 1359 75 8 9 (77 10 60 63 63 22 ) [[ 79 ]] # Static uncommon_trap(reason='predicate' action='maybe_recompile') void ( int ) C=0.000100 LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204) reexecute !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
   79 Proj === 78 [[ 82 ]] #0 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
   82 Halt === 79 1 1 8 1 [[ 0 ]] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  129 ConI === 0 [[ 130 224 1326 1395 ]] #int:16
  130 AddP === _ 10 10 129 [[ 131 ]] Oop:compiler/vectorization/runner/LoopRangeStrideTest:NotNull+16 * !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:24 (line 205)
  131 LoadP === _ 7 130 [[ 167 134 1157 1156 1155 1154 1174 978 1158 1158 1172 1173 782 968 1171 684 471 471 790 440 440 439 973 956 149 149 ]] @compiler/vectorization/runner/LoopRangeStrideTest+16 *, name=a, idx=7; #int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact * !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:24 (line 205)
  133 ConP === 0 [[ 134 174 ]] #NULL
  134 CmpP === _ 131 133 [[ 135 ]] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  135 Bool === _ 134 [[ 267 ]] [ne] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  148 ConI === 0 [[ 149 315 1386 ]] #int:8
  149 AddP === _ 131 131 148 [[ 150 ]] !orig=[270],... !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  150 LoadRange === 268 7 149 [[ 366 599 293 377 1312 1305 ]] @bottom[int:>=0] (java/lang/Cloneable,java/io/Serializable)+8 *, idx=8; #int:>=0 !orig=[271],... !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  167 AddP === _ 131 1158 1250 [[ 169 ]] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  169 LoadI === 418 676 167 |268 [[ 206 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  170 ConI === 0 [[ 171 ]] #int:20
  171 AddP === _ 10 10 170 [[ 172 ]] Oop:compiler/vectorization/runner/LoopRangeStrideTest:NotNull+20 * !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:34 (line 205)
  172 LoadP === _ 7 171 [[ 315 174 1146 1145 1144 1143 1164 960 962 786 1162 1163 777 964 1147 1147 466 466 679 435 435 434 1161 203 951 315 ]] @compiler/vectorization/runner/LoopRangeStrideTest+20 *, name=b, idx=9; #int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact * !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:34 (line 205)
  174 CmpP === _ 172 133 [[ 175 ]] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  175 Bool === _ 174 [[ 312 ]] [ne] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  203 AddP === _ 172 1147 1250 [[ 205 ]] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  205 LoadI === 418 676 203 |313 [[ 206 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  206 MulI === _ 169 205 [[ 223 ]] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
  221 AddP === _ 60 1152 1250 [[ 223 ]] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  223 StoreI === 1181 676 221 206 [[ 1184 446 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  224 AddI === _ 1185 129 [[ 1185 246 ]] !orig=[245],... !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:45 (line 204)
  234 IfTrue === 248 [[ 1181 ]] #1 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  242 Return === 449 1359 16 8 9 returns 60 [[ 0 ]]
  243 Rethrow === 49 54 50 8 9 exception 52 [[ 0 ]]
  246 CmpI === _ 224 1111 [[ 247 ]] !orig=[231] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  247 Bool === _ 246 [[ 248 ]] [lt] !orig=[232] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  248 CountedLoopEnd === 1181 247 [[ 249 234 ]] [lt] P=0.996347, C=68466.000000 !orig=[233] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  249 IfFalse === 248 [[ 438 593 1324 433 ]] #0 !orig=[235] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  265 Region === 265 314 269 371 382 419 428 [[ 265 78 ]] !orig=[74] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  267 If === 1400 135 [[ 268 269 ]] P=0.999999, C=-1.000000
  268 IfTrue === 267 [[ 1412 1138 169 150 955 943 438 470 683 1127 938 781 1119 1114 772 946 1122 1153 1135 1130 ]] #1
  269 IfFalse === 267 [[ 265 ]] #0
  293 ConvI2L === _ 150 [[ 588 1316 ]] #long:0..maxint
  312 If === 381 175 [[ 313 314 ]] P=0.999999, C=-1.000000
  313 IfTrue === 312 [[ 1414 1139 316 950 205 1115 433 465 678 947 776 1126 1118 773 942 939 1123 1142 1131 1134 ]] #1
  314 IfFalse === 312 [[ 265 ]] #0
  315 AddP === _ 172 172 148 [[ 316 ]] !orig=[187] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  316 LoadRange === 313 7 315 [[ 423 408 337 621 1300 1303 ]] @bottom[int:>=0] (java/lang/Cloneable,java/io/Serializable)+8 *, idx=8; #int:>=0 !orig=[188] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  337 ConvI2L === _ 316 [[ 609 1314 ]] #long:0..maxint
  366 CmpU === _ 150 39 [[ 368 ]] !orig=[275]
  368 Bool === _ 366 [[ 1412 ]] [le]
  370 IfFalse === 1412 [[ 1413 ]] #0 !orig=[278]
  371 IfTrue === 1412 [[ 265 ]] #1 !orig=[279]
  376 ConI === 0 [[ 377 408 1185 ]] #int:272
  377 CmpU === _ 150 376 [[ 379 ]] !orig=[282]
  379 Bool === _ 377 [[ 1413 ]] [le]
  381 IfFalse === 1413 [[ 312 470 ]] #0 !orig=[285]
  382 IfTrue === 1413 [[ 265 ]] #1 !orig=[286]
  386 ConL === 0 [[ 587 ]] #long:543
  408 CmpU === _ 316 376 [[ 416 ]] !orig=[327]
  416 Bool === _ 408 [[ 1415 ]] [le]
  418 IfFalse === 1415 [[ 463 465 169 1142 1139 1138 1135 1134 1131 1130 1127 1126 1123 1122 1119 1118 1115 1114 955 950 947 946 943 942 939 938 781 776 773 772 683 678 205 1416 1153 ]] #0 !orig=[330] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  419 IfTrue === 1415 [[ 265 ]] #1 !orig=[331]
  423 CmpU === _ 316 39 [[ 425 ]] !orig=[320]
  425 Bool === _ 423 [[ 1414 ]] [le]
  427 IfFalse === 1414 [[ 1415 ]] #0 !orig=[323]
  428 IfTrue === 1414 [[ 265 ]] #1 !orig=[324]
  429 Bool === _ 430 [[ 447 ]] [lt] !orig=247,[232] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  430 CmpI === _ 443 22 [[ 429 ]] !orig=246,[231] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  431 StoreI === 444 446 436 432 [[ 446 16 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  432 MulI === _ 433 438 [[ 431 ]] !orig=206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
  433 LoadI === 249 446 434 |313 [[ 432 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  434 AddP === _ 172 435 37 [[ 433 ]] !orig=203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  435 AddP === _ 172 172 441 [[ 434 ]] !orig=[358]
  436 AddP === _ 60 437 37 [[ 431 ]] !orig=221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  437 AddP === _ 60 60 441 [[ 436 ]] !orig=[359]
  438 LoadI === 249 446 439 |268 [[ 432 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  439 AddP === _ 131 440 37 [[ 438 ]] !orig=167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  440 AddP === _ 131 131 441 [[ 439 ]] !orig=[357]
  441 LShiftI === _ 442 30 [[ 435 437 440 ]] !orig=[261]
  442 SubI === _ 28 445 [[ 441 ]] !orig=[258]
  443 AddI === _ 445 39 [[ 430 445 ]] !orig=224,... !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:45 (line 204)
  444 CountedLoop === 444 624 448 [[ 431 444 445 446 447 ]] inner stride: 1 post of N253 !orig=[253],[244],[118] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:17 (line 205)
  445 Phi === 444 1326 443 [[ 442 443 ]] #int:288..542:www #tripcount !orig=125 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:17 (line 205)
  446 Phi === 444 223 431 [[ 431 433 438 ]] #memory Memory: @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; !orig=124 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:17 (line 205)
  447 CountedLoopEnd === 444 429 [[ 448 449 ]] [lt] P=0.500000, C=68466.000000 !orig=248,[233] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  448 IfTrue === 447 [[ 444 ]] #1 !orig=234 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  449 IfFalse === 447 [[ 242 ]] #0 !orig=249,[235] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:14 (line 204)
  463 StoreI === 418 1401 468 464 [[ 1184 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact[272] *, idx=6; !orig=223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  464 MulI === _ 465 470 [[ 463 ]] !orig=206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
  465 LoadI === 418 1401 466 |313 [[ 464 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  466 AddP === _ 172 172 1320 [[ 465 ]] !orig=203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  468 AddP === _ 60 60 1320 [[ 463 ]] !orig=221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  470 LoadI === 381 1401 471 |268 [[ 464 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  471 AddP === _ 131 131 1320 [[ 470 ]] !orig=167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  509 Halt === 1356 1 1 8 1 [[ 0 ]]
  531 Halt === 1340 1 1 8 1 [[ 0 ]]
  552 Halt === 1352 1 1 8 1 [[ 0 ]]
  573 Halt === 1348 1 1 8 1 [[ 0 ]]
  586 ConvI2L === _ 1326 [[ 587 ]] #long:288..528:www !orig=[564],[288],[383]
  587 SubL === _ 386 586 [[ 588 609 ]] !orig=[565],[387],[292]
  588 CmpUL === _ 587 293 [[ 589 ]] !orig=[566],[294]
  589 Bool === _ 588 [[ 593 ]] [lt] !orig=[567],[295]
  591 IfTrue === 593 [[ 1420 ]] #1 !orig=[569],[298]
  592 IfFalse === 593 [[ 595 ]] #0 !orig=[570],[299]
  593 If === 249 589 [[ 591 592 ]] P=0.999999, C=-1.000000 !orig=[571],[297]
  595 Halt === 592 1 1 8 1 [[ 0 ]]
  599 CmpU === _ 1328 150 [[ 600 ]] !orig=[545],[306]
  600 Bool === _ 599 [[ 1420 ]] [lt] !orig=[546],[307]
  602 IfTrue === 1420 [[ 614 ]] #1 !orig=[548],[310]
  603 IfFalse === 1420 [[ 606 ]] #0 !orig=[549],[311]
  606 Halt === 603 1 1 8 1 [[ 0 ]]
  609 CmpUL === _ 587 337 [[ 610 ]] !orig=[524],[338]
  610 Bool === _ 609 [[ 614 ]] [lt] !orig=[525],[339]
  612 IfTrue === 614 [[ 1421 ]] #1 !orig=[527],[342],[354]
  613 IfFalse === 614 [[ 616 ]] #0 !orig=[528],[343]
  614 If === 602 610 [[ 612 613 ]] P=0.999999, C=-1.000000 !orig=[529],[341]
  616 Halt === 613 1 1 8 1 [[ 0 ]]
  621 CmpU === _ 1328 316 [[ 622 ]] !orig=[502],[350]
  622 Bool === _ 621 [[ 1421 ]] [lt] !orig=[503],[351]
  624 IfTrue === 1421 [[ 444 ]] #1 !orig=[505],[354]
  625 IfFalse === 1421 [[ 628 ]] #0 !orig=[506],[355]
  628 Halt === 625 1 1 8 1 [[ 0 ]]
  676 StoreI === 1181 770 681 677 [[ 169 223 205 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  677 MulI === _ 678 683 [[ 676 ]] !orig=206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
  678 LoadI === 418 770 679 |313 [[ 677 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  679 AddP === _ 172 1147 1251 [[ 678 ]] !orig=203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  681 AddP === _ 60 1152 1251 [[ 676 ]] !orig=221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  683 LoadI === 418 770 684 |268 [[ 677 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  684 AddP === _ 131 1158 1251 [[ 683 ]] !orig=167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  726 ConI === 0 [[ 1384 ]] #int:4
  770 StoreI === 1181 774 788 771 [[ 676 678 683 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  771 MulI === _ 772 773 [[ 770 ]] !orig=206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
  772 LoadI === 418 774 790 |268 [[ 771 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  773 LoadI === 418 774 786 |313 [[ 771 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  774 StoreI === 1181 936 779 775 [[ 770 772 773 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=676,223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  775 MulI === _ 776 781 [[ 774 ]] !orig=677,206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
  776 LoadI === 418 936 777 |313 [[ 775 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=678,205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  777 AddP === _ 172 1147 1249 [[ 776 ]] !orig=679,203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  779 AddP === _ 60 1152 1249 [[ 774 ]] !orig=681,221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  781 LoadI === 418 936 782 |268 [[ 775 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=683,169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  782 AddP === _ 131 1158 1249 [[ 781 ]] !orig=684,167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  786 AddP === _ 172 1147 1248 [[ 773 ]] !orig=203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  788 AddP === _ 60 1152 1248 [[ 770 ]] !orig=221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  790 AddP === _ 131 1158 1248 [[ 772 ]] !orig=167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  936 StoreI === 1181 940 966 937 [[ 774 776 781 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  937 MulI === _ 938 939 [[ 936 ]] !orig=206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
  938 LoadI === 418 940 968 |268 [[ 937 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  939 LoadI === 418 940 960 |313 [[ 937 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  940 StoreI === 1181 944 971 941 [[ 936 938 939 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=676,223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  941 MulI === _ 942 943 [[ 940 ]] !orig=677,206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
  942 LoadI === 418 944 962 |313 [[ 941 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=678,205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  943 LoadI === 418 944 973 |268 [[ 941 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=683,169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  944 StoreI === 1181 948 976 945 [[ 940 942 943 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=770,223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  945 MulI === _ 946 947 [[ 944 ]] !orig=771,206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
  946 LoadI === 418 948 978 |268 [[ 945 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=772,169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  947 LoadI === 418 948 964 |313 [[ 945 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=773,205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  948 StoreI === 1181 1112 953 949 [[ 944 946 947 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=774,676,223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  949 MulI === _ 950 955 [[ 948 ]] !orig=775,677,206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
  950 LoadI === 418 1112 951 |313 [[ 949 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=776,678,205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  951 AddP === _ 172 1147 1244 [[ 950 ]] !orig=777,679,203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  953 AddP === _ 60 1152 1244 [[ 948 ]] !orig=779,681,221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  955 LoadI === 418 1112 956 |268 [[ 949 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=781,683,169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  956 AddP === _ 131 1158 1244 [[ 955 ]] !orig=782,684,167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  960 AddP === _ 172 1147 1246 [[ 939 ]] !orig=203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  962 AddP === _ 172 1147 1245 [[ 942 ]] !orig=679,203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  964 AddP === _ 172 1147 1247 [[ 947 ]] !orig=786,203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
  966 AddP === _ 60 1152 1246 [[ 936 ]] !orig=221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  968 AddP === _ 131 1158 1246 [[ 938 ]] !orig=167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  971 AddP === _ 60 1152 1245 [[ 940 ]] !orig=681,221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  973 AddP === _ 131 1158 1245 [[ 943 ]] !orig=684,167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
  976 AddP === _ 60 1152 1247 [[ 944 ]] !orig=788,221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
  978 AddP === _ 131 1158 1247 [[ 946 ]] !orig=790,167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1000 ConI === 0 [[ 1155 1150 1145 ]] #int:2176
1004 ConI === 0 [[ 1157 1151 1146 ]] #int:2180
1008 ConI === 0 [[ 1156 1149 1144 ]] #int:2172
1089 Halt === 1344 1 1 8 1 [[ 0 ]]
1099 Halt === 1336 1 1 8 1 [[ 0 ]]
1110 Halt === 1332 1 1 8 1 [[ 0 ]]
1111 ConI === 0 [[ 246 ]] #int:528
1112 StoreI === 1181 1116 1167 1113 [[ 948 950 955 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1113 MulI === _ 1114 1115 [[ 1112 ]] !orig=206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
1114 LoadI === 418 1116 1172 |268 [[ 1113 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1115 LoadI === 418 1116 1161 |313 [[ 1113 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1116 StoreI === 1181 1120 1168 1117 [[ 1112 1114 1115 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=676,223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1117 MulI === _ 1118 1119 [[ 1116 ]] !orig=677,206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
1118 LoadI === 418 1120 1162 |313 [[ 1117 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=678,205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1119 LoadI === 418 1120 1173 |268 [[ 1117 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=683,169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1120 StoreI === 1181 1124 1169 1121 [[ 1116 1118 1119 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=770,223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1121 MulI === _ 1122 1123 [[ 1120 ]] !orig=771,206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
1122 LoadI === 418 1124 1174 |268 [[ 1121 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=772,169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1123 LoadI === 418 1124 1164 |313 [[ 1121 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=773,205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1124 StoreI === 1181 1128 1166 1125 [[ 1120 1122 1123 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=774,676,223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1125 MulI === _ 1126 1127 [[ 1124 ]] !orig=775,677,206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
1126 LoadI === 418 1128 1163 |313 [[ 1125 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=776,678,205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1127 LoadI === 418 1128 1171 |268 [[ 1125 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=781,683,169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1128 StoreI === 1181 1132 1149 1129 [[ 1124 1126 1127 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=936,223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1129 MulI === _ 1130 1131 [[ 1128 ]] !orig=937,206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
1130 LoadI === 418 1132 1156 |268 [[ 1129 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=938,169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1131 LoadI === 418 1132 1144 |313 [[ 1129 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=939,205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1132 StoreI === 1181 1136 1150 1133 [[ 1128 1130 1131 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=940,676,223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1133 MulI === _ 1134 1135 [[ 1132 ]] !orig=941,677,206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
1134 LoadI === 418 1136 1145 |313 [[ 1133 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=942,678,205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1135 LoadI === 418 1136 1155 |268 [[ 1133 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=943,683,169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1136 StoreI === 1181 1140 1151 1137 [[ 1132 1134 1135 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=944,770,223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1137 MulI === _ 1138 1139 [[ 1136 ]] !orig=945,771,206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
1138 LoadI === 418 1140 1157 |268 [[ 1137 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=946,772,169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1139 LoadI === 418 1140 1146 |313 [[ 1137 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=947,773,205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1140 StoreI === 1181 1184 1148 1141 [[ 1136 1138 1139 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; Memory: @int[int:543] (java/lang/Cloneable,java/io/Serializable):NotNull:exact+any *, idx=6; !orig=948,774,676,223,696 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1141 MulI === _ 1142 1153 [[ 1140 ]] !orig=949,775,677,206 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:43 (line 205)
1142 LoadI === 418 1184 1143 |313 [[ 1141 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=950,776,678,205 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1143 AddP === _ 172 1147 37 [[ 1142 ]] !orig=951,777,679,203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1144 AddP === _ 172 1147 1008 [[ 1131 ]] !orig=960,203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1145 AddP === _ 172 1147 1000 [[ 1134 ]] !orig=962,679,203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1146 AddP === _ 172 1147 1004 [[ 1139 ]] !orig=964,786,203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1147 AddP === _ 172 172 1159 [[ 1143 1144 1145 1146 1161 1164 1163 1162 964 679 203 777 951 960 962 786 ]] !orig=[952],[778],[680],[358]
1148 AddP === _ 60 1152 37 [[ 1140 ]] !orig=953,779,681,221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1149 AddP === _ 60 1152 1008 [[ 1128 ]] !orig=966,221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1150 AddP === _ 60 1152 1000 [[ 1132 ]] !orig=971,681,221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1151 AddP === _ 60 1152 1004 [[ 1136 ]] !orig=976,788,221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1152 AddP === _ 60 60 1159 [[ 1148 1149 1150 1151 1166 1169 1168 1167 681 953 966 971 976 788 779 221 ]] !orig=[954],[780],[682],[359]
1153 LoadI === 418 1184 1154 |268 [[ 1141 ]] @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; #int !orig=955,781,683,169 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1154 AddP === _ 131 1158 37 [[ 1153 ]] !orig=956,782,684,167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1155 AddP === _ 131 1158 1000 [[ 1135 ]] !orig=973,684,167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1156 AddP === _ 131 1158 1008 [[ 1130 ]] !orig=968,167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1157 AddP === _ 131 1158 1004 [[ 1138 ]] !orig=978,790,167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1158 AddP === _ 131 131 1159 [[ 1154 1155 1156 1157 1171 1174 1173 1172 684 956 973 968 978 790 782 167 ]] !orig=[957],[783],[685],[357]
1159 LShiftI === _ 1160 30 [[ 1147 1152 1158 ]] !orig=[958],[784],[686],[261]
1160 SubI === _ 28 1185 [[ 1159 ]] !orig=[959],[785],[687],[258]
1161 AddP === _ 172 1147 1195 [[ 1115 ]] !orig=203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1162 AddP === _ 172 1147 1196 [[ 1118 ]] !orig=679,203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1163 AddP === _ 172 1147 1194 [[ 1126 ]] !orig=777,679,203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1164 AddP === _ 172 1147 1197 [[ 1123 ]] !orig=786,203 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:42 (line 205)
1166 AddP === _ 60 1152 1194 [[ 1124 ]] !orig=779,681,221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1167 AddP === _ 60 1152 1195 [[ 1112 ]] !orig=221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1168 AddP === _ 60 1152 1196 [[ 1116 ]] !orig=681,221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1169 AddP === _ 60 1152 1197 [[ 1120 ]] !orig=788,221 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:44 (line 205)
1171 AddP === _ 131 1158 1194 [[ 1127 ]] !orig=782,684,167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1172 AddP === _ 131 1158 1195 [[ 1114 ]] !orig=167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1173 AddP === _ 131 1158 1196 [[ 1119 ]] !orig=684,167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1174 AddP === _ 131 1158 1197 [[ 1122 ]] !orig=790,167 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:32 (line 205)
1181 CountedLoop === 1181 1331 234 [[ 1112 1116 1120 1124 1128 1132 1136 1140 1181 936 1184 1185 940 944 948 248 770 774 223 676 ]] inner stride: 16 main of N1181 !orig=[988],[797],[689],[253],[244],[118] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:17 (line 205)
1184 Phi === 1181 463 223 [[ 1140 1142 1153 ]] #memory Memory: @int[int:>=0] (java/lang/Cloneable,java/io/Serializable):exact+any *, idx=6; !orig=[991],[800],[691],124 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:17 (line 205)
1185 Phi === 1181 376 224 [[ 1160 224 1324 ]] #int:272..512:www #tripcount !orig=[987],[801],[690],125 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:17 (line 205)
1194 ConI === 0 [[ 1163 1166 1171 ]] #int:2168
1195 ConI === 0 [[ 1161 1167 1172 ]] #int:2156
1196 ConI === 0 [[ 1162 1173 1168 ]] #int:2160
1197 ConI === 0 [[ 1164 1169 1174 ]] #int:2164
1244 ConI === 0 [[ 956 953 951 ]] #int:2152
1245 ConI === 0 [[ 973 971 962 ]] #int:2144
1246 ConI === 0 [[ 968 966 960 ]] #int:2140
1247 ConI === 0 [[ 978 976 964 ]] #int:2148
1248 ConI === 0 [[ 790 788 786 ]] #int:2132
1249 ConI === 0 [[ 782 779 777 ]] #int:2136
1250 ConI === 0 [[ 167 221 203 ]] #int:2124
1251 ConI === 0 [[ 684 679 681 ]] #int:2128
1292 ConI === 0 [[ 1305 1303 1374 ]] #int:256
1300 CmpU === _ 316 63 [[ 1353 ]] !orig=[502],[350]
1303 CmpU === _ 316 1292 [[ 1329 ]] !orig=[1103],[502],[350]
1305 CmpU === _ 150 1292 [[ 1341 ]] !orig=[1082],[545],[306]
1311 ConL === 0 [[ 1314 1316 ]] #long:271
1312 CmpU === _ 150 63 [[ 1349 ]] !orig=[545],[306]
1314 CmpUL === _ 337 1311 [[ 1333 ]] !orig=[524],[338]
1316 CmpUL === _ 293 1311 [[ 1345 ]] !orig=[566],[294]
1320 ConI === 0 [[ 468 466 471 ]] #int:1100
1324 CastII === 249 1185 [[ 1326 1328 ]] #int:272..512:www unconditional dependency
1326 AddI === _ 1324 129 [[ 445 586 ]] !orig=[460],[715],[619],[500],[422],[347],[398]
1327 ConI === 0 [[ 1328 ]] #int:527
1328 SubI === _ 1327 1324 [[ 621 599 ]] !orig=[718],[598],[544],[397],[305]
1329 Bool === _ 1303 [[ 1419 ]] [le]
1331 IfFalse === 1419 [[ 1181 ]] #0 !orig=[1106],[505],[354]
1332 IfTrue === 1419 [[ 1110 ]] #1 !orig=[1107],[506],[355]
1333 Bool === _ 1314 [[ 1334 1338 ]] [le] !orig=[1337]
1334 If === 1343 1333 [[ 1335 1336 ]] P=0.000001, C=-1.000000 !orig=[1097],[529],[341]
1335 IfFalse === 1334 [[ 1419 ]] #0 !orig=[1095],[527],[342],[354]
1336 IfTrue === 1334 [[ 1099 ]] #1 !orig=[1096],[528],[343]
1338 If === 1355 1333 [[ 1339 1340 ]] P=0.000001, C=-1.000000 !orig=[529],[341]
1339 IfFalse === 1338 [[ 1417 ]] #0 !orig=[527],[342],[354]
1340 IfTrue === 1338 [[ 531 ]] #1 !orig=[528],[343]
1341 Bool === _ 1305 [[ 1418 ]] [le]
1343 IfFalse === 1418 [[ 1334 ]] #0 !orig=[1085],[548],[310]
1344 IfTrue === 1418 [[ 1089 ]] #1 !orig=[1086],[549],[311]
1345 Bool === _ 1316 [[ 1346 ]] [le]
1346 If === 1351 1345 [[ 1347 1348 ]] P=0.000001, C=-1.000000 !orig=[571],[297]
1347 IfFalse === 1346 [[ 1418 ]] #0 !orig=[569],[298]
1348 IfTrue === 1346 [[ 573 ]] #1 !orig=[570],[299]
1349 Bool === _ 1312 [[ 1417 ]] [le]
1351 IfFalse === 1417 [[ 1346 ]] #0 !orig=[548],[310]
1352 IfTrue === 1417 [[ 552 ]] #1 !orig=[549],[311]
1353 Bool === _ 1300 [[ 1416 ]] [le]
1355 IfFalse === 1416 [[ 1338 ]] #0 !orig=[505],[354]
1356 IfTrue === 1416 [[ 509 ]] #1 !orig=[506],[355]
1357 Region === 1357 1403 1408 [[ 1357 1358 1359 1360 56 ]] !orig=[48] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
1358 Phi === 1357 53 1410 [[ 59 56 ]] #memory Memory: @rawptr:BotPTR, idx=Raw;
1359 Phi === 1357 6 1381 [[ 242 78 ]] #abIO
1360 Phi === 1357 1404 1367 [[ 60 ]] #rawptr:BotPTR !orig=[55] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
1361 ThreadLocal === 0 [[ 1363 1365 ]]
1362 ConI === 0 [[ 1363 ]] #int:216
1363 AddP === _ 1 1361 1362 [[ 1367 1382 ]]
1364 ConI === 0 [[ 1365 ]] #int:224
1365 AddP === _ 1 1361 1364 [[ 1366 ]]
1366 LoadP === 5 7 1365 [[ 1369 ]] @rawptr:BotPTR, idx=Raw; #rawptr:BotPTR (does not depend only on test, raw access)
1367 LoadP === 5 7 1363 [[ 1368 1374 1377 1380 1383 1384 1384 1386 1386 1389 1389 1395 1395 1360 ]] @rawptr:BotPTR, idx=Raw; #rawptr:BotPTR (does not depend only on test, raw access)
1368 AddP === _ 1 1367 37 [[ 1369 1374 1377 1380 1382 ]]
1369 CmpP === _ 1368 1366 [[ 1405 ]]
1374 AddP === _ 1367 1368 1292 [[ 1375 ]]
1375 PrefetchAllocation === 1408 6 1374 [[ 1378 ]]
1376 ConI === 0 [[ 1377 ]] #int:320
1377 AddP === _ 1367 1368 1376 [[ 1378 ]]
1378 PrefetchAllocation === _ 1375 1377 [[ 1381 ]]
1379 ConI === 0 [[ 1380 ]] #int:384
1380 AddP === _ 1367 1368 1379 [[ 1381 ]]
1381 PrefetchAllocation === _ 1378 1380 [[ 1359 ]]
1382 StoreP === 1408 7 1363 1368 [[ 1383 ]] @rawptr:BotPTR, idx=Raw; Memory: @rawptr:BotPTR, idx=Raw;
1383 StoreI === 1408 1382 1367 39 [[ 1385 ]] @NULL Memory: @rawptr:BotPTR, idx=Raw;
1384 AddP === _ 1367 1367 726 [[ 1385 ]]
1385 StoreP === 1408 1383 1384 23 [[ 1387 ]] @NULL Memory: @rawptr:BotPTR, idx=Raw;
1386 AddP === _ 1367 1367 148 [[ 1387 ]]
1387 StoreI === 1408 1385 1386 22 [[ 1390 ]] @NULL Memory: @rawptr:BotPTR, idx=Raw;
1388 ConI === 0 [[ 1389 ]] #int:12
1389 AddP === _ 1367 1367 1388 [[ 1390 ]]
1390 StoreI === 1408 1387 1389 28 [[ 1410 ]] @rawptr:BotPTR, idx=Raw; Memory: @rawptr:BotPTR, idx=Raw;
1395 AddP === _ 1367 1367 129 [[ 1410 ]]
1397 MemBarStoreStore === 1398 1 1399 1 1 [[ 1400 1401 ]]
1398 Proj === 56 [[ 1397 ]] #0
1399 Proj === 56 [[ 1397 ]] #2 Memory: @rawptr:BotPTR, idx=Raw;
1400 Proj === 1397 [[ 60 267 ]] #0 !orig=[57] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
1401 Proj === 1397 [[ 75 75 75 75 465 470 16 16 16 463 ]] #2 Memory: @BotPTR *+bot, idx=Bot; !orig=[58],[116] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
1402 CallStaticJava === 1407 1 7 8 1 (1411 22 10 1 1 ) [[ 1404 54 53 44 ]] # Static _new_array_Java rawptr:NotNull ( java/lang/Object:NotNull *, int ) C=0.000100 LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203) !orig=43 !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
1403 CatchProj === 47 [[ 1357 ]] #0@bci -1 !orig=[48] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
1404 Proj === 1402 [[ 1360 ]] #5 !orig=[55] !jvms: LoopRangeStrideTest::countupLoopWithNegScale @ bci:3 (line 203)
1405 Bool === _ 1369 [[ 1406 ]] [lt]
1406 If === 5 1405 [[ 1407 1408 ]] P=0.999900, C=-1.000000 !orig=[1371]
1407 IfFalse === 1406 [[ 1402 ]] #0 !orig=[1372]
1408 IfTrue === 1406 [[ 1357 1410 1390 1387 1385 1383 1382 1375 ]] #1 !orig=[1373]
1410 ClearArray === 1408 1390 63 1395 [[ 1358 ]] Memory: @rawptr:BotPTR, idx=Raw; !orig=[1396]
1411 ConP === 0 [[ 1402 ]] #precise [int (java/lang/Cloneable,java/io/Serializable): :Constant:exact *
1412 If === 268 368 [[ 371 370 ]] P=0.000001, C=-1.000000
1413 If === 370 379 [[ 382 381 ]] P=0.000001, C=-1.000000
1414 If === 313 425 [[ 428 427 ]] P=0.000001, C=-1.000000
1415 If === 427 416 [[ 419 418 ]] P=0.000001, C=-1.000000
1416 If === 418 1353 [[ 1356 1355 ]] P=0.000001, C=-1.000000
1417 If === 1339 1349 [[ 1352 1351 ]] P=0.000001, C=-1.000000
1418 If === 1347 1341 [[ 1344 1343 ]] P=0.000001, C=-1.000000
1419 If === 1335 1329 [[ 1332 1331 ]] P=0.000001, C=-1.000000
1420 If === 591 600 [[ 603 602 ]] P=0.999999, C=-1.000000
1421 If === 612 622 [[ 625 624 ]] P=0.999999, C=-1.000000

STDERR:

Command Line:
/home/runner/work/jdk/jdk/bundles/jdk/jdk-21/fastdebug/bin/java -DReproduce=true -cp /home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes/compiler/vectorization/runner/LoopRangeStrideTest.d:/home/runner/work/jdk/jdk/test/hotspot/jtreg/compiler/vectorization/runner:/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes/test/lib:/home/runner/work/jdk/jdk/test/lib:/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes:/home/runner/work/jdk/jdk/test/hotspot/jtreg:/home/runner/work/jdk/jdk/jtreg/installed/lib/javatest.jar:/home/runner/work/jdk/jdk/jtreg/installed/lib/jtreg.jar -Djava.library.path=/home/runner/work/jdk/jdk/bundles/tests/hotspot/jtreg/native -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:MaxRAMPercentage=25 -Dtest.boot.jdk=bootjdk/jdk -Djava.io.tmpdir=/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/tmp -XX:-CreateCoredumpOnCrash -Dir.framework.server.port=36331 -XX:-OptimizeFill -XX:+PrintCompilation -XX:+UnlockDiagnosticVMOptions -XX:+LogCompilation -XX:CompilerDirectivesFile=test-vm-compile-commands-pid-58826.log -XX:CompilerDirectivesLimit=91 -XX:-OmitStackTraceInFastThrow -DShouldDoIRVerification=true -XX:-BackgroundCompilation -XX:CompileCommand=quiet compiler.lib.ir_framework.test.TestVM compiler.vectorization.runner.LoopRangeStrideTest

One or more @IR rules failed:

Failed IR Rules (2) of Methods (2)
----------------------------------
1) Method "public int[] compiler.vectorization.runner.LoopRangeStrideTest.countDownLoopWithNegScale()" - [Failed IR rules: 1]:
   * @IR rule 1: "@compiler.lib.ir_framework.IR(phase={DEFAULT}, applyIfCPUFeatureAnd={}, applyIfCPUFeatureOr={"asimd", "true", "sse4.1", "true"}, applyIf={}, applyIfCPUFeature={}, counts={"_#STORE_VECTOR#_", ">0"}, failOn={}, applyIfAnd={}, applyIfOr={}, applyIfNot={})"
     > Phase "PrintIdeal":
       - counts: Graph contains wrong number of nodes:
         * Constraint 1: "(\d+(\s){2}(StoreVector.*)+(\s){2}===.*)"
           - Failed comparison: [found] 0 > 0 [given]
           - No nodes matched!

2) Method "public int[] compiler.vectorization.runner.LoopRangeStrideTest.countupLoopWithNegScale()" - [Failed IR rules: 1]:
   * @IR rule 1: "@compiler.lib.ir_framework.IR(phase={DEFAULT}, applyIfCPUFeatureAnd={}, applyIfCPUFeatureOr={"asimd", "true", "sse4.1", "true"}, applyIf={}, applyIfCPUFeature={}, counts={"_#STORE_VECTOR#_", ">0"}, failOn={}, applyIfAnd={}, applyIfOr={}, applyIfNot={})"
     > Phase "PrintIdeal":
       - counts: Graph contains wrong number of nodes:
         * Constraint 1: "(\d+(\s){2}(StoreVector.*)+(\s){2}===.*)"
           - Failed comparison: [found] 0 > 0 [given]
           - No nodes matched!

>>> Check stdout for compilation output of the failed methods

  #############################################################
   - To only run the failed tests use -DTest, -DExclude,
     and/or -DScenarios.
   - To also get the standard output of the test VM run with
     -DReportStdout=true or for even more fine-grained logging
     use -DVerbose=true.
  #############################################################

compiler.lib.ir_framework.driver.irmatching.IRViolationException: There were one or multiple IR rule failures. Please check stderr for more information.
at compiler.lib.ir_framework.driver.irmatching.IRMatcher.reportFailures(IRMatcher.java:61)
at compiler.lib.ir_framework.driver.irmatching.IRMatcher.match(IRMatcher.java:49)
at compiler.lib.ir_framework.TestFramework.runTestVM(TestFramework.java:754)
at compiler.lib.ir_framework.TestFramework.start(TestFramework.java:719)
at compiler.lib.ir_framework.TestFramework.start(TestFramework.java:339)
at compiler.vectorization.runner.VectorizationTestRunner.run(VectorizationTestRunner.java:85)
at compiler.vectorization.runner.VectorizationTestRunner.main(VectorizationTestRunner.java:211)
at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
at java.base/java.lang.reflect.Method.invoke(Method.java:578)
at com.sun.javatest.regtest.agent.MainWrapper$MainThread.run(MainWrapper.java:125)
at java.base/java.lang.Thread.run(Thread.java:1623)

JavaTest Message: Test threw exception: compiler.lib.ir_framework.driver.irmatching.IRViolationException: There were one or multiple IR rule failures. Please check stderr for more information.
JavaTest Message: shutting down test

STATUS:Failed.`main' threw exception: compiler.lib.ir_framework.driver.irmatching.IRViolationException: There were one or multiple IR rule failures. Please check stderr for more information.
rerun:
cd /home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/scratch && \
HOME=/home/runner \
LANG=C.UTF-8 \
LC_ALL=C \
PATH=/bin:/usr/bin:/usr/sbin \
TEST_IMAGE_DIR=/home/runner/work/jdk/jdk/bundles/tests \
_JVM_DWARF_PATH=/home/runner/work/jdk/jdk/bundles/symbols/jdk-21/fastdebug \
CLASSPATH=/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes/compiler/vectorization/runner/LoopRangeStrideTest.d:/home/runner/work/jdk/jdk/test/hotspot/jtreg/compiler/vectorization/runner:/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes/test/lib:/home/runner/work/jdk/jdk/test/lib:/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes:/home/runner/work/jdk/jdk/test/hotspot/jtreg:/home/runner/work/jdk/jdk/jtreg/installed/lib/javatest.jar:/home/runner/work/jdk/jdk/jtreg/installed/lib/jtreg.jar \
    /home/runner/work/jdk/jdk/bundles/jdk/jdk-21/fastdebug/bin/java \
        -Dtest.vm.opts='-XX:MaxRAMPercentage=25 -Dtest.boot.jdk=bootjdk/jdk -Djava.io.tmpdir=/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/tmp' \
        -Dtest.tool.vm.opts='-J-XX:MaxRAMPercentage=25 -J-Dtest.boot.jdk=bootjdk/jdk -J-Djava.io.tmpdir=/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/tmp' \
        -Dtest.compiler.opts= \
        -Dtest.java.opts=-XX:-CreateCoredumpOnCrash \
        -Dtest.jdk=/home/runner/work/jdk/jdk/bundles/jdk/jdk-21/fastdebug \
        -Dcompile.jdk=/home/runner/work/jdk/jdk/bundles/jdk/jdk-21/fastdebug \
        -Dtest.timeout.factor=4.0 \
        -Dtest.nativepath=/home/runner/work/jdk/jdk/bundles/tests/hotspot/jtreg/native \
        -Dtest.root=/home/runner/work/jdk/jdk/test/hotspot/jtreg \
        -Dtest.name=compiler/vectorization/runner/LoopRangeStrideTest.java \
        -Dtest.file=/home/runner/work/jdk/jdk/test/hotspot/jtreg/compiler/vectorization/runner/LoopRangeStrideTest.java \
        -Dtest.src=/home/runner/work/jdk/jdk/test/hotspot/jtreg/compiler/vectorization/runner \
        -Dtest.src.path=/home/runner/work/jdk/jdk/test/hotspot/jtreg/compiler/vectorization/runner:/home/runner/work/jdk/jdk/test/lib:/home/runner/work/jdk/jdk/test/hotspot/jtreg \
        -Dtest.classes=/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes/compiler/vectorization/runner/LoopRangeStrideTest.d \
        -Dtest.class.path=/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes/compiler/vectorization/runner/LoopRangeStrideTest.d:/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes/test/lib:/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes \
        -Dtest.class.path.prefix=/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes/compiler/vectorization/runner/LoopRangeStrideTest.d:/home/runner/work/jdk/jdk/test/hotspot/jtreg/compiler/vectorization/runner:/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes/test/lib:/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/classes \
        -XX:MaxRAMPercentage=25 \
        -Dtest.boot.jdk=bootjdk/jdk \
        -Djava.io.tmpdir=/home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/tmp \
        -XX:-CreateCoredumpOnCrash \
        -Djava.library.path=/home/runner/work/jdk/jdk/bundles/tests/hotspot/jtreg/native \
        -Xbootclasspath/a:. \
        -XX:+UnlockDiagnosticVMOptions \
        -XX:+WhiteBoxAPI \
        com.sun.javatest.regtest.agent.MainWrapper /home/runner/work/jdk/jdk/build/run-test-prebuilt/test-support/jtreg_test_hotspot_jtreg_tier1_compiler/compiler/vectorization/runner/LoopRangeStrideTest.d/main.0.jta

TEST RESULT: Failed. Execution failed: `main' threw exception: compiler.lib.ir_framework.driver.irmatching.IRViolationException: There were one or multiple IR rule failures. Please check stderr for more information.

Attachments

Issue Links

relates to

JDK-8303885 SLP fails due to different address patters on 32bit JVM

Open

JDK-8302668 [TESTBUG] Tests require feature sse4_1 which does not exist, should be sse4.1

Resolved

links to

Commit openjdk/jdk/713def0b

Review openjdk/jdk/12938

Activity

People

Assignee:: Jatin Bhateja

Reporter:: Tobias Hartmann

Votes:: 0 Vote for this issue

Watchers:: 6 Start watching this issue

Dates

Created:: 2023-02-22 23:04

Updated:: 2023-03-16 00:17

Resolved:: 2023-03-09 04:07