mir_analysis.cc revision b1f1d642093418612c0a27ce4203b421bb6eb767
1/* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "compiler_internals.h" 18#include "dataflow_iterator-inl.h" 19#include "dex/quick/dex_file_method_inliner.h" 20#include "dex/quick/dex_file_to_method_inliner_map.h" 21#include "driver/compiler_options.h" 22 23namespace art { 24 25 // Instruction characteristics used to statically identify computation-intensive methods. 26const uint32_t MIRGraph::analysis_attributes_[kMirOpLast] = { 27 // 00 NOP 28 AN_NONE, 29 30 // 01 MOVE vA, vB 31 AN_MOVE, 32 33 // 02 MOVE_FROM16 vAA, vBBBB 34 AN_MOVE, 35 36 // 03 MOVE_16 vAAAA, vBBBB 37 AN_MOVE, 38 39 // 04 MOVE_WIDE vA, vB 40 AN_MOVE, 41 42 // 05 MOVE_WIDE_FROM16 vAA, vBBBB 43 AN_MOVE, 44 45 // 06 MOVE_WIDE_16 vAAAA, vBBBB 46 AN_MOVE, 47 48 // 07 MOVE_OBJECT vA, vB 49 AN_MOVE, 50 51 // 08 MOVE_OBJECT_FROM16 vAA, vBBBB 52 AN_MOVE, 53 54 // 09 MOVE_OBJECT_16 vAAAA, vBBBB 55 AN_MOVE, 56 57 // 0A MOVE_RESULT vAA 58 AN_MOVE, 59 60 // 0B MOVE_RESULT_WIDE vAA 61 AN_MOVE, 62 63 // 0C MOVE_RESULT_OBJECT vAA 64 AN_MOVE, 65 66 // 0D MOVE_EXCEPTION vAA 67 AN_MOVE, 68 69 // 0E RETURN_VOID 70 AN_BRANCH, 71 72 // 0F RETURN vAA 73 AN_BRANCH, 74 75 // 10 RETURN_WIDE vAA 76 AN_BRANCH, 77 78 // 11 RETURN_OBJECT vAA 79 AN_BRANCH, 80 81 // 12 CONST_4 vA, #+B 82 AN_SIMPLECONST, 83 84 // 13 CONST_16 vAA, #+BBBB 85 AN_SIMPLECONST, 86 87 // 14 CONST vAA, #+BBBBBBBB 88 AN_SIMPLECONST, 89 90 // 15 CONST_HIGH16 VAA, #+BBBB0000 91 AN_SIMPLECONST, 92 93 // 16 CONST_WIDE_16 vAA, #+BBBB 94 AN_SIMPLECONST, 95 96 // 17 CONST_WIDE_32 vAA, #+BBBBBBBB 97 AN_SIMPLECONST, 98 99 // 18 CONST_WIDE vAA, #+BBBBBBBBBBBBBBBB 100 AN_SIMPLECONST, 101 102 // 19 CONST_WIDE_HIGH16 vAA, #+BBBB000000000000 103 AN_SIMPLECONST, 104 105 // 1A CONST_STRING vAA, string@BBBB 106 AN_NONE, 107 108 // 1B CONST_STRING_JUMBO vAA, string@BBBBBBBB 109 AN_NONE, 110 111 // 1C CONST_CLASS vAA, type@BBBB 112 AN_NONE, 113 114 // 1D MONITOR_ENTER vAA 115 AN_NONE, 116 117 // 1E MONITOR_EXIT vAA 118 AN_NONE, 119 120 // 1F CHK_CAST vAA, type@BBBB 121 AN_NONE, 122 123 // 20 INSTANCE_OF vA, vB, type@CCCC 124 AN_NONE, 125 126 // 21 ARRAY_LENGTH vA, vB 127 AN_ARRAYOP, 128 129 // 22 NEW_INSTANCE vAA, type@BBBB 130 AN_HEAVYWEIGHT, 131 132 // 23 NEW_ARRAY vA, vB, type@CCCC 133 AN_HEAVYWEIGHT, 134 135 // 24 FILLED_NEW_ARRAY {vD, vE, vF, vG, vA} 136 AN_HEAVYWEIGHT, 137 138 // 25 FILLED_NEW_ARRAY_RANGE {vCCCC .. vNNNN}, type@BBBB 139 AN_HEAVYWEIGHT, 140 141 // 26 FILL_ARRAY_DATA vAA, +BBBBBBBB 142 AN_NONE, 143 144 // 27 THROW vAA 145 AN_HEAVYWEIGHT | AN_BRANCH, 146 147 // 28 GOTO 148 AN_BRANCH, 149 150 // 29 GOTO_16 151 AN_BRANCH, 152 153 // 2A GOTO_32 154 AN_BRANCH, 155 156 // 2B PACKED_SWITCH vAA, +BBBBBBBB 157 AN_SWITCH, 158 159 // 2C SPARSE_SWITCH vAA, +BBBBBBBB 160 AN_SWITCH, 161 162 // 2D CMPL_FLOAT vAA, vBB, vCC 163 AN_MATH | AN_FP | AN_SINGLE, 164 165 // 2E CMPG_FLOAT vAA, vBB, vCC 166 AN_MATH | AN_FP | AN_SINGLE, 167 168 // 2F CMPL_DOUBLE vAA, vBB, vCC 169 AN_MATH | AN_FP | AN_DOUBLE, 170 171 // 30 CMPG_DOUBLE vAA, vBB, vCC 172 AN_MATH | AN_FP | AN_DOUBLE, 173 174 // 31 CMP_LONG vAA, vBB, vCC 175 AN_MATH | AN_LONG, 176 177 // 32 IF_EQ vA, vB, +CCCC 178 AN_MATH | AN_BRANCH | AN_INT, 179 180 // 33 IF_NE vA, vB, +CCCC 181 AN_MATH | AN_BRANCH | AN_INT, 182 183 // 34 IF_LT vA, vB, +CCCC 184 AN_MATH | AN_BRANCH | AN_INT, 185 186 // 35 IF_GE vA, vB, +CCCC 187 AN_MATH | AN_BRANCH | AN_INT, 188 189 // 36 IF_GT vA, vB, +CCCC 190 AN_MATH | AN_BRANCH | AN_INT, 191 192 // 37 IF_LE vA, vB, +CCCC 193 AN_MATH | AN_BRANCH | AN_INT, 194 195 // 38 IF_EQZ vAA, +BBBB 196 AN_MATH | AN_BRANCH | AN_INT, 197 198 // 39 IF_NEZ vAA, +BBBB 199 AN_MATH | AN_BRANCH | AN_INT, 200 201 // 3A IF_LTZ vAA, +BBBB 202 AN_MATH | AN_BRANCH | AN_INT, 203 204 // 3B IF_GEZ vAA, +BBBB 205 AN_MATH | AN_BRANCH | AN_INT, 206 207 // 3C IF_GTZ vAA, +BBBB 208 AN_MATH | AN_BRANCH | AN_INT, 209 210 // 3D IF_LEZ vAA, +BBBB 211 AN_MATH | AN_BRANCH | AN_INT, 212 213 // 3E UNUSED_3E 214 AN_NONE, 215 216 // 3F UNUSED_3F 217 AN_NONE, 218 219 // 40 UNUSED_40 220 AN_NONE, 221 222 // 41 UNUSED_41 223 AN_NONE, 224 225 // 42 UNUSED_42 226 AN_NONE, 227 228 // 43 UNUSED_43 229 AN_NONE, 230 231 // 44 AGET vAA, vBB, vCC 232 AN_ARRAYOP, 233 234 // 45 AGET_WIDE vAA, vBB, vCC 235 AN_ARRAYOP, 236 237 // 46 AGET_OBJECT vAA, vBB, vCC 238 AN_ARRAYOP, 239 240 // 47 AGET_BOOLEAN vAA, vBB, vCC 241 AN_ARRAYOP, 242 243 // 48 AGET_BYTE vAA, vBB, vCC 244 AN_ARRAYOP, 245 246 // 49 AGET_CHAR vAA, vBB, vCC 247 AN_ARRAYOP, 248 249 // 4A AGET_SHORT vAA, vBB, vCC 250 AN_ARRAYOP, 251 252 // 4B APUT vAA, vBB, vCC 253 AN_ARRAYOP, 254 255 // 4C APUT_WIDE vAA, vBB, vCC 256 AN_ARRAYOP, 257 258 // 4D APUT_OBJECT vAA, vBB, vCC 259 AN_ARRAYOP, 260 261 // 4E APUT_BOOLEAN vAA, vBB, vCC 262 AN_ARRAYOP, 263 264 // 4F APUT_BYTE vAA, vBB, vCC 265 AN_ARRAYOP, 266 267 // 50 APUT_CHAR vAA, vBB, vCC 268 AN_ARRAYOP, 269 270 // 51 APUT_SHORT vAA, vBB, vCC 271 AN_ARRAYOP, 272 273 // 52 IGET vA, vB, field@CCCC 274 AN_NONE, 275 276 // 53 IGET_WIDE vA, vB, field@CCCC 277 AN_NONE, 278 279 // 54 IGET_OBJECT vA, vB, field@CCCC 280 AN_NONE, 281 282 // 55 IGET_BOOLEAN vA, vB, field@CCCC 283 AN_NONE, 284 285 // 56 IGET_BYTE vA, vB, field@CCCC 286 AN_NONE, 287 288 // 57 IGET_CHAR vA, vB, field@CCCC 289 AN_NONE, 290 291 // 58 IGET_SHORT vA, vB, field@CCCC 292 AN_NONE, 293 294 // 59 IPUT vA, vB, field@CCCC 295 AN_NONE, 296 297 // 5A IPUT_WIDE vA, vB, field@CCCC 298 AN_NONE, 299 300 // 5B IPUT_OBJECT vA, vB, field@CCCC 301 AN_NONE, 302 303 // 5C IPUT_BOOLEAN vA, vB, field@CCCC 304 AN_NONE, 305 306 // 5D IPUT_BYTE vA, vB, field@CCCC 307 AN_NONE, 308 309 // 5E IPUT_CHAR vA, vB, field@CCCC 310 AN_NONE, 311 312 // 5F IPUT_SHORT vA, vB, field@CCCC 313 AN_NONE, 314 315 // 60 SGET vAA, field@BBBB 316 AN_NONE, 317 318 // 61 SGET_WIDE vAA, field@BBBB 319 AN_NONE, 320 321 // 62 SGET_OBJECT vAA, field@BBBB 322 AN_NONE, 323 324 // 63 SGET_BOOLEAN vAA, field@BBBB 325 AN_NONE, 326 327 // 64 SGET_BYTE vAA, field@BBBB 328 AN_NONE, 329 330 // 65 SGET_CHAR vAA, field@BBBB 331 AN_NONE, 332 333 // 66 SGET_SHORT vAA, field@BBBB 334 AN_NONE, 335 336 // 67 SPUT vAA, field@BBBB 337 AN_NONE, 338 339 // 68 SPUT_WIDE vAA, field@BBBB 340 AN_NONE, 341 342 // 69 SPUT_OBJECT vAA, field@BBBB 343 AN_NONE, 344 345 // 6A SPUT_BOOLEAN vAA, field@BBBB 346 AN_NONE, 347 348 // 6B SPUT_BYTE vAA, field@BBBB 349 AN_NONE, 350 351 // 6C SPUT_CHAR vAA, field@BBBB 352 AN_NONE, 353 354 // 6D SPUT_SHORT vAA, field@BBBB 355 AN_NONE, 356 357 // 6E INVOKE_VIRTUAL {vD, vE, vF, vG, vA} 358 AN_INVOKE | AN_HEAVYWEIGHT, 359 360 // 6F INVOKE_SUPER {vD, vE, vF, vG, vA} 361 AN_INVOKE | AN_HEAVYWEIGHT, 362 363 // 70 INVOKE_DIRECT {vD, vE, vF, vG, vA} 364 AN_INVOKE | AN_HEAVYWEIGHT, 365 366 // 71 INVOKE_STATIC {vD, vE, vF, vG, vA} 367 AN_INVOKE | AN_HEAVYWEIGHT, 368 369 // 72 INVOKE_INTERFACE {vD, vE, vF, vG, vA} 370 AN_INVOKE | AN_HEAVYWEIGHT, 371 372 // 73 UNUSED_73 373 AN_NONE, 374 375 // 74 INVOKE_VIRTUAL_RANGE {vCCCC .. vNNNN} 376 AN_INVOKE | AN_HEAVYWEIGHT, 377 378 // 75 INVOKE_SUPER_RANGE {vCCCC .. vNNNN} 379 AN_INVOKE | AN_HEAVYWEIGHT, 380 381 // 76 INVOKE_DIRECT_RANGE {vCCCC .. vNNNN} 382 AN_INVOKE | AN_HEAVYWEIGHT, 383 384 // 77 INVOKE_STATIC_RANGE {vCCCC .. vNNNN} 385 AN_INVOKE | AN_HEAVYWEIGHT, 386 387 // 78 INVOKE_INTERFACE_RANGE {vCCCC .. vNNNN} 388 AN_INVOKE | AN_HEAVYWEIGHT, 389 390 // 79 UNUSED_79 391 AN_NONE, 392 393 // 7A UNUSED_7A 394 AN_NONE, 395 396 // 7B NEG_INT vA, vB 397 AN_MATH | AN_INT, 398 399 // 7C NOT_INT vA, vB 400 AN_MATH | AN_INT, 401 402 // 7D NEG_LONG vA, vB 403 AN_MATH | AN_LONG, 404 405 // 7E NOT_LONG vA, vB 406 AN_MATH | AN_LONG, 407 408 // 7F NEG_FLOAT vA, vB 409 AN_MATH | AN_FP | AN_SINGLE, 410 411 // 80 NEG_DOUBLE vA, vB 412 AN_MATH | AN_FP | AN_DOUBLE, 413 414 // 81 INT_TO_LONG vA, vB 415 AN_MATH | AN_INT | AN_LONG, 416 417 // 82 INT_TO_FLOAT vA, vB 418 AN_MATH | AN_FP | AN_INT | AN_SINGLE, 419 420 // 83 INT_TO_DOUBLE vA, vB 421 AN_MATH | AN_FP | AN_INT | AN_DOUBLE, 422 423 // 84 LONG_TO_INT vA, vB 424 AN_MATH | AN_INT | AN_LONG, 425 426 // 85 LONG_TO_FLOAT vA, vB 427 AN_MATH | AN_FP | AN_LONG | AN_SINGLE, 428 429 // 86 LONG_TO_DOUBLE vA, vB 430 AN_MATH | AN_FP | AN_LONG | AN_DOUBLE, 431 432 // 87 FLOAT_TO_INT vA, vB 433 AN_MATH | AN_FP | AN_INT | AN_SINGLE, 434 435 // 88 FLOAT_TO_LONG vA, vB 436 AN_MATH | AN_FP | AN_LONG | AN_SINGLE, 437 438 // 89 FLOAT_TO_DOUBLE vA, vB 439 AN_MATH | AN_FP | AN_SINGLE | AN_DOUBLE, 440 441 // 8A DOUBLE_TO_INT vA, vB 442 AN_MATH | AN_FP | AN_INT | AN_DOUBLE, 443 444 // 8B DOUBLE_TO_LONG vA, vB 445 AN_MATH | AN_FP | AN_LONG | AN_DOUBLE, 446 447 // 8C DOUBLE_TO_FLOAT vA, vB 448 AN_MATH | AN_FP | AN_SINGLE | AN_DOUBLE, 449 450 // 8D INT_TO_BYTE vA, vB 451 AN_MATH | AN_INT, 452 453 // 8E INT_TO_CHAR vA, vB 454 AN_MATH | AN_INT, 455 456 // 8F INT_TO_SHORT vA, vB 457 AN_MATH | AN_INT, 458 459 // 90 ADD_INT vAA, vBB, vCC 460 AN_MATH | AN_INT, 461 462 // 91 SUB_INT vAA, vBB, vCC 463 AN_MATH | AN_INT, 464 465 // 92 MUL_INT vAA, vBB, vCC 466 AN_MATH | AN_INT, 467 468 // 93 DIV_INT vAA, vBB, vCC 469 AN_MATH | AN_INT, 470 471 // 94 REM_INT vAA, vBB, vCC 472 AN_MATH | AN_INT, 473 474 // 95 AND_INT vAA, vBB, vCC 475 AN_MATH | AN_INT, 476 477 // 96 OR_INT vAA, vBB, vCC 478 AN_MATH | AN_INT, 479 480 // 97 XOR_INT vAA, vBB, vCC 481 AN_MATH | AN_INT, 482 483 // 98 SHL_INT vAA, vBB, vCC 484 AN_MATH | AN_INT, 485 486 // 99 SHR_INT vAA, vBB, vCC 487 AN_MATH | AN_INT, 488 489 // 9A USHR_INT vAA, vBB, vCC 490 AN_MATH | AN_INT, 491 492 // 9B ADD_LONG vAA, vBB, vCC 493 AN_MATH | AN_LONG, 494 495 // 9C SUB_LONG vAA, vBB, vCC 496 AN_MATH | AN_LONG, 497 498 // 9D MUL_LONG vAA, vBB, vCC 499 AN_MATH | AN_LONG, 500 501 // 9E DIV_LONG vAA, vBB, vCC 502 AN_MATH | AN_LONG, 503 504 // 9F REM_LONG vAA, vBB, vCC 505 AN_MATH | AN_LONG, 506 507 // A0 AND_LONG vAA, vBB, vCC 508 AN_MATH | AN_LONG, 509 510 // A1 OR_LONG vAA, vBB, vCC 511 AN_MATH | AN_LONG, 512 513 // A2 XOR_LONG vAA, vBB, vCC 514 AN_MATH | AN_LONG, 515 516 // A3 SHL_LONG vAA, vBB, vCC 517 AN_MATH | AN_LONG, 518 519 // A4 SHR_LONG vAA, vBB, vCC 520 AN_MATH | AN_LONG, 521 522 // A5 USHR_LONG vAA, vBB, vCC 523 AN_MATH | AN_LONG, 524 525 // A6 ADD_FLOAT vAA, vBB, vCC 526 AN_MATH | AN_FP | AN_SINGLE, 527 528 // A7 SUB_FLOAT vAA, vBB, vCC 529 AN_MATH | AN_FP | AN_SINGLE, 530 531 // A8 MUL_FLOAT vAA, vBB, vCC 532 AN_MATH | AN_FP | AN_SINGLE, 533 534 // A9 DIV_FLOAT vAA, vBB, vCC 535 AN_MATH | AN_FP | AN_SINGLE, 536 537 // AA REM_FLOAT vAA, vBB, vCC 538 AN_MATH | AN_FP | AN_SINGLE, 539 540 // AB ADD_DOUBLE vAA, vBB, vCC 541 AN_MATH | AN_FP | AN_DOUBLE, 542 543 // AC SUB_DOUBLE vAA, vBB, vCC 544 AN_MATH | AN_FP | AN_DOUBLE, 545 546 // AD MUL_DOUBLE vAA, vBB, vCC 547 AN_MATH | AN_FP | AN_DOUBLE, 548 549 // AE DIV_DOUBLE vAA, vBB, vCC 550 AN_MATH | AN_FP | AN_DOUBLE, 551 552 // AF REM_DOUBLE vAA, vBB, vCC 553 AN_MATH | AN_FP | AN_DOUBLE, 554 555 // B0 ADD_INT_2ADDR vA, vB 556 AN_MATH | AN_INT, 557 558 // B1 SUB_INT_2ADDR vA, vB 559 AN_MATH | AN_INT, 560 561 // B2 MUL_INT_2ADDR vA, vB 562 AN_MATH | AN_INT, 563 564 // B3 DIV_INT_2ADDR vA, vB 565 AN_MATH | AN_INT, 566 567 // B4 REM_INT_2ADDR vA, vB 568 AN_MATH | AN_INT, 569 570 // B5 AND_INT_2ADDR vA, vB 571 AN_MATH | AN_INT, 572 573 // B6 OR_INT_2ADDR vA, vB 574 AN_MATH | AN_INT, 575 576 // B7 XOR_INT_2ADDR vA, vB 577 AN_MATH | AN_INT, 578 579 // B8 SHL_INT_2ADDR vA, vB 580 AN_MATH | AN_INT, 581 582 // B9 SHR_INT_2ADDR vA, vB 583 AN_MATH | AN_INT, 584 585 // BA USHR_INT_2ADDR vA, vB 586 AN_MATH | AN_INT, 587 588 // BB ADD_LONG_2ADDR vA, vB 589 AN_MATH | AN_LONG, 590 591 // BC SUB_LONG_2ADDR vA, vB 592 AN_MATH | AN_LONG, 593 594 // BD MUL_LONG_2ADDR vA, vB 595 AN_MATH | AN_LONG, 596 597 // BE DIV_LONG_2ADDR vA, vB 598 AN_MATH | AN_LONG, 599 600 // BF REM_LONG_2ADDR vA, vB 601 AN_MATH | AN_LONG, 602 603 // C0 AND_LONG_2ADDR vA, vB 604 AN_MATH | AN_LONG, 605 606 // C1 OR_LONG_2ADDR vA, vB 607 AN_MATH | AN_LONG, 608 609 // C2 XOR_LONG_2ADDR vA, vB 610 AN_MATH | AN_LONG, 611 612 // C3 SHL_LONG_2ADDR vA, vB 613 AN_MATH | AN_LONG, 614 615 // C4 SHR_LONG_2ADDR vA, vB 616 AN_MATH | AN_LONG, 617 618 // C5 USHR_LONG_2ADDR vA, vB 619 AN_MATH | AN_LONG, 620 621 // C6 ADD_FLOAT_2ADDR vA, vB 622 AN_MATH | AN_FP | AN_SINGLE, 623 624 // C7 SUB_FLOAT_2ADDR vA, vB 625 AN_MATH | AN_FP | AN_SINGLE, 626 627 // C8 MUL_FLOAT_2ADDR vA, vB 628 AN_MATH | AN_FP | AN_SINGLE, 629 630 // C9 DIV_FLOAT_2ADDR vA, vB 631 AN_MATH | AN_FP | AN_SINGLE, 632 633 // CA REM_FLOAT_2ADDR vA, vB 634 AN_MATH | AN_FP | AN_SINGLE, 635 636 // CB ADD_DOUBLE_2ADDR vA, vB 637 AN_MATH | AN_FP | AN_DOUBLE, 638 639 // CC SUB_DOUBLE_2ADDR vA, vB 640 AN_MATH | AN_FP | AN_DOUBLE, 641 642 // CD MUL_DOUBLE_2ADDR vA, vB 643 AN_MATH | AN_FP | AN_DOUBLE, 644 645 // CE DIV_DOUBLE_2ADDR vA, vB 646 AN_MATH | AN_FP | AN_DOUBLE, 647 648 // CF REM_DOUBLE_2ADDR vA, vB 649 AN_MATH | AN_FP | AN_DOUBLE, 650 651 // D0 ADD_INT_LIT16 vA, vB, #+CCCC 652 AN_MATH | AN_INT, 653 654 // D1 RSUB_INT vA, vB, #+CCCC 655 AN_MATH | AN_INT, 656 657 // D2 MUL_INT_LIT16 vA, vB, #+CCCC 658 AN_MATH | AN_INT, 659 660 // D3 DIV_INT_LIT16 vA, vB, #+CCCC 661 AN_MATH | AN_INT, 662 663 // D4 REM_INT_LIT16 vA, vB, #+CCCC 664 AN_MATH | AN_INT, 665 666 // D5 AND_INT_LIT16 vA, vB, #+CCCC 667 AN_MATH | AN_INT, 668 669 // D6 OR_INT_LIT16 vA, vB, #+CCCC 670 AN_MATH | AN_INT, 671 672 // D7 XOR_INT_LIT16 vA, vB, #+CCCC 673 AN_MATH | AN_INT, 674 675 // D8 ADD_INT_LIT8 vAA, vBB, #+CC 676 AN_MATH | AN_INT, 677 678 // D9 RSUB_INT_LIT8 vAA, vBB, #+CC 679 AN_MATH | AN_INT, 680 681 // DA MUL_INT_LIT8 vAA, vBB, #+CC 682 AN_MATH | AN_INT, 683 684 // DB DIV_INT_LIT8 vAA, vBB, #+CC 685 AN_MATH | AN_INT, 686 687 // DC REM_INT_LIT8 vAA, vBB, #+CC 688 AN_MATH | AN_INT, 689 690 // DD AND_INT_LIT8 vAA, vBB, #+CC 691 AN_MATH | AN_INT, 692 693 // DE OR_INT_LIT8 vAA, vBB, #+CC 694 AN_MATH | AN_INT, 695 696 // DF XOR_INT_LIT8 vAA, vBB, #+CC 697 AN_MATH | AN_INT, 698 699 // E0 SHL_INT_LIT8 vAA, vBB, #+CC 700 AN_MATH | AN_INT, 701 702 // E1 SHR_INT_LIT8 vAA, vBB, #+CC 703 AN_MATH | AN_INT, 704 705 // E2 USHR_INT_LIT8 vAA, vBB, #+CC 706 AN_MATH | AN_INT, 707 708 // E3 IGET_VOLATILE 709 AN_NONE, 710 711 // E4 IPUT_VOLATILE 712 AN_NONE, 713 714 // E5 SGET_VOLATILE 715 AN_NONE, 716 717 // E6 SPUT_VOLATILE 718 AN_NONE, 719 720 // E7 IGET_OBJECT_VOLATILE 721 AN_NONE, 722 723 // E8 IGET_WIDE_VOLATILE 724 AN_NONE, 725 726 // E9 IPUT_WIDE_VOLATILE 727 AN_NONE, 728 729 // EA SGET_WIDE_VOLATILE 730 AN_NONE, 731 732 // EB SPUT_WIDE_VOLATILE 733 AN_NONE, 734 735 // EC BREAKPOINT 736 AN_NONE, 737 738 // ED THROW_VERIFICATION_ERROR 739 AN_HEAVYWEIGHT | AN_BRANCH, 740 741 // EE EXECUTE_INLINE 742 AN_NONE, 743 744 // EF EXECUTE_INLINE_RANGE 745 AN_NONE, 746 747 // F0 INVOKE_OBJECT_INIT_RANGE 748 AN_INVOKE | AN_HEAVYWEIGHT, 749 750 // F1 RETURN_VOID_BARRIER 751 AN_BRANCH, 752 753 // F2 IGET_QUICK 754 AN_NONE, 755 756 // F3 IGET_WIDE_QUICK 757 AN_NONE, 758 759 // F4 IGET_OBJECT_QUICK 760 AN_NONE, 761 762 // F5 IPUT_QUICK 763 AN_NONE, 764 765 // F6 IPUT_WIDE_QUICK 766 AN_NONE, 767 768 // F7 IPUT_OBJECT_QUICK 769 AN_NONE, 770 771 // F8 INVOKE_VIRTUAL_QUICK 772 AN_INVOKE | AN_HEAVYWEIGHT, 773 774 // F9 INVOKE_VIRTUAL_QUICK_RANGE 775 AN_INVOKE | AN_HEAVYWEIGHT, 776 777 // FA INVOKE_SUPER_QUICK 778 AN_INVOKE | AN_HEAVYWEIGHT, 779 780 // FB INVOKE_SUPER_QUICK_RANGE 781 AN_INVOKE | AN_HEAVYWEIGHT, 782 783 // FC IPUT_OBJECT_VOLATILE 784 AN_NONE, 785 786 // FD SGET_OBJECT_VOLATILE 787 AN_NONE, 788 789 // FE SPUT_OBJECT_VOLATILE 790 AN_NONE, 791 792 // FF UNUSED_FF 793 AN_NONE, 794 795 // Beginning of extended MIR opcodes 796 // 100 MIR_PHI 797 AN_NONE, 798 799 // 101 MIR_COPY 800 AN_NONE, 801 802 // 102 MIR_FUSED_CMPL_FLOAT 803 AN_NONE, 804 805 // 103 MIR_FUSED_CMPG_FLOAT 806 AN_NONE, 807 808 // 104 MIR_FUSED_CMPL_DOUBLE 809 AN_NONE, 810 811 // 105 MIR_FUSED_CMPG_DOUBLE 812 AN_NONE, 813 814 // 106 MIR_FUSED_CMP_LONG 815 AN_NONE, 816 817 // 107 MIR_NOP 818 AN_NONE, 819 820 // 108 MIR_NULL_CHECK 821 AN_NONE, 822 823 // 109 MIR_RANGE_CHECK 824 AN_NONE, 825 826 // 110 MIR_DIV_ZERO_CHECK 827 AN_NONE, 828 829 // 111 MIR_CHECK 830 AN_NONE, 831 832 // 112 MIR_CHECKPART2 833 AN_NONE, 834 835 // 113 MIR_SELECT 836 AN_NONE, 837}; 838 839struct MethodStats { 840 int dex_instructions; 841 int math_ops; 842 int fp_ops; 843 int array_ops; 844 int branch_ops; 845 int heavyweight_ops; 846 bool has_computational_loop; 847 bool has_switch; 848 float math_ratio; 849 float fp_ratio; 850 float array_ratio; 851 float branch_ratio; 852 float heavyweight_ratio; 853}; 854 855void MIRGraph::AnalyzeBlock(BasicBlock* bb, MethodStats* stats) { 856 if (bb->visited || (bb->block_type != kDalvikByteCode)) { 857 return; 858 } 859 bool computational_block = true; 860 bool has_math = false; 861 /* 862 * For the purposes of this scan, we want to treat the set of basic blocks broken 863 * by an exception edge as a single basic block. We'll scan forward along the fallthrough 864 * edges until we reach an explicit branch or return. 865 */ 866 BasicBlock* ending_bb = bb; 867 if (ending_bb->last_mir_insn != NULL) { 868 uint32_t ending_flags = analysis_attributes_[ending_bb->last_mir_insn->dalvikInsn.opcode]; 869 while ((ending_flags & AN_BRANCH) == 0) { 870 ending_bb = GetBasicBlock(ending_bb->fall_through); 871 ending_flags = analysis_attributes_[ending_bb->last_mir_insn->dalvikInsn.opcode]; 872 } 873 } 874 /* 875 * Ideally, we'd weight the operations by loop nesting level, but to do so we'd 876 * first need to do some expensive loop detection - and the point of this is to make 877 * an informed guess before investing in computation. However, we can cheaply detect 878 * many simple loop forms without having to do full dataflow analysis. 879 */ 880 int loop_scale_factor = 1; 881 // Simple for and while loops 882 if ((ending_bb->taken != NullBasicBlockId) && (ending_bb->fall_through == NullBasicBlockId)) { 883 if ((GetBasicBlock(ending_bb->taken)->taken == bb->id) || 884 (GetBasicBlock(ending_bb->taken)->fall_through == bb->id)) { 885 loop_scale_factor = 25; 886 } 887 } 888 // Simple do-while loop 889 if ((ending_bb->taken != NullBasicBlockId) && (ending_bb->taken == bb->id)) { 890 loop_scale_factor = 25; 891 } 892 893 BasicBlock* tbb = bb; 894 bool done = false; 895 while (!done) { 896 tbb->visited = true; 897 for (MIR* mir = tbb->first_mir_insn; mir != NULL; mir = mir->next) { 898 if (static_cast<uint32_t>(mir->dalvikInsn.opcode) >= kMirOpFirst) { 899 // Skip any MIR pseudo-op. 900 continue; 901 } 902 uint32_t flags = analysis_attributes_[mir->dalvikInsn.opcode]; 903 stats->dex_instructions += loop_scale_factor; 904 if ((flags & AN_BRANCH) == 0) { 905 computational_block &= ((flags & AN_COMPUTATIONAL) != 0); 906 } else { 907 stats->branch_ops += loop_scale_factor; 908 } 909 if ((flags & AN_MATH) != 0) { 910 stats->math_ops += loop_scale_factor; 911 has_math = true; 912 } 913 if ((flags & AN_FP) != 0) { 914 stats->fp_ops += loop_scale_factor; 915 } 916 if ((flags & AN_ARRAYOP) != 0) { 917 stats->array_ops += loop_scale_factor; 918 } 919 if ((flags & AN_HEAVYWEIGHT) != 0) { 920 stats->heavyweight_ops += loop_scale_factor; 921 } 922 if ((flags & AN_SWITCH) != 0) { 923 stats->has_switch = true; 924 } 925 } 926 if (tbb == ending_bb) { 927 done = true; 928 } else { 929 tbb = GetBasicBlock(tbb->fall_through); 930 } 931 } 932 if (has_math && computational_block && (loop_scale_factor > 1)) { 933 stats->has_computational_loop = true; 934 } 935} 936 937bool MIRGraph::ComputeSkipCompilation(MethodStats* stats, bool skip_default) { 938 float count = stats->dex_instructions; 939 stats->math_ratio = stats->math_ops / count; 940 stats->fp_ratio = stats->fp_ops / count; 941 stats->branch_ratio = stats->branch_ops / count; 942 stats->array_ratio = stats->array_ops / count; 943 stats->heavyweight_ratio = stats->heavyweight_ops / count; 944 945 if (cu_->enable_debug & (1 << kDebugShowFilterStats)) { 946 LOG(INFO) << "STATS " << stats->dex_instructions << ", math:" 947 << stats->math_ratio << ", fp:" 948 << stats->fp_ratio << ", br:" 949 << stats->branch_ratio << ", hw:" 950 << stats->heavyweight_ratio << ", arr:" 951 << stats->array_ratio << ", hot:" 952 << stats->has_computational_loop << ", " 953 << PrettyMethod(cu_->method_idx, *cu_->dex_file); 954 } 955 956 // Computation intensive? 957 if (stats->has_computational_loop && (stats->heavyweight_ratio < 0.04)) { 958 return false; 959 } 960 961 // Complex, logic-intensive? 962 if (cu_->compiler_driver->GetCompilerOptions().IsSmallMethod(GetNumDalvikInsns()) && 963 stats->branch_ratio > 0.3) { 964 return false; 965 } 966 967 // Significant floating point? 968 if (stats->fp_ratio > 0.05) { 969 return false; 970 } 971 972 // Significant generic math? 973 if (stats->math_ratio > 0.3) { 974 return false; 975 } 976 977 // If array-intensive, compiling is probably worthwhile. 978 if (stats->array_ratio > 0.1) { 979 return false; 980 } 981 982 // Switch operations benefit greatly from compilation, so go ahead and spend the cycles. 983 if (stats->has_switch) { 984 return false; 985 } 986 987 // If significant in size and high proportion of expensive operations, skip. 988 if (cu_->compiler_driver->GetCompilerOptions().IsSmallMethod(GetNumDalvikInsns()) && 989 (stats->heavyweight_ratio > 0.3)) { 990 return true; 991 } 992 993 return skip_default; 994} 995 996 /* 997 * Will eventually want this to be a bit more sophisticated and happen at verification time. 998 * Ultimate goal is to drive with profile data. 999 */ 1000bool MIRGraph::SkipCompilation() { 1001 const CompilerOptions& compiler_options = cu_->compiler_driver->GetCompilerOptions(); 1002 CompilerOptions::CompilerFilter compiler_filter = compiler_options.GetCompilerFilter(); 1003 if (compiler_filter == CompilerOptions::kEverything) { 1004 return false; 1005 } 1006 1007 // Contains a pattern we don't want to compile? 1008 if (punt_to_interpreter_) { 1009 return true; 1010 } 1011 1012 if (compiler_filter == CompilerOptions::kInterpretOnly) { 1013 LOG(WARNING) << "InterpretOnly should ideally be filtered out prior to parsing."; 1014 return true; 1015 } 1016 1017 // Set up compilation cutoffs based on current filter mode. 1018 size_t small_cutoff = 0; 1019 size_t default_cutoff = 0; 1020 switch (compiler_filter) { 1021 case CompilerOptions::kBalanced: 1022 small_cutoff = compiler_options.GetSmallMethodThreshold(); 1023 default_cutoff = compiler_options.GetLargeMethodThreshold(); 1024 break; 1025 case CompilerOptions::kSpace: 1026 small_cutoff = compiler_options.GetTinyMethodThreshold(); 1027 default_cutoff = compiler_options.GetSmallMethodThreshold(); 1028 break; 1029 case CompilerOptions::kSpeed: 1030 small_cutoff = compiler_options.GetHugeMethodThreshold(); 1031 default_cutoff = compiler_options.GetHugeMethodThreshold(); 1032 break; 1033 default: 1034 LOG(FATAL) << "Unexpected compiler_filter_: " << compiler_filter; 1035 } 1036 1037 // If size < cutoff, assume we'll compile - but allow removal. 1038 bool skip_compilation = (GetNumDalvikInsns() >= default_cutoff); 1039 1040 /* 1041 * Filter 1: Huge methods are likely to be machine generated, but some aren't. 1042 * If huge, assume we won't compile, but allow futher analysis to turn it back on. 1043 */ 1044 if (compiler_options.IsHugeMethod(GetNumDalvikInsns())) { 1045 skip_compilation = true; 1046 // If we're got a huge number of basic blocks, don't bother with further analysis. 1047 if (static_cast<size_t>(num_blocks_) > (compiler_options.GetHugeMethodThreshold() / 2)) { 1048 return true; 1049 } 1050 } else if (compiler_options.IsLargeMethod(GetNumDalvikInsns()) && 1051 /* If it's large and contains no branches, it's likely to be machine generated initialization */ 1052 (GetBranchCount() == 0)) { 1053 return true; 1054 } else if (compiler_filter == CompilerOptions::kSpeed) { 1055 // If not huge, compile. 1056 return false; 1057 } 1058 1059 // Filter 2: Skip class initializers. 1060 if (((cu_->access_flags & kAccConstructor) != 0) && ((cu_->access_flags & kAccStatic) != 0)) { 1061 return true; 1062 } 1063 1064 // Filter 3: if this method is a special pattern, go ahead and emit the canned pattern. 1065 if (cu_->compiler_driver->GetMethodInlinerMap() != nullptr && 1066 cu_->compiler_driver->GetMethodInlinerMap()->GetMethodInliner(cu_->dex_file) 1067 ->IsSpecial(cu_->method_idx)) { 1068 return false; 1069 } 1070 1071 // Filter 4: if small, just compile. 1072 if (GetNumDalvikInsns() < small_cutoff) { 1073 return false; 1074 } 1075 1076 // Analyze graph for: 1077 // o floating point computation 1078 // o basic blocks contained in loop with heavy arithmetic. 1079 // o proportion of conditional branches. 1080 1081 MethodStats stats; 1082 memset(&stats, 0, sizeof(stats)); 1083 1084 ClearAllVisitedFlags(); 1085 AllNodesIterator iter(this); 1086 for (BasicBlock* bb = iter.Next(); bb != NULL; bb = iter.Next()) { 1087 AnalyzeBlock(bb, &stats); 1088 } 1089 1090 return ComputeSkipCompilation(&stats, skip_compilation); 1091} 1092 1093} // namespace art 1094