Elliott Hughes | 0f3c553 | 2012-03-30 14:51:51 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012 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 | |
Ian Rogers | 7655f29 | 2013-07-29 11:07:13 -0700 | [diff] [blame] | 17 | #include "asm_support_arm.S" |
Ian Rogers | 9651f42 | 2011-09-19 20:26:07 -0700 | [diff] [blame] | 18 | |
Ian Rogers | ff1ed47 | 2011-09-20 13:46:24 -0700 | [diff] [blame] | 19 | /* Deliver the given exception */ |
| 20 | .extern artDeliverExceptionFromCode |
| 21 | /* Deliver an exception pending on a thread */ |
| 22 | .extern artDeliverPendingException |
| 23 | |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 24 | /* |
| 25 | * Macro that sets up the callee save frame to conform with |
| 26 | * Runtime::CreateCalleeSaveMethod(kSaveAll) |
| 27 | */ |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 28 | .macro SETUP_SAVE_ALL_CALLEE_SAVE_FRAME |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 29 | push {r4-r11, lr} @ 9 words of callee saves |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 30 | .save {r4-r11, lr} |
| 31 | .cfi_adjust_cfa_offset 36 |
| 32 | .cfi_rel_offset r4, 0 |
| 33 | .cfi_rel_offset r5, 4 |
| 34 | .cfi_rel_offset r6, 8 |
| 35 | .cfi_rel_offset r7, 12 |
| 36 | .cfi_rel_offset r8, 16 |
| 37 | .cfi_rel_offset r9, 20 |
| 38 | .cfi_rel_offset r10, 24 |
| 39 | .cfi_rel_offset r11, 28 |
| 40 | .cfi_rel_offset lr, 32 |
Ian Rogers | 15fdb8c | 2011-09-25 15:45:07 -0700 | [diff] [blame] | 41 | vpush {s0-s31} |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 42 | .pad #128 |
| 43 | .cfi_adjust_cfa_offset 128 |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 44 | sub sp, #12 @ 3 words of space, bottom word will hold Method* |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 45 | .pad #12 |
| 46 | .cfi_adjust_cfa_offset 12 |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 47 | .endm |
| 48 | |
| 49 | /* |
| 50 | * Macro that sets up the callee save frame to conform with |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 51 | * Runtime::CreateCalleeSaveMethod(kRefsOnly). Restoration assumes non-moving GC. |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 52 | */ |
| 53 | .macro SETUP_REF_ONLY_CALLEE_SAVE_FRAME |
| 54 | push {r5-r8, r10-r11, lr} @ 7 words of callee saves |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 55 | .save {r5-r8, r10-r11, lr} |
| 56 | .cfi_adjust_cfa_offset 28 |
| 57 | .cfi_rel_offset r5, 0 |
| 58 | .cfi_rel_offset r6, 4 |
| 59 | .cfi_rel_offset r7, 8 |
| 60 | .cfi_rel_offset r8, 12 |
| 61 | .cfi_rel_offset r10, 16 |
| 62 | .cfi_rel_offset r11, 20 |
| 63 | .cfi_rel_offset lr, 24 |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 64 | sub sp, #4 @ bottom word will hold Method* |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 65 | .pad #4 |
| 66 | .cfi_adjust_cfa_offset 4 |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 67 | .endm |
| 68 | |
| 69 | .macro RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 70 | ldr lr, [sp, #28] @ restore lr for return |
| 71 | add sp, #32 @ unwind stack |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 72 | .cfi_adjust_cfa_offset -32 |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 73 | .endm |
| 74 | |
| 75 | .macro RESTORE_REF_ONLY_CALLEE_SAVE_FRAME_AND_RETURN |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 76 | ldr lr, [sp, #28] @ restore lr for return |
| 77 | add sp, #32 @ unwind stack |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 78 | .cfi_adjust_cfa_offset -32 |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 79 | bx lr @ return |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 80 | .endm |
| 81 | |
| 82 | /* |
| 83 | * Macro that sets up the callee save frame to conform with |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 84 | * Runtime::CreateCalleeSaveMethod(kRefsAndArgs). Restoration assumes non-moving GC. |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 85 | */ |
| 86 | .macro SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 87 | push {r1-r3, r5-r8, r10-r11, lr} @ 10 words of callee saves |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 88 | .save {r1-r3, r5-r8, r10-r11, lr} |
| 89 | .cfi_adjust_cfa_offset 40 |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 90 | .cfi_rel_offset r1, 0 |
| 91 | .cfi_rel_offset r2, 4 |
| 92 | .cfi_rel_offset r3, 8 |
| 93 | .cfi_rel_offset r5, 12 |
| 94 | .cfi_rel_offset r6, 16 |
| 95 | .cfi_rel_offset r7, 20 |
| 96 | .cfi_rel_offset r8, 24 |
| 97 | .cfi_rel_offset r10, 28 |
| 98 | .cfi_rel_offset r11, 32 |
| 99 | .cfi_rel_offset lr, 36 |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 100 | sub sp, #8 @ 2 words of space, bottom word will hold Method* |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 101 | .pad #8 |
| 102 | .cfi_adjust_cfa_offset 8 |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 103 | .endm |
| 104 | |
| 105 | .macro RESTORE_REF_AND_ARGS_CALLEE_SAVE_FRAME |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 106 | ldr r1, [sp, #8] @ restore non-callee save r1 |
| 107 | ldrd r2, [sp, #12] @ restore non-callee saves r2-r3 |
| 108 | ldr lr, [sp, #44] @ restore lr |
| 109 | add sp, #48 @ rewind sp |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 110 | .cfi_adjust_cfa_offset -48 |
Ian Rogers | 15fdb8c | 2011-09-25 15:45:07 -0700 | [diff] [blame] | 111 | .endm |
| 112 | |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 113 | /* |
| 114 | * Macro that set calls through to artDeliverPendingExceptionFromCode, where the pending |
| 115 | * exception is Thread::Current()->exception_ |
| 116 | */ |
| 117 | .macro DELIVER_PENDING_EXCEPTION |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 118 | .fnend |
| 119 | .fnstart |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 120 | SETUP_SAVE_ALL_CALLEE_SAVE_FRAME @ save callee saves for throw |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 121 | mov r0, r9 @ pass Thread::Current |
| 122 | mov r1, sp @ pass SP |
| 123 | b artDeliverPendingExceptionFromCode @ artDeliverPendingExceptionFromCode(Thread*, SP) |
| 124 | .endm |
| 125 | |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 126 | .macro NO_ARG_RUNTIME_EXCEPTION c_name, cxx_name |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 127 | .extern \cxx_name |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 128 | ENTRY \c_name |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 129 | SETUP_SAVE_ALL_CALLEE_SAVE_FRAME // save all registers as basis for long jump context |
| 130 | mov r0, r9 @ pass Thread::Current |
| 131 | mov r1, sp @ pass SP |
| 132 | b \cxx_name @ \cxx_name(Thread*, SP) |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 133 | END \c_name |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 134 | .endm |
buzbee | 44b412b | 2012-02-04 08:50:53 -0800 | [diff] [blame] | 135 | |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 136 | .macro ONE_ARG_RUNTIME_EXCEPTION c_name, cxx_name |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 137 | .extern \cxx_name |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 138 | ENTRY \c_name |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 139 | SETUP_SAVE_ALL_CALLEE_SAVE_FRAME // save all registers as basis for long jump context |
Ian Rogers | ff1ed47 | 2011-09-20 13:46:24 -0700 | [diff] [blame] | 140 | mov r1, r9 @ pass Thread::Current |
| 141 | mov r2, sp @ pass SP |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 142 | b \cxx_name @ \cxx_name(Thread*, SP) |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 143 | END \c_name |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 144 | .endm |
Ian Rogers | 9651f42 | 2011-09-19 20:26:07 -0700 | [diff] [blame] | 145 | |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 146 | .macro TWO_ARG_RUNTIME_EXCEPTION c_name, cxx_name |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 147 | .extern \cxx_name |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 148 | ENTRY \c_name |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 149 | SETUP_SAVE_ALL_CALLEE_SAVE_FRAME // save all registers as basis for long jump context |
Ian Rogers | ff1ed47 | 2011-09-20 13:46:24 -0700 | [diff] [blame] | 150 | mov r2, r9 @ pass Thread::Current |
| 151 | mov r3, sp @ pass SP |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 152 | b \cxx_name @ \cxx_name(Thread*, SP) |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 153 | END \c_name |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 154 | .endm |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 155 | |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 156 | /* |
| 157 | * Called by managed code, saves callee saves and then calls artThrowException |
| 158 | * that will place a mock Method* at the bottom of the stack. Arg1 holds the exception. |
| 159 | */ |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 160 | ONE_ARG_RUNTIME_EXCEPTION art_quick_deliver_exception, artDeliverExceptionFromCode |
Ian Rogers | 932746a | 2011-09-22 18:57:50 -0700 | [diff] [blame] | 161 | |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 162 | /* |
| 163 | * Called by managed code to create and deliver a NullPointerException. |
| 164 | */ |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 165 | NO_ARG_RUNTIME_EXCEPTION art_quick_throw_null_pointer_exception, artThrowNullPointerExceptionFromCode |
Ian Rogers | c0c8dc8 | 2011-09-24 18:15:59 -0700 | [diff] [blame] | 166 | |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 167 | /* |
| 168 | * Called by managed code to create and deliver an ArithmeticException. |
| 169 | */ |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 170 | NO_ARG_RUNTIME_EXCEPTION art_quick_throw_div_zero, artThrowDivZeroFromCode |
Ian Rogers | c0c8dc8 | 2011-09-24 18:15:59 -0700 | [diff] [blame] | 171 | |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 172 | /* |
| 173 | * Called by managed code to create and deliver an ArrayIndexOutOfBoundsException. Arg1 holds |
| 174 | * index, arg2 holds limit. |
| 175 | */ |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 176 | TWO_ARG_RUNTIME_EXCEPTION art_quick_throw_array_bounds, artThrowArrayBoundsFromCode |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 177 | |
| 178 | /* |
| 179 | * Called by managed code to create and deliver a StackOverflowError. |
| 180 | */ |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 181 | NO_ARG_RUNTIME_EXCEPTION art_quick_throw_stack_overflow, artThrowStackOverflowFromCode |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 182 | |
| 183 | /* |
| 184 | * Called by managed code to create and deliver a NoSuchMethodError. |
| 185 | */ |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 186 | ONE_ARG_RUNTIME_EXCEPTION art_quick_throw_no_such_method, artThrowNoSuchMethodFromCode |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 187 | |
| 188 | /* |
Ian Rogers | c8b306f | 2012-02-17 21:34:44 -0800 | [diff] [blame] | 189 | * All generated callsites for interface invokes and invocation slow paths will load arguments |
| 190 | * as usual - except instead of loading arg0/r0 with the target Method*, arg0/r0 will contain |
| 191 | * the method_idx. This wrapper will save arg1-arg3, load the caller's Method*, align the |
| 192 | * stack and call the appropriate C helper. |
Elliott Hughes | 634eb2e | 2012-03-22 16:06:28 -0700 | [diff] [blame] | 193 | * NOTE: "this" is first visible argument of the target, and so can be found in arg1/r1. |
buzbee | 4a3164f | 2011-09-03 11:25:10 -0700 | [diff] [blame] | 194 | * |
Ian Rogers | c8b306f | 2012-02-17 21:34:44 -0800 | [diff] [blame] | 195 | * The helper will attempt to locate the target and return a 64-bit result in r0/r1 consisting |
| 196 | * of the target Method* in r0 and method->code_ in r1. |
buzbee | 4a3164f | 2011-09-03 11:25:10 -0700 | [diff] [blame] | 197 | * |
Ian Rogers | c8b306f | 2012-02-17 21:34:44 -0800 | [diff] [blame] | 198 | * If unsuccessful, the helper will return NULL/NULL. There will bea pending exception in the |
| 199 | * thread and we branch to another stub to deliver it. |
buzbee | 4a3164f | 2011-09-03 11:25:10 -0700 | [diff] [blame] | 200 | * |
Ian Rogers | ff1ed47 | 2011-09-20 13:46:24 -0700 | [diff] [blame] | 201 | * On success this wrapper will restore arguments and *jump* to the target, leaving the lr |
| 202 | * pointing back to the original caller. |
buzbee | 4a3164f | 2011-09-03 11:25:10 -0700 | [diff] [blame] | 203 | */ |
Ian Rogers | c8b306f | 2012-02-17 21:34:44 -0800 | [diff] [blame] | 204 | .macro INVOKE_TRAMPOLINE c_name, cxx_name |
Ian Rogers | c8b306f | 2012-02-17 21:34:44 -0800 | [diff] [blame] | 205 | .extern \cxx_name |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 206 | ENTRY \c_name |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 207 | SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME @ save callee saves in case allocation triggers GC |
Ian Rogers | c8b306f | 2012-02-17 21:34:44 -0800 | [diff] [blame] | 208 | ldr r2, [sp, #48] @ pass caller Method* |
| 209 | mov r3, r9 @ pass Thread::Current |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 210 | mov r12, sp |
| 211 | str r12, [sp, #-16]! @ expand the frame and pass SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 212 | .pad #16 |
| 213 | .cfi_adjust_cfa_offset 16 |
Ian Rogers | c8b306f | 2012-02-17 21:34:44 -0800 | [diff] [blame] | 214 | bl \cxx_name @ (method_idx, this, caller, Thread*, SP) |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 215 | add sp, #16 @ strip the extra frame |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 216 | .cfi_adjust_cfa_offset -16 |
Elliott Hughes | 634eb2e | 2012-03-22 16:06:28 -0700 | [diff] [blame] | 217 | mov r12, r1 @ save Method*->code_ |
Ian Rogers | a32a6fd | 2012-02-06 20:18:44 -0800 | [diff] [blame] | 218 | RESTORE_REF_AND_ARGS_CALLEE_SAVE_FRAME |
Ian Rogers | c8b306f | 2012-02-17 21:34:44 -0800 | [diff] [blame] | 219 | cmp r0, #0 @ did we find the target? |
| 220 | bxne r12 @ tail call to target if so |
Ian Rogers | a32a6fd | 2012-02-06 20:18:44 -0800 | [diff] [blame] | 221 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 222 | END \c_name |
Ian Rogers | c8b306f | 2012-02-17 21:34:44 -0800 | [diff] [blame] | 223 | .endm |
Ian Rogers | a32a6fd | 2012-02-06 20:18:44 -0800 | [diff] [blame] | 224 | |
Logan Chien | 8dbb708 | 2013-01-25 20:31:17 +0800 | [diff] [blame] | 225 | INVOKE_TRAMPOLINE art_quick_invoke_interface_trampoline, artInvokeInterfaceTrampoline |
| 226 | INVOKE_TRAMPOLINE art_quick_invoke_interface_trampoline_with_access_check, artInvokeInterfaceTrampolineWithAccessCheck |
Ian Rogers | a32a6fd | 2012-02-06 20:18:44 -0800 | [diff] [blame] | 227 | |
Logan Chien | 8dbb708 | 2013-01-25 20:31:17 +0800 | [diff] [blame] | 228 | INVOKE_TRAMPOLINE art_quick_invoke_static_trampoline_with_access_check, artInvokeStaticTrampolineWithAccessCheck |
| 229 | INVOKE_TRAMPOLINE art_quick_invoke_direct_trampoline_with_access_check, artInvokeDirectTrampolineWithAccessCheck |
| 230 | INVOKE_TRAMPOLINE art_quick_invoke_super_trampoline_with_access_check, artInvokeSuperTrampolineWithAccessCheck |
| 231 | INVOKE_TRAMPOLINE art_quick_invoke_virtual_trampoline_with_access_check, artInvokeVirtualTrampolineWithAccessCheck |
Ian Rogers | ff1ed47 | 2011-09-20 13:46:24 -0700 | [diff] [blame] | 232 | |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 233 | /* |
Jeff Hao | 6474d19 | 2013-03-26 14:08:09 -0700 | [diff] [blame] | 234 | * Quick invocation stub. |
| 235 | * On entry: |
| 236 | * r0 = method pointer |
| 237 | * r1 = argument array or NULL for no argument methods |
| 238 | * r2 = size of argument array in bytes |
| 239 | * r3 = (managed) thread pointer |
| 240 | * [sp] = JValue* result |
| 241 | * [sp + 4] = result type char |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 242 | */ |
| 243 | ENTRY art_quick_invoke_stub |
| 244 | push {r0, r4, r5, r9, r11, lr} @ spill regs |
| 245 | .save {r0, r4, r5, r9, r11, lr} |
| 246 | .pad #24 |
| 247 | .cfi_adjust_cfa_offset 24 |
| 248 | .cfi_rel_offset r0, 0 |
| 249 | .cfi_rel_offset r4, 4 |
| 250 | .cfi_rel_offset r5, 8 |
| 251 | .cfi_rel_offset r9, 12 |
| 252 | .cfi_rel_offset r11, 16 |
| 253 | .cfi_rel_offset lr, 20 |
| 254 | mov r11, sp @ save the stack pointer |
| 255 | .cfi_def_cfa_register r11 |
| 256 | mov r9, r3 @ move managed thread pointer into r9 |
| 257 | mov r4, #SUSPEND_CHECK_INTERVAL @ reset r4 to suspend check interval |
| 258 | add r5, r2, #16 @ create space for method pointer in frame |
Jeff Hao | 6474d19 | 2013-03-26 14:08:09 -0700 | [diff] [blame] | 259 | and r5, #0xFFFFFFF0 @ align frame size to 16 bytes |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 260 | sub sp, r5 @ reserve stack space for argument array |
| 261 | add r0, sp, #4 @ pass stack pointer + method ptr as dest for memcpy |
| 262 | bl memcpy @ memcpy (dest, src, bytes) |
| 263 | ldr r0, [r11] @ restore method* |
| 264 | ldr r1, [sp, #4] @ copy arg value for r1 |
| 265 | ldr r2, [sp, #8] @ copy arg value for r2 |
| 266 | ldr r3, [sp, #12] @ copy arg value for r3 |
| 267 | mov ip, #0 @ set ip to 0 |
| 268 | str ip, [sp] @ store NULL for method* at bottom of frame |
| 269 | ldr ip, [r0, #METHOD_CODE_OFFSET] @ get pointer to the code |
| 270 | blx ip @ call the method |
Jeff Hao | 6474d19 | 2013-03-26 14:08:09 -0700 | [diff] [blame] | 271 | mov sp, r11 @ restore the stack pointer |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 272 | ldr ip, [sp, #24] @ load the result pointer |
| 273 | strd r0, [ip] @ store r0/r1 into result pointer |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 274 | pop {r0, r4, r5, r9, r11, lr} @ restore spill regs |
| 275 | .cfi_adjust_cfa_offset -24 |
| 276 | bx lr |
| 277 | END art_quick_invoke_stub |
Jeff Hao | 6474d19 | 2013-03-26 14:08:09 -0700 | [diff] [blame] | 278 | |
Jeff Hao | 5d91730 | 2013-02-27 17:57:33 -0800 | [diff] [blame] | 279 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 280 | * On entry r0 is uint32_t* gprs_ and r1 is uint32_t* fprs_ |
| 281 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 282 | ENTRY art_quick_do_long_jump |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 283 | vldm r1, {s0-s31} @ load all fprs from argument fprs_ |
| 284 | ldr r2, [r0, #60] @ r2 = r15 (PC from gprs_ 60=4*15) |
| 285 | add r0, r0, #12 @ increment r0 to skip gprs_[0..2] 12=4*3 |
| 286 | ldm r0, {r3-r14} @ load remaining gprs from argument gprs_ |
| 287 | mov r0, #0 @ clear result registers r0 and r1 |
| 288 | mov r1, #0 |
| 289 | bx r2 @ do long jump |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 290 | END art_quick_do_long_jump |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 291 | |
Ian Rogers | 60db5ab | 2012-02-20 17:02:00 -0800 | [diff] [blame] | 292 | /* |
Ian Rogers | ff1ed47 | 2011-09-20 13:46:24 -0700 | [diff] [blame] | 293 | * Entry from managed code that calls artHandleFillArrayDataFromCode and delivers exception on |
| 294 | * failure. |
| 295 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 296 | .extern artHandleFillArrayDataFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 297 | ENTRY art_quick_handle_fill_data |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 298 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case exception allocation triggers GC |
| 299 | mov r2, r9 @ pass Thread::Current |
| 300 | mov r3, sp @ pass SP |
Elliott Hughes | af778e6 | 2012-05-01 18:45:31 -0700 | [diff] [blame] | 301 | bl artHandleFillArrayDataFromCode @ (Array*, const DexFile::Payload*, Thread*, SP) |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 302 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 303 | cmp r0, #0 @ success? |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 304 | bxeq lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 305 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 306 | END art_quick_handle_fill_data |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 307 | |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 308 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 309 | * Entry from managed code that calls artLockObjectFromCode, may block for GC. |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 310 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 311 | .extern artLockObjectFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 312 | ENTRY art_quick_lock_object |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 313 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case we block |
| 314 | mov r1, r9 @ pass Thread::Current |
| 315 | mov r2, sp @ pass SP |
| 316 | bl artLockObjectFromCode @ (Object* obj, Thread*, SP) |
| 317 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME_AND_RETURN |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 318 | END art_quick_lock_object |
Ian Rogers | ff1ed47 | 2011-09-20 13:46:24 -0700 | [diff] [blame] | 319 | |
Ian Rogers | ff1ed47 | 2011-09-20 13:46:24 -0700 | [diff] [blame] | 320 | /* |
| 321 | * Entry from managed code that calls artUnlockObjectFromCode and delivers exception on failure. |
| 322 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 323 | .extern artUnlockObjectFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 324 | ENTRY art_quick_unlock_object |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 325 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case exception allocation triggers GC |
| 326 | mov r1, r9 @ pass Thread::Current |
| 327 | mov r2, sp @ pass SP |
| 328 | bl artUnlockObjectFromCode @ (Object* obj, Thread*, SP) |
| 329 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 330 | cmp r0, #0 @ success? |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 331 | bxeq lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 332 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 333 | END art_quick_unlock_object |
Ian Rogers | ff1ed47 | 2011-09-20 13:46:24 -0700 | [diff] [blame] | 334 | |
Ian Rogers | ff1ed47 | 2011-09-20 13:46:24 -0700 | [diff] [blame] | 335 | /* |
| 336 | * Entry from managed code that calls artCheckCastFromCode and delivers exception on failure. |
| 337 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 338 | .extern artCheckCastFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 339 | ENTRY art_quick_check_cast |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 340 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case exception allocation triggers GC |
| 341 | mov r2, r9 @ pass Thread::Current |
| 342 | mov r3, sp @ pass SP |
| 343 | bl artCheckCastFromCode @ (Class* a, Class* b, Thread*, SP) |
| 344 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 345 | cmp r0, #0 @ success? |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 346 | bxeq lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 347 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 348 | END art_quick_check_cast |
buzbee | 4a3164f | 2011-09-03 11:25:10 -0700 | [diff] [blame] | 349 | |
Ian Rogers | e51a511 | 2011-09-23 14:16:35 -0700 | [diff] [blame] | 350 | /* |
| 351 | * Entry from managed code that calls artCanPutArrayElementFromCode and delivers exception on |
| 352 | * failure. |
| 353 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 354 | .extern artCanPutArrayElementFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 355 | ENTRY art_quick_can_put_array_element |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 356 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case exception allocation triggers GC |
| 357 | mov r2, r9 @ pass Thread::Current |
| 358 | mov r3, sp @ pass SP |
| 359 | bl artCanPutArrayElementFromCode @ (Object* element, Class* array_class, Thread*, SP) |
| 360 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 361 | cmp r0, #0 @ success? |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 362 | bxeq lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 363 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 364 | END art_quick_can_put_array_element |
Ian Rogers | e51a511 | 2011-09-23 14:16:35 -0700 | [diff] [blame] | 365 | |
Ian Rogers | cbba6ac | 2011-09-22 16:28:37 -0700 | [diff] [blame] | 366 | /* |
| 367 | * Entry from managed code when uninitialized static storage, this stub will run the class |
| 368 | * initializer and deliver the exception on error. On success the static storage base is |
| 369 | * returned. |
| 370 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 371 | .extern artInitializeStaticStorageFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 372 | ENTRY art_quick_initialize_static_storage |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 373 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 374 | mov r2, r9 @ pass Thread::Current |
| 375 | mov r3, sp @ pass SP |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 376 | @ artInitializeStaticStorageFromCode(uint32_t type_idx, Method* referrer, Thread*, SP) |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 377 | bl artInitializeStaticStorageFromCode |
| 378 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 379 | cmp r0, #0 @ success if result is non-null |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 380 | bxne lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 381 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 382 | END art_quick_initialize_static_storage |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 383 | |
Ian Rogers | 28ad40d | 2011-10-27 15:19:26 -0700 | [diff] [blame] | 384 | /* |
| 385 | * Entry from managed code when dex cache misses for a type_idx |
| 386 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 387 | .extern artInitializeTypeFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 388 | ENTRY art_quick_initialize_type |
Ian Rogers | 28ad40d | 2011-10-27 15:19:26 -0700 | [diff] [blame] | 389 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 390 | mov r2, r9 @ pass Thread::Current |
| 391 | mov r3, sp @ pass SP |
| 392 | @ artInitializeTypeFromCode(uint32_t type_idx, Method* referrer, Thread*, SP) |
| 393 | bl artInitializeTypeFromCode |
| 394 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 395 | cmp r0, #0 @ success if result is non-null |
| 396 | bxne lr @ return on success |
| 397 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 398 | END art_quick_initialize_type |
Ian Rogers | 28ad40d | 2011-10-27 15:19:26 -0700 | [diff] [blame] | 399 | |
Ian Rogers | b093c6b | 2011-10-31 16:19:55 -0700 | [diff] [blame] | 400 | /* |
| 401 | * Entry from managed code when type_idx needs to be checked for access and dex cache may also |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 402 | * miss. |
Ian Rogers | b093c6b | 2011-10-31 16:19:55 -0700 | [diff] [blame] | 403 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 404 | .extern artInitializeTypeAndVerifyAccessFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 405 | ENTRY art_quick_initialize_type_and_verify_access |
Ian Rogers | b093c6b | 2011-10-31 16:19:55 -0700 | [diff] [blame] | 406 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 407 | mov r2, r9 @ pass Thread::Current |
| 408 | mov r3, sp @ pass SP |
Elliott Hughes | 8a1ea9f | 2012-04-16 20:41:17 -0700 | [diff] [blame] | 409 | @ artInitializeTypeAndVerifyAccessFromCode(uint32_t type_idx, Method* referrer, Thread*, SP) |
Ian Rogers | b093c6b | 2011-10-31 16:19:55 -0700 | [diff] [blame] | 410 | bl artInitializeTypeAndVerifyAccessFromCode |
| 411 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 412 | cmp r0, #0 @ success if result is non-null |
| 413 | bxne lr @ return on success |
| 414 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 415 | END art_quick_initialize_type_and_verify_access |
Ian Rogers | b093c6b | 2011-10-31 16:19:55 -0700 | [diff] [blame] | 416 | |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 417 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 418 | * Called by managed code to resolve a static field and load a 32-bit primitive value. |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 419 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 420 | .extern artGet32StaticFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 421 | ENTRY art_quick_get32_static |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 422 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 423 | ldr r1, [sp, #32] @ pass referrer |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 424 | mov r2, r9 @ pass Thread::Current |
| 425 | mov r3, sp @ pass SP |
| 426 | bl artGet32StaticFromCode @ (uint32_t field_idx, const Method* referrer, Thread*, SP) |
| 427 | ldr r12, [r9, #THREAD_EXCEPTION_OFFSET] @ load Thread::Current()->exception_ |
| 428 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 429 | cmp r12, #0 @ success if no exception is pending |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 430 | bxeq lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 431 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 432 | END art_quick_get32_static |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 433 | |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 434 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 435 | * Called by managed code to resolve a static field and load a 64-bit primitive value. |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 436 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 437 | .extern artGet64StaticFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 438 | ENTRY art_quick_get64_static |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 439 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 440 | ldr r1, [sp, #32] @ pass referrer |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 441 | mov r2, r9 @ pass Thread::Current |
| 442 | mov r3, sp @ pass SP |
| 443 | bl artGet64StaticFromCode @ (uint32_t field_idx, const Method* referrer, Thread*, SP) |
| 444 | ldr r12, [r9, #THREAD_EXCEPTION_OFFSET] @ load Thread::Current()->exception_ |
| 445 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 446 | cmp r12, #0 @ success if no exception is pending |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 447 | bxeq lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 448 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 449 | END art_quick_get64_static |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 450 | |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 451 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 452 | * Called by managed code to resolve a static field and load an object reference. |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 453 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 454 | .extern artGetObjStaticFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 455 | ENTRY art_quick_get_obj_static |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 456 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 457 | ldr r1, [sp, #32] @ pass referrer |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 458 | mov r2, r9 @ pass Thread::Current |
| 459 | mov r3, sp @ pass SP |
| 460 | bl artGetObjStaticFromCode @ (uint32_t field_idx, const Method* referrer, Thread*, SP) |
| 461 | ldr r12, [r9, #THREAD_EXCEPTION_OFFSET] @ load Thread::Current()->exception_ |
| 462 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 463 | cmp r12, #0 @ success if no exception is pending |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 464 | bxeq lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 465 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 466 | END art_quick_get_obj_static |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 467 | |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 468 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 469 | * Called by managed code to resolve an instance field and load a 32-bit primitive value. |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 470 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 471 | .extern artGet32InstanceFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 472 | ENTRY art_quick_get32_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 473 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 474 | ldr r2, [sp, #32] @ pass referrer |
| 475 | mov r3, r9 @ pass Thread::Current |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 476 | mov r12, sp |
| 477 | str r12, [sp, #-16]! @ expand the frame and pass SP |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 478 | bl artGet32InstanceFromCode @ (field_idx, Object*, referrer, Thread*, SP) |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 479 | add sp, #16 @ strip the extra frame |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 480 | ldr r12, [r9, #THREAD_EXCEPTION_OFFSET] @ load Thread::Current()->exception_ |
| 481 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 482 | cmp r12, #0 @ success if no exception is pending |
| 483 | bxeq lr @ return on success |
| 484 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 485 | END art_quick_get32_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 486 | |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 487 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 488 | * Called by managed code to resolve an instance field and load a 64-bit primitive value. |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 489 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 490 | .extern artGet64InstanceFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 491 | ENTRY art_quick_get64_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 492 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 493 | ldr r2, [sp, #32] @ pass referrer |
| 494 | mov r3, r9 @ pass Thread::Current |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 495 | mov r12, sp |
| 496 | str r12, [sp, #-16]! @ expand the frame and pass SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 497 | .pad #16 |
| 498 | .cfi_adjust_cfa_offset 16 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 499 | bl artGet64InstanceFromCode @ (field_idx, Object*, referrer, Thread*, SP) |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 500 | add sp, #16 @ strip the extra frame |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 501 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 502 | ldr r12, [r9, #THREAD_EXCEPTION_OFFSET] @ load Thread::Current()->exception_ |
| 503 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 504 | cmp r12, #0 @ success if no exception is pending |
| 505 | bxeq lr @ return on success |
| 506 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 507 | END art_quick_get64_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 508 | |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 509 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 510 | * Called by managed code to resolve an instance field and load an object reference. |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 511 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 512 | .extern artGetObjInstanceFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 513 | ENTRY art_quick_get_obj_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 514 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 515 | ldr r2, [sp, #32] @ pass referrer |
| 516 | mov r3, r9 @ pass Thread::Current |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 517 | mov r12, sp |
| 518 | str r12, [sp, #-16]! @ expand the frame and pass SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 519 | .pad #16 |
| 520 | .cfi_adjust_cfa_offset 16 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 521 | bl artGetObjInstanceFromCode @ (field_idx, Object*, referrer, Thread*, SP) |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 522 | add sp, #16 @ strip the extra frame |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 523 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 524 | ldr r12, [r9, #THREAD_EXCEPTION_OFFSET] @ load Thread::Current()->exception_ |
| 525 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 526 | cmp r12, #0 @ success if no exception is pending |
| 527 | bxeq lr @ return on success |
| 528 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 529 | END art_quick_get_obj_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 530 | |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 531 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 532 | * Called by managed code to resolve a static field and store a 32-bit primitive value. |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 533 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 534 | .extern artSet32StaticFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 535 | ENTRY art_quick_set32_static |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 536 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 537 | ldr r2, [sp, #32] @ pass referrer |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 538 | mov r3, r9 @ pass Thread::Current |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 539 | mov r12, sp |
| 540 | str r12, [sp, #-16]! @ expand the frame and pass SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 541 | .pad #16 |
| 542 | .cfi_adjust_cfa_offset 16 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 543 | bl artSet32StaticFromCode @ (field_idx, new_val, referrer, Thread*, SP) |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 544 | add sp, #16 @ strip the extra frame |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 545 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 546 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 547 | cmp r0, #0 @ success if result is 0 |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 548 | bxeq lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 549 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 550 | END art_quick_set32_static |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 551 | |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 552 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 553 | * Called by managed code to resolve a static field and store a 64-bit primitive value. |
Brian Carlstrom | 19abfb4 | 2012-04-01 16:58:53 -0700 | [diff] [blame] | 554 | * On entry r0 holds field index, r1:r2 hold new_val |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 555 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 556 | .extern artSet64StaticFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 557 | ENTRY art_quick_set64_static |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 558 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
Brian Carlstrom | 19abfb4 | 2012-04-01 16:58:53 -0700 | [diff] [blame] | 559 | mov r3, r2 @ pass one half of wide argument |
| 560 | mov r2, r1 @ pass other half of wide argument |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 561 | ldr r1, [sp, #32] @ pass referrer |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 562 | mov r12, sp @ save SP |
| 563 | sub sp, #8 @ grow frame for alignment with stack args |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 564 | .pad #8 |
| 565 | .cfi_adjust_cfa_offset 8 |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 566 | push {r9, r12} @ pass Thread::Current and SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 567 | .save {r9, r12} |
| 568 | .cfi_adjust_cfa_offset 8 |
| 569 | .cfi_rel_offset r9, 0 |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 570 | bl artSet64StaticFromCode @ (field_idx, referrer, new_val, Thread*, SP) |
| 571 | add sp, #16 @ release out args |
| 572 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME @ TODO: we can clearly save an add here |
| 573 | cmp r0, #0 @ success if result is 0 |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 574 | bxeq lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 575 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 576 | END art_quick_set64_static |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 577 | |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 578 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 579 | * Called by managed code to resolve a static field and store an object reference. |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 580 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 581 | .extern artSetObjStaticFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 582 | ENTRY art_quick_set_obj_static |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 583 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 584 | ldr r2, [sp, #32] @ pass referrer |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 585 | mov r3, r9 @ pass Thread::Current |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 586 | mov r12, sp |
| 587 | str r12, [sp, #-16]! @ expand the frame and pass SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 588 | .pad #16 |
| 589 | .cfi_adjust_cfa_offset 16 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 590 | bl artSetObjStaticFromCode @ (field_idx, new_val, referrer, Thread*, SP) |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 591 | add sp, #16 @ strip the extra frame |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 592 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 593 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 594 | cmp r0, #0 @ success if result is 0 |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 595 | bxeq lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 596 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 597 | END art_quick_set_obj_static |
Ian Rogers | cbba6ac | 2011-09-22 16:28:37 -0700 | [diff] [blame] | 598 | |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 599 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 600 | * Called by managed code to resolve an instance field and store a 32-bit primitive value. |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 601 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 602 | .extern artSet32InstanceFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 603 | ENTRY art_quick_set32_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 604 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 605 | ldr r3, [sp, #32] @ pass referrer |
| 606 | mov r12, sp @ save SP |
| 607 | sub sp, #8 @ grow frame for alignment with stack args |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 608 | .pad #8 |
| 609 | .cfi_adjust_cfa_offset 8 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 610 | push {r9, r12} @ pass Thread::Current and SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 611 | .save {r9, r12} |
| 612 | .cfi_adjust_cfa_offset 8 |
| 613 | .cfi_rel_offset r9, 0 |
| 614 | .cfi_rel_offset r12, 4 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 615 | bl artSet32InstanceFromCode @ (field_idx, Object*, new_val, referrer, Thread*, SP) |
| 616 | add sp, #16 @ release out args |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 617 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 618 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME @ TODO: we can clearly save an add here |
| 619 | cmp r0, #0 @ success if result is 0 |
| 620 | bxeq lr @ return on success |
| 621 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 622 | END art_quick_set32_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 623 | |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 624 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 625 | * Called by managed code to resolve an instance field and store a 64-bit primitive value. |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 626 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 627 | .extern artSet32InstanceFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 628 | ENTRY art_quick_set64_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 629 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 630 | mov r12, sp @ save SP |
| 631 | sub sp, #8 @ grow frame for alignment with stack args |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 632 | .pad #8 |
| 633 | .cfi_adjust_cfa_offset 8 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 634 | push {r9, r12} @ pass Thread::Current and SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 635 | .save {r9, r12} |
| 636 | .cfi_adjust_cfa_offset 8 |
| 637 | .cfi_rel_offset r9, 0 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 638 | bl artSet64InstanceFromCode @ (field_idx, Object*, new_val, Thread*, SP) |
| 639 | add sp, #16 @ release out args |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 640 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 641 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME @ TODO: we can clearly save an add here |
| 642 | cmp r0, #0 @ success if result is 0 |
| 643 | bxeq lr @ return on success |
| 644 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 645 | END art_quick_set64_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 646 | |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 647 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 648 | * Called by managed code to resolve an instance field and store an object reference. |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 649 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 650 | .extern artSetObjInstanceFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 651 | ENTRY art_quick_set_obj_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 652 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 653 | ldr r3, [sp, #32] @ pass referrer |
| 654 | mov r12, sp @ save SP |
| 655 | sub sp, #8 @ grow frame for alignment with stack args |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 656 | .pad #8 |
| 657 | .cfi_adjust_cfa_offset 8 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 658 | push {r9, r12} @ pass Thread::Current and SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 659 | .save {r9, r12} |
| 660 | .cfi_adjust_cfa_offset 8 |
| 661 | .cfi_rel_offset r9, 0 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 662 | bl artSetObjInstanceFromCode @ (field_idx, Object*, new_val, referrer, Thread*, SP) |
| 663 | add sp, #16 @ release out args |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 664 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 665 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME @ TODO: we can clearly save an add here |
| 666 | cmp r0, #0 @ success if result is 0 |
| 667 | bxeq lr @ return on success |
| 668 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 669 | END art_quick_set_obj_instance |
Ian Rogers | 1bddec3 | 2012-02-04 12:27:34 -0800 | [diff] [blame] | 670 | |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 671 | /* |
Ian Rogers | caab8c4 | 2011-10-12 12:11:18 -0700 | [diff] [blame] | 672 | * Entry from managed code to resolve a string, this stub will allocate a String and deliver an |
| 673 | * exception on error. On success the String is returned. R0 holds the referring method, |
| 674 | * R1 holds the string index. The fast path check for hit in strings cache has already been |
| 675 | * performed. |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 676 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 677 | .extern artResolveStringFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 678 | ENTRY art_quick_resolve_string |
Ian Rogers | caab8c4 | 2011-10-12 12:11:18 -0700 | [diff] [blame] | 679 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 680 | mov r2, r9 @ pass Thread::Current |
| 681 | mov r3, sp @ pass SP |
| 682 | @ artResolveStringFromCode(Method* referrer, uint32_t string_idx, Thread*, SP) |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 683 | bl artResolveStringFromCode |
| 684 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
Ian Rogers | caab8c4 | 2011-10-12 12:11:18 -0700 | [diff] [blame] | 685 | cmp r0, #0 @ success if result is non-null |
| 686 | bxne lr @ return on success |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 687 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 688 | END art_quick_resolve_string |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 689 | |
Ian Rogers | 21d9e83 | 2011-09-23 17:05:09 -0700 | [diff] [blame] | 690 | /* |
| 691 | * Called by managed code to allocate an object |
| 692 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 693 | .extern artAllocObjectFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 694 | ENTRY art_quick_alloc_object |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 695 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 696 | mov r2, r9 @ pass Thread::Current |
| 697 | mov r3, sp @ pass SP |
| 698 | bl artAllocObjectFromCode @ (uint32_t type_idx, Method* method, Thread*, SP) |
| 699 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 700 | cmp r0, #0 @ success if result is non-null |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 701 | bxne lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 702 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 703 | END art_quick_alloc_object |
Ian Rogers | 21d9e83 | 2011-09-23 17:05:09 -0700 | [diff] [blame] | 704 | |
buzbee | cc4540e | 2011-10-27 13:06:03 -0700 | [diff] [blame] | 705 | /* |
Ian Rogers | 28ad40d | 2011-10-27 15:19:26 -0700 | [diff] [blame] | 706 | * Called by managed code to allocate an object when the caller doesn't know whether it has |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 707 | * access to the created type. |
buzbee | cc4540e | 2011-10-27 13:06:03 -0700 | [diff] [blame] | 708 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 709 | .extern artAllocObjectFromCodeWithAccessCheck |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 710 | ENTRY art_quick_alloc_object_with_access_check |
buzbee | cc4540e | 2011-10-27 13:06:03 -0700 | [diff] [blame] | 711 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 712 | mov r2, r9 @ pass Thread::Current |
| 713 | mov r3, sp @ pass SP |
Ian Rogers | 28ad40d | 2011-10-27 15:19:26 -0700 | [diff] [blame] | 714 | bl artAllocObjectFromCodeWithAccessCheck @ (uint32_t type_idx, Method* method, Thread*, SP) |
buzbee | cc4540e | 2011-10-27 13:06:03 -0700 | [diff] [blame] | 715 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 716 | cmp r0, #0 @ success if result is non-null |
| 717 | bxne lr @ return on success |
| 718 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 719 | END art_quick_alloc_object_with_access_check |
buzbee | cc4540e | 2011-10-27 13:06:03 -0700 | [diff] [blame] | 720 | |
Ian Rogers | b886da8 | 2011-09-23 16:27:54 -0700 | [diff] [blame] | 721 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 722 | * Called by managed code to allocate an array. |
Ian Rogers | b886da8 | 2011-09-23 16:27:54 -0700 | [diff] [blame] | 723 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 724 | .extern artAllocArrayFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 725 | ENTRY art_quick_alloc_array |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 726 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 727 | mov r3, r9 @ pass Thread::Current |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 728 | mov r12, sp |
| 729 | str r12, [sp, #-16]! @ expand the frame and pass SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 730 | .pad #16 |
| 731 | .cfi_adjust_cfa_offset 16 |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 732 | @ artAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count, Thread*, SP) |
| 733 | bl artAllocArrayFromCode |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 734 | add sp, #16 @ strip the extra frame |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 735 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 736 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 737 | cmp r0, #0 @ success if result is non-null |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 738 | bxne lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 739 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 740 | END art_quick_alloc_array |
Ian Rogers | b886da8 | 2011-09-23 16:27:54 -0700 | [diff] [blame] | 741 | |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 742 | /* |
| 743 | * Called by managed code to allocate an array when the caller doesn't know whether it has |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 744 | * access to the created type. |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 745 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 746 | .extern artAllocArrayFromCodeWithAccessCheck |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 747 | ENTRY art_quick_alloc_array_with_access_check |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 748 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 749 | mov r3, r9 @ pass Thread::Current |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 750 | mov r12, sp |
| 751 | str r12, [sp, #-16]! @ expand the frame and pass SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 752 | .pad #16 |
| 753 | .cfi_adjust_cfa_offset 16 |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 754 | @ artAllocArrayFromCodeWithAccessCheck(type_idx, method, component_count, Thread*, SP) |
| 755 | bl artAllocArrayFromCodeWithAccessCheck |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 756 | add sp, #16 @ strip the extra frame |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 757 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 758 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 759 | cmp r0, #0 @ success if result is non-null |
| 760 | bxne lr @ return on success |
| 761 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 762 | END art_quick_alloc_array_with_access_check |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 763 | |
Ian Rogers | b886da8 | 2011-09-23 16:27:54 -0700 | [diff] [blame] | 764 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 765 | * Called by managed code to allocate an array in a special case for FILLED_NEW_ARRAY. |
Ian Rogers | b886da8 | 2011-09-23 16:27:54 -0700 | [diff] [blame] | 766 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 767 | .extern artCheckAndAllocArrayFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 768 | ENTRY art_quick_check_and_alloc_array |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 769 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 770 | mov r3, r9 @ pass Thread::Current |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 771 | mov r12, sp |
| 772 | str r12, [sp, #-16]! @ expand the frame and pass SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 773 | .pad #16 |
| 774 | .cfi_adjust_cfa_offset 16 |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 775 | @ artCheckAndAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t count, Thread* , SP) |
| 776 | bl artCheckAndAllocArrayFromCode |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 777 | add sp, #16 @ strip the extra frame |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 778 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 779 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 780 | cmp r0, #0 @ success if result is non-null |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 781 | bxne lr @ return on success |
Ian Rogers | ce9eca6 | 2011-10-07 17:11:03 -0700 | [diff] [blame] | 782 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 783 | END art_quick_check_and_alloc_array |
Ian Rogers | b886da8 | 2011-09-23 16:27:54 -0700 | [diff] [blame] | 784 | |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 785 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 786 | * Called by managed code to allocate an array in a special case for FILLED_NEW_ARRAY. |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 787 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 788 | .extern artCheckAndAllocArrayFromCodeWithAccessCheck |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 789 | ENTRY art_quick_check_and_alloc_array_with_access_check |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 790 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC |
| 791 | mov r3, r9 @ pass Thread::Current |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 792 | mov r12, sp |
| 793 | str r12, [sp, #-16]! @ expand the frame and pass SP |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 794 | .pad #16 |
| 795 | .cfi_adjust_cfa_offset 16 |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 796 | @ artCheckAndAllocArrayFromCodeWithAccessCheck(type_idx, method, count, Thread* , SP) |
| 797 | bl artCheckAndAllocArrayFromCodeWithAccessCheck |
buzbee | 865e6e0 | 2012-08-14 15:09:57 -0700 | [diff] [blame] | 798 | add sp, #16 @ strip the extra frame |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 799 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 800 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME |
| 801 | cmp r0, #0 @ success if result is non-null |
| 802 | bxne lr @ return on success |
| 803 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 804 | END art_quick_check_and_alloc_array_with_access_check |
Ian Rogers | 0eb7d7e | 2012-01-31 21:12:32 -0800 | [diff] [blame] | 805 | |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 806 | /* |
Ian Rogers | 57b86d4 | 2012-03-27 16:05:41 -0700 | [diff] [blame] | 807 | * Called by managed code when the value in rSUSPEND has been decremented to 0. |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 808 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 809 | .extern artTestSuspendFromCode |
| 810 | ENTRY art_quick_test_suspend |
Ian Rogers | 474b6da | 2012-09-25 00:20:38 -0700 | [diff] [blame] | 811 | ldrh r0, [rSELF, #THREAD_FLAGS_OFFSET] |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 812 | mov rSUSPEND, #SUSPEND_CHECK_INTERVAL @ reset rSUSPEND to SUSPEND_CHECK_INTERVAL |
| 813 | cmp r0, #0 @ check Thread::Current()->suspend_count_ == 0 |
Ian Rogers | 306057f | 2012-11-26 12:45:53 -0800 | [diff] [blame] | 814 | bxeq lr @ return if suspend_count_ == 0 |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 815 | mov r0, rSELF |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 816 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves for stack crawl |
buzbee | c10717a | 2011-10-09 14:40:13 -0700 | [diff] [blame] | 817 | mov r1, sp |
Ian Rogers | 4a510d8 | 2011-10-09 14:30:24 -0700 | [diff] [blame] | 818 | bl artTestSuspendFromCode @ (Thread*, SP) |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 819 | RESTORE_REF_ONLY_CALLEE_SAVE_FRAME_AND_RETURN |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 820 | END art_quick_test_suspend |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 821 | |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 822 | /* |
| 823 | * Called by managed code that is attempting to call a method on a proxy class. On entry |
Ian Rogers | af6e67a | 2013-01-16 08:38:37 -0800 | [diff] [blame] | 824 | * r0 holds the proxy method and r1 holds the receiver; r2 and r3 may contain arguments. The |
| 825 | * frame size of the invoked proxy method agrees with a ref and args callee save frame. |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 826 | */ |
Jeff Hao | 5fa60c3 | 2013-04-04 17:57:01 -0700 | [diff] [blame] | 827 | .extern artQuickProxyInvokeHandler |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 828 | ENTRY art_quick_proxy_invoke_handler |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 829 | SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME |
| 830 | str r0, [sp, #0] @ place proxy method at bottom of frame |
| 831 | mov r2, r9 @ pass Thread::Current |
Ian Rogers | af6e67a | 2013-01-16 08:38:37 -0800 | [diff] [blame] | 832 | mov r3, sp @ pass SP |
Jeff Hao | 5fa60c3 | 2013-04-04 17:57:01 -0700 | [diff] [blame] | 833 | blx artQuickProxyInvokeHandler @ (Method* proxy method, receiver, Thread*, SP) |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 834 | ldr r12, [r9, #THREAD_EXCEPTION_OFFSET] @ load Thread::Current()->exception_ |
Ian Rogers | 466bb25 | 2011-10-14 03:29:56 -0700 | [diff] [blame] | 835 | ldr lr, [sp, #44] @ restore lr |
Ian Rogers | 466bb25 | 2011-10-14 03:29:56 -0700 | [diff] [blame] | 836 | add sp, #48 @ pop frame |
Jeff Hao | d4c3f7d | 2013-02-14 14:14:44 -0800 | [diff] [blame] | 837 | .cfi_adjust_cfa_offset -48 |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 838 | cmp r12, #0 @ success if no exception is pending |
| 839 | bxeq lr @ return on success |
| 840 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 841 | END art_quick_proxy_invoke_handler |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 842 | |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 843 | .extern artQuickResolutionTrampoline |
| 844 | ENTRY art_quick_resolution_trampoline |
Ian Rogers | 7db619b | 2013-01-16 18:35:48 -0800 | [diff] [blame] | 845 | SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 846 | mov r2, r9 @ pass Thread::Current |
| 847 | mov r3, sp @ pass SP |
| 848 | blx artQuickResolutionTrampoline @ (Method* called, receiver, Thread*, SP) |
| 849 | cmp r0, #0 @ is code pointer null? |
| 850 | beq 1f @ goto exception |
| 851 | mov r12, r0 |
| 852 | ldr r0, [sp, #0] @ load resolved method in r0 |
| 853 | ldr r1, [sp, #8] @ restore non-callee save r1 |
| 854 | ldrd r2, [sp, #12] @ restore non-callee saves r2-r3 |
| 855 | ldr lr, [sp, #44] @ restore lr |
| 856 | add sp, #48 @ rewind sp |
| 857 | .cfi_adjust_cfa_offset -48 |
| 858 | bx r12 @ tail-call into actual code |
| 859 | 1: |
| 860 | RESTORE_REF_AND_ARGS_CALLEE_SAVE_FRAME |
| 861 | DELIVER_PENDING_EXCEPTION |
| 862 | END art_quick_resolution_trampoline |
| 863 | |
| 864 | .extern artQuickToInterpreterBridge |
| 865 | ENTRY art_quick_to_interpreter_bridge |
| 866 | SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME |
Ian Rogers | 7db619b | 2013-01-16 18:35:48 -0800 | [diff] [blame] | 867 | mov r1, r9 @ pass Thread::Current |
| 868 | mov r2, sp @ pass SP |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 869 | blx artQuickToInterpreterBridge @ (Method* method, Thread*, SP) |
Ian Rogers | 7db619b | 2013-01-16 18:35:48 -0800 | [diff] [blame] | 870 | ldr r12, [r9, #THREAD_EXCEPTION_OFFSET] @ load Thread::Current()->exception_ |
| 871 | ldr lr, [sp, #44] @ restore lr |
| 872 | add sp, #48 @ pop frame |
Jeff Hao | d4c3f7d | 2013-02-14 14:14:44 -0800 | [diff] [blame] | 873 | .cfi_adjust_cfa_offset -48 |
Ian Rogers | 7db619b | 2013-01-16 18:35:48 -0800 | [diff] [blame] | 874 | cmp r12, #0 @ success if no exception is pending |
| 875 | bxeq lr @ return on success |
| 876 | DELIVER_PENDING_EXCEPTION |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 877 | END art_quick_to_interpreter_bridge |
Ian Rogers | 7db619b | 2013-01-16 18:35:48 -0800 | [diff] [blame] | 878 | |
jeffhao | e343b76 | 2011-12-05 16:36:44 -0800 | [diff] [blame] | 879 | /* |
jeffhao | 0791adc | 2012-04-04 11:14:32 -0700 | [diff] [blame] | 880 | * Routine that intercepts method calls and returns. |
jeffhao | e343b76 | 2011-12-05 16:36:44 -0800 | [diff] [blame] | 881 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 882 | .extern artInstrumentationMethodEntryFromCode |
| 883 | .extern artInstrumentationMethodExitFromCode |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 884 | ENTRY art_quick_instrumentation_entry |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 885 | SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME |
| 886 | str r0, [sp, #4] @ preserve r0 |
| 887 | mov r12, sp @ remember sp |
| 888 | str lr, [sp, #-16]! @ expand the frame and pass LR |
| 889 | .pad #16 |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 890 | .cfi_adjust_cfa_offset 16 |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 891 | .cfi_rel_offset lr, 0 |
| 892 | mov r2, r9 @ pass Thread::Current |
| 893 | mov r3, r12 @ pass SP |
| 894 | blx artInstrumentationMethodEntryFromCode @ (Method*, Object*, Thread*, SP, LR) |
| 895 | add sp, #16 @ remove out argument and padding from stack |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 896 | .cfi_adjust_cfa_offset -16 |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 897 | mov r12, r0 @ r12 holds reference to code |
| 898 | ldr r0, [sp, #4] @ restore r0 |
| 899 | RESTORE_REF_AND_ARGS_CALLEE_SAVE_FRAME |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 900 | blx r12 @ call method with lr set to art_quick_instrumentation_exit |
| 901 | END art_quick_instrumentation_entry |
| 902 | .type art_quick_instrumentation_exit, #function |
| 903 | .global art_quick_instrumentation_exit |
| 904 | art_quick_instrumentation_exit: |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 905 | .cfi_startproc |
| 906 | .fnstart |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 907 | mov lr, #0 @ link register is to here, so clobber with 0 for later checks |
| 908 | SETUP_REF_ONLY_CALLEE_SAVE_FRAME |
Ian Rogers | 306057f | 2012-11-26 12:45:53 -0800 | [diff] [blame] | 909 | mov r12, sp @ remember bottom of caller's frame |
jeffhao | e343b76 | 2011-12-05 16:36:44 -0800 | [diff] [blame] | 910 | push {r0-r1} @ save return value |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 911 | .save {r0-r1} |
| 912 | .cfi_adjust_cfa_offset 8 |
| 913 | .cfi_rel_offset r0, 0 |
| 914 | .cfi_rel_offset r1, 4 |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 915 | sub sp, #8 @ space for return value argument |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 916 | .pad #8 |
| 917 | .cfi_adjust_cfa_offset 8 |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 918 | strd r0, [sp] @ r0/r1 -> [sp] for fpr_res |
| 919 | mov r2, r0 @ pass return value as gpr_res |
| 920 | mov r3, r1 |
Ian Rogers | 306057f | 2012-11-26 12:45:53 -0800 | [diff] [blame] | 921 | mov r0, r9 @ pass Thread::Current |
| 922 | mov r1, r12 @ pass SP |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 923 | blx artInstrumentationMethodExitFromCode @ (Thread*, SP, gpr_res, fpr_res) |
Ian Rogers | 306057f | 2012-11-26 12:45:53 -0800 | [diff] [blame] | 924 | add sp, #8 |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 925 | .cfi_adjust_cfa_offset -8 |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 926 | |
Ian Rogers | 306057f | 2012-11-26 12:45:53 -0800 | [diff] [blame] | 927 | mov r2, r0 @ link register saved by instrumentation |
| 928 | mov lr, r1 @ r1 is holding link register if we're to bounce to deoptimize |
jeffhao | e343b76 | 2011-12-05 16:36:44 -0800 | [diff] [blame] | 929 | pop {r0, r1} @ restore return value |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 930 | add sp, #32 @ remove callee save frame |
| 931 | .cfi_adjust_cfa_offset -32 |
Ian Rogers | 306057f | 2012-11-26 12:45:53 -0800 | [diff] [blame] | 932 | bx r2 @ return |
Ian Rogers | 468532e | 2013-08-05 10:56:33 -0700 | [diff] [blame^] | 933 | END art_quick_instrumentation_exit |
Ian Rogers | 306057f | 2012-11-26 12:45:53 -0800 | [diff] [blame] | 934 | |
Ian Rogers | 306057f | 2012-11-26 12:45:53 -0800 | [diff] [blame] | 935 | /* |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 936 | * Instrumentation has requested that we deoptimize into the interpreter. The deoptimization |
| 937 | * will long jump to the upcall with a special exception of -1. |
Ian Rogers | 306057f | 2012-11-26 12:45:53 -0800 | [diff] [blame] | 938 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 939 | .extern artDeoptimize |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 940 | ENTRY art_quick_deoptimize |
Jeff Hao | 14dd5a8 | 2013-04-11 10:23:36 -0700 | [diff] [blame] | 941 | SETUP_SAVE_ALL_CALLEE_SAVE_FRAME |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 942 | mov r0, r9 @ Set up args. |
| 943 | mov r1, sp |
| 944 | blx artDeoptimize @ artDeoptimize(Thread*, SP) |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 945 | END art_quick_deoptimize |
jeffhao | e343b76 | 2011-12-05 16:36:44 -0800 | [diff] [blame] | 946 | |
Ian Rogers | 324e190 | 2012-09-09 12:17:52 -0700 | [diff] [blame] | 947 | /* |
| 948 | * Signed 64-bit integer multiply. |
| 949 | * |
| 950 | * Consider WXxYZ (r1r0 x r3r2) with a long multiply: |
| 951 | * WX |
| 952 | * x YZ |
| 953 | * -------- |
| 954 | * ZW ZX |
| 955 | * YW YX |
| 956 | * |
| 957 | * The low word of the result holds ZX, the high word holds |
| 958 | * (ZW+YX) + (the high overflow from ZX). YW doesn't matter because |
| 959 | * it doesn't fit in the low 64 bits. |
| 960 | * |
| 961 | * Unlike most ARM math operations, multiply instructions have |
| 962 | * restrictions on using the same register more than once (Rd and Rm |
| 963 | * cannot be the same). |
| 964 | */ |
| 965 | /* mul-long vAA, vBB, vCC */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 966 | ENTRY art_quick_mul_long |
Ian Rogers | 324e190 | 2012-09-09 12:17:52 -0700 | [diff] [blame] | 967 | push {r9 - r10} |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 968 | .save {r9 - r10} |
| 969 | .cfi_adjust_cfa_offset 8 |
| 970 | .cfi_rel_offset r9, 0 |
| 971 | .cfi_rel_offset r10, 4 |
Ian Rogers | 324e190 | 2012-09-09 12:17:52 -0700 | [diff] [blame] | 972 | mul ip, r2, r1 @ ip<- ZxW |
| 973 | umull r9, r10, r2, r0 @ r9/r10 <- ZxX |
| 974 | mla r2, r0, r3, ip @ r2<- YxX + (ZxW) |
| 975 | add r10, r2, r10 @ r10<- r10 + low(ZxW + (YxX)) |
| 976 | mov r0,r9 |
| 977 | mov r1,r10 |
| 978 | pop {r9 - r10} |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 979 | .cfi_adjust_cfa_offset -8 |
Ian Rogers | 324e190 | 2012-09-09 12:17:52 -0700 | [diff] [blame] | 980 | bx lr |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 981 | END art_quick_mul_long |
Ian Rogers | 324e190 | 2012-09-09 12:17:52 -0700 | [diff] [blame] | 982 | |
buzbee | 5433072 | 2011-08-23 16:46:55 -0700 | [diff] [blame] | 983 | /* |
| 984 | * Long integer shift. This is different from the generic 32/64-bit |
| 985 | * binary operations because vAA/vBB are 64-bit but vCC (the shift |
| 986 | * distance) is 32-bit. Also, Dalvik requires us to ignore all but the low |
| 987 | * 6 bits. |
| 988 | * On entry: |
| 989 | * r0: low word |
| 990 | * r1: high word |
| 991 | * r2: shift count |
| 992 | */ |
| 993 | /* shl-long vAA, vBB, vCC */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 994 | ENTRY art_quick_shl_long |
buzbee | 5433072 | 2011-08-23 16:46:55 -0700 | [diff] [blame] | 995 | and r2, r2, #63 @ r2<- r2 & 0x3f |
| 996 | mov r1, r1, asl r2 @ r1<- r1 << r2 |
| 997 | rsb r3, r2, #32 @ r3<- 32 - r2 |
| 998 | orr r1, r1, r0, lsr r3 @ r1<- r1 | (r0 << (32-r2)) |
| 999 | subs ip, r2, #32 @ ip<- r2 - 32 |
| 1000 | movpl r1, r0, asl ip @ if r2 >= 32, r1<- r0 << (r2-32) |
| 1001 | mov r0, r0, asl r2 @ r0<- r0 << r2 |
| 1002 | bx lr |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 1003 | END art_quick_shl_long |
buzbee | 5433072 | 2011-08-23 16:46:55 -0700 | [diff] [blame] | 1004 | |
buzbee | 5433072 | 2011-08-23 16:46:55 -0700 | [diff] [blame] | 1005 | /* |
| 1006 | * Long integer shift. This is different from the generic 32/64-bit |
| 1007 | * binary operations because vAA/vBB are 64-bit but vCC (the shift |
| 1008 | * distance) is 32-bit. Also, Dalvik requires us to ignore all but the low |
| 1009 | * 6 bits. |
| 1010 | * On entry: |
| 1011 | * r0: low word |
| 1012 | * r1: high word |
| 1013 | * r2: shift count |
| 1014 | */ |
| 1015 | /* shr-long vAA, vBB, vCC */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 1016 | ENTRY art_quick_shr_long |
buzbee | 5433072 | 2011-08-23 16:46:55 -0700 | [diff] [blame] | 1017 | and r2, r2, #63 @ r0<- r0 & 0x3f |
| 1018 | mov r0, r0, lsr r2 @ r0<- r2 >> r2 |
| 1019 | rsb r3, r2, #32 @ r3<- 32 - r2 |
| 1020 | orr r0, r0, r1, asl r3 @ r0<- r0 | (r1 << (32-r2)) |
| 1021 | subs ip, r2, #32 @ ip<- r2 - 32 |
| 1022 | movpl r0, r1, asr ip @ if r2 >= 32, r0<-r1 >> (r2-32) |
| 1023 | mov r1, r1, asr r2 @ r1<- r1 >> r2 |
| 1024 | bx lr |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 1025 | END art_quick_shr_long |
buzbee | 5433072 | 2011-08-23 16:46:55 -0700 | [diff] [blame] | 1026 | |
buzbee | 5433072 | 2011-08-23 16:46:55 -0700 | [diff] [blame] | 1027 | /* |
| 1028 | * Long integer shift. This is different from the generic 32/64-bit |
| 1029 | * binary operations because vAA/vBB are 64-bit but vCC (the shift |
| 1030 | * distance) is 32-bit. Also, Dalvik requires us to ignore all but the low |
| 1031 | * 6 bits. |
| 1032 | * On entry: |
| 1033 | * r0: low word |
| 1034 | * r1: high word |
| 1035 | * r2: shift count |
| 1036 | */ |
| 1037 | /* ushr-long vAA, vBB, vCC */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 1038 | ENTRY art_quick_ushr_long |
buzbee | 5433072 | 2011-08-23 16:46:55 -0700 | [diff] [blame] | 1039 | and r2, r2, #63 @ r0<- r0 & 0x3f |
| 1040 | mov r0, r0, lsr r2 @ r0<- r2 >> r2 |
| 1041 | rsb r3, r2, #32 @ r3<- 32 - r2 |
| 1042 | orr r0, r0, r1, asl r3 @ r0<- r0 | (r1 << (32-r2)) |
| 1043 | subs ip, r2, #32 @ ip<- r2 - 32 |
| 1044 | movpl r0, r1, lsr ip @ if r2 >= 32, r0<-r1 >>> (r2-32) |
| 1045 | mov r1, r1, lsr r2 @ r1<- r1 >>> r2 |
| 1046 | bx lr |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 1047 | END art_quick_ushr_long |
buzbee | fc9e6fa | 2012-03-23 15:14:29 -0700 | [diff] [blame] | 1048 | |
buzbee | fc9e6fa | 2012-03-23 15:14:29 -0700 | [diff] [blame] | 1049 | /* |
| 1050 | * String's indexOf. |
| 1051 | * |
| 1052 | * On entry: |
| 1053 | * r0: string object (known non-null) |
jeffhao | 86e4671 | 2012-08-08 17:30:59 -0700 | [diff] [blame] | 1054 | * r1: char to match (known <= 0xFFFF) |
buzbee | fc9e6fa | 2012-03-23 15:14:29 -0700 | [diff] [blame] | 1055 | * r2: Starting offset in string data |
| 1056 | */ |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 1057 | ENTRY art_quick_indexof |
buzbee | fc9e6fa | 2012-03-23 15:14:29 -0700 | [diff] [blame] | 1058 | push {r4, r10-r11, lr} @ 4 words of callee saves |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 1059 | .save {r4, r10-r11, lr} |
| 1060 | .cfi_adjust_cfa_offset 16 |
| 1061 | .cfi_rel_offset r4, 0 |
| 1062 | .cfi_rel_offset r10, 4 |
| 1063 | .cfi_rel_offset r11, 8 |
| 1064 | .cfi_rel_offset lr, 12 |
buzbee | fc9e6fa | 2012-03-23 15:14:29 -0700 | [diff] [blame] | 1065 | ldr r3, [r0, #STRING_COUNT_OFFSET] |
| 1066 | ldr r12, [r0, #STRING_OFFSET_OFFSET] |
| 1067 | ldr r0, [r0, #STRING_VALUE_OFFSET] |
| 1068 | |
| 1069 | /* Clamp start to [0..count] */ |
| 1070 | cmp r2, #0 |
| 1071 | movlt r2, #0 |
| 1072 | cmp r2, r3 |
| 1073 | movgt r2, r3 |
| 1074 | |
| 1075 | /* Build a pointer to the start of string data */ |
| 1076 | add r0, #STRING_DATA_OFFSET |
| 1077 | add r0, r0, r12, lsl #1 |
| 1078 | |
| 1079 | /* Save a copy in r12 to later compute result */ |
| 1080 | mov r12, r0 |
| 1081 | |
| 1082 | /* Build pointer to start of data to compare and pre-bias */ |
| 1083 | add r0, r0, r2, lsl #1 |
| 1084 | sub r0, #2 |
| 1085 | |
| 1086 | /* Compute iteration count */ |
| 1087 | sub r2, r3, r2 |
| 1088 | |
| 1089 | /* |
| 1090 | * At this point we have: |
| 1091 | * r0: start of data to test |
| 1092 | * r1: char to compare |
| 1093 | * r2: iteration count |
| 1094 | * r12: original start of string data |
| 1095 | * r3, r4, r10, r11 available for loading string data |
| 1096 | */ |
| 1097 | |
| 1098 | subs r2, #4 |
| 1099 | blt indexof_remainder |
| 1100 | |
| 1101 | indexof_loop4: |
| 1102 | ldrh r3, [r0, #2]! |
| 1103 | ldrh r4, [r0, #2]! |
| 1104 | ldrh r10, [r0, #2]! |
| 1105 | ldrh r11, [r0, #2]! |
| 1106 | cmp r3, r1 |
| 1107 | beq match_0 |
| 1108 | cmp r4, r1 |
| 1109 | beq match_1 |
| 1110 | cmp r10, r1 |
| 1111 | beq match_2 |
| 1112 | cmp r11, r1 |
| 1113 | beq match_3 |
| 1114 | subs r2, #4 |
| 1115 | bge indexof_loop4 |
| 1116 | |
| 1117 | indexof_remainder: |
| 1118 | adds r2, #4 |
| 1119 | beq indexof_nomatch |
| 1120 | |
| 1121 | indexof_loop1: |
| 1122 | ldrh r3, [r0, #2]! |
| 1123 | cmp r3, r1 |
| 1124 | beq match_3 |
| 1125 | subs r2, #1 |
| 1126 | bne indexof_loop1 |
| 1127 | |
| 1128 | indexof_nomatch: |
| 1129 | mov r0, #-1 |
| 1130 | pop {r4, r10-r11, pc} |
| 1131 | |
| 1132 | match_0: |
| 1133 | sub r0, #6 |
| 1134 | sub r0, r12 |
| 1135 | asr r0, r0, #1 |
| 1136 | pop {r4, r10-r11, pc} |
| 1137 | match_1: |
| 1138 | sub r0, #4 |
| 1139 | sub r0, r12 |
| 1140 | asr r0, r0, #1 |
| 1141 | pop {r4, r10-r11, pc} |
| 1142 | match_2: |
| 1143 | sub r0, #2 |
| 1144 | sub r0, r12 |
| 1145 | asr r0, r0, #1 |
| 1146 | pop {r4, r10-r11, pc} |
| 1147 | match_3: |
| 1148 | sub r0, r12 |
| 1149 | asr r0, r0, #1 |
| 1150 | pop {r4, r10-r11, pc} |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 1151 | END art_quick_indexof |
buzbee | fc9e6fa | 2012-03-23 15:14:29 -0700 | [diff] [blame] | 1152 | |
| 1153 | /* |
| 1154 | * String's compareTo. |
| 1155 | * |
| 1156 | * Requires rARG0/rARG1 to have been previously checked for null. Will |
| 1157 | * return negative if this's string is < comp, 0 if they are the |
| 1158 | * same and positive if >. |
| 1159 | * |
| 1160 | * On entry: |
| 1161 | * r0: this object pointer |
| 1162 | * r1: comp object pointer |
| 1163 | * |
| 1164 | */ |
buzbee | fc9e6fa | 2012-03-23 15:14:29 -0700 | [diff] [blame] | 1165 | .extern __memcmp16 |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 1166 | ENTRY art_quick_string_compareto |
buzbee | fc9e6fa | 2012-03-23 15:14:29 -0700 | [diff] [blame] | 1167 | mov r2, r0 @ this to r2, opening up r0 for return value |
| 1168 | subs r0, r2, r1 @ Same? |
| 1169 | bxeq lr |
| 1170 | |
| 1171 | push {r4, r7-r12, lr} @ 8 words - keep alignment |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 1172 | .save {r4, r7-r12, lr} |
| 1173 | .cfi_adjust_cfa_offset 32 |
| 1174 | .cfi_rel_offset r4, 0 |
| 1175 | .cfi_rel_offset r7, 4 |
| 1176 | .cfi_rel_offset r8, 8 |
| 1177 | .cfi_rel_offset r9, 12 |
| 1178 | .cfi_rel_offset r10, 16 |
| 1179 | .cfi_rel_offset r11, 20 |
| 1180 | .cfi_rel_offset r12, 24 |
| 1181 | .cfi_rel_offset lr, 28 |
buzbee | fc9e6fa | 2012-03-23 15:14:29 -0700 | [diff] [blame] | 1182 | |
| 1183 | ldr r4, [r2, #STRING_OFFSET_OFFSET] |
| 1184 | ldr r9, [r1, #STRING_OFFSET_OFFSET] |
| 1185 | ldr r7, [r2, #STRING_COUNT_OFFSET] |
| 1186 | ldr r10, [r1, #STRING_COUNT_OFFSET] |
| 1187 | ldr r2, [r2, #STRING_VALUE_OFFSET] |
| 1188 | ldr r1, [r1, #STRING_VALUE_OFFSET] |
| 1189 | |
| 1190 | /* |
| 1191 | * At this point, we have: |
| 1192 | * value: r2/r1 |
| 1193 | * offset: r4/r9 |
| 1194 | * count: r7/r10 |
| 1195 | * We're going to compute |
| 1196 | * r11 <- countDiff |
| 1197 | * r10 <- minCount |
| 1198 | */ |
| 1199 | subs r11, r7, r10 |
| 1200 | movls r10, r7 |
| 1201 | |
| 1202 | /* Now, build pointers to the string data */ |
| 1203 | add r2, r2, r4, lsl #1 |
| 1204 | add r1, r1, r9, lsl #1 |
| 1205 | /* |
| 1206 | * Note: data pointers point to previous element so we can use pre-index |
| 1207 | * mode with base writeback. |
| 1208 | */ |
| 1209 | add r2, #STRING_DATA_OFFSET-2 @ offset to contents[-1] |
| 1210 | add r1, #STRING_DATA_OFFSET-2 @ offset to contents[-1] |
| 1211 | |
| 1212 | /* |
| 1213 | * At this point we have: |
| 1214 | * r2: *this string data |
| 1215 | * r1: *comp string data |
| 1216 | * r10: iteration count for comparison |
| 1217 | * r11: value to return if the first part of the string is equal |
| 1218 | * r0: reserved for result |
| 1219 | * r3, r4, r7, r8, r9, r12 available for loading string data |
| 1220 | */ |
| 1221 | |
| 1222 | subs r10, #2 |
| 1223 | blt do_remainder2 |
| 1224 | |
| 1225 | /* |
| 1226 | * Unroll the first two checks so we can quickly catch early mismatch |
| 1227 | * on long strings (but preserve incoming alignment) |
| 1228 | */ |
| 1229 | |
| 1230 | ldrh r3, [r2, #2]! |
| 1231 | ldrh r4, [r1, #2]! |
| 1232 | ldrh r7, [r2, #2]! |
| 1233 | ldrh r8, [r1, #2]! |
| 1234 | subs r0, r3, r4 |
| 1235 | subeqs r0, r7, r8 |
| 1236 | bne done |
| 1237 | cmp r10, #28 |
| 1238 | bgt do_memcmp16 |
| 1239 | subs r10, #3 |
| 1240 | blt do_remainder |
| 1241 | |
| 1242 | loopback_triple: |
| 1243 | ldrh r3, [r2, #2]! |
| 1244 | ldrh r4, [r1, #2]! |
| 1245 | ldrh r7, [r2, #2]! |
| 1246 | ldrh r8, [r1, #2]! |
| 1247 | ldrh r9, [r2, #2]! |
| 1248 | ldrh r12,[r1, #2]! |
| 1249 | subs r0, r3, r4 |
| 1250 | subeqs r0, r7, r8 |
| 1251 | subeqs r0, r9, r12 |
| 1252 | bne done |
| 1253 | subs r10, #3 |
| 1254 | bge loopback_triple |
| 1255 | |
| 1256 | do_remainder: |
| 1257 | adds r10, #3 |
| 1258 | beq returnDiff |
| 1259 | |
| 1260 | loopback_single: |
| 1261 | ldrh r3, [r2, #2]! |
| 1262 | ldrh r4, [r1, #2]! |
| 1263 | subs r0, r3, r4 |
| 1264 | bne done |
| 1265 | subs r10, #1 |
| 1266 | bne loopback_single |
| 1267 | |
| 1268 | returnDiff: |
| 1269 | mov r0, r11 |
| 1270 | pop {r4, r7-r12, pc} |
| 1271 | |
| 1272 | do_remainder2: |
| 1273 | adds r10, #2 |
| 1274 | bne loopback_single |
| 1275 | mov r0, r11 |
| 1276 | pop {r4, r7-r12, pc} |
| 1277 | |
| 1278 | /* Long string case */ |
| 1279 | do_memcmp16: |
| 1280 | mov r7, r11 |
| 1281 | add r0, r2, #2 |
| 1282 | add r1, r1, #2 |
| 1283 | mov r2, r10 |
| 1284 | bl __memcmp16 |
| 1285 | cmp r0, #0 |
| 1286 | moveq r0, r7 |
| 1287 | done: |
| 1288 | pop {r4, r7-r12, pc} |
Ian Rogers | 9329bbb | 2013-02-08 19:56:30 -0800 | [diff] [blame] | 1289 | END art_quick_string_compareto |