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 <algorithm> 18 #include <memory> 19 20 #include "base/logging.h" 21 #include "base/scoped_arena_containers.h" 22 #include "dataflow_iterator-inl.h" 23 #include "compiler_ir.h" 24 #include "dex_flags.h" 25 #include "dex_instruction-inl.h" 26 #include "dex/mir_field_info.h" 27 #include "dex/verified_method.h" 28 #include "dex/quick/dex_file_method_inliner.h" 29 #include "dex/quick/dex_file_to_method_inliner_map.h" 30 #include "driver/compiler_driver.h" 31 #include "driver/compiler_options.h" 32 #include "driver/dex_compilation_unit.h" 33 #include "utils.h" 34 35 namespace art { 36 37 enum InstructionAnalysisAttributeOps : uint8_t { 38 kUninterestingOp = 0, 39 kArithmeticOp, 40 kFpOp, 41 kSingleOp, 42 kDoubleOp, 43 kIntOp, 44 kLongOp, 45 kBranchOp, 46 kInvokeOp, 47 kArrayOp, 48 kHeavyweightOp, 49 kSimpleConstOp, 50 kMoveOp, 51 kSwitch 52 }; 53 54 enum InstructionAnalysisAttributeMasks : uint16_t { 55 kAnNone = 1 << kUninterestingOp, 56 kAnMath = 1 << kArithmeticOp, 57 kAnFp = 1 << kFpOp, 58 kAnLong = 1 << kLongOp, 59 kAnInt = 1 << kIntOp, 60 kAnSingle = 1 << kSingleOp, 61 kAnDouble = 1 << kDoubleOp, 62 kAnFloatMath = 1 << kFpOp, 63 kAnBranch = 1 << kBranchOp, 64 kAnInvoke = 1 << kInvokeOp, 65 kAnArrayOp = 1 << kArrayOp, 66 kAnHeavyWeight = 1 << kHeavyweightOp, 67 kAnSimpleConst = 1 << kSimpleConstOp, 68 kAnMove = 1 << kMoveOp, 69 kAnSwitch = 1 << kSwitch, 70 kAnComputational = kAnMath | kAnArrayOp | kAnMove | kAnSimpleConst, 71 }; 72 73 // Instruction characteristics used to statically identify computation-intensive methods. 74 static const uint16_t kAnalysisAttributes[kMirOpLast] = { 75 // 00 NOP 76 kAnNone, 77 78 // 01 MOVE vA, vB 79 kAnMove, 80 81 // 02 MOVE_FROM16 vAA, vBBBB 82 kAnMove, 83 84 // 03 MOVE_16 vAAAA, vBBBB 85 kAnMove, 86 87 // 04 MOVE_WIDE vA, vB 88 kAnMove, 89 90 // 05 MOVE_WIDE_FROM16 vAA, vBBBB 91 kAnMove, 92 93 // 06 MOVE_WIDE_16 vAAAA, vBBBB 94 kAnMove, 95 96 // 07 MOVE_OBJECT vA, vB 97 kAnMove, 98 99 // 08 MOVE_OBJECT_FROM16 vAA, vBBBB 100 kAnMove, 101 102 // 09 MOVE_OBJECT_16 vAAAA, vBBBB 103 kAnMove, 104 105 // 0A MOVE_RESULT vAA 106 kAnMove, 107 108 // 0B MOVE_RESULT_WIDE vAA 109 kAnMove, 110 111 // 0C MOVE_RESULT_OBJECT vAA 112 kAnMove, 113 114 // 0D MOVE_EXCEPTION vAA 115 kAnMove, 116 117 // 0E RETURN_VOID 118 kAnBranch, 119 120 // 0F RETURN vAA 121 kAnBranch, 122 123 // 10 RETURN_WIDE vAA 124 kAnBranch, 125 126 // 11 RETURN_OBJECT vAA 127 kAnBranch, 128 129 // 12 CONST_4 vA, #+B 130 kAnSimpleConst, 131 132 // 13 CONST_16 vAA, #+BBBB 133 kAnSimpleConst, 134 135 // 14 CONST vAA, #+BBBBBBBB 136 kAnSimpleConst, 137 138 // 15 CONST_HIGH16 VAA, #+BBBB0000 139 kAnSimpleConst, 140 141 // 16 CONST_WIDE_16 vAA, #+BBBB 142 kAnSimpleConst, 143 144 // 17 CONST_WIDE_32 vAA, #+BBBBBBBB 145 kAnSimpleConst, 146 147 // 18 CONST_WIDE vAA, #+BBBBBBBBBBBBBBBB 148 kAnSimpleConst, 149 150 // 19 CONST_WIDE_HIGH16 vAA, #+BBBB000000000000 151 kAnSimpleConst, 152 153 // 1A CONST_STRING vAA, string@BBBB 154 kAnNone, 155 156 // 1B CONST_STRING_JUMBO vAA, string@BBBBBBBB 157 kAnNone, 158 159 // 1C CONST_CLASS vAA, type@BBBB 160 kAnNone, 161 162 // 1D MONITOR_ENTER vAA 163 kAnNone, 164 165 // 1E MONITOR_EXIT vAA 166 kAnNone, 167 168 // 1F CHK_CAST vAA, type@BBBB 169 kAnNone, 170 171 // 20 INSTANCE_OF vA, vB, type@CCCC 172 kAnNone, 173 174 // 21 ARRAY_LENGTH vA, vB 175 kAnArrayOp, 176 177 // 22 NEW_INSTANCE vAA, type@BBBB 178 kAnHeavyWeight, 179 180 // 23 NEW_ARRAY vA, vB, type@CCCC 181 kAnHeavyWeight, 182 183 // 24 FILLED_NEW_ARRAY {vD, vE, vF, vG, vA} 184 kAnHeavyWeight, 185 186 // 25 FILLED_NEW_ARRAY_RANGE {vCCCC .. vNNNN}, type@BBBB 187 kAnHeavyWeight, 188 189 // 26 FILL_ARRAY_DATA vAA, +BBBBBBBB 190 kAnNone, 191 192 // 27 THROW vAA 193 kAnHeavyWeight | kAnBranch, 194 195 // 28 GOTO 196 kAnBranch, 197 198 // 29 GOTO_16 199 kAnBranch, 200 201 // 2A GOTO_32 202 kAnBranch, 203 204 // 2B PACKED_SWITCH vAA, +BBBBBBBB 205 kAnSwitch, 206 207 // 2C SPARSE_SWITCH vAA, +BBBBBBBB 208 kAnSwitch, 209 210 // 2D CMPL_FLOAT vAA, vBB, vCC 211 kAnMath | kAnFp | kAnSingle, 212 213 // 2E CMPG_FLOAT vAA, vBB, vCC 214 kAnMath | kAnFp | kAnSingle, 215 216 // 2F CMPL_DOUBLE vAA, vBB, vCC 217 kAnMath | kAnFp | kAnDouble, 218 219 // 30 CMPG_DOUBLE vAA, vBB, vCC 220 kAnMath | kAnFp | kAnDouble, 221 222 // 31 CMP_LONG vAA, vBB, vCC 223 kAnMath | kAnLong, 224 225 // 32 IF_EQ vA, vB, +CCCC 226 kAnMath | kAnBranch | kAnInt, 227 228 // 33 IF_NE vA, vB, +CCCC 229 kAnMath | kAnBranch | kAnInt, 230 231 // 34 IF_LT vA, vB, +CCCC 232 kAnMath | kAnBranch | kAnInt, 233 234 // 35 IF_GE vA, vB, +CCCC 235 kAnMath | kAnBranch | kAnInt, 236 237 // 36 IF_GT vA, vB, +CCCC 238 kAnMath | kAnBranch | kAnInt, 239 240 // 37 IF_LE vA, vB, +CCCC 241 kAnMath | kAnBranch | kAnInt, 242 243 // 38 IF_EQZ vAA, +BBBB 244 kAnMath | kAnBranch | kAnInt, 245 246 // 39 IF_NEZ vAA, +BBBB 247 kAnMath | kAnBranch | kAnInt, 248 249 // 3A IF_LTZ vAA, +BBBB 250 kAnMath | kAnBranch | kAnInt, 251 252 // 3B IF_GEZ vAA, +BBBB 253 kAnMath | kAnBranch | kAnInt, 254 255 // 3C IF_GTZ vAA, +BBBB 256 kAnMath | kAnBranch | kAnInt, 257 258 // 3D IF_LEZ vAA, +BBBB 259 kAnMath | kAnBranch | kAnInt, 260 261 // 3E UNUSED_3E 262 kAnNone, 263 264 // 3F UNUSED_3F 265 kAnNone, 266 267 // 40 UNUSED_40 268 kAnNone, 269 270 // 41 UNUSED_41 271 kAnNone, 272 273 // 42 UNUSED_42 274 kAnNone, 275 276 // 43 UNUSED_43 277 kAnNone, 278 279 // 44 AGET vAA, vBB, vCC 280 kAnArrayOp, 281 282 // 45 AGET_WIDE vAA, vBB, vCC 283 kAnArrayOp, 284 285 // 46 AGET_OBJECT vAA, vBB, vCC 286 kAnArrayOp, 287 288 // 47 AGET_BOOLEAN vAA, vBB, vCC 289 kAnArrayOp, 290 291 // 48 AGET_BYTE vAA, vBB, vCC 292 kAnArrayOp, 293 294 // 49 AGET_CHAR vAA, vBB, vCC 295 kAnArrayOp, 296 297 // 4A AGET_SHORT vAA, vBB, vCC 298 kAnArrayOp, 299 300 // 4B APUT vAA, vBB, vCC 301 kAnArrayOp, 302 303 // 4C APUT_WIDE vAA, vBB, vCC 304 kAnArrayOp, 305 306 // 4D APUT_OBJECT vAA, vBB, vCC 307 kAnArrayOp, 308 309 // 4E APUT_BOOLEAN vAA, vBB, vCC 310 kAnArrayOp, 311 312 // 4F APUT_BYTE vAA, vBB, vCC 313 kAnArrayOp, 314 315 // 50 APUT_CHAR vAA, vBB, vCC 316 kAnArrayOp, 317 318 // 51 APUT_SHORT vAA, vBB, vCC 319 kAnArrayOp, 320 321 // 52 IGET vA, vB, field@CCCC 322 kAnNone, 323 324 // 53 IGET_WIDE vA, vB, field@CCCC 325 kAnNone, 326 327 // 54 IGET_OBJECT vA, vB, field@CCCC 328 kAnNone, 329 330 // 55 IGET_BOOLEAN vA, vB, field@CCCC 331 kAnNone, 332 333 // 56 IGET_BYTE vA, vB, field@CCCC 334 kAnNone, 335 336 // 57 IGET_CHAR vA, vB, field@CCCC 337 kAnNone, 338 339 // 58 IGET_SHORT vA, vB, field@CCCC 340 kAnNone, 341 342 // 59 IPUT vA, vB, field@CCCC 343 kAnNone, 344 345 // 5A IPUT_WIDE vA, vB, field@CCCC 346 kAnNone, 347 348 // 5B IPUT_OBJECT vA, vB, field@CCCC 349 kAnNone, 350 351 // 5C IPUT_BOOLEAN vA, vB, field@CCCC 352 kAnNone, 353 354 // 5D IPUT_BYTE vA, vB, field@CCCC 355 kAnNone, 356 357 // 5E IPUT_CHAR vA, vB, field@CCCC 358 kAnNone, 359 360 // 5F IPUT_SHORT vA, vB, field@CCCC 361 kAnNone, 362 363 // 60 SGET vAA, field@BBBB 364 kAnNone, 365 366 // 61 SGET_WIDE vAA, field@BBBB 367 kAnNone, 368 369 // 62 SGET_OBJECT vAA, field@BBBB 370 kAnNone, 371 372 // 63 SGET_BOOLEAN vAA, field@BBBB 373 kAnNone, 374 375 // 64 SGET_BYTE vAA, field@BBBB 376 kAnNone, 377 378 // 65 SGET_CHAR vAA, field@BBBB 379 kAnNone, 380 381 // 66 SGET_SHORT vAA, field@BBBB 382 kAnNone, 383 384 // 67 SPUT vAA, field@BBBB 385 kAnNone, 386 387 // 68 SPUT_WIDE vAA, field@BBBB 388 kAnNone, 389 390 // 69 SPUT_OBJECT vAA, field@BBBB 391 kAnNone, 392 393 // 6A SPUT_BOOLEAN vAA, field@BBBB 394 kAnNone, 395 396 // 6B SPUT_BYTE vAA, field@BBBB 397 kAnNone, 398 399 // 6C SPUT_CHAR vAA, field@BBBB 400 kAnNone, 401 402 // 6D SPUT_SHORT vAA, field@BBBB 403 kAnNone, 404 405 // 6E INVOKE_VIRTUAL {vD, vE, vF, vG, vA} 406 kAnInvoke | kAnHeavyWeight, 407 408 // 6F INVOKE_SUPER {vD, vE, vF, vG, vA} 409 kAnInvoke | kAnHeavyWeight, 410 411 // 70 INVOKE_DIRECT {vD, vE, vF, vG, vA} 412 kAnInvoke | kAnHeavyWeight, 413 414 // 71 INVOKE_STATIC {vD, vE, vF, vG, vA} 415 kAnInvoke | kAnHeavyWeight, 416 417 // 72 INVOKE_INTERFACE {vD, vE, vF, vG, vA} 418 kAnInvoke | kAnHeavyWeight, 419 420 // 73 RETURN_VOID_NO_BARRIER 421 kAnBranch, 422 423 // 74 INVOKE_VIRTUAL_RANGE {vCCCC .. vNNNN} 424 kAnInvoke | kAnHeavyWeight, 425 426 // 75 INVOKE_SUPER_RANGE {vCCCC .. vNNNN} 427 kAnInvoke | kAnHeavyWeight, 428 429 // 76 INVOKE_DIRECT_RANGE {vCCCC .. vNNNN} 430 kAnInvoke | kAnHeavyWeight, 431 432 // 77 INVOKE_STATIC_RANGE {vCCCC .. vNNNN} 433 kAnInvoke | kAnHeavyWeight, 434 435 // 78 INVOKE_INTERFACE_RANGE {vCCCC .. vNNNN} 436 kAnInvoke | kAnHeavyWeight, 437 438 // 79 UNUSED_79 439 kAnNone, 440 441 // 7A UNUSED_7A 442 kAnNone, 443 444 // 7B NEG_INT vA, vB 445 kAnMath | kAnInt, 446 447 // 7C NOT_INT vA, vB 448 kAnMath | kAnInt, 449 450 // 7D NEG_LONG vA, vB 451 kAnMath | kAnLong, 452 453 // 7E NOT_LONG vA, vB 454 kAnMath | kAnLong, 455 456 // 7F NEG_FLOAT vA, vB 457 kAnMath | kAnFp | kAnSingle, 458 459 // 80 NEG_DOUBLE vA, vB 460 kAnMath | kAnFp | kAnDouble, 461 462 // 81 INT_TO_LONG vA, vB 463 kAnMath | kAnInt | kAnLong, 464 465 // 82 INT_TO_FLOAT vA, vB 466 kAnMath | kAnFp | kAnInt | kAnSingle, 467 468 // 83 INT_TO_DOUBLE vA, vB 469 kAnMath | kAnFp | kAnInt | kAnDouble, 470 471 // 84 LONG_TO_INT vA, vB 472 kAnMath | kAnInt | kAnLong, 473 474 // 85 LONG_TO_FLOAT vA, vB 475 kAnMath | kAnFp | kAnLong | kAnSingle, 476 477 // 86 LONG_TO_DOUBLE vA, vB 478 kAnMath | kAnFp | kAnLong | kAnDouble, 479 480 // 87 FLOAT_TO_INT vA, vB 481 kAnMath | kAnFp | kAnInt | kAnSingle, 482 483 // 88 FLOAT_TO_LONG vA, vB 484 kAnMath | kAnFp | kAnLong | kAnSingle, 485 486 // 89 FLOAT_TO_DOUBLE vA, vB 487 kAnMath | kAnFp | kAnSingle | kAnDouble, 488 489 // 8A DOUBLE_TO_INT vA, vB 490 kAnMath | kAnFp | kAnInt | kAnDouble, 491 492 // 8B DOUBLE_TO_LONG vA, vB 493 kAnMath | kAnFp | kAnLong | kAnDouble, 494 495 // 8C DOUBLE_TO_FLOAT vA, vB 496 kAnMath | kAnFp | kAnSingle | kAnDouble, 497 498 // 8D INT_TO_BYTE vA, vB 499 kAnMath | kAnInt, 500 501 // 8E INT_TO_CHAR vA, vB 502 kAnMath | kAnInt, 503 504 // 8F INT_TO_SHORT vA, vB 505 kAnMath | kAnInt, 506 507 // 90 ADD_INT vAA, vBB, vCC 508 kAnMath | kAnInt, 509 510 // 91 SUB_INT vAA, vBB, vCC 511 kAnMath | kAnInt, 512 513 // 92 MUL_INT vAA, vBB, vCC 514 kAnMath | kAnInt, 515 516 // 93 DIV_INT vAA, vBB, vCC 517 kAnMath | kAnInt, 518 519 // 94 REM_INT vAA, vBB, vCC 520 kAnMath | kAnInt, 521 522 // 95 AND_INT vAA, vBB, vCC 523 kAnMath | kAnInt, 524 525 // 96 OR_INT vAA, vBB, vCC 526 kAnMath | kAnInt, 527 528 // 97 XOR_INT vAA, vBB, vCC 529 kAnMath | kAnInt, 530 531 // 98 SHL_INT vAA, vBB, vCC 532 kAnMath | kAnInt, 533 534 // 99 SHR_INT vAA, vBB, vCC 535 kAnMath | kAnInt, 536 537 // 9A USHR_INT vAA, vBB, vCC 538 kAnMath | kAnInt, 539 540 // 9B ADD_LONG vAA, vBB, vCC 541 kAnMath | kAnLong, 542 543 // 9C SUB_LONG vAA, vBB, vCC 544 kAnMath | kAnLong, 545 546 // 9D MUL_LONG vAA, vBB, vCC 547 kAnMath | kAnLong, 548 549 // 9E DIV_LONG vAA, vBB, vCC 550 kAnMath | kAnLong, 551 552 // 9F REM_LONG vAA, vBB, vCC 553 kAnMath | kAnLong, 554 555 // A0 AND_LONG vAA, vBB, vCC 556 kAnMath | kAnLong, 557 558 // A1 OR_LONG vAA, vBB, vCC 559 kAnMath | kAnLong, 560 561 // A2 XOR_LONG vAA, vBB, vCC 562 kAnMath | kAnLong, 563 564 // A3 SHL_LONG vAA, vBB, vCC 565 kAnMath | kAnLong, 566 567 // A4 SHR_LONG vAA, vBB, vCC 568 kAnMath | kAnLong, 569 570 // A5 USHR_LONG vAA, vBB, vCC 571 kAnMath | kAnLong, 572 573 // A6 ADD_FLOAT vAA, vBB, vCC 574 kAnMath | kAnFp | kAnSingle, 575 576 // A7 SUB_FLOAT vAA, vBB, vCC 577 kAnMath | kAnFp | kAnSingle, 578 579 // A8 MUL_FLOAT vAA, vBB, vCC 580 kAnMath | kAnFp | kAnSingle, 581 582 // A9 DIV_FLOAT vAA, vBB, vCC 583 kAnMath | kAnFp | kAnSingle, 584 585 // AA REM_FLOAT vAA, vBB, vCC 586 kAnMath | kAnFp | kAnSingle, 587 588 // AB ADD_DOUBLE vAA, vBB, vCC 589 kAnMath | kAnFp | kAnDouble, 590 591 // AC SUB_DOUBLE vAA, vBB, vCC 592 kAnMath | kAnFp | kAnDouble, 593 594 // AD MUL_DOUBLE vAA, vBB, vCC 595 kAnMath | kAnFp | kAnDouble, 596 597 // AE DIV_DOUBLE vAA, vBB, vCC 598 kAnMath | kAnFp | kAnDouble, 599 600 // AF REM_DOUBLE vAA, vBB, vCC 601 kAnMath | kAnFp | kAnDouble, 602 603 // B0 ADD_INT_2ADDR vA, vB 604 kAnMath | kAnInt, 605 606 // B1 SUB_INT_2ADDR vA, vB 607 kAnMath | kAnInt, 608 609 // B2 MUL_INT_2ADDR vA, vB 610 kAnMath | kAnInt, 611 612 // B3 DIV_INT_2ADDR vA, vB 613 kAnMath | kAnInt, 614 615 // B4 REM_INT_2ADDR vA, vB 616 kAnMath | kAnInt, 617 618 // B5 AND_INT_2ADDR vA, vB 619 kAnMath | kAnInt, 620 621 // B6 OR_INT_2ADDR vA, vB 622 kAnMath | kAnInt, 623 624 // B7 XOR_INT_2ADDR vA, vB 625 kAnMath | kAnInt, 626 627 // B8 SHL_INT_2ADDR vA, vB 628 kAnMath | kAnInt, 629 630 // B9 SHR_INT_2ADDR vA, vB 631 kAnMath | kAnInt, 632 633 // BA USHR_INT_2ADDR vA, vB 634 kAnMath | kAnInt, 635 636 // BB ADD_LONG_2ADDR vA, vB 637 kAnMath | kAnLong, 638 639 // BC SUB_LONG_2ADDR vA, vB 640 kAnMath | kAnLong, 641 642 // BD MUL_LONG_2ADDR vA, vB 643 kAnMath | kAnLong, 644 645 // BE DIV_LONG_2ADDR vA, vB 646 kAnMath | kAnLong, 647 648 // BF REM_LONG_2ADDR vA, vB 649 kAnMath | kAnLong, 650 651 // C0 AND_LONG_2ADDR vA, vB 652 kAnMath | kAnLong, 653 654 // C1 OR_LONG_2ADDR vA, vB 655 kAnMath | kAnLong, 656 657 // C2 XOR_LONG_2ADDR vA, vB 658 kAnMath | kAnLong, 659 660 // C3 SHL_LONG_2ADDR vA, vB 661 kAnMath | kAnLong, 662 663 // C4 SHR_LONG_2ADDR vA, vB 664 kAnMath | kAnLong, 665 666 // C5 USHR_LONG_2ADDR vA, vB 667 kAnMath | kAnLong, 668 669 // C6 ADD_FLOAT_2ADDR vA, vB 670 kAnMath | kAnFp | kAnSingle, 671 672 // C7 SUB_FLOAT_2ADDR vA, vB 673 kAnMath | kAnFp | kAnSingle, 674 675 // C8 MUL_FLOAT_2ADDR vA, vB 676 kAnMath | kAnFp | kAnSingle, 677 678 // C9 DIV_FLOAT_2ADDR vA, vB 679 kAnMath | kAnFp | kAnSingle, 680 681 // CA REM_FLOAT_2ADDR vA, vB 682 kAnMath | kAnFp | kAnSingle, 683 684 // CB ADD_DOUBLE_2ADDR vA, vB 685 kAnMath | kAnFp | kAnDouble, 686 687 // CC SUB_DOUBLE_2ADDR vA, vB 688 kAnMath | kAnFp | kAnDouble, 689 690 // CD MUL_DOUBLE_2ADDR vA, vB 691 kAnMath | kAnFp | kAnDouble, 692 693 // CE DIV_DOUBLE_2ADDR vA, vB 694 kAnMath | kAnFp | kAnDouble, 695 696 // CF REM_DOUBLE_2ADDR vA, vB 697 kAnMath | kAnFp | kAnDouble, 698 699 // D0 ADD_INT_LIT16 vA, vB, #+CCCC 700 kAnMath | kAnInt, 701 702 // D1 RSUB_INT vA, vB, #+CCCC 703 kAnMath | kAnInt, 704 705 // D2 MUL_INT_LIT16 vA, vB, #+CCCC 706 kAnMath | kAnInt, 707 708 // D3 DIV_INT_LIT16 vA, vB, #+CCCC 709 kAnMath | kAnInt, 710 711 // D4 REM_INT_LIT16 vA, vB, #+CCCC 712 kAnMath | kAnInt, 713 714 // D5 AND_INT_LIT16 vA, vB, #+CCCC 715 kAnMath | kAnInt, 716 717 // D6 OR_INT_LIT16 vA, vB, #+CCCC 718 kAnMath | kAnInt, 719 720 // D7 XOR_INT_LIT16 vA, vB, #+CCCC 721 kAnMath | kAnInt, 722 723 // D8 ADD_INT_LIT8 vAA, vBB, #+CC 724 kAnMath | kAnInt, 725 726 // D9 RSUB_INT_LIT8 vAA, vBB, #+CC 727 kAnMath | kAnInt, 728 729 // DA MUL_INT_LIT8 vAA, vBB, #+CC 730 kAnMath | kAnInt, 731 732 // DB DIV_INT_LIT8 vAA, vBB, #+CC 733 kAnMath | kAnInt, 734 735 // DC REM_INT_LIT8 vAA, vBB, #+CC 736 kAnMath | kAnInt, 737 738 // DD AND_INT_LIT8 vAA, vBB, #+CC 739 kAnMath | kAnInt, 740 741 // DE OR_INT_LIT8 vAA, vBB, #+CC 742 kAnMath | kAnInt, 743 744 // DF XOR_INT_LIT8 vAA, vBB, #+CC 745 kAnMath | kAnInt, 746 747 // E0 SHL_INT_LIT8 vAA, vBB, #+CC 748 kAnMath | kAnInt, 749 750 // E1 SHR_INT_LIT8 vAA, vBB, #+CC 751 kAnMath | kAnInt, 752 753 // E2 USHR_INT_LIT8 vAA, vBB, #+CC 754 kAnMath | kAnInt, 755 756 // E3 IGET_QUICK 757 kAnNone, 758 759 // E4 IGET_WIDE_QUICK 760 kAnNone, 761 762 // E5 IGET_OBJECT_QUICK 763 kAnNone, 764 765 // E6 IPUT_QUICK 766 kAnNone, 767 768 // E7 IPUT_WIDE_QUICK 769 kAnNone, 770 771 // E8 IPUT_OBJECT_QUICK 772 kAnNone, 773 774 // E9 INVOKE_VIRTUAL_QUICK 775 kAnInvoke | kAnHeavyWeight, 776 777 // EA INVOKE_VIRTUAL_RANGE_QUICK 778 kAnInvoke | kAnHeavyWeight, 779 780 // EB IPUT_BOOLEAN_QUICK 781 kAnNone, 782 783 // EC IPUT_BYTE_QUICK 784 kAnNone, 785 786 // ED IPUT_CHAR_QUICK 787 kAnNone, 788 789 // EE IPUT_SHORT_QUICK 790 kAnNone, 791 792 // EF IGET_BOOLEAN_QUICK 793 kAnNone, 794 795 // F0 IGET_BYTE_QUICK 796 kAnNone, 797 798 // F1 IGET_CHAR_QUICK 799 kAnNone, 800 801 // F2 IGET_SHORT_QUICK 802 kAnNone, 803 804 // F3 UNUSED_F3 805 kAnNone, 806 807 // F4 UNUSED_F4 808 kAnNone, 809 810 // F5 UNUSED_F5 811 kAnNone, 812 813 // F6 UNUSED_F6 814 kAnNone, 815 816 // F7 UNUSED_F7 817 kAnNone, 818 819 // F8 UNUSED_F8 820 kAnNone, 821 822 // F9 UNUSED_F9 823 kAnNone, 824 825 // FA UNUSED_FA 826 kAnNone, 827 828 // FB UNUSED_FB 829 kAnNone, 830 831 // FC UNUSED_FC 832 kAnNone, 833 834 // FD UNUSED_FD 835 kAnNone, 836 837 // FE UNUSED_FE 838 kAnNone, 839 840 // FF UNUSED_FF 841 kAnNone, 842 843 // Beginning of extended MIR opcodes 844 // 100 MIR_PHI 845 kAnNone, 846 847 // 101 MIR_COPY 848 kAnNone, 849 850 // 102 MIR_FUSED_CMPL_FLOAT 851 kAnNone, 852 853 // 103 MIR_FUSED_CMPG_FLOAT 854 kAnNone, 855 856 // 104 MIR_FUSED_CMPL_DOUBLE 857 kAnNone, 858 859 // 105 MIR_FUSED_CMPG_DOUBLE 860 kAnNone, 861 862 // 106 MIR_FUSED_CMP_LONG 863 kAnNone, 864 865 // 107 MIR_NOP 866 kAnNone, 867 868 // 108 MIR_NULL_CHECK 869 kAnNone, 870 871 // 109 MIR_RANGE_CHECK 872 kAnNone, 873 874 // 10A MIR_DIV_ZERO_CHECK 875 kAnNone, 876 877 // 10B MIR_CHECK 878 kAnNone, 879 880 // 10C MIR_CHECKPART2 881 kAnNone, 882 883 // 10D MIR_SELECT 884 kAnNone, 885 886 // 10E MirOpConstVector 887 kAnNone, 888 889 // 10F MirOpMoveVector 890 kAnNone, 891 892 // 110 MirOpPackedMultiply 893 kAnNone, 894 895 // 111 MirOpPackedAddition 896 kAnNone, 897 898 // 112 MirOpPackedSubtract 899 kAnNone, 900 901 // 113 MirOpPackedShiftLeft 902 kAnNone, 903 904 // 114 MirOpPackedSignedShiftRight 905 kAnNone, 906 907 // 115 MirOpPackedUnsignedShiftRight 908 kAnNone, 909 910 // 116 MirOpPackedAnd 911 kAnNone, 912 913 // 117 MirOpPackedOr 914 kAnNone, 915 916 // 118 MirOpPackedXor 917 kAnNone, 918 919 // 119 MirOpPackedAddReduce 920 kAnNone, 921 922 // 11A MirOpPackedReduce 923 kAnNone, 924 925 // 11B MirOpPackedSet 926 kAnNone, 927 928 // 11C MirOpReserveVectorRegisters 929 kAnNone, 930 931 // 11D MirOpReturnVectorRegisters 932 kAnNone, 933 934 // 11E MirOpMemBarrier 935 kAnNone, 936 937 // 11F MirOpPackedArrayGet 938 kAnArrayOp, 939 940 // 120 MirOpPackedArrayPut 941 kAnArrayOp, 942 }; 943 944 struct MethodStats { 945 int dex_instructions; 946 int math_ops; 947 int fp_ops; 948 int array_ops; 949 int branch_ops; 950 int heavyweight_ops; 951 bool has_computational_loop; 952 bool has_switch; 953 float math_ratio; 954 float fp_ratio; 955 float array_ratio; 956 float branch_ratio; 957 float heavyweight_ratio; 958 }; 959 960 void MIRGraph::AnalyzeBlock(BasicBlock* bb, MethodStats* stats) { 961 if (bb->visited || (bb->block_type != kDalvikByteCode)) { 962 return; 963 } 964 bool computational_block = true; 965 bool has_math = false; 966 /* 967 * For the purposes of this scan, we want to treat the set of basic blocks broken 968 * by an exception edge as a single basic block. We'll scan forward along the fallthrough 969 * edges until we reach an explicit branch or return. 970 */ 971 BasicBlock* ending_bb = bb; 972 if (ending_bb->last_mir_insn != nullptr) { 973 uint32_t ending_flags = kAnalysisAttributes[ending_bb->last_mir_insn->dalvikInsn.opcode]; 974 while ((ending_flags & kAnBranch) == 0) { 975 ending_bb = GetBasicBlock(ending_bb->fall_through); 976 ending_flags = kAnalysisAttributes[ending_bb->last_mir_insn->dalvikInsn.opcode]; 977 } 978 } 979 /* 980 * Ideally, we'd weight the operations by loop nesting level, but to do so we'd 981 * first need to do some expensive loop detection - and the point of this is to make 982 * an informed guess before investing in computation. However, we can cheaply detect 983 * many simple loop forms without having to do full dataflow analysis. 984 */ 985 int loop_scale_factor = 1; 986 // Simple for and while loops 987 if ((ending_bb->taken != NullBasicBlockId) && (ending_bb->fall_through == NullBasicBlockId)) { 988 if ((GetBasicBlock(ending_bb->taken)->taken == bb->id) || 989 (GetBasicBlock(ending_bb->taken)->fall_through == bb->id)) { 990 loop_scale_factor = 25; 991 } 992 } 993 // Simple do-while loop 994 if ((ending_bb->taken != NullBasicBlockId) && (ending_bb->taken == bb->id)) { 995 loop_scale_factor = 25; 996 } 997 998 BasicBlock* tbb = bb; 999 bool done = false; 1000 while (!done) { 1001 tbb->visited = true; 1002 for (MIR* mir = tbb->first_mir_insn; mir != nullptr; mir = mir->next) { 1003 if (MIR::DecodedInstruction::IsPseudoMirOp(mir->dalvikInsn.opcode)) { 1004 // Skip any MIR pseudo-op. 1005 continue; 1006 } 1007 uint16_t flags = kAnalysisAttributes[mir->dalvikInsn.opcode]; 1008 stats->dex_instructions += loop_scale_factor; 1009 if ((flags & kAnBranch) == 0) { 1010 computational_block &= ((flags & kAnComputational) != 0); 1011 } else { 1012 stats->branch_ops += loop_scale_factor; 1013 } 1014 if ((flags & kAnMath) != 0) { 1015 stats->math_ops += loop_scale_factor; 1016 has_math = true; 1017 } 1018 if ((flags & kAnFp) != 0) { 1019 stats->fp_ops += loop_scale_factor; 1020 } 1021 if ((flags & kAnArrayOp) != 0) { 1022 stats->array_ops += loop_scale_factor; 1023 } 1024 if ((flags & kAnHeavyWeight) != 0) { 1025 stats->heavyweight_ops += loop_scale_factor; 1026 } 1027 if ((flags & kAnSwitch) != 0) { 1028 stats->has_switch = true; 1029 } 1030 } 1031 if (tbb == ending_bb) { 1032 done = true; 1033 } else { 1034 tbb = GetBasicBlock(tbb->fall_through); 1035 } 1036 } 1037 if (has_math && computational_block && (loop_scale_factor > 1)) { 1038 stats->has_computational_loop = true; 1039 } 1040 } 1041 1042 bool MIRGraph::ComputeSkipCompilation(MethodStats* stats, bool skip_default, 1043 std::string* skip_message) { 1044 float count = stats->dex_instructions; 1045 stats->math_ratio = stats->math_ops / count; 1046 stats->fp_ratio = stats->fp_ops / count; 1047 stats->branch_ratio = stats->branch_ops / count; 1048 stats->array_ratio = stats->array_ops / count; 1049 stats->heavyweight_ratio = stats->heavyweight_ops / count; 1050 1051 if (cu_->enable_debug & (1 << kDebugShowFilterStats)) { 1052 LOG(INFO) << "STATS " << stats->dex_instructions << ", math:" 1053 << stats->math_ratio << ", fp:" 1054 << stats->fp_ratio << ", br:" 1055 << stats->branch_ratio << ", hw:" 1056 << stats->heavyweight_ratio << ", arr:" 1057 << stats->array_ratio << ", hot:" 1058 << stats->has_computational_loop << ", " 1059 << PrettyMethod(cu_->method_idx, *cu_->dex_file); 1060 } 1061 1062 // Computation intensive? 1063 if (stats->has_computational_loop && (stats->heavyweight_ratio < 0.04)) { 1064 return false; 1065 } 1066 1067 // Complex, logic-intensive? 1068 if (cu_->compiler_driver->GetCompilerOptions().IsSmallMethod(GetNumDalvikInsns()) && 1069 stats->branch_ratio > 0.3) { 1070 return false; 1071 } 1072 1073 // Significant floating point? 1074 if (stats->fp_ratio > 0.05) { 1075 return false; 1076 } 1077 1078 // Significant generic math? 1079 if (stats->math_ratio > 0.3) { 1080 return false; 1081 } 1082 1083 // If array-intensive, compiling is probably worthwhile. 1084 if (stats->array_ratio > 0.1) { 1085 return false; 1086 } 1087 1088 // Switch operations benefit greatly from compilation, so go ahead and spend the cycles. 1089 if (stats->has_switch) { 1090 return false; 1091 } 1092 1093 // If significant in size and high proportion of expensive operations, skip. 1094 if (cu_->compiler_driver->GetCompilerOptions().IsSmallMethod(GetNumDalvikInsns()) && 1095 (stats->heavyweight_ratio > 0.3)) { 1096 *skip_message = "Is a small method with heavyweight ratio " + 1097 std::to_string(stats->heavyweight_ratio); 1098 return true; 1099 } 1100 1101 return skip_default; 1102 } 1103 1104 /* 1105 * Will eventually want this to be a bit more sophisticated and happen at verification time. 1106 */ 1107 bool MIRGraph::SkipCompilation(std::string* skip_message) { 1108 const CompilerOptions& compiler_options = cu_->compiler_driver->GetCompilerOptions(); 1109 CompilerOptions::CompilerFilter compiler_filter = compiler_options.GetCompilerFilter(); 1110 if (compiler_filter == CompilerOptions::kEverything) { 1111 return false; 1112 } 1113 1114 // Contains a pattern we don't want to compile? 1115 if (PuntToInterpreter()) { 1116 *skip_message = "Punt to interpreter set"; 1117 return true; 1118 } 1119 1120 DCHECK(compiler_options.IsCompilationEnabled()); 1121 1122 // Set up compilation cutoffs based on current filter mode. 1123 size_t small_cutoff; 1124 size_t default_cutoff; 1125 switch (compiler_filter) { 1126 case CompilerOptions::kBalanced: 1127 small_cutoff = compiler_options.GetSmallMethodThreshold(); 1128 default_cutoff = compiler_options.GetLargeMethodThreshold(); 1129 break; 1130 case CompilerOptions::kSpace: 1131 small_cutoff = compiler_options.GetTinyMethodThreshold(); 1132 default_cutoff = compiler_options.GetSmallMethodThreshold(); 1133 break; 1134 case CompilerOptions::kSpeed: 1135 case CompilerOptions::kTime: 1136 small_cutoff = compiler_options.GetHugeMethodThreshold(); 1137 default_cutoff = compiler_options.GetHugeMethodThreshold(); 1138 break; 1139 default: 1140 LOG(FATAL) << "Unexpected compiler_filter_: " << compiler_filter; 1141 UNREACHABLE(); 1142 } 1143 1144 // If size < cutoff, assume we'll compile - but allow removal. 1145 bool skip_compilation = (GetNumDalvikInsns() >= default_cutoff); 1146 if (skip_compilation) { 1147 *skip_message = "#Insns >= default_cutoff: " + std::to_string(GetNumDalvikInsns()); 1148 } 1149 1150 /* 1151 * Filter 1: Huge methods are likely to be machine generated, but some aren't. 1152 * If huge, assume we won't compile, but allow futher analysis to turn it back on. 1153 */ 1154 if (compiler_options.IsHugeMethod(GetNumDalvikInsns())) { 1155 skip_compilation = true; 1156 *skip_message = "Huge method: " + std::to_string(GetNumDalvikInsns()); 1157 // If we're got a huge number of basic blocks, don't bother with further analysis. 1158 if (static_cast<size_t>(GetNumBlocks()) > (compiler_options.GetHugeMethodThreshold() / 2)) { 1159 return true; 1160 } 1161 } else if (compiler_options.IsLargeMethod(GetNumDalvikInsns()) && 1162 /* If it's large and contains no branches, it's likely to be machine generated initialization */ 1163 (GetBranchCount() == 0)) { 1164 *skip_message = "Large method with no branches"; 1165 return true; 1166 } else if (compiler_filter == CompilerOptions::kSpeed) { 1167 // If not huge, compile. 1168 return false; 1169 } 1170 1171 // Filter 2: Skip class initializers. 1172 if (((cu_->access_flags & kAccConstructor) != 0) && ((cu_->access_flags & kAccStatic) != 0)) { 1173 *skip_message = "Class initializer"; 1174 return true; 1175 } 1176 1177 // Filter 3: if this method is a special pattern, go ahead and emit the canned pattern. 1178 if (cu_->compiler_driver->GetMethodInlinerMap() != nullptr && 1179 cu_->compiler_driver->GetMethodInlinerMap()->GetMethodInliner(cu_->dex_file) 1180 ->IsSpecial(cu_->method_idx)) { 1181 return false; 1182 } 1183 1184 // Filter 4: if small, just compile. 1185 if (GetNumDalvikInsns() < small_cutoff) { 1186 return false; 1187 } 1188 1189 // Analyze graph for: 1190 // o floating point computation 1191 // o basic blocks contained in loop with heavy arithmetic. 1192 // o proportion of conditional branches. 1193 1194 MethodStats stats; 1195 memset(&stats, 0, sizeof(stats)); 1196 1197 ClearAllVisitedFlags(); 1198 AllNodesIterator iter(this); 1199 for (BasicBlock* bb = iter.Next(); bb != nullptr; bb = iter.Next()) { 1200 AnalyzeBlock(bb, &stats); 1201 } 1202 1203 return ComputeSkipCompilation(&stats, skip_compilation, skip_message); 1204 } 1205 1206 void MIRGraph::DoCacheFieldLoweringInfo() { 1207 static constexpr uint32_t kFieldIndexFlagQuickened = 0x80000000; 1208 // All IGET/IPUT/SGET/SPUT instructions take 2 code units and there must also be a RETURN. 1209 const uint32_t max_refs = (GetNumDalvikInsns() - 1u) / 2u; 1210 ScopedArenaAllocator allocator(&cu_->arena_stack); 1211 auto* field_idxs = allocator.AllocArray<uint32_t>(max_refs, kArenaAllocMisc); 1212 DexMemAccessType* field_types = allocator.AllocArray<DexMemAccessType>( 1213 max_refs, kArenaAllocMisc); 1214 // Find IGET/IPUT/SGET/SPUT insns, store IGET/IPUT fields at the beginning, SGET/SPUT at the end. 1215 size_t ifield_pos = 0u; 1216 size_t sfield_pos = max_refs; 1217 AllNodesIterator iter(this); 1218 for (BasicBlock* bb = iter.Next(); bb != nullptr; bb = iter.Next()) { 1219 if (bb->block_type != kDalvikByteCode) { 1220 continue; 1221 } 1222 for (MIR* mir = bb->first_mir_insn; mir != nullptr; mir = mir->next) { 1223 // Get field index and try to find it among existing indexes. If found, it's usually among 1224 // the last few added, so we'll start the search from ifield_pos/sfield_pos. Though this 1225 // is a linear search, it actually performs much better than map based approach. 1226 const bool is_iget_or_iput = IsInstructionIGetOrIPut(mir->dalvikInsn.opcode); 1227 const bool is_iget_or_iput_quick = IsInstructionIGetQuickOrIPutQuick(mir->dalvikInsn.opcode); 1228 if (is_iget_or_iput || is_iget_or_iput_quick) { 1229 uint32_t field_idx; 1230 DexMemAccessType access_type; 1231 if (is_iget_or_iput) { 1232 field_idx = mir->dalvikInsn.vC; 1233 access_type = IGetOrIPutMemAccessType(mir->dalvikInsn.opcode); 1234 } else { 1235 DCHECK(is_iget_or_iput_quick); 1236 // Set kFieldIndexFlagQuickened so that we don't deduplicate against non quickened field 1237 // indexes. 1238 field_idx = mir->offset | kFieldIndexFlagQuickened; 1239 access_type = IGetQuickOrIPutQuickMemAccessType(mir->dalvikInsn.opcode); 1240 } 1241 size_t i = ifield_pos; 1242 while (i != 0u && field_idxs[i - 1] != field_idx) { 1243 --i; 1244 } 1245 if (i != 0u) { 1246 mir->meta.ifield_lowering_info = i - 1; 1247 DCHECK_EQ(field_types[i - 1], access_type); 1248 } else { 1249 mir->meta.ifield_lowering_info = ifield_pos; 1250 field_idxs[ifield_pos] = field_idx; 1251 field_types[ifield_pos] = access_type; 1252 ++ifield_pos; 1253 } 1254 } else if (IsInstructionSGetOrSPut(mir->dalvikInsn.opcode)) { 1255 auto field_idx = mir->dalvikInsn.vB; 1256 size_t i = sfield_pos; 1257 while (i != max_refs && field_idxs[i] != field_idx) { 1258 ++i; 1259 } 1260 if (i != max_refs) { 1261 mir->meta.sfield_lowering_info = max_refs - i - 1u; 1262 DCHECK_EQ(field_types[i], SGetOrSPutMemAccessType(mir->dalvikInsn.opcode)); 1263 } else { 1264 mir->meta.sfield_lowering_info = max_refs - sfield_pos; 1265 --sfield_pos; 1266 field_idxs[sfield_pos] = field_idx; 1267 field_types[sfield_pos] = SGetOrSPutMemAccessType(mir->dalvikInsn.opcode); 1268 } 1269 } 1270 DCHECK_LE(ifield_pos, sfield_pos); 1271 } 1272 } 1273 1274 if (ifield_pos != 0u) { 1275 // Resolve instance field infos. 1276 DCHECK_EQ(ifield_lowering_infos_.size(), 0u); 1277 ifield_lowering_infos_.reserve(ifield_pos); 1278 for (size_t pos = 0u; pos != ifield_pos; ++pos) { 1279 const uint32_t field_idx = field_idxs[pos]; 1280 const bool is_quickened = (field_idx & kFieldIndexFlagQuickened) != 0; 1281 const uint32_t masked_field_idx = field_idx & ~kFieldIndexFlagQuickened; 1282 CHECK_LT(masked_field_idx, 1u << 16); 1283 ifield_lowering_infos_.push_back( 1284 MirIFieldLoweringInfo(masked_field_idx, field_types[pos], is_quickened)); 1285 } 1286 MirIFieldLoweringInfo::Resolve(cu_->compiler_driver, GetCurrentDexCompilationUnit(), 1287 ifield_lowering_infos_.data(), ifield_pos); 1288 } 1289 1290 if (sfield_pos != max_refs) { 1291 // Resolve static field infos. 1292 DCHECK_EQ(sfield_lowering_infos_.size(), 0u); 1293 sfield_lowering_infos_.reserve(max_refs - sfield_pos); 1294 for (size_t pos = max_refs; pos != sfield_pos;) { 1295 --pos; 1296 sfield_lowering_infos_.push_back(MirSFieldLoweringInfo(field_idxs[pos], field_types[pos])); 1297 } 1298 MirSFieldLoweringInfo::Resolve(cu_->compiler_driver, GetCurrentDexCompilationUnit(), 1299 sfield_lowering_infos_.data(), max_refs - sfield_pos); 1300 } 1301 } 1302 1303 void MIRGraph::DoCacheMethodLoweringInfo() { 1304 static constexpr uint16_t invoke_types[] = { kVirtual, kSuper, kDirect, kStatic, kInterface }; 1305 static constexpr uint32_t kMethodIdxFlagQuickened = 0x80000000; 1306 1307 // Embed the map value in the entry to avoid extra padding in 64-bit builds. 1308 struct MapEntry { 1309 // Map key: target_method_idx, invoke_type, devirt_target. Ordered to avoid padding. 1310 const MethodReference* devirt_target; 1311 uint32_t target_method_idx; 1312 uint32_t vtable_idx; 1313 uint16_t invoke_type; 1314 // Map value. 1315 uint32_t lowering_info_index; 1316 }; 1317 1318 struct MapEntryComparator { 1319 bool operator()(const MapEntry& lhs, const MapEntry& rhs) const { 1320 if (lhs.target_method_idx != rhs.target_method_idx) { 1321 return lhs.target_method_idx < rhs.target_method_idx; 1322 } 1323 if (lhs.invoke_type != rhs.invoke_type) { 1324 return lhs.invoke_type < rhs.invoke_type; 1325 } 1326 if (lhs.vtable_idx != rhs.vtable_idx) { 1327 return lhs.vtable_idx < rhs.vtable_idx; 1328 } 1329 if (lhs.devirt_target != rhs.devirt_target) { 1330 if (lhs.devirt_target == nullptr) { 1331 return true; 1332 } 1333 if (rhs.devirt_target == nullptr) { 1334 return false; 1335 } 1336 return devirt_cmp(*lhs.devirt_target, *rhs.devirt_target); 1337 } 1338 return false; 1339 } 1340 MethodReferenceComparator devirt_cmp; 1341 }; 1342 1343 ScopedArenaAllocator allocator(&cu_->arena_stack); 1344 1345 // All INVOKE instructions take 3 code units and there must also be a RETURN. 1346 const uint32_t max_refs = (GetNumDalvikInsns() - 1u) / 3u; 1347 1348 // Map invoke key (see MapEntry) to lowering info index and vice versa. 1349 // The invoke_map and sequential entries are essentially equivalent to Boost.MultiIndex's 1350 // multi_index_container with one ordered index and one sequential index. 1351 ScopedArenaSet<MapEntry, MapEntryComparator> invoke_map(MapEntryComparator(), 1352 allocator.Adapter()); 1353 const MapEntry** sequential_entries = 1354 allocator.AllocArray<const MapEntry*>(max_refs, kArenaAllocMisc); 1355 1356 // Find INVOKE insns and their devirtualization targets. 1357 const VerifiedMethod* verified_method = GetCurrentDexCompilationUnit()->GetVerifiedMethod(); 1358 AllNodesIterator iter(this); 1359 for (BasicBlock* bb = iter.Next(); bb != nullptr; bb = iter.Next()) { 1360 if (bb->block_type != kDalvikByteCode) { 1361 continue; 1362 } 1363 for (MIR* mir = bb->first_mir_insn; mir != nullptr; mir = mir->next) { 1364 const bool is_quick_invoke = IsInstructionQuickInvoke(mir->dalvikInsn.opcode); 1365 const bool is_invoke = IsInstructionInvoke(mir->dalvikInsn.opcode); 1366 if (is_quick_invoke || is_invoke) { 1367 uint32_t vtable_index = 0; 1368 uint32_t target_method_idx = 0; 1369 uint32_t invoke_type_idx = 0; // Default to virtual (in case of quickened). 1370 DCHECK_EQ(invoke_types[invoke_type_idx], kVirtual); 1371 if (is_quick_invoke) { 1372 // We need to store the vtable index since we can't necessarily recreate it at resolve 1373 // phase if the dequickening resolved to an interface method. 1374 vtable_index = mir->dalvikInsn.vB; 1375 // Fake up the method index by storing the mir offset so that we can read the dequicken 1376 // info in resolve. 1377 target_method_idx = mir->offset | kMethodIdxFlagQuickened; 1378 } else { 1379 DCHECK(is_invoke); 1380 // Decode target method index and invoke type. 1381 invoke_type_idx = InvokeInstructionType(mir->dalvikInsn.opcode); 1382 target_method_idx = mir->dalvikInsn.vB; 1383 } 1384 // Find devirtualization target. 1385 // TODO: The devirt map is ordered by the dex pc here. Is there a way to get INVOKEs 1386 // ordered by dex pc as well? That would allow us to keep an iterator to devirt targets 1387 // and increment it as needed instead of making O(log n) lookups. 1388 const MethodReference* devirt_target = verified_method->GetDevirtTarget(mir->offset); 1389 // Try to insert a new entry. If the insertion fails, we will have found an old one. 1390 MapEntry entry = { 1391 devirt_target, 1392 target_method_idx, 1393 vtable_index, 1394 invoke_types[invoke_type_idx], 1395 static_cast<uint32_t>(invoke_map.size()) 1396 }; 1397 auto it = invoke_map.insert(entry).first; // Iterator to either the old or the new entry. 1398 mir->meta.method_lowering_info = it->lowering_info_index; 1399 // If we didn't actually insert, this will just overwrite an existing value with the same. 1400 sequential_entries[it->lowering_info_index] = &*it; 1401 } 1402 } 1403 } 1404 if (invoke_map.empty()) { 1405 return; 1406 } 1407 // Prepare unique method infos, set method info indexes for their MIRs. 1408 const size_t count = invoke_map.size(); 1409 method_lowering_infos_.reserve(count); 1410 for (size_t pos = 0u; pos != count; ++pos) { 1411 const MapEntry* entry = sequential_entries[pos]; 1412 const bool is_quick = (entry->target_method_idx & kMethodIdxFlagQuickened) != 0; 1413 const uint32_t masked_method_idx = entry->target_method_idx & ~kMethodIdxFlagQuickened; 1414 MirMethodLoweringInfo method_info(masked_method_idx, 1415 static_cast<InvokeType>(entry->invoke_type), is_quick); 1416 if (entry->devirt_target != nullptr) { 1417 method_info.SetDevirtualizationTarget(*entry->devirt_target); 1418 } 1419 if (is_quick) { 1420 method_info.SetVTableIndex(entry->vtable_idx); 1421 } 1422 method_lowering_infos_.push_back(method_info); 1423 } 1424 MirMethodLoweringInfo::Resolve(cu_->compiler_driver, GetCurrentDexCompilationUnit(), 1425 method_lowering_infos_.data(), count); 1426 } 1427 1428 bool MIRGraph::SkipCompilationByName(const std::string& methodname) { 1429 return cu_->compiler_driver->SkipCompilation(methodname); 1430 } 1431 1432 } // namespace art 1433
