1/* 2 * Copyright (C) 2014 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 "asm_support_mips64.S" 18 19#include "arch/quick_alloc_entrypoints.S" 20 21 .set noreorder 22 .balign 16 23 24 /* Deliver the given exception */ 25 .extern artDeliverExceptionFromCode 26 /* Deliver an exception pending on a thread */ 27 .extern artDeliverPendingExceptionFromCode 28 29 /* 30 * Macro that sets up $gp and stores the previous $gp value to $t8. 31 * This macro modifies v1 and t8. 32 */ 33.macro SETUP_GP 34 move $v1, $ra 35 bal 1f 36 nop 371: 38 .cpsetup $ra, $t8, 1b 39 move $ra, $v1 40.endm 41 42 /* 43 * Macro that sets up the callee save frame to conform with 44 * Runtime::CreateCalleeSaveMethod(kSaveAllCalleeSaves) 45 * callee-save: padding + $f24-$f31 + $s0-$s7 + $gp + $ra + $s8 = 19 total + 1x8 bytes padding 46 */ 47.macro SETUP_SAVE_ALL_CALLEE_SAVES_FRAME 48 daddiu $sp, $sp, -160 49 .cfi_adjust_cfa_offset 160 50 51 // Ugly compile-time check, but we only have the preprocessor. 52#if (FRAME_SIZE_SAVE_ALL_CALLEE_SAVES != 160) 53#error "FRAME_SIZE_SAVE_ALL_CALLEE_SAVES(MIPS64) size not as expected." 54#endif 55 56 sd $ra, 152($sp) 57 .cfi_rel_offset 31, 152 58 sd $s8, 144($sp) 59 .cfi_rel_offset 30, 144 60 sd $t8, 136($sp) # t8 holds caller's gp, now save it to the stack. 61 .cfi_rel_offset 28, 136 # Value from gp is pushed, so set the cfi offset accordingly. 62 sd $s7, 128($sp) 63 .cfi_rel_offset 23, 128 64 sd $s6, 120($sp) 65 .cfi_rel_offset 22, 120 66 sd $s5, 112($sp) 67 .cfi_rel_offset 21, 112 68 sd $s4, 104($sp) 69 .cfi_rel_offset 20, 104 70 sd $s3, 96($sp) 71 .cfi_rel_offset 19, 96 72 sd $s2, 88($sp) 73 .cfi_rel_offset 18, 88 74 sd $s1, 80($sp) 75 .cfi_rel_offset 17, 80 76 sd $s0, 72($sp) 77 .cfi_rel_offset 16, 72 78 79 // FP callee-saves 80 s.d $f31, 64($sp) 81 s.d $f30, 56($sp) 82 s.d $f29, 48($sp) 83 s.d $f28, 40($sp) 84 s.d $f27, 32($sp) 85 s.d $f26, 24($sp) 86 s.d $f25, 16($sp) 87 s.d $f24, 8($sp) 88 89 # load appropriate callee-save-method 90 ld $t1, %got(_ZN3art7Runtime9instance_E)($gp) 91 ld $t1, 0($t1) 92 ld $t1, RUNTIME_SAVE_ALL_CALLEE_SAVES_METHOD_OFFSET($t1) 93 sd $t1, 0($sp) # Place ArtMethod* at bottom of stack. 94 sd $sp, THREAD_TOP_QUICK_FRAME_OFFSET(rSELF) # Place sp in Thread::Current()->top_quick_frame. 95.endm 96 97 /* 98 * Macro that sets up the callee save frame to conform with 99 * Runtime::CreateCalleeSaveMethod(kSaveRefsOnly). Restoration assumes 100 * non-moving GC. 101 * Does not include rSUSPEND or rSELF 102 * callee-save: padding + $s2-$s7 + $gp + $ra + $s8 = 9 total + 1x8 bytes padding 103 */ 104.macro SETUP_SAVE_REFS_ONLY_FRAME 105 daddiu $sp, $sp, -80 106 .cfi_adjust_cfa_offset 80 107 108 // Ugly compile-time check, but we only have the preprocessor. 109#if (FRAME_SIZE_SAVE_REFS_ONLY != 80) 110#error "FRAME_SIZE_SAVE_REFS_ONLY(MIPS64) size not as expected." 111#endif 112 113 sd $ra, 72($sp) 114 .cfi_rel_offset 31, 72 115 sd $s8, 64($sp) 116 .cfi_rel_offset 30, 64 117 sd $t8, 56($sp) # t8 holds caller's gp, now save it to the stack. 118 .cfi_rel_offset 28, 56 # Value from gp is pushed, so set the cfi offset accordingly. 119 sd $s7, 48($sp) 120 .cfi_rel_offset 23, 48 121 sd $s6, 40($sp) 122 .cfi_rel_offset 22, 40 123 sd $s5, 32($sp) 124 .cfi_rel_offset 21, 32 125 sd $s4, 24($sp) 126 .cfi_rel_offset 20, 24 127 sd $s3, 16($sp) 128 .cfi_rel_offset 19, 16 129 sd $s2, 8($sp) 130 .cfi_rel_offset 18, 8 131 # load appropriate callee-save-method 132 ld $t1, %got(_ZN3art7Runtime9instance_E)($gp) 133 ld $t1, 0($t1) 134 ld $t1, RUNTIME_SAVE_REFS_ONLY_METHOD_OFFSET($t1) 135 sd $t1, 0($sp) # Place Method* at bottom of stack. 136 sd $sp, THREAD_TOP_QUICK_FRAME_OFFSET(rSELF) # Place sp in Thread::Current()->top_quick_frame. 137.endm 138 139.macro RESTORE_SAVE_REFS_ONLY_FRAME 140 ld $ra, 72($sp) 141 .cfi_restore 31 142 ld $s8, 64($sp) 143 .cfi_restore 30 144 ld $t8, 56($sp) # Restore gp back to it's temp storage. 145 .cfi_restore 28 146 ld $s7, 48($sp) 147 .cfi_restore 23 148 ld $s6, 40($sp) 149 .cfi_restore 22 150 ld $s5, 32($sp) 151 .cfi_restore 21 152 ld $s4, 24($sp) 153 .cfi_restore 20 154 ld $s3, 16($sp) 155 .cfi_restore 19 156 ld $s2, 8($sp) 157 .cfi_restore 18 158 daddiu $sp, $sp, 80 159 .cfi_adjust_cfa_offset -80 160 .cpreturn 161.endm 162 163.macro RESTORE_SAVE_REFS_ONLY_FRAME_AND_RETURN 164 ld $ra, 72($sp) 165 .cfi_restore 31 166 ld $s8, 64($sp) 167 .cfi_restore 30 168 ld $t8, 56($sp) # Restore gp back to it's temp storage. 169 .cfi_restore 28 170 ld $s7, 48($sp) 171 .cfi_restore 23 172 ld $s6, 40($sp) 173 .cfi_restore 22 174 ld $s5, 32($sp) 175 .cfi_restore 21 176 ld $s4, 24($sp) 177 .cfi_restore 20 178 ld $s3, 16($sp) 179 .cfi_restore 19 180 ld $s2, 8($sp) 181 .cfi_restore 18 182 .cpreturn 183 jalr $zero, $ra 184 daddiu $sp, $sp, 80 185 .cfi_adjust_cfa_offset -80 186.endm 187 188// This assumes the top part of these stack frame types are identical. 189#define REFS_AND_ARGS_MINUS_REFS_SIZE (FRAME_SIZE_SAVE_REFS_AND_ARGS - FRAME_SIZE_SAVE_REFS_ONLY) 190 191.macro SETUP_SAVE_REFS_AND_ARGS_FRAME_INTERNAL 192 daddiu $sp, $sp, -208 193 .cfi_adjust_cfa_offset 208 194 195 // Ugly compile-time check, but we only have the preprocessor. 196#if (FRAME_SIZE_SAVE_REFS_AND_ARGS != 208) 197#error "FRAME_SIZE_SAVE_REFS_AND_ARGS(MIPS64) size not as expected." 198#endif 199 200 sd $ra, 200($sp) # = kQuickCalleeSaveFrame_RefAndArgs_LrOffset 201 .cfi_rel_offset 31, 200 202 sd $s8, 192($sp) 203 .cfi_rel_offset 30, 192 204 sd $t8, 184($sp) # t8 holds caller's gp, now save it to the stack. 205 .cfi_rel_offset 28, 184 # Value from gp is pushed, so set the cfi offset accordingly. 206 sd $s7, 176($sp) 207 .cfi_rel_offset 23, 176 208 sd $s6, 168($sp) 209 .cfi_rel_offset 22, 168 210 sd $s5, 160($sp) 211 .cfi_rel_offset 21, 160 212 sd $s4, 152($sp) 213 .cfi_rel_offset 20, 152 214 sd $s3, 144($sp) 215 .cfi_rel_offset 19, 144 216 sd $s2, 136($sp) 217 .cfi_rel_offset 18, 136 218 219 sd $a7, 128($sp) 220 .cfi_rel_offset 11, 128 221 sd $a6, 120($sp) 222 .cfi_rel_offset 10, 120 223 sd $a5, 112($sp) 224 .cfi_rel_offset 9, 112 225 sd $a4, 104($sp) 226 .cfi_rel_offset 8, 104 227 sd $a3, 96($sp) 228 .cfi_rel_offset 7, 96 229 sd $a2, 88($sp) 230 .cfi_rel_offset 6, 88 231 sd $a1, 80($sp) # = kQuickCalleeSaveFrame_RefAndArgs_Gpr1Offset 232 .cfi_rel_offset 5, 80 233 234 s.d $f19, 72($sp) 235 s.d $f18, 64($sp) 236 s.d $f17, 56($sp) 237 s.d $f16, 48($sp) 238 s.d $f15, 40($sp) 239 s.d $f14, 32($sp) 240 s.d $f13, 24($sp) # = kQuickCalleeSaveFrame_RefAndArgs_Fpr1Offset 241 s.d $f12, 16($sp) # This isn't necessary to store. 242 # 1x8 bytes padding + Method* 243.endm 244 245 /* 246 * Macro that sets up the callee save frame to conform with 247 * Runtime::CreateCalleeSaveMethod(kSaveRefsAndArgs). Restoration assumes 248 * non-moving GC. 249 * callee-save: padding + $f12-$f19 + $a1-$a7 + $s2-$s7 + $gp + $ra + $s8 = 24 total + 1 words padding + Method* 250 */ 251.macro SETUP_SAVE_REFS_AND_ARGS_FRAME 252 SETUP_SAVE_REFS_AND_ARGS_FRAME_INTERNAL 253 # load appropriate callee-save-method 254 ld $t1, %got(_ZN3art7Runtime9instance_E)($gp) 255 ld $t1, 0($t1) 256 ld $t1, RUNTIME_SAVE_REFS_AND_ARGS_METHOD_OFFSET($t1) 257 sd $t1, 0($sp) # Place Method* at bottom of stack. 258 sd $sp, THREAD_TOP_QUICK_FRAME_OFFSET(rSELF) # Place sp in Thread::Current()->top_quick_frame. 259.endm 260 261.macro SETUP_SAVE_REFS_AND_ARGS_FRAME_WITH_METHOD_IN_A0 262 SETUP_SAVE_REFS_AND_ARGS_FRAME_INTERNAL 263 sd $a0, 0($sp) # Place Method* at bottom of stack. 264 sd $sp, THREAD_TOP_QUICK_FRAME_OFFSET(rSELF) # Place sp in Thread::Current()->top_quick_frame. 265.endm 266 267.macro RESTORE_SAVE_REFS_AND_ARGS_FRAME 268 ld $ra, 200($sp) 269 .cfi_restore 31 270 ld $s8, 192($sp) 271 .cfi_restore 30 272 ld $t8, 184($sp) # Restore gp back to it's temp storage. 273 .cfi_restore 28 274 ld $s7, 176($sp) 275 .cfi_restore 23 276 ld $s6, 168($sp) 277 .cfi_restore 22 278 ld $s5, 160($sp) 279 .cfi_restore 21 280 ld $s4, 152($sp) 281 .cfi_restore 20 282 ld $s3, 144($sp) 283 .cfi_restore 19 284 ld $s2, 136($sp) 285 .cfi_restore 18 286 287 ld $a7, 128($sp) 288 .cfi_restore 11 289 ld $a6, 120($sp) 290 .cfi_restore 10 291 ld $a5, 112($sp) 292 .cfi_restore 9 293 ld $a4, 104($sp) 294 .cfi_restore 8 295 ld $a3, 96($sp) 296 .cfi_restore 7 297 ld $a2, 88($sp) 298 .cfi_restore 6 299 ld $a1, 80($sp) 300 .cfi_restore 5 301 302 l.d $f19, 72($sp) 303 l.d $f18, 64($sp) 304 l.d $f17, 56($sp) 305 l.d $f16, 48($sp) 306 l.d $f15, 40($sp) 307 l.d $f14, 32($sp) 308 l.d $f13, 24($sp) 309 l.d $f12, 16($sp) 310 311 .cpreturn 312 daddiu $sp, $sp, 208 313 .cfi_adjust_cfa_offset -208 314.endm 315 316 /* 317 * Macro that sets up the callee save frame to conform with 318 * Runtime::CreateCalleeSaveMethod(kSaveEverything). 319 * when the $sp has already been decremented by FRAME_SIZE_SAVE_EVERYTHING. 320 * callee-save: $at + $v0-$v1 + $a0-$a7 + $t0-$t3 + $s0-$s7 + $t8-$t9 + $gp + $s8 + $ra + $s8, 321 * $f0-$f31; 28(GPR)+ 32(FPR) + 1x8 bytes padding + method* 322 * This macro sets up $gp; entrypoints using it should start with ENTRY_NO_GP. 323 */ 324.macro SETUP_SAVE_EVERYTHING_FRAME_DECREMENTED_SP 325 // Ugly compile-time check, but we only have the preprocessor. 326#if (FRAME_SIZE_SAVE_EVERYTHING != 496) 327#error "FRAME_SIZE_SAVE_EVERYTHING(MIPS64) size not as expected." 328#endif 329 330 // Save core registers. 331 sd $ra, 488($sp) 332 .cfi_rel_offset 31, 488 333 sd $s8, 480($sp) 334 .cfi_rel_offset 30, 480 335 sd $t9, 464($sp) 336 .cfi_rel_offset 25, 464 337 sd $t8, 456($sp) 338 .cfi_rel_offset 24, 456 339 sd $s7, 448($sp) 340 .cfi_rel_offset 23, 448 341 sd $s6, 440($sp) 342 .cfi_rel_offset 22, 440 343 sd $s5, 432($sp) 344 .cfi_rel_offset 21, 432 345 sd $s4, 424($sp) 346 .cfi_rel_offset 20, 424 347 sd $s3, 416($sp) 348 .cfi_rel_offset 19, 416 349 sd $s2, 408($sp) 350 .cfi_rel_offset 18, 408 351 sd $s1, 400($sp) 352 .cfi_rel_offset 17, 400 353 sd $s0, 392($sp) 354 .cfi_rel_offset 16, 392 355 sd $t3, 384($sp) 356 .cfi_rel_offset 15, 384 357 sd $t2, 376($sp) 358 .cfi_rel_offset 14, 376 359 sd $t1, 368($sp) 360 .cfi_rel_offset 13, 368 361 sd $t0, 360($sp) 362 .cfi_rel_offset 12, 360 363 sd $a7, 352($sp) 364 .cfi_rel_offset 11, 352 365 sd $a6, 344($sp) 366 .cfi_rel_offset 10, 344 367 sd $a5, 336($sp) 368 .cfi_rel_offset 9, 336 369 sd $a4, 328($sp) 370 .cfi_rel_offset 8, 328 371 sd $a3, 320($sp) 372 .cfi_rel_offset 7, 320 373 sd $a2, 312($sp) 374 .cfi_rel_offset 6, 312 375 sd $a1, 304($sp) 376 .cfi_rel_offset 5, 304 377 sd $a0, 296($sp) 378 .cfi_rel_offset 4, 296 379 sd $v1, 288($sp) 380 .cfi_rel_offset 3, 288 381 sd $v0, 280($sp) 382 .cfi_rel_offset 2, 280 383 384 // Set up $gp, clobbering $ra and using the branch delay slot for a useful instruction. 385 bal 1f 386 .set push 387 .set noat 388 sd $at, 272($sp) 389 .cfi_rel_offset 1, 272 390 .set pop 3911: 392 .cpsetup $ra, 472, 1b 393 394 // Save FP registers. 395 s.d $f31, 264($sp) 396 s.d $f30, 256($sp) 397 s.d $f29, 248($sp) 398 s.d $f28, 240($sp) 399 s.d $f27, 232($sp) 400 s.d $f26, 224($sp) 401 s.d $f25, 216($sp) 402 s.d $f24, 208($sp) 403 s.d $f23, 200($sp) 404 s.d $f22, 192($sp) 405 s.d $f21, 184($sp) 406 s.d $f20, 176($sp) 407 s.d $f19, 168($sp) 408 s.d $f18, 160($sp) 409 s.d $f17, 152($sp) 410 s.d $f16, 144($sp) 411 s.d $f15, 136($sp) 412 s.d $f14, 128($sp) 413 s.d $f13, 120($sp) 414 s.d $f12, 112($sp) 415 s.d $f11, 104($sp) 416 s.d $f10, 96($sp) 417 s.d $f9, 88($sp) 418 s.d $f8, 80($sp) 419 s.d $f7, 72($sp) 420 s.d $f6, 64($sp) 421 s.d $f5, 56($sp) 422 s.d $f4, 48($sp) 423 s.d $f3, 40($sp) 424 s.d $f2, 32($sp) 425 s.d $f1, 24($sp) 426 s.d $f0, 16($sp) 427 428 # load appropriate callee-save-method 429 ld $t1, %got(_ZN3art7Runtime9instance_E)($gp) 430 ld $t1, 0($t1) 431 ld $t1, RUNTIME_SAVE_EVERYTHING_METHOD_OFFSET($t1) 432 sd $t1, 0($sp) # Place ArtMethod* at bottom of stack. 433 # Place sp in Thread::Current()->top_quick_frame. 434 sd $sp, THREAD_TOP_QUICK_FRAME_OFFSET(rSELF) 435.endm 436 437 /* 438 * Macro that sets up the callee save frame to conform with 439 * Runtime::CreateCalleeSaveMethod(kSaveEverything). 440 * callee-save: $at + $v0-$v1 + $a0-$a7 + $t0-$t3 + $s0-$s7 + $t8-$t9 + $gp + $s8 + $ra + $s8, 441 * $f0-$f31; 28(GPR)+ 32(FPR) + 1x8 bytes padding + method* 442 * This macro sets up $gp; entrypoints using it should start with ENTRY_NO_GP. 443 */ 444.macro SETUP_SAVE_EVERYTHING_FRAME 445 daddiu $sp, $sp, -(FRAME_SIZE_SAVE_EVERYTHING) 446 .cfi_adjust_cfa_offset (FRAME_SIZE_SAVE_EVERYTHING) 447 SETUP_SAVE_EVERYTHING_FRAME_DECREMENTED_SP 448.endm 449 450.macro RESTORE_SAVE_EVERYTHING_FRAME 451 // Restore FP registers. 452 l.d $f31, 264($sp) 453 l.d $f30, 256($sp) 454 l.d $f29, 248($sp) 455 l.d $f28, 240($sp) 456 l.d $f27, 232($sp) 457 l.d $f26, 224($sp) 458 l.d $f25, 216($sp) 459 l.d $f24, 208($sp) 460 l.d $f23, 200($sp) 461 l.d $f22, 192($sp) 462 l.d $f21, 184($sp) 463 l.d $f20, 176($sp) 464 l.d $f19, 168($sp) 465 l.d $f18, 160($sp) 466 l.d $f17, 152($sp) 467 l.d $f16, 144($sp) 468 l.d $f15, 136($sp) 469 l.d $f14, 128($sp) 470 l.d $f13, 120($sp) 471 l.d $f12, 112($sp) 472 l.d $f11, 104($sp) 473 l.d $f10, 96($sp) 474 l.d $f9, 88($sp) 475 l.d $f8, 80($sp) 476 l.d $f7, 72($sp) 477 l.d $f6, 64($sp) 478 l.d $f5, 56($sp) 479 l.d $f4, 48($sp) 480 l.d $f3, 40($sp) 481 l.d $f2, 32($sp) 482 l.d $f1, 24($sp) 483 l.d $f0, 16($sp) 484 485 // Restore core registers. 486 .cpreturn 487 ld $ra, 488($sp) 488 .cfi_restore 31 489 ld $s8, 480($sp) 490 .cfi_restore 30 491 ld $t9, 464($sp) 492 .cfi_restore 25 493 ld $t8, 456($sp) 494 .cfi_restore 24 495 ld $s7, 448($sp) 496 .cfi_restore 23 497 ld $s6, 440($sp) 498 .cfi_restore 22 499 ld $s5, 432($sp) 500 .cfi_restore 21 501 ld $s4, 424($sp) 502 .cfi_restore 20 503 ld $s3, 416($sp) 504 .cfi_restore 19 505 ld $s2, 408($sp) 506 .cfi_restore 18 507 ld $s1, 400($sp) 508 .cfi_restore 17 509 ld $s0, 392($sp) 510 .cfi_restore 16 511 ld $t3, 384($sp) 512 .cfi_restore 15 513 ld $t2, 376($sp) 514 .cfi_restore 14 515 ld $t1, 368($sp) 516 .cfi_restore 13 517 ld $t0, 360($sp) 518 .cfi_restore 12 519 ld $a7, 352($sp) 520 .cfi_restore 11 521 ld $a6, 344($sp) 522 .cfi_restore 10 523 ld $a5, 336($sp) 524 .cfi_restore 9 525 ld $a4, 328($sp) 526 .cfi_restore 8 527 ld $a3, 320($sp) 528 .cfi_restore 7 529 ld $a2, 312($sp) 530 .cfi_restore 6 531 ld $a1, 304($sp) 532 .cfi_restore 5 533 ld $a0, 296($sp) 534 .cfi_restore 4 535 ld $v1, 288($sp) 536 .cfi_restore 3 537 ld $v0, 280($sp) 538 .cfi_restore 2 539 .set push 540 .set noat 541 ld $at, 272($sp) 542 .cfi_restore 1 543 .set pop 544 545 daddiu $sp, $sp, 496 546 .cfi_adjust_cfa_offset -496 547.endm 548 549 /* 550 * Macro that set calls through to artDeliverPendingExceptionFromCode, 551 * where the pending 552 * exception is Thread::Current()->exception_ 553 */ 554.macro DELIVER_PENDING_EXCEPTION 555 SETUP_GP 556 SETUP_SAVE_ALL_CALLEE_SAVES_FRAME # save callee saves for throw 557 dla $t9, artDeliverPendingExceptionFromCode 558 jalr $zero, $t9 # artDeliverPendingExceptionFromCode(Thread*) 559 move $a0, rSELF # pass Thread::Current 560.endm 561 562.macro RETURN_IF_NO_EXCEPTION 563 ld $t0, THREAD_EXCEPTION_OFFSET(rSELF) # load Thread::Current()->exception_ 564 RESTORE_SAVE_REFS_ONLY_FRAME 565 bne $t0, $zero, 1f # success if no exception is pending 566 nop 567 jalr $zero, $ra 568 nop 5691: 570 DELIVER_PENDING_EXCEPTION 571.endm 572 573.macro RETURN_IF_ZERO 574 RESTORE_SAVE_REFS_ONLY_FRAME 575 bne $v0, $zero, 1f # success? 576 nop 577 jalr $zero, $ra # return on success 578 nop 5791: 580 DELIVER_PENDING_EXCEPTION 581.endm 582 583.macro RETURN_IF_RESULT_IS_NON_ZERO_OR_DELIVER 584 RESTORE_SAVE_REFS_ONLY_FRAME 585 beq $v0, $zero, 1f # success? 586 nop 587 jalr $zero, $ra # return on success 588 nop 5891: 590 DELIVER_PENDING_EXCEPTION 591.endm 592 593 /* 594 * On stack replacement stub. 595 * On entry: 596 * a0 = stack to copy 597 * a1 = size of stack 598 * a2 = pc to call 599 * a3 = JValue* result 600 * a4 = shorty 601 * a5 = thread 602 */ 603ENTRY art_quick_osr_stub 604 move $t0, $sp # save stack pointer 605 daddiu $t1, $sp, -112 # reserve stack space 606 dsrl $t1, $t1, 4 # enforce 16 byte stack alignment 607 dsll $sp, $t1, 4 # update stack pointer 608 609 // Save callee general purpose registers, SP, T8(GP), RA, A3, and A4 (8x14 bytes) 610 sd $ra, 104($sp) 611 .cfi_rel_offset 31, 104 612 sd $s8, 96($sp) 613 .cfi_rel_offset 30, 96 614 sd $t0, 88($sp) # save original stack pointer stored in t0 615 .cfi_rel_offset 29, 88 616 sd $t8, 80($sp) # t8 holds caller's gp, now save it to the stack. 617 .cfi_rel_offset 28, 80 # Value from gp is pushed, so set the cfi offset accordingly. 618 sd $s7, 72($sp) 619 .cfi_rel_offset 23, 72 620 sd $s6, 64($sp) 621 .cfi_rel_offset 22, 64 622 sd $s5, 56($sp) 623 .cfi_rel_offset 21, 56 624 sd $s4, 48($sp) 625 .cfi_rel_offset 20, 48 626 sd $s3, 40($sp) 627 .cfi_rel_offset 19, 40 628 sd $s2, 32($sp) 629 .cfi_rel_offset 18, 32 630 sd $s1, 24($sp) 631 .cfi_rel_offset 17, 24 632 sd $s0, 16($sp) 633 .cfi_rel_offset 16, 16 634 sd $a4, 8($sp) 635 .cfi_rel_offset 8, 8 636 sd $a3, 0($sp) 637 .cfi_rel_offset 7, 0 638 move rSELF, $a5 # Save managed thread pointer into rSELF 639 640 daddiu $sp, $sp, -16 641 jal .Losr_entry 642 sd $zero, 0($sp) # Store null for ArtMethod* at bottom of frame 643 daddiu $sp, $sp, 16 644 645 // Restore return value address and shorty address 646 ld $a4, 8($sp) # shorty address 647 .cfi_restore 8 648 ld $a3, 0($sp) # result value address 649 .cfi_restore 7 650 651 lbu $t1, 0($a4) # load return type 652 li $t2, 'D' # put char 'D' into t2 653 beq $t1, $t2, .Losr_fp_result # branch if result type char == 'D' 654 li $t2, 'F' # put char 'F' into t2 655 beq $t1, $t2, .Losr_fp_result # branch if result type char == 'F' 656 nop 657 b .Losr_exit 658 dsrl $v1, $v0, 32 # put high half of result in v1 659.Losr_fp_result: 660 mfc1 $v0, $f0 661 mfhc1 $v1, $f0 # put high half of FP result in v1 662.Losr_exit: 663 sw $v0, 0($a3) # store low half of result 664 sw $v1, 4($a3) # store high half of result 665 666 // Restore callee registers 667 ld $ra, 104($sp) 668 .cfi_restore 31 669 ld $s8, 96($sp) 670 .cfi_restore 30 671 ld $t0, 88($sp) # save SP into t0 for now 672 .cfi_restore 29 673 ld $t8, 80($sp) # Restore gp back to it's temp storage. 674 .cfi_restore 28 675 ld $s7, 72($sp) 676 .cfi_restore 23 677 ld $s6, 64($sp) 678 .cfi_restore 22 679 ld $s5, 56($sp) 680 .cfi_restore 21 681 ld $s4, 48($sp) 682 .cfi_restore 20 683 ld $s3, 40($sp) 684 .cfi_restore 19 685 ld $s2, 32($sp) 686 .cfi_restore 18 687 ld $s1, 24($sp) 688 .cfi_restore 17 689 ld $s0, 16($sp) 690 .cfi_restore 16 691 jalr $zero, $ra 692 move $sp, $t0 693 694.Losr_entry: 695 dsubu $sp, $sp, $a1 # Reserve space for callee stack 696 daddiu $a1, $a1, -8 697 daddu $t0, $a1, $sp 698 sw $ra, 0($t0) # Store low half of RA per compiler ABI 699 dsrl $t1, $ra, 32 700 sw $t1, 4($t0) # Store high half of RA per compiler ABI 701 702 // Copy arguments into callee stack 703 // Use simple copy routine for now. 704 // 4 bytes per slot. 705 // a0 = source address 706 // a1 = args length in bytes (does not include 8 bytes for RA) 707 // sp = destination address 708 beqz $a1, .Losr_loop_exit 709 daddiu $a1, $a1, -4 710 daddu $t1, $a0, $a1 711 daddu $t2, $sp, $a1 712.Losr_loop_entry: 713 lw $t0, 0($t1) 714 daddiu $t1, $t1, -4 715 sw $t0, 0($t2) 716 bne $sp, $t2, .Losr_loop_entry 717 daddiu $t2, $t2, -4 718 719.Losr_loop_exit: 720 move $t9, $a2 721 jalr $zero, $t9 # Jump to the OSR entry point. 722 nop 723END art_quick_osr_stub 724 725 /* 726 * On entry $a0 is uint32_t* gprs_ and $a1 is uint32_t* fprs_ 727 * FIXME: just guessing about the shape of the jmpbuf. Where will pc be? 728 */ 729ENTRY_NO_GP art_quick_do_long_jump 730 l.d $f0, 0($a1) 731 l.d $f1, 8($a1) 732 l.d $f2, 16($a1) 733 l.d $f3, 24($a1) 734 l.d $f4, 32($a1) 735 l.d $f5, 40($a1) 736 l.d $f6, 48($a1) 737 l.d $f7, 56($a1) 738 l.d $f8, 64($a1) 739 l.d $f9, 72($a1) 740 l.d $f10, 80($a1) 741 l.d $f11, 88($a1) 742 l.d $f12, 96($a1) 743 l.d $f13, 104($a1) 744 l.d $f14, 112($a1) 745 l.d $f15, 120($a1) 746 l.d $f16, 128($a1) 747 l.d $f17, 136($a1) 748 l.d $f18, 144($a1) 749 l.d $f19, 152($a1) 750 l.d $f20, 160($a1) 751 l.d $f21, 168($a1) 752 l.d $f22, 176($a1) 753 l.d $f23, 184($a1) 754 l.d $f24, 192($a1) 755 l.d $f25, 200($a1) 756 l.d $f26, 208($a1) 757 l.d $f27, 216($a1) 758 l.d $f28, 224($a1) 759 l.d $f29, 232($a1) 760 l.d $f30, 240($a1) 761 l.d $f31, 248($a1) 762 .set push 763 .set nomacro 764 .set noat 765# no need to load zero 766 ld $at, 8($a0) 767 .set pop 768 ld $v0, 16($a0) 769 ld $v1, 24($a0) 770# a0 has to be loaded last 771 ld $a1, 40($a0) 772 ld $a2, 48($a0) 773 ld $a3, 56($a0) 774 ld $a4, 64($a0) 775 ld $a5, 72($a0) 776 ld $a6, 80($a0) 777 ld $a7, 88($a0) 778 ld $t0, 96($a0) 779 ld $t1, 104($a0) 780 ld $t2, 112($a0) 781 ld $t3, 120($a0) 782 ld $s0, 128($a0) 783 ld $s1, 136($a0) 784 ld $s2, 144($a0) 785 ld $s3, 152($a0) 786 ld $s4, 160($a0) 787 ld $s5, 168($a0) 788 ld $s6, 176($a0) 789 ld $s7, 184($a0) 790 ld $t8, 192($a0) 791 ld $t9, 200($a0) 792# no need to load k0, k1 793 ld $gp, 224($a0) 794 ld $sp, 232($a0) 795 ld $s8, 240($a0) 796 ld $ra, 248($a0) 797 ld $a0, 32($a0) 798 move $v0, $zero # clear result registers v0 and v1 799 jalr $zero, $t9 # do long jump (do not use ra, it must not be clobbered) 800 move $v1, $zero 801END art_quick_do_long_jump 802 803 /* 804 * Called by managed code, saves most registers (forms basis of long jump 805 * context) and passes the bottom of the stack. 806 * artDeliverExceptionFromCode will place the callee save Method* at 807 * the bottom of the thread. On entry a0 holds Throwable* 808 */ 809ENTRY art_quick_deliver_exception 810 SETUP_SAVE_ALL_CALLEE_SAVES_FRAME 811 dla $t9, artDeliverExceptionFromCode 812 jalr $zero, $t9 # artDeliverExceptionFromCode(Throwable*, Thread*) 813 move $a1, rSELF # pass Thread::Current 814END art_quick_deliver_exception 815 816 /* 817 * Called by managed code to create and deliver a NullPointerException 818 */ 819 .extern artThrowNullPointerExceptionFromCode 820ENTRY_NO_GP art_quick_throw_null_pointer_exception 821 // Note that setting up $gp does not rely on $t9 here, so branching here directly is OK, 822 // even after clobbering any registers we don't need to preserve, such as $gp or $t0. 823 SETUP_SAVE_EVERYTHING_FRAME 824 dla $t9, artThrowNullPointerExceptionFromCode 825 jalr $zero, $t9 # artThrowNullPointerExceptionFromCode(Thread*) 826 move $a0, rSELF # pass Thread::Current 827END art_quick_throw_null_pointer_exception 828 829 /* 830 * Call installed by a signal handler to create and deliver a NullPointerException 831 */ 832 .extern artThrowNullPointerExceptionFromSignal 833ENTRY_NO_GP_CUSTOM_CFA art_quick_throw_null_pointer_exception_from_signal, FRAME_SIZE_SAVE_EVERYTHING 834 SETUP_SAVE_EVERYTHING_FRAME_DECREMENTED_SP 835 # Retrieve the fault address from the padding where the signal handler stores it. 836 ld $a0, (__SIZEOF_POINTER__)($sp) 837 dla $t9, artThrowNullPointerExceptionFromSignal 838 jalr $zero, $t9 # artThrowNullPointerExceptionFromSignal(uinptr_t, Thread*) 839 move $a1, rSELF # pass Thread::Current 840END art_quick_throw_null_pointer_exception 841 842 /* 843 * Called by managed code to create and deliver an ArithmeticException 844 */ 845 .extern artThrowDivZeroFromCode 846ENTRY_NO_GP art_quick_throw_div_zero 847 SETUP_SAVE_EVERYTHING_FRAME 848 dla $t9, artThrowDivZeroFromCode 849 jalr $zero, $t9 # artThrowDivZeroFromCode(Thread*) 850 move $a0, rSELF # pass Thread::Current 851END art_quick_throw_div_zero 852 853 /* 854 * Called by managed code to create and deliver an 855 * ArrayIndexOutOfBoundsException 856 */ 857 .extern artThrowArrayBoundsFromCode 858ENTRY_NO_GP art_quick_throw_array_bounds 859 // Note that setting up $gp does not rely on $t9 here, so branching here directly is OK, 860 // even after clobbering any registers we don't need to preserve, such as $gp or $t0. 861 SETUP_SAVE_EVERYTHING_FRAME 862 dla $t9, artThrowArrayBoundsFromCode 863 jalr $zero, $t9 # artThrowArrayBoundsFromCode(index, limit, Thread*) 864 move $a2, rSELF # pass Thread::Current 865END art_quick_throw_array_bounds 866 867 /* 868 * Called by managed code to create and deliver a StringIndexOutOfBoundsException 869 * as if thrown from a call to String.charAt(). 870 */ 871 .extern artThrowStringBoundsFromCode 872ENTRY_NO_GP art_quick_throw_string_bounds 873 SETUP_SAVE_EVERYTHING_FRAME 874 dla $t9, artThrowStringBoundsFromCode 875 jalr $zero, $t9 # artThrowStringBoundsFromCode(index, limit, Thread*) 876 move $a2, rSELF # pass Thread::Current 877END art_quick_throw_string_bounds 878 879 /* 880 * Called by managed code to create and deliver a StackOverflowError. 881 */ 882 .extern artThrowStackOverflowFromCode 883ENTRY art_quick_throw_stack_overflow 884 SETUP_SAVE_ALL_CALLEE_SAVES_FRAME 885 dla $t9, artThrowStackOverflowFromCode 886 jalr $zero, $t9 # artThrowStackOverflowFromCode(Thread*) 887 move $a0, rSELF # pass Thread::Current 888END art_quick_throw_stack_overflow 889 890 /* 891 * All generated callsites for interface invokes and invocation slow paths will load arguments 892 * as usual - except instead of loading arg0/$a0 with the target Method*, arg0/$a0 will contain 893 * the method_idx. This wrapper will save arg1-arg3, load the caller's Method*, align the 894 * stack and call the appropriate C helper. 895 * NOTE: "this" is first visable argument of the target, and so can be found in arg1/$a1. 896 * 897 * The helper will attempt to locate the target and return a 128-bit result in $v0/$v1 consisting 898 * of the target Method* in $v0 and method->code_ in $v1. 899 * 900 * If unsuccessful, the helper will return null/null. There will be a pending exception in the 901 * thread and we branch to another stub to deliver it. 902 * 903 * On success this wrapper will restore arguments and *jump* to the target, leaving the ra 904 * pointing back to the original caller. 905 */ 906.macro INVOKE_TRAMPOLINE_BODY cxx_name 907 .extern \cxx_name 908 SETUP_SAVE_REFS_AND_ARGS_FRAME # save callee saves in case allocation triggers GC 909 move $a2, rSELF # pass Thread::Current 910 jal \cxx_name # (method_idx, this, Thread*, $sp) 911 move $a3, $sp # pass $sp 912 move $a0, $v0 # save target Method* 913 move $t9, $v1 # save $v0->code_ 914 RESTORE_SAVE_REFS_AND_ARGS_FRAME 915 beq $v0, $zero, 1f 916 nop 917 jalr $zero, $t9 918 nop 9191: 920 DELIVER_PENDING_EXCEPTION 921.endm 922.macro INVOKE_TRAMPOLINE c_name, cxx_name 923ENTRY \c_name 924 INVOKE_TRAMPOLINE_BODY \cxx_name 925END \c_name 926.endm 927 928INVOKE_TRAMPOLINE art_quick_invoke_interface_trampoline_with_access_check, artInvokeInterfaceTrampolineWithAccessCheck 929 930INVOKE_TRAMPOLINE art_quick_invoke_static_trampoline_with_access_check, artInvokeStaticTrampolineWithAccessCheck 931INVOKE_TRAMPOLINE art_quick_invoke_direct_trampoline_with_access_check, artInvokeDirectTrampolineWithAccessCheck 932INVOKE_TRAMPOLINE art_quick_invoke_super_trampoline_with_access_check, artInvokeSuperTrampolineWithAccessCheck 933INVOKE_TRAMPOLINE art_quick_invoke_virtual_trampoline_with_access_check, artInvokeVirtualTrampolineWithAccessCheck 934 935 # On entry: 936 # t0 = shorty 937 # t1 = ptr to arg_array 938 # t2 = number of argument bytes remain 939 # v0 = ptr to stack frame where to copy arg_array 940 # This macro modifies t3, t9 and v0 941.macro LOOP_OVER_SHORTY_LOADING_REG gpu, fpu, label 942 lbu $t3, 0($t0) # get argument type from shorty 943 beqz $t3, \label 944 daddiu $t0, 1 945 li $t9, 68 # put char 'D' into t9 946 beq $t9, $t3, 1f # branch if result type char == 'D' 947 li $t9, 70 # put char 'F' into t9 948 beq $t9, $t3, 2f # branch if result type char == 'F' 949 li $t9, 74 # put char 'J' into t9 950 beq $t9, $t3, 3f # branch if result type char == 'J' 951 nop 952 lw $\gpu, 0($t1) 953 sw $\gpu, 0($v0) 954 daddiu $v0, 4 955 daddiu $t1, 4 956 b 4f 957 daddiu $t2, -4 # delay slot 958 9591: # found double 960 lwu $t3, 0($t1) 961 mtc1 $t3, $\fpu 962 sw $t3, 0($v0) 963 lwu $t3, 4($t1) 964 mthc1 $t3, $\fpu 965 sw $t3, 4($v0) 966 daddiu $v0, 8 967 daddiu $t1, 8 968 b 4f 969 daddiu $t2, -8 # delay slot 970 9712: # found float 972 lwu $t3, 0($t1) 973 mtc1 $t3, $\fpu 974 sw $t3, 0($v0) 975 daddiu $v0, 4 976 daddiu $t1, 4 977 b 4f 978 daddiu $t2, -4 # delay slot 979 9803: # found long (8 bytes) 981 lwu $t3, 0($t1) 982 sw $t3, 0($v0) 983 lwu $t9, 4($t1) 984 sw $t9, 4($v0) 985 dsll $t9, $t9, 32 986 or $\gpu, $t9, $t3 987 daddiu $v0, 8 988 daddiu $t1, 8 989 daddiu $t2, -8 9904: 991.endm 992 993 /* 994 * Invocation stub for quick code. 995 * On entry: 996 * a0 = method pointer 997 * a1 = argument array that must at least contain the this ptr. 998 * a2 = size of argument array in bytes 999 * a3 = (managed) thread pointer 1000 * a4 = JValue* result 1001 * a5 = shorty 1002 */ 1003ENTRY_NO_GP art_quick_invoke_stub 1004 # push a4, a5, s0(rSUSPEND), s1(rSELF), s8, ra onto the stack 1005 daddiu $sp, $sp, -48 1006 .cfi_adjust_cfa_offset 48 1007 sd $ra, 40($sp) 1008 .cfi_rel_offset 31, 40 1009 sd $s8, 32($sp) 1010 .cfi_rel_offset 30, 32 1011 sd $s1, 24($sp) 1012 .cfi_rel_offset 17, 24 1013 sd $s0, 16($sp) 1014 .cfi_rel_offset 16, 16 1015 sd $a5, 8($sp) 1016 .cfi_rel_offset 9, 8 1017 sd $a4, 0($sp) 1018 .cfi_rel_offset 8, 0 1019 1020 daddiu $s0, $zero, SUSPEND_CHECK_INTERVAL # reset rSUSPEND to SUSPEND_CHECK_INTERVAL 1021 move $s1, $a3 # move managed thread pointer into s1 (rSELF) 1022 move $s8, $sp # save sp in s8 (fp) 1023 1024 daddiu $t3, $a2, 24 # add 8 for ArtMethod* and 16 for stack alignment 1025 dsrl $t3, $t3, 4 # shift the frame size right 4 1026 dsll $t3, $t3, 4 # shift the frame size left 4 to align to 16 bytes 1027 dsubu $sp, $sp, $t3 # reserve stack space for argument array 1028 1029 daddiu $t0, $a5, 1 # t0 = shorty[1] (skip 1 for return type) 1030 daddiu $t1, $a1, 4 # t1 = ptr to arg_array[4] (skip this ptr) 1031 daddiu $t2, $a2, -4 # t2 = number of argument bytes remain (skip this ptr) 1032 daddiu $v0, $sp, 12 # v0 points to where to copy arg_array 1033 LOOP_OVER_SHORTY_LOADING_REG a2, f14, call_fn 1034 LOOP_OVER_SHORTY_LOADING_REG a3, f15, call_fn 1035 LOOP_OVER_SHORTY_LOADING_REG a4, f16, call_fn 1036 LOOP_OVER_SHORTY_LOADING_REG a5, f17, call_fn 1037 LOOP_OVER_SHORTY_LOADING_REG a6, f18, call_fn 1038 LOOP_OVER_SHORTY_LOADING_REG a7, f19, call_fn 1039 1040 # copy arguments onto stack (t2 should be multiples of 4) 1041 ble $t2, $zero, call_fn # t2 = number of argument bytes remain 10421: 1043 lw $t3, 0($t1) # load from argument array 1044 daddiu $t1, $t1, 4 1045 sw $t3, 0($v0) # save to stack 1046 daddiu $t2, -4 1047 bgt $t2, $zero, 1b # t2 = number of argument bytes remain 1048 daddiu $v0, $v0, 4 1049 1050call_fn: 1051 # call method (a0 and a1 have been untouched) 1052 lwu $a1, 0($a1) # make a1 = this ptr 1053 sw $a1, 8($sp) # copy this ptr (skip 8 bytes for ArtMethod*) 1054 sd $zero, 0($sp) # store null for ArtMethod* at bottom of frame 1055 ld $t9, ART_METHOD_QUICK_CODE_OFFSET_64($a0) # get pointer to the code 1056 jalr $t9 # call the method 1057 nop 1058 move $sp, $s8 # restore sp 1059 1060 # pop a4, a5, s1(rSELF), s8, ra off of the stack 1061 ld $a4, 0($sp) 1062 .cfi_restore 8 1063 ld $a5, 8($sp) 1064 .cfi_restore 9 1065 ld $s0, 16($sp) 1066 .cfi_restore 16 1067 ld $s1, 24($sp) 1068 .cfi_restore 17 1069 ld $s8, 32($sp) 1070 .cfi_restore 30 1071 ld $ra, 40($sp) 1072 .cfi_restore 31 1073 daddiu $sp, $sp, 48 1074 .cfi_adjust_cfa_offset -48 1075 1076 # a4 = JValue* result 1077 # a5 = shorty string 1078 lbu $t1, 0($a5) # get result type from shorty 1079 li $t2, 68 # put char 'D' into t2 1080 beq $t1, $t2, 1f # branch if result type char == 'D' 1081 li $t3, 70 # put char 'F' into t3 1082 beq $t1, $t3, 1f # branch if result type char == 'F' 1083 sw $v0, 0($a4) # store the result 1084 dsrl $v1, $v0, 32 1085 jalr $zero, $ra 1086 sw $v1, 4($a4) # store the other half of the result 10871: 1088 mfc1 $v0, $f0 1089 mfhc1 $v1, $f0 1090 sw $v0, 0($a4) # store the result 1091 jalr $zero, $ra 1092 sw $v1, 4($a4) # store the other half of the result 1093END art_quick_invoke_stub 1094 1095 /* 1096 * Invocation static stub for quick code. 1097 * On entry: 1098 * a0 = method pointer 1099 * a1 = argument array that must at least contain the this ptr. 1100 * a2 = size of argument array in bytes 1101 * a3 = (managed) thread pointer 1102 * a4 = JValue* result 1103 * a5 = shorty 1104 */ 1105ENTRY_NO_GP art_quick_invoke_static_stub 1106 1107 # push a4, a5, s0(rSUSPEND), s1(rSELF), s8, ra, onto the stack 1108 daddiu $sp, $sp, -48 1109 .cfi_adjust_cfa_offset 48 1110 sd $ra, 40($sp) 1111 .cfi_rel_offset 31, 40 1112 sd $s8, 32($sp) 1113 .cfi_rel_offset 30, 32 1114 sd $s1, 24($sp) 1115 .cfi_rel_offset 17, 24 1116 sd $s0, 16($sp) 1117 .cfi_rel_offset 16, 16 1118 sd $a5, 8($sp) 1119 .cfi_rel_offset 9, 8 1120 sd $a4, 0($sp) 1121 .cfi_rel_offset 8, 0 1122 1123 daddiu $s0, $zero, SUSPEND_CHECK_INTERVAL # reset rSUSPEND to SUSPEND_CHECK_INTERVAL 1124 move $s1, $a3 # move managed thread pointer into s1 (rSELF) 1125 move $s8, $sp # save sp in s8 (fp) 1126 1127 daddiu $t3, $a2, 24 # add 8 for ArtMethod* and 16 for stack alignment 1128 dsrl $t3, $t3, 4 # shift the frame size right 4 1129 dsll $t3, $t3, 4 # shift the frame size left 4 to align to 16 bytes 1130 dsubu $sp, $sp, $t3 # reserve stack space for argument array 1131 1132 daddiu $t0, $a5, 1 # t0 = shorty[1] (skip 1 for return type) 1133 move $t1, $a1 # t1 = arg_array 1134 move $t2, $a2 # t2 = number of argument bytes remain 1135 daddiu $v0, $sp, 8 # v0 points to where to copy arg_array 1136 LOOP_OVER_SHORTY_LOADING_REG a1, f13, call_sfn 1137 LOOP_OVER_SHORTY_LOADING_REG a2, f14, call_sfn 1138 LOOP_OVER_SHORTY_LOADING_REG a3, f15, call_sfn 1139 LOOP_OVER_SHORTY_LOADING_REG a4, f16, call_sfn 1140 LOOP_OVER_SHORTY_LOADING_REG a5, f17, call_sfn 1141 LOOP_OVER_SHORTY_LOADING_REG a6, f18, call_sfn 1142 LOOP_OVER_SHORTY_LOADING_REG a7, f19, call_sfn 1143 1144 # copy arguments onto stack (t2 should be multiples of 4) 1145 ble $t2, $zero, call_sfn # t2 = number of argument bytes remain 11461: 1147 lw $t3, 0($t1) # load from argument array 1148 daddiu $t1, $t1, 4 1149 sw $t3, 0($v0) # save to stack 1150 daddiu $t2, -4 1151 bgt $t2, $zero, 1b # t2 = number of argument bytes remain 1152 daddiu $v0, $v0, 4 1153 1154call_sfn: 1155 # call method (a0 has been untouched) 1156 sd $zero, 0($sp) # store null for ArtMethod* at bottom of frame 1157 ld $t9, ART_METHOD_QUICK_CODE_OFFSET_64($a0) # get pointer to the code 1158 jalr $t9 # call the method 1159 nop 1160 move $sp, $s8 # restore sp 1161 1162 # pop a4, a5, s0(rSUSPEND), s1(rSELF), s8, ra off of the stack 1163 ld $a4, 0($sp) 1164 .cfi_restore 8 1165 ld $a5, 8($sp) 1166 .cfi_restore 9 1167 ld $s0, 16($sp) 1168 .cfi_restore 16 1169 ld $s1, 24($sp) 1170 .cfi_restore 17 1171 ld $s8, 32($sp) 1172 .cfi_restore 30 1173 ld $ra, 40($sp) 1174 .cfi_restore 31 1175 daddiu $sp, $sp, 48 1176 .cfi_adjust_cfa_offset -48 1177 1178 # a4 = JValue* result 1179 # a5 = shorty string 1180 lbu $t1, 0($a5) # get result type from shorty 1181 li $t2, 68 # put char 'D' into t2 1182 beq $t1, $t2, 1f # branch if result type char == 'D' 1183 li $t3, 70 # put char 'F' into t3 1184 beq $t1, $t3, 1f # branch if result type char == 'F' 1185 sw $v0, 0($a4) # store the result 1186 dsrl $v1, $v0, 32 1187 jalr $zero, $ra 1188 sw $v1, 4($a4) # store the other half of the result 11891: 1190 mfc1 $v0, $f0 1191 mfhc1 $v1, $f0 1192 sw $v0, 0($a4) # store the result 1193 jalr $zero, $ra 1194 sw $v1, 4($a4) # store the other half of the result 1195END art_quick_invoke_static_stub 1196 1197 /* 1198 * Entry from managed code that calls artHandleFillArrayDataFromCode and 1199 * delivers exception on failure. 1200 */ 1201 .extern artHandleFillArrayDataFromCode 1202ENTRY art_quick_handle_fill_data 1203 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case exception allocation triggers GC 1204 ld $a2, FRAME_SIZE_SAVE_REFS_ONLY($sp) # pass referrer's Method* 1205 jal artHandleFillArrayDataFromCode # (payload offset, Array*, method, Thread*) 1206 move $a3, rSELF # pass Thread::Current 1207 RETURN_IF_ZERO 1208END art_quick_handle_fill_data 1209 1210 /* 1211 * Entry from managed code that calls artLockObjectFromCode, may block for GC. 1212 */ 1213 .extern artLockObjectFromCode 1214ENTRY_NO_GP art_quick_lock_object 1215 beq $a0, $zero, art_quick_throw_null_pointer_exception 1216 nop 1217 .cpsetup $t9, $t8, art_quick_lock_object 1218 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case we block 1219 jal artLockObjectFromCode # (Object* obj, Thread*) 1220 move $a1, rSELF # pass Thread::Current 1221 RETURN_IF_ZERO 1222END art_quick_lock_object 1223 1224ENTRY_NO_GP art_quick_lock_object_no_inline 1225 beq $a0, $zero, art_quick_throw_null_pointer_exception 1226 nop 1227 .cpsetup $t9, $t8, art_quick_lock_object_no_inline 1228 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case we block 1229 jal artLockObjectFromCode # (Object* obj, Thread*) 1230 move $a1, rSELF # pass Thread::Current 1231 RETURN_IF_ZERO 1232END art_quick_lock_object_no_inline 1233 1234 /* 1235 * Entry from managed code that calls artUnlockObjectFromCode and delivers exception on failure. 1236 */ 1237 .extern artUnlockObjectFromCode 1238ENTRY_NO_GP art_quick_unlock_object 1239 beq $a0, $zero, art_quick_throw_null_pointer_exception 1240 nop 1241 .cpsetup $t9, $t8, art_quick_unlock_object 1242 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case exception allocation triggers GC 1243 jal artUnlockObjectFromCode # (Object* obj, Thread*) 1244 move $a1, rSELF # pass Thread::Current 1245 RETURN_IF_ZERO 1246END art_quick_unlock_object 1247 1248ENTRY_NO_GP art_quick_unlock_object_no_inline 1249 beq $a0, $zero, art_quick_throw_null_pointer_exception 1250 nop 1251 .cpsetup $t9, $t8, art_quick_unlock_object_no_inline 1252 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case exception allocation triggers GC 1253 jal artUnlockObjectFromCode # (Object* obj, Thread*) 1254 move $a1, rSELF # pass Thread::Current 1255 RETURN_IF_ZERO 1256END art_quick_unlock_object_no_inline 1257 1258 /* 1259 * Entry from managed code that calls artInstanceOfFromCode and delivers exception on failure. 1260 */ 1261 .extern artInstanceOfFromCode 1262 .extern artThrowClassCastExceptionForObject 1263ENTRY art_quick_check_instance_of 1264 daddiu $sp, $sp, -32 1265 .cfi_adjust_cfa_offset 32 1266 sd $ra, 24($sp) 1267 .cfi_rel_offset 31, 24 1268 sd $t9, 16($sp) 1269 sd $a1, 8($sp) 1270 sd $a0, 0($sp) 1271 jal artInstanceOfFromCode 1272 .cpreturn # Restore gp from t8 in branch delay slot. 1273 # t8 may be clobbered in artIsAssignableFromCode. 1274 beq $v0, $zero, .Lthrow_class_cast_exception 1275 ld $ra, 24($sp) 1276 jalr $zero, $ra 1277 daddiu $sp, $sp, 32 1278 .cfi_adjust_cfa_offset -32 1279.Lthrow_class_cast_exception: 1280 ld $t9, 16($sp) 1281 ld $a1, 8($sp) 1282 ld $a0, 0($sp) 1283 daddiu $sp, $sp, 32 1284 .cfi_adjust_cfa_offset -32 1285 SETUP_GP 1286 SETUP_SAVE_ALL_CALLEE_SAVES_FRAME 1287 dla $t9, artThrowClassCastExceptionForObject 1288 jalr $zero, $t9 # artThrowClassCastException (Object*, Class*, Thread*) 1289 move $a2, rSELF # pass Thread::Current 1290END art_quick_check_instance_of 1291 1292 1293 /* 1294 * Restore rReg's value from offset($sp) if rReg is not the same as rExclude. 1295 * nReg is the register number for rReg. 1296 */ 1297.macro POP_REG_NE rReg, nReg, offset, rExclude 1298 .ifnc \rReg, \rExclude 1299 ld \rReg, \offset($sp) # restore rReg 1300 .cfi_restore \nReg 1301 .endif 1302.endm 1303 1304 /* 1305 * Macro to insert read barrier, only used in art_quick_aput_obj. 1306 * rObj and rDest are registers, offset is a defined literal such as MIRROR_OBJECT_CLASS_OFFSET. 1307 * TODO: When read barrier has a fast path, add heap unpoisoning support for the fast path. 1308 */ 1309.macro READ_BARRIER rDest, rObj, offset 1310#ifdef USE_READ_BARRIER 1311 # saved registers used in art_quick_aput_obj: a0-a2, t0-t1, t9, ra. 16B-aligned. 1312 daddiu $sp, $sp, -64 1313 .cfi_adjust_cfa_offset 64 1314 sd $ra, 56($sp) 1315 .cfi_rel_offset 31, 56 1316 sd $t9, 48($sp) 1317 .cfi_rel_offset 25, 48 1318 sd $t1, 40($sp) 1319 .cfi_rel_offset 13, 40 1320 sd $t0, 32($sp) 1321 .cfi_rel_offset 12, 32 1322 sd $a2, 16($sp) # padding slot at offset 24 (padding can be any slot in the 64B) 1323 .cfi_rel_offset 6, 16 1324 sd $a1, 8($sp) 1325 .cfi_rel_offset 5, 8 1326 sd $a0, 0($sp) 1327 .cfi_rel_offset 4, 0 1328 1329 # move $a0, \rRef # pass ref in a0 (no-op for now since parameter ref is unused) 1330 .ifnc \rObj, $a1 1331 move $a1, \rObj # pass rObj 1332 .endif 1333 daddiu $a2, $zero, \offset # pass offset 1334 jal artReadBarrierSlow # artReadBarrierSlow(ref, rObj, offset) 1335 .cpreturn # Restore gp from t8 in branch delay slot. 1336 # t8 may be clobbered in artReadBarrierSlow. 1337 # No need to unpoison return value in v0, artReadBarrierSlow() would do the unpoisoning. 1338 move \rDest, $v0 # save return value in rDest 1339 # (rDest cannot be v0 in art_quick_aput_obj) 1340 1341 ld $a0, 0($sp) # restore registers except rDest 1342 # (rDest can only be t0 or t1 in art_quick_aput_obj) 1343 .cfi_restore 4 1344 ld $a1, 8($sp) 1345 .cfi_restore 5 1346 ld $a2, 16($sp) 1347 .cfi_restore 6 1348 POP_REG_NE $t0, 12, 32, \rDest 1349 POP_REG_NE $t1, 13, 40, \rDest 1350 ld $t9, 48($sp) 1351 .cfi_restore 25 1352 ld $ra, 56($sp) # restore $ra 1353 .cfi_restore 31 1354 daddiu $sp, $sp, 64 1355 .cfi_adjust_cfa_offset -64 1356 SETUP_GP # set up gp because we are not returning 1357#else 1358 lwu \rDest, \offset(\rObj) 1359 UNPOISON_HEAP_REF \rDest 1360#endif // USE_READ_BARRIER 1361.endm 1362 1363ENTRY art_quick_aput_obj 1364 beq $a2, $zero, .Ldo_aput_null 1365 nop 1366 READ_BARRIER $t0, $a0, MIRROR_OBJECT_CLASS_OFFSET 1367 READ_BARRIER $t1, $a2, MIRROR_OBJECT_CLASS_OFFSET 1368 READ_BARRIER $t0, $t0, MIRROR_CLASS_COMPONENT_TYPE_OFFSET 1369 bne $t1, $t0, .Lcheck_assignability # value's type == array's component type - trivial assignability 1370 nop 1371.Ldo_aput: 1372 dsll $a1, $a1, 2 1373 daddu $t0, $a0, $a1 1374 POISON_HEAP_REF $a2 1375 sw $a2, MIRROR_OBJECT_ARRAY_DATA_OFFSET($t0) 1376 ld $t0, THREAD_CARD_TABLE_OFFSET(rSELF) 1377 dsrl $t1, $a0, 7 1378 daddu $t1, $t1, $t0 1379 sb $t0, ($t1) 1380 jalr $zero, $ra 1381 .cpreturn # Restore gp from t8 in branch delay slot. 1382.Ldo_aput_null: 1383 dsll $a1, $a1, 2 1384 daddu $t0, $a0, $a1 1385 sw $a2, MIRROR_OBJECT_ARRAY_DATA_OFFSET($t0) 1386 jalr $zero, $ra 1387 .cpreturn # Restore gp from t8 in branch delay slot. 1388.Lcheck_assignability: 1389 daddiu $sp, $sp, -64 1390 .cfi_adjust_cfa_offset 64 1391 sd $ra, 56($sp) 1392 .cfi_rel_offset 31, 56 1393 sd $t9, 24($sp) 1394 sd $a2, 16($sp) 1395 sd $a1, 8($sp) 1396 sd $a0, 0($sp) 1397 move $a1, $t1 1398 move $a0, $t0 1399 jal artIsAssignableFromCode # (Class*, Class*) 1400 .cpreturn # Restore gp from t8 in branch delay slot. 1401 # t8 may be clobbered in artIsAssignableFromCode. 1402 ld $ra, 56($sp) 1403 ld $t9, 24($sp) 1404 ld $a2, 16($sp) 1405 ld $a1, 8($sp) 1406 ld $a0, 0($sp) 1407 daddiu $sp, $sp, 64 1408 .cfi_adjust_cfa_offset -64 1409 SETUP_GP 1410 bne $v0, $zero, .Ldo_aput 1411 nop 1412 SETUP_SAVE_ALL_CALLEE_SAVES_FRAME 1413 move $a1, $a2 1414 dla $t9, artThrowArrayStoreException 1415 jalr $zero, $t9 # artThrowArrayStoreException(Class*, Class*, Thread*) 1416 move $a2, rSELF # pass Thread::Current 1417END art_quick_aput_obj 1418 1419// Macros taking opportunity of code similarities for downcalls. 1420.macro ONE_ARG_REF_DOWNCALL name, entrypoint, return, extend=0 1421 .extern \entrypoint 1422ENTRY \name 1423 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case of GC 1424 dla $t9, \entrypoint 1425 jalr $t9 # (field_idx, Thread*) 1426 move $a1, rSELF # pass Thread::Current 1427 .if \extend 1428 sll $v0, $v0, 0 # sign-extend 32-bit result 1429 .endif 1430 \return # RETURN_IF_NO_EXCEPTION or RETURN_IF_ZERO 1431END \name 1432.endm 1433 1434.macro TWO_ARG_REF_DOWNCALL name, entrypoint, return, extend=0 1435 .extern \entrypoint 1436ENTRY \name 1437 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case of GC 1438 dla $t9, \entrypoint 1439 jalr $t9 # (field_idx, Object*, Thread*) or 1440 # (field_idx, new_val, Thread*) 1441 move $a2, rSELF # pass Thread::Current 1442 .if \extend 1443 sll $v0, $v0, 0 # sign-extend 32-bit result 1444 .endif 1445 \return # RETURN_IF_NO_EXCEPTION or RETURN_IF_ZERO 1446END \name 1447.endm 1448 1449.macro THREE_ARG_REF_DOWNCALL name, entrypoint, return, extend=0 1450 .extern \entrypoint 1451ENTRY \name 1452 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case of GC 1453 dla $t9, \entrypoint 1454 jalr $t9 # (field_idx, Object*, new_val, Thread*) 1455 move $a3, rSELF # pass Thread::Current 1456 .if \extend 1457 sll $v0, $v0, 0 # sign-extend 32-bit result 1458 .endif 1459 \return # RETURN_IF_NO_EXCEPTION or RETURN_IF_ZERO 1460END \name 1461.endm 1462 1463 /* 1464 * Called by managed code to resolve a static/instance field and load/store a value. 1465 */ 1466ONE_ARG_REF_DOWNCALL art_quick_get_byte_static, artGetByteStaticFromCompiledCode, RETURN_IF_NO_EXCEPTION 1467ONE_ARG_REF_DOWNCALL art_quick_get_boolean_static, artGetBooleanStaticFromCompiledCode, RETURN_IF_NO_EXCEPTION 1468ONE_ARG_REF_DOWNCALL art_quick_get_short_static, artGetShortStaticFromCompiledCode, RETURN_IF_NO_EXCEPTION 1469ONE_ARG_REF_DOWNCALL art_quick_get_char_static, artGetCharStaticFromCompiledCode, RETURN_IF_NO_EXCEPTION 1470ONE_ARG_REF_DOWNCALL art_quick_get32_static, artGet32StaticFromCompiledCode, RETURN_IF_NO_EXCEPTION, 1 1471ONE_ARG_REF_DOWNCALL art_quick_get_obj_static, artGetObjStaticFromCompiledCode, RETURN_IF_NO_EXCEPTION 1472ONE_ARG_REF_DOWNCALL art_quick_get64_static, artGet64StaticFromCompiledCode, RETURN_IF_NO_EXCEPTION 1473TWO_ARG_REF_DOWNCALL art_quick_get_byte_instance, artGetByteInstanceFromCompiledCode, RETURN_IF_NO_EXCEPTION 1474TWO_ARG_REF_DOWNCALL art_quick_get_boolean_instance, artGetBooleanInstanceFromCompiledCode, RETURN_IF_NO_EXCEPTION 1475TWO_ARG_REF_DOWNCALL art_quick_get_short_instance, artGetShortInstanceFromCompiledCode, RETURN_IF_NO_EXCEPTION 1476TWO_ARG_REF_DOWNCALL art_quick_get_char_instance, artGetCharInstanceFromCompiledCode, RETURN_IF_NO_EXCEPTION 1477TWO_ARG_REF_DOWNCALL art_quick_get32_instance, artGet32InstanceFromCompiledCode, RETURN_IF_NO_EXCEPTION, 1 1478TWO_ARG_REF_DOWNCALL art_quick_get_obj_instance, artGetObjInstanceFromCompiledCode, RETURN_IF_NO_EXCEPTION 1479TWO_ARG_REF_DOWNCALL art_quick_get64_instance, artGet64InstanceFromCompiledCode, RETURN_IF_NO_EXCEPTION 1480TWO_ARG_REF_DOWNCALL art_quick_set8_static, artSet8StaticFromCompiledCode, RETURN_IF_ZERO 1481TWO_ARG_REF_DOWNCALL art_quick_set16_static, artSet16StaticFromCompiledCode, RETURN_IF_ZERO 1482TWO_ARG_REF_DOWNCALL art_quick_set32_static, artSet32StaticFromCompiledCode, RETURN_IF_ZERO 1483TWO_ARG_REF_DOWNCALL art_quick_set_obj_static, artSetObjStaticFromCompiledCode, RETURN_IF_ZERO 1484TWO_ARG_REF_DOWNCALL art_quick_set64_static, artSet64StaticFromCompiledCode, RETURN_IF_ZERO 1485THREE_ARG_REF_DOWNCALL art_quick_set8_instance, artSet8InstanceFromCompiledCode, RETURN_IF_ZERO 1486THREE_ARG_REF_DOWNCALL art_quick_set16_instance, artSet16InstanceFromCompiledCode, RETURN_IF_ZERO 1487THREE_ARG_REF_DOWNCALL art_quick_set32_instance, artSet32InstanceFromCompiledCode, RETURN_IF_ZERO 1488THREE_ARG_REF_DOWNCALL art_quick_set_obj_instance, artSetObjInstanceFromCompiledCode, RETURN_IF_ZERO 1489THREE_ARG_REF_DOWNCALL art_quick_set64_instance, artSet64InstanceFromCompiledCode, RETURN_IF_ZERO 1490 1491// Macro to facilitate adding new allocation entrypoints. 1492.macro ONE_ARG_DOWNCALL name, entrypoint, return 1493 .extern \entrypoint 1494ENTRY \name 1495 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case of GC 1496 jal \entrypoint 1497 move $a1, rSELF # pass Thread::Current 1498 \return 1499END \name 1500.endm 1501 1502// Macro to facilitate adding new allocation entrypoints. 1503.macro TWO_ARG_DOWNCALL name, entrypoint, return 1504 .extern \entrypoint 1505ENTRY \name 1506 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case of GC 1507 jal \entrypoint 1508 move $a2, rSELF # pass Thread::Current 1509 \return 1510END \name 1511.endm 1512 1513.macro THREE_ARG_DOWNCALL name, entrypoint, return 1514 .extern \entrypoint 1515ENTRY \name 1516 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case of GC 1517 jal \entrypoint 1518 move $a3, rSELF # pass Thread::Current 1519 \return 1520END \name 1521.endm 1522 1523.macro FOUR_ARG_DOWNCALL name, entrypoint, return 1524 .extern \entrypoint 1525ENTRY \name 1526 SETUP_SAVE_REFS_ONLY_FRAME # save callee saves in case of GC 1527 jal \entrypoint 1528 move $a4, rSELF # pass Thread::Current 1529 \return 1530END \name 1531.endm 1532 1533// Generate the allocation entrypoints for each allocator. 1534GENERATE_ALLOC_ENTRYPOINTS_FOR_EACH_ALLOCATOR 1535 1536// A hand-written override for: 1537// GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_rosalloc, RosAlloc) 1538// GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_INITIALIZED(_rosalloc, RosAlloc) 1539.macro ART_QUICK_ALLOC_OBJECT_ROSALLOC c_name, cxx_name 1540ENTRY \c_name 1541 # Fast path rosalloc allocation 1542 # a0: type 1543 # s1: Thread::Current 1544 # ----------------------------- 1545 # t1: object size 1546 # t2: rosalloc run 1547 # t3: thread stack top offset 1548 # a4: thread stack bottom offset 1549 # v0: free list head 1550 # 1551 # a5, a6 : temps 1552 ld $t3, THREAD_LOCAL_ALLOC_STACK_TOP_OFFSET($s1) # Check if thread local allocation stack 1553 ld $a4, THREAD_LOCAL_ALLOC_STACK_END_OFFSET($s1) # has any room left. 1554 bgeuc $t3, $a4, .Lslow_path_\c_name 1555 1556 lwu $t1, MIRROR_CLASS_OBJECT_SIZE_ALLOC_FAST_PATH_OFFSET($a0) # Load object size (t1). 1557 li $a5, ROSALLOC_MAX_THREAD_LOCAL_BRACKET_SIZE # Check if size is for a thread local 1558 # allocation. Also does the initialized 1559 # and finalizable checks. 1560 bltuc $a5, $t1, .Lslow_path_\c_name 1561 1562 # Compute the rosalloc bracket index from the size. Since the size is already aligned we can 1563 # combine the two shifts together. 1564 dsrl $t1, $t1, (ROSALLOC_BRACKET_QUANTUM_SIZE_SHIFT - POINTER_SIZE_SHIFT) 1565 1566 daddu $t2, $t1, $s1 1567 ld $t2, (THREAD_ROSALLOC_RUNS_OFFSET - __SIZEOF_POINTER__)($t2) # Load rosalloc run (t2). 1568 1569 # Load the free list head (v0). 1570 # NOTE: this will be the return val. 1571 ld $v0, (ROSALLOC_RUN_FREE_LIST_OFFSET + ROSALLOC_RUN_FREE_LIST_HEAD_OFFSET)($t2) 1572 beqzc $v0, .Lslow_path_\c_name 1573 1574 # Load the next pointer of the head and update the list head with the next pointer. 1575 ld $a5, ROSALLOC_SLOT_NEXT_OFFSET($v0) 1576 sd $a5, (ROSALLOC_RUN_FREE_LIST_OFFSET + ROSALLOC_RUN_FREE_LIST_HEAD_OFFSET)($t2) 1577 1578 # Store the class pointer in the header. This also overwrites the first pointer. The offsets are 1579 # asserted to match. 1580 1581#if ROSALLOC_SLOT_NEXT_OFFSET != MIRROR_OBJECT_CLASS_OFFSET 1582#error "Class pointer needs to overwrite next pointer." 1583#endif 1584 1585 POISON_HEAP_REF $a0 1586 sw $a0, MIRROR_OBJECT_CLASS_OFFSET($v0) 1587 1588 # Push the new object onto the thread local allocation stack and increment the thread local 1589 # allocation stack top. 1590 sd $v0, 0($t3) 1591 daddiu $t3, $t3, COMPRESSED_REFERENCE_SIZE 1592 sd $t3, THREAD_LOCAL_ALLOC_STACK_TOP_OFFSET($s1) 1593 1594 # Decrement the size of the free list. 1595 lw $a5, (ROSALLOC_RUN_FREE_LIST_OFFSET + ROSALLOC_RUN_FREE_LIST_SIZE_OFFSET)($t2) 1596 addiu $a5, $a5, -1 1597 sw $a5, (ROSALLOC_RUN_FREE_LIST_OFFSET + ROSALLOC_RUN_FREE_LIST_SIZE_OFFSET)($t2) 1598 1599 sync # Fence. 1600 1601 jalr $zero, $ra 1602 .cpreturn # Restore gp from t8 in branch delay slot. 1603 1604.Lslow_path_\c_name: 1605 SETUP_SAVE_REFS_ONLY_FRAME 1606 jal \cxx_name 1607 move $a1 ,$s1 # Pass self as argument. 1608 RETURN_IF_RESULT_IS_NON_ZERO_OR_DELIVER 1609END \c_name 1610.endm 1611 1612ART_QUICK_ALLOC_OBJECT_ROSALLOC art_quick_alloc_object_resolved_rosalloc, artAllocObjectFromCodeResolvedRosAlloc 1613ART_QUICK_ALLOC_OBJECT_ROSALLOC art_quick_alloc_object_initialized_rosalloc, artAllocObjectFromCodeInitializedRosAlloc 1614 1615GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_tlab, TLAB) 1616GENERATE_ALLOC_ENTRYPOINTS_ALLOC_OBJECT_RESOLVED(_region_tlab, RegionTLAB) 1617 1618 /* 1619 * Entry from managed code to resolve a string, this stub will allocate a String and deliver an 1620 * exception on error. On success the String is returned. A0 holds the string index. The fast 1621 * path check for hit in strings cache has already been performed. 1622 */ 1623ONE_ARG_DOWNCALL art_quick_resolve_string, artResolveStringFromCode, RETURN_IF_RESULT_IS_NON_ZERO_OR_DELIVER 1624 1625 /* 1626 * Entry from managed code when uninitialized static storage, this stub will run the class 1627 * initializer and deliver the exception on error. On success the static storage base is 1628 * returned. 1629 */ 1630ONE_ARG_DOWNCALL art_quick_initialize_static_storage, artInitializeStaticStorageFromCode, RETURN_IF_RESULT_IS_NON_ZERO_OR_DELIVER 1631 1632 /* 1633 * Entry from managed code when dex cache misses for a type_idx. 1634 */ 1635ONE_ARG_DOWNCALL art_quick_initialize_type, artInitializeTypeFromCode, RETURN_IF_RESULT_IS_NON_ZERO_OR_DELIVER 1636 1637 /* 1638 * Entry from managed code when type_idx needs to be checked for access and dex cache may also 1639 * miss. 1640 */ 1641ONE_ARG_DOWNCALL art_quick_initialize_type_and_verify_access, artInitializeTypeAndVerifyAccessFromCode, RETURN_IF_RESULT_IS_NON_ZERO_OR_DELIVER 1642 1643 /* 1644 * Called by managed code when the value in rSUSPEND has been decremented to 0. 1645 */ 1646 .extern artTestSuspendFromCode 1647ENTRY_NO_GP art_quick_test_suspend 1648 lh rSUSPEND, THREAD_FLAGS_OFFSET(rSELF) 1649 bne rSUSPEND, $zero, 1f 1650 daddiu rSUSPEND, $zero, SUSPEND_CHECK_INTERVAL # reset rSUSPEND to SUSPEND_CHECK_INTERVAL 1651 jalr $zero, $ra 1652 nop 16531: 1654 SETUP_SAVE_EVERYTHING_FRAME # save everything for stack crawl 1655 jal artTestSuspendFromCode # (Thread*) 1656 move $a0, rSELF 1657 RESTORE_SAVE_EVERYTHING_FRAME 1658 jalr $zero, $ra 1659 nop 1660END art_quick_test_suspend 1661 1662 /* 1663 * Called by managed code that is attempting to call a method on a proxy class. On entry 1664 * r0 holds the proxy method; r1, r2 and r3 may contain arguments. 1665 */ 1666 .extern artQuickProxyInvokeHandler 1667ENTRY art_quick_proxy_invoke_handler 1668 SETUP_SAVE_REFS_AND_ARGS_FRAME_WITH_METHOD_IN_A0 1669 move $a2, rSELF # pass Thread::Current 1670 jal artQuickProxyInvokeHandler # (Method* proxy method, receiver, Thread*, SP) 1671 move $a3, $sp # pass $sp 1672 ld $t0, THREAD_EXCEPTION_OFFSET(rSELF) # load Thread::Current()->exception_ 1673 daddiu $sp, $sp, REFS_AND_ARGS_MINUS_REFS_SIZE # skip a0-a7 and f12-f19 1674 RESTORE_SAVE_REFS_ONLY_FRAME 1675 bne $t0, $zero, 1f 1676 dmtc1 $v0, $f0 # place return value to FP return value 1677 jalr $zero, $ra 1678 dmtc1 $v1, $f1 # place return value to FP return value 16791: 1680 DELIVER_PENDING_EXCEPTION 1681END art_quick_proxy_invoke_handler 1682 1683 /* 1684 * Called to resolve an imt conflict. 1685 * a0 is the conflict ArtMethod. 1686 * t0 is a hidden argument that holds the target interface method's dex method index. 1687 * 1688 * Mote that this stub writes to a0, t0 and t1. 1689 */ 1690ENTRY art_quick_imt_conflict_trampoline 1691 ld $t1, 0($sp) # Load referrer. 1692 ld $t1, ART_METHOD_DEX_CACHE_METHODS_OFFSET_64($t1) # Load dex cache methods array. 1693 dsll $t0, $t0, POINTER_SIZE_SHIFT # Calculate offset. 1694 daddu $t0, $t1, $t0 # Add offset to base. 1695 ld $t0, 0($t0) # Load interface method. 1696 ld $a0, ART_METHOD_JNI_OFFSET_64($a0) # Load ImtConflictTable. 1697 1698.Limt_table_iterate: 1699 ld $t1, 0($a0) # Load next entry in ImtConflictTable. 1700 # Branch if found. 1701 beq $t1, $t0, .Limt_table_found 1702 nop 1703 # If the entry is null, the interface method is not in the ImtConflictTable. 1704 beqzc $t1, .Lconflict_trampoline 1705 # Iterate over the entries of the ImtConflictTable. 1706 daddiu $a0, $a0, 2 * __SIZEOF_POINTER__ # Iterate to the next entry. 1707 bc .Limt_table_iterate 1708 1709.Limt_table_found: 1710 # We successfully hit an entry in the table. Load the target method and jump to it. 1711 ld $a0, __SIZEOF_POINTER__($a0) 1712 ld $t9, ART_METHOD_QUICK_CODE_OFFSET_64($a0) 1713 jr $t9 1714 .cpreturn # Restore gp from t8 in branch delay slot. 1715 1716.Lconflict_trampoline: 1717 # Call the runtime stub to populate the ImtConflictTable and jump to the resolved method. 1718 move $a0, $t0 # Load interface method. 1719 INVOKE_TRAMPOLINE_BODY artInvokeInterfaceTrampoline 1720END art_quick_imt_conflict_trampoline 1721 1722 .extern artQuickResolutionTrampoline 1723ENTRY art_quick_resolution_trampoline 1724 SETUP_SAVE_REFS_AND_ARGS_FRAME 1725 move $a2, rSELF # pass Thread::Current 1726 jal artQuickResolutionTrampoline # (Method* called, receiver, Thread*, SP) 1727 move $a3, $sp # pass $sp 1728 beq $v0, $zero, 1f 1729 ld $a0, 0($sp) # load resolved method in $a0 1730 # artQuickResolutionTrampoline puts resolved method in *SP 1731 RESTORE_SAVE_REFS_AND_ARGS_FRAME 1732 move $t9, $v0 # code pointer must be in $t9 to generate the global pointer 1733 jalr $zero, $t9 # tail call to method 1734 nop 17351: 1736 RESTORE_SAVE_REFS_AND_ARGS_FRAME 1737 DELIVER_PENDING_EXCEPTION 1738END art_quick_resolution_trampoline 1739 1740 .extern artQuickGenericJniTrampoline 1741 .extern artQuickGenericJniEndTrampoline 1742ENTRY art_quick_generic_jni_trampoline 1743 SETUP_SAVE_REFS_AND_ARGS_FRAME_WITH_METHOD_IN_A0 1744 move $s8, $sp # save $sp 1745 1746 # prepare for call to artQuickGenericJniTrampoline(Thread*, SP) 1747 move $a0, rSELF # pass Thread::Current 1748 move $a1, $sp # pass $sp 1749 jal artQuickGenericJniTrampoline # (Thread*, SP) 1750 daddiu $sp, $sp, -5120 # reserve space on the stack 1751 1752 # The C call will have registered the complete save-frame on success. 1753 # The result of the call is: 1754 # v0: ptr to native code, 0 on error. 1755 # v1: ptr to the bottom of the used area of the alloca, can restore stack till here. 1756 beq $v0, $zero, 1f # check entry error 1757 move $t9, $v0 # save the code ptr 1758 move $sp, $v1 # release part of the alloca 1759 1760 # Load parameters from stack into registers 1761 ld $a0, 0($sp) 1762 ld $a1, 8($sp) 1763 ld $a2, 16($sp) 1764 ld $a3, 24($sp) 1765 ld $a4, 32($sp) 1766 ld $a5, 40($sp) 1767 ld $a6, 48($sp) 1768 ld $a7, 56($sp) 1769 # Load FPRs the same as GPRs. Look at BuildNativeCallFrameStateMachine. 1770 l.d $f12, 0($sp) 1771 l.d $f13, 8($sp) 1772 l.d $f14, 16($sp) 1773 l.d $f15, 24($sp) 1774 l.d $f16, 32($sp) 1775 l.d $f17, 40($sp) 1776 l.d $f18, 48($sp) 1777 l.d $f19, 56($sp) 1778 jalr $t9 # native call 1779 daddiu $sp, $sp, 64 1780 1781 # result sign extension is handled in C code 1782 # prepare for call to artQuickGenericJniEndTrampoline(Thread*, result, result_f) 1783 move $a0, rSELF # pass Thread::Current 1784 move $a1, $v0 1785 jal artQuickGenericJniEndTrampoline 1786 dmfc1 $a2, $f0 1787 1788 ld $t0, THREAD_EXCEPTION_OFFSET(rSELF) # load Thread::Current()->exception_ 1789 bne $t0, $zero, 1f # check for pending exceptions 1790 move $sp, $s8 # tear down the alloca 1791 1792 # tear dpown the callee-save frame 1793 RESTORE_SAVE_REFS_AND_ARGS_FRAME 1794 1795 jalr $zero, $ra 1796 dmtc1 $v0, $f0 # place return value to FP return value 1797 17981: 1799 ld $sp, THREAD_TOP_QUICK_FRAME_OFFSET(rSELF) 1800 # This will create a new save-all frame, required by the runtime. 1801 DELIVER_PENDING_EXCEPTION 1802END art_quick_generic_jni_trampoline 1803 1804 .extern artQuickToInterpreterBridge 1805ENTRY art_quick_to_interpreter_bridge 1806 SETUP_SAVE_REFS_AND_ARGS_FRAME 1807 move $a1, rSELF # pass Thread::Current 1808 jal artQuickToInterpreterBridge # (Method* method, Thread*, SP) 1809 move $a2, $sp # pass $sp 1810 ld $t0, THREAD_EXCEPTION_OFFSET(rSELF) # load Thread::Current()->exception_ 1811 daddiu $sp, $sp, REFS_AND_ARGS_MINUS_REFS_SIZE # skip a0-a7 and f12-f19 1812 RESTORE_SAVE_REFS_ONLY_FRAME 1813 bne $t0, $zero, 1f 1814 dmtc1 $v0, $f0 # place return value to FP return value 1815 jalr $zero, $ra 1816 dmtc1 $v1, $f1 # place return value to FP return value 18171: 1818 DELIVER_PENDING_EXCEPTION 1819END art_quick_to_interpreter_bridge 1820 1821 .extern artInvokeObsoleteMethod 1822ENTRY art_invoke_obsolete_method_stub 1823 SETUP_SAVE_ALL_CALLEE_SAVES_FRAME 1824 jal artInvokeObsoleteMethod # (Method* method, Thread* self) 1825 move $a1, rSELF # pass Thread::Current 1826END art_invoke_obsolete_method_stub 1827 1828 /* 1829 * Routine that intercepts method calls and returns. 1830 */ 1831 .extern artInstrumentationMethodEntryFromCode 1832 .extern artInstrumentationMethodExitFromCode 1833ENTRY art_quick_instrumentation_entry 1834 SETUP_SAVE_REFS_AND_ARGS_FRAME 1835 daddiu $sp, $sp, -16 # space for saving arg0 1836 .cfi_adjust_cfa_offset 16 1837 sd $a0, 0($sp) # save arg0 1838 move $a3, $ra # pass $ra 1839 jal artInstrumentationMethodEntryFromCode # (Method*, Object*, Thread*, RA) 1840 move $a2, rSELF # pass Thread::Current 1841 move $t9, $v0 # $t9 holds reference to code 1842 ld $a0, 0($sp) # restore arg0 1843 daddiu $sp, $sp, 16 # remove args 1844 .cfi_adjust_cfa_offset -16 1845 RESTORE_SAVE_REFS_AND_ARGS_FRAME 1846 jalr $t9 # call method 1847 nop 1848END art_quick_instrumentation_entry 1849 /* intentional fallthrough */ 1850 .global art_quick_instrumentation_exit 1851art_quick_instrumentation_exit: 1852 .cfi_startproc 1853 SETUP_GP 1854 move $ra, $zero # link register is to here, so clobber with 0 for later checks 1855 SETUP_SAVE_REFS_ONLY_FRAME 1856 move $t0, $sp # remember bottom of caller's frame 1857 daddiu $sp, $sp, -16 # save return values and set up args 1858 .cfi_adjust_cfa_offset 16 1859 sd $v0, 0($sp) 1860 .cfi_rel_offset 2, 0 1861 s.d $f0, 8($sp) 1862 mov.d $f15, $f0 # pass fpr result 1863 move $a2, $v0 # pass gpr result 1864 move $a1, $t0 # pass $sp 1865 move $a0, rSELF # pass Thread::Current 1866 jal artInstrumentationMethodExitFromCode # (Thread*, SP, gpr_res, fpr_res) 1867 .cpreturn # Restore gp from t8 in branch delay slot. gp is not used anymore, 1868 # and t8 may be clobbered in artInstrumentationMethodExitFromCode. 1869 1870 move $t9, $v0 # set aside returned link register 1871 move $ra, $v1 # set link register for deoptimization 1872 ld $v0, 0($sp) # restore return values 1873 l.d $f0, 8($sp) 1874 jalr $zero, $t9 # return 1875 # restore stack, 16 bytes of saved values + ref_only callee save frame 1876 daddiu $sp, $sp, 16+FRAME_SIZE_SAVE_REFS_ONLY 1877 .cfi_adjust_cfa_offset -(16+FRAME_SIZE_SAVE_REFS_ONLY) 1878END art_quick_instrumentation_exit 1879 1880 /* 1881 * Instrumentation has requested that we deoptimize into the interpreter. The deoptimization 1882 * will long jump to the upcall with a special exception of -1. 1883 */ 1884 .extern artDeoptimize 1885 .extern artEnterInterpreterFromDeoptimize 1886ENTRY art_quick_deoptimize 1887 SETUP_SAVE_ALL_CALLEE_SAVES_FRAME 1888 jal artDeoptimize # artDeoptimize(Thread*) 1889 move $a0, rSELF # pass Thread::current 1890END art_quick_deoptimize 1891 1892 /* 1893 * Compiled code has requested that we deoptimize into the interpreter. The deoptimization 1894 * will long jump to the upcall with a special exception of -1. 1895 */ 1896 .extern artDeoptimizeFromCompiledCode 1897ENTRY_NO_GP art_quick_deoptimize_from_compiled_code 1898 SETUP_SAVE_EVERYTHING_FRAME 1899 jal artDeoptimizeFromCompiledCode # (DeoptimizationKind, Thread*) 1900 move $a1, rSELF # pass Thread::current 1901END art_quick_deoptimize_from_compiled_code 1902 1903 .set push 1904 .set noat 1905/* java.lang.String.compareTo(String anotherString) */ 1906ENTRY_NO_GP art_quick_string_compareto 1907/* $a0 holds address of "this" */ 1908/* $a1 holds address of "anotherString" */ 1909 move $a2, $zero 1910 beq $a0, $a1, .Lstring_compareto_length_diff # this and anotherString are the same object 1911 move $a3, $zero # return 0 (it returns a2 - a3) 1912 1913#if (STRING_COMPRESSION_FEATURE) 1914 lw $a4, MIRROR_STRING_COUNT_OFFSET($a0) # 'count' field of this 1915 lw $a5, MIRROR_STRING_COUNT_OFFSET($a1) # 'count' field of anotherString 1916 sra $a2, $a4, 1 # this.length() 1917 sra $a3, $a5, 1 # anotherString.length() 1918#else 1919 lw $a2, MIRROR_STRING_COUNT_OFFSET($a0) # this.length() 1920 lw $a3, MIRROR_STRING_COUNT_OFFSET($a1) # anotherString.length() 1921#endif 1922 1923 MINu $t2, $a2, $a3 1924 # $t2 now holds min(this.length(),anotherString.length()) 1925 1926 # while min(this.length(),anotherString.length())-i != 0 1927 beqzc $t2, .Lstring_compareto_length_diff # if $t2==0 1928 # return (this.length() - anotherString.length()) 1929 1930#if (STRING_COMPRESSION_FEATURE) 1931 # Differ cases: 1932 dext $a6, $a4, 0, 1 1933 beqz $a6, .Lstring_compareto_this_is_compressed 1934 dext $a6, $a5, 0, 1 # In branch delay slot. 1935 beqz $a6, .Lstring_compareto_that_is_compressed 1936 nop 1937 b .Lstring_compareto_both_not_compressed 1938 nop 1939 1940.Lstring_compareto_this_is_compressed: 1941 beqzc $a6, .Lstring_compareto_both_compressed 1942 /* If (this->IsCompressed() && that->IsCompressed() == false) */ 1943.Lstring_compareto_loop_comparison_this_compressed: 1944 lbu $t0, MIRROR_STRING_VALUE_OFFSET($a0) 1945 lhu $t1, MIRROR_STRING_VALUE_OFFSET($a1) 1946 bnec $t0, $t1, .Lstring_compareto_char_diff 1947 daddiu $a0, $a0, 1 # point at this.charAt(i++) - compressed 1948 subu $t2, $t2, 1 # new value of min(this.length(),anotherString.length())-i 1949 bnez $t2, .Lstring_compareto_loop_comparison_this_compressed 1950 daddiu $a1, $a1, 2 # point at anotherString.charAt(i++) - uncompressed 1951 jalr $zero, $ra 1952 subu $v0, $a2, $a3 # return (this.length() - anotherString.length()) 1953 1954.Lstring_compareto_that_is_compressed: 1955 lhu $t0, MIRROR_STRING_VALUE_OFFSET($a0) 1956 lbu $t1, MIRROR_STRING_VALUE_OFFSET($a1) 1957 bnec $t0, $t1, .Lstring_compareto_char_diff 1958 daddiu $a0, $a0, 2 # point at this.charAt(i++) - uncompressed 1959 subu $t2, $t2, 1 # new value of min(this.length(),anotherString.length())-i 1960 bnez $t2, .Lstring_compareto_that_is_compressed 1961 daddiu $a1, $a1, 1 # point at anotherString.charAt(i++) - compressed 1962 jalr $zero, $ra 1963 subu $v0, $a2, $a3 # return (this.length() - anotherString.length()) 1964 1965.Lstring_compareto_both_compressed: 1966 lbu $t0, MIRROR_STRING_VALUE_OFFSET($a0) 1967 lbu $t1, MIRROR_STRING_VALUE_OFFSET($a1) 1968 bnec $t0, $t1, .Lstring_compareto_char_diff 1969 daddiu $a0, $a0, 1 # point at this.charAt(i++) - compressed 1970 subu $t2, $t2, 1 # new value of min(this.length(),anotherString.length())-i 1971 bnez $t2, .Lstring_compareto_both_compressed 1972 daddiu $a1, $a1, 1 # point at anotherString.charAt(i++) - compressed 1973 jalr $zero, $ra 1974 subu $v0, $a2, $a3 # return (this.length() - anotherString.length()) 1975#endif 1976 1977.Lstring_compareto_both_not_compressed: 1978 lhu $t0, MIRROR_STRING_VALUE_OFFSET($a0) # while this.charAt(i) == anotherString.charAt(i) 1979 lhu $t1, MIRROR_STRING_VALUE_OFFSET($a1) 1980 bnec $t0, $t1, .Lstring_compareto_char_diff # if this.charAt(i) != anotherString.charAt(i) 1981 # return (this.charAt(i) - anotherString.charAt(i)) 1982 daddiu $a0, $a0, 2 # point at this.charAt(i++) 1983 subu $t2, $t2, 1 # new value of min(this.length(),anotherString.length())-i 1984 bnez $t2, .Lstring_compareto_both_not_compressed 1985 daddiu $a1, $a1, 2 # point at anotherString.charAt(i++) 1986 1987.Lstring_compareto_length_diff: 1988 jalr $zero, $ra 1989 subu $v0, $a2, $a3 # return (this.length() - anotherString.length()) 1990 1991.Lstring_compareto_char_diff: 1992 jalr $zero, $ra 1993 subu $v0, $t0, $t1 # return (this.charAt(i) - anotherString.charAt(i)) 1994END art_quick_string_compareto 1995 1996/* java.lang.String.indexOf(int ch, int fromIndex=0) */ 1997ENTRY_NO_GP art_quick_indexof 1998/* $a0 holds address of "this" */ 1999/* $a1 holds "ch" */ 2000/* $a2 holds "fromIndex" */ 2001#if (STRING_COMPRESSION_FEATURE) 2002 lw $a3, MIRROR_STRING_COUNT_OFFSET($a0) # 'count' field of this 2003#else 2004 lw $t0, MIRROR_STRING_COUNT_OFFSET($a0) # this.length() 2005#endif 2006 slt $at, $a2, $zero # if fromIndex < 0 2007 seleqz $a2, $a2, $at # fromIndex = 0; 2008#if (STRING_COMPRESSION_FEATURE) 2009 srl $t0, $a3, 1 # $a3 holds count (with flag) and $t0 holds actual length 2010#endif 2011 subu $t0, $t0, $a2 # this.length() - fromIndex 2012 blez $t0, 6f # if this.length()-fromIndex <= 0 2013 li $v0, -1 # return -1; 2014 2015#if (STRING_COMPRESSION_FEATURE) 2016 dext $a3, $a3, 0, 1 # Extract compression flag. 2017 beqzc $a3, .Lstring_indexof_compressed 2018#endif 2019 2020 sll $v0, $a2, 1 # $a0 += $a2 * 2 2021 daddu $a0, $a0, $v0 # " ditto " 2022 move $v0, $a2 # Set i to fromIndex. 2023 20241: 2025 lhu $t3, MIRROR_STRING_VALUE_OFFSET($a0) # if this.charAt(i) == ch 2026 beq $t3, $a1, 6f # return i; 2027 daddu $a0, $a0, 2 # i++ 2028 subu $t0, $t0, 1 # this.length() - i 2029 bnez $t0, 1b # while this.length() - i > 0 2030 addu $v0, $v0, 1 # i++ 2031 2032 li $v0, -1 # if this.length() - i <= 0 2033 # return -1; 2034 20356: 2036 j $ra 2037 nop 2038 2039#if (STRING_COMPRESSION_FEATURE) 2040.Lstring_indexof_compressed: 2041 move $a4, $a0 # Save a copy in $a4 to later compute result. 2042 daddu $a0, $a0, $a2 # $a0 += $a2 2043 2044.Lstring_indexof_compressed_loop: 2045 lbu $t3, MIRROR_STRING_VALUE_OFFSET($a0) 2046 beq $t3, $a1, .Lstring_indexof_compressed_matched 2047 subu $t0, $t0, 1 2048 bgtz $t0, .Lstring_indexof_compressed_loop 2049 daddu $a0, $a0, 1 2050 2051.Lstring_indexof_nomatch: 2052 jalr $zero, $ra 2053 li $v0, -1 # return -1; 2054 2055.Lstring_indexof_compressed_matched: 2056 jalr $zero, $ra 2057 dsubu $v0, $a0, $a4 # return (current - start); 2058#endif 2059END art_quick_indexof 2060 2061 /* 2062 * Create a function `name` calling the ReadBarrier::Mark routine, 2063 * getting its argument and returning its result through register 2064 * `reg`, saving and restoring all caller-save registers. 2065 */ 2066.macro READ_BARRIER_MARK_REG name, reg 2067ENTRY \name 2068 /* TODO: optimizations: mark bit, forwarding. */ 2069 daddiu $sp, $sp, -320 2070 .cfi_adjust_cfa_offset 320 2071 2072 sd $ra, 312($sp) 2073 .cfi_rel_offset 31, 312 2074 sd $t8, 304($sp) # save t8 holding caller's gp 2075 .cfi_rel_offset 24, 304 2076 sd $t3, 296($sp) 2077 .cfi_rel_offset 15, 296 2078 sd $t2, 288($sp) 2079 .cfi_rel_offset 14, 288 2080 sd $t1, 280($sp) 2081 .cfi_rel_offset 13, 280 2082 sd $t0, 272($sp) 2083 .cfi_rel_offset 12, 272 2084 sd $a7, 264($sp) 2085 .cfi_rel_offset 11, 264 2086 sd $a6, 256($sp) 2087 .cfi_rel_offset 10, 256 2088 sd $a5, 248($sp) 2089 .cfi_rel_offset 9, 248 2090 sd $a4, 240($sp) 2091 .cfi_rel_offset 8, 240 2092 sd $a3, 232($sp) 2093 .cfi_rel_offset 7, 232 2094 sd $a2, 224($sp) 2095 .cfi_rel_offset 6, 224 2096 sd $a1, 216($sp) 2097 .cfi_rel_offset 5, 216 2098 sd $a0, 208($sp) 2099 .cfi_rel_offset 4, 208 2100 sd $v1, 200($sp) 2101 .cfi_rel_offset 3, 200 2102 sd $v0, 192($sp) 2103 .cfi_rel_offset 2, 192 2104 2105 dla $t9, artReadBarrierMark 2106 2107 sdc1 $f23, 184($sp) 2108 sdc1 $f22, 176($sp) 2109 sdc1 $f21, 168($sp) 2110 sdc1 $f20, 160($sp) 2111 sdc1 $f19, 152($sp) 2112 sdc1 $f18, 144($sp) 2113 sdc1 $f17, 136($sp) 2114 sdc1 $f16, 128($sp) 2115 sdc1 $f15, 120($sp) 2116 sdc1 $f14, 112($sp) 2117 sdc1 $f13, 104($sp) 2118 sdc1 $f12, 96($sp) 2119 sdc1 $f11, 88($sp) 2120 sdc1 $f10, 80($sp) 2121 sdc1 $f9, 72($sp) 2122 sdc1 $f8, 64($sp) 2123 sdc1 $f7, 56($sp) 2124 sdc1 $f6, 48($sp) 2125 sdc1 $f5, 40($sp) 2126 sdc1 $f4, 32($sp) 2127 sdc1 $f3, 24($sp) 2128 sdc1 $f2, 16($sp) 2129 sdc1 $f1, 8($sp) 2130 2131 .ifnc \reg, $a0 2132 move $a0, \reg # pass obj from `reg` in a0 2133 .endif 2134 jalr $t9 # v0 <- artReadBarrierMark(obj) 2135 sdc1 $f0, 0($sp) # in delay slot 2136 2137 ld $ra, 312($sp) 2138 .cfi_restore 31 2139 ld $t8, 304($sp) # restore t8 holding caller's gp 2140 .cfi_restore 24 2141 ld $t3, 296($sp) 2142 .cfi_restore 15 2143 ld $t2, 288($sp) 2144 .cfi_restore 14 2145 ld $t1, 280($sp) 2146 .cfi_restore 13 2147 ld $t0, 272($sp) 2148 .cfi_restore 12 2149 ld $a7, 264($sp) 2150 .cfi_restore 11 2151 ld $a6, 256($sp) 2152 .cfi_restore 10 2153 ld $a5, 248($sp) 2154 .cfi_restore 9 2155 ld $a4, 240($sp) 2156 .cfi_restore 8 2157 ld $a3, 232($sp) 2158 .cfi_restore 7 2159 ld $a2, 224($sp) 2160 .cfi_restore 6 2161 ld $a1, 216($sp) 2162 .cfi_restore 5 2163 ld $a0, 208($sp) 2164 .cfi_restore 4 2165 ld $v1, 200($sp) 2166 .cfi_restore 3 2167 2168 .ifnc \reg, $v0 2169 move \reg, $v0 # `reg` <- v0 2170 ld $v0, 192($sp) 2171 .cfi_restore 2 2172 .endif 2173 2174 ldc1 $f23, 184($sp) 2175 ldc1 $f22, 176($sp) 2176 ldc1 $f21, 168($sp) 2177 ldc1 $f20, 160($sp) 2178 ldc1 $f19, 152($sp) 2179 ldc1 $f18, 144($sp) 2180 ldc1 $f17, 136($sp) 2181 ldc1 $f16, 128($sp) 2182 ldc1 $f15, 120($sp) 2183 ldc1 $f14, 112($sp) 2184 ldc1 $f13, 104($sp) 2185 ldc1 $f12, 96($sp) 2186 ldc1 $f11, 88($sp) 2187 ldc1 $f10, 80($sp) 2188 ldc1 $f9, 72($sp) 2189 ldc1 $f8, 64($sp) 2190 ldc1 $f7, 56($sp) 2191 ldc1 $f6, 48($sp) 2192 ldc1 $f5, 40($sp) 2193 ldc1 $f4, 32($sp) 2194 ldc1 $f3, 24($sp) 2195 ldc1 $f2, 16($sp) 2196 ldc1 $f1, 8($sp) 2197 ldc1 $f0, 0($sp) 2198 2199 .cpreturn # restore caller's gp from t8 2200 jalr $zero, $ra 2201 daddiu $sp, $sp, 320 2202 .cfi_adjust_cfa_offset -320 2203END \name 2204.endm 2205 2206// Note that art_quick_read_barrier_mark_regXX corresponds to register XX+1. 2207// ZERO (register 0) is reserved. 2208// AT (register 1) is reserved as a temporary/scratch register. 2209READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg01, $v0 2210READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg02, $v1 2211READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg03, $a0 2212READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg04, $a1 2213READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg05, $a2 2214READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg06, $a3 2215READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg07, $a4 2216READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg08, $a5 2217READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg09, $a6 2218READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg10, $a7 2219READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg11, $t0 2220READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg12, $t1 2221READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg13, $t2 2222// T3 (register 15) is reserved as a temporary/scratch register. 2223// S0 and S1 (registers 16 and 17) are reserved as suspended and thread registers. 2224READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg17, $s2 2225READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg18, $s3 2226READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg19, $s4 2227READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg20, $s5 2228READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg21, $s6 2229READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg22, $s7 2230// T8 and T9 (registers 24 and 25) are reserved as temporary/scratch registers. 2231// K0, K1, GP, SP (registers 26 - 29) are reserved. 2232READ_BARRIER_MARK_REG art_quick_read_barrier_mark_reg29, $s8 2233// RA (register 31) is reserved. 2234 2235.extern artInvokePolymorphic 2236ENTRY art_quick_invoke_polymorphic 2237 SETUP_SAVE_REFS_AND_ARGS_FRAME 2238 move $a2, rSELF # Make $a2 an alias for the current Thread. 2239 move $a3, $sp # Make $a3 a pointer to the saved frame context. 2240 daddiu $sp, $sp, -8 # Reserve space for JValue result. 2241 .cfi_adjust_cfa_offset 8 2242 sd $zero, 0($sp) # Initialize JValue result. 2243 jal artInvokePolymorphic # (result, receiver, Thread*, context) 2244 move $a0, $sp # Make $a0 a pointer to the JValue result 2245.macro MATCH_RETURN_TYPE c, handler 2246 li $t0, \c 2247 beq $v0, $t0, \handler 2248.endm 2249 MATCH_RETURN_TYPE 'V', .Lcleanup_and_return 2250 MATCH_RETURN_TYPE 'L', .Lstore_ref_result 2251 MATCH_RETURN_TYPE 'I', .Lstore_long_result 2252 MATCH_RETURN_TYPE 'J', .Lstore_long_result 2253 MATCH_RETURN_TYPE 'B', .Lstore_long_result 2254 MATCH_RETURN_TYPE 'C', .Lstore_char_result 2255 MATCH_RETURN_TYPE 'D', .Lstore_double_result 2256 MATCH_RETURN_TYPE 'F', .Lstore_float_result 2257 MATCH_RETURN_TYPE 'S', .Lstore_long_result 2258 MATCH_RETURN_TYPE 'Z', .Lstore_boolean_result 2259.purgem MATCH_RETURN_TYPE 2260 nop 2261 b .Lcleanup_and_return 2262 nop 2263.Lstore_boolean_result: 2264 b .Lcleanup_and_return 2265 lbu $v0, 0($sp) # Move byte from JValue result to return value register. 2266.Lstore_char_result: 2267 b .Lcleanup_and_return 2268 lhu $v0, 0($sp) # Move char from JValue result to return value register. 2269.Lstore_double_result: 2270.Lstore_float_result: 2271 b .Lcleanup_and_return 2272 l.d $f0, 0($sp) # Move double/float from JValue result to return value register. 2273.Lstore_ref_result: 2274 b .Lcleanup_and_return 2275 lwu $v0, 0($sp) # Move zero extended lower 32-bits to return value register. 2276.Lstore_long_result: 2277 ld $v0, 0($sp) # Move long from JValue result to return value register. 2278 // Fall-through to clean up and return. 2279.Lcleanup_and_return: 2280 daddiu $sp, $sp, 8 # Remove space for JValue result. 2281 .cfi_adjust_cfa_offset -8 2282 ld $t0, THREAD_EXCEPTION_OFFSET(rSELF) # Load Thread::Current()->exception_ 2283 RESTORE_SAVE_REFS_AND_ARGS_FRAME 2284 bnez $t0, 1f # Success if no exception is pending. 2285 nop 2286 jalr $zero, $ra 2287 nop 22881: 2289 DELIVER_PENDING_EXCEPTION 2290END art_quick_invoke_polymorphic 2291 2292 .set pop 2293