| OLD | NEW |
| 1 // Copyright 2014 the V8 project authors. All rights reserved. | 1 // Copyright 2014 the V8 project authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
| 4 | 4 |
| 5 #if V8_TARGET_ARCH_PPC | 5 #if V8_TARGET_ARCH_PPC |
| 6 | 6 |
| 7 #include "src/interface-descriptors.h" | 7 #include "src/interface-descriptors.h" |
| 8 | 8 |
| 9 namespace v8 { | 9 namespace v8 { |
| 10 namespace internal { | 10 namespace internal { |
| (...skipping 137 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 148 | 148 |
| 149 | 149 |
| 150 void CallTrampolineDescriptor::InitializePlatformSpecific( | 150 void CallTrampolineDescriptor::InitializePlatformSpecific( |
| 151 CallInterfaceDescriptorData* data) { | 151 CallInterfaceDescriptorData* data) { |
| 152 // r3 : number of arguments | 152 // r3 : number of arguments |
| 153 // r4 : the target to call | 153 // r4 : the target to call |
| 154 Register registers[] = {r4, r3}; | 154 Register registers[] = {r4, r3}; |
| 155 data->InitializePlatformSpecific(arraysize(registers), registers); | 155 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 156 } | 156 } |
| 157 | 157 |
| 158 void CallVarargsDescriptor::InitializePlatformSpecific( |
| 159 CallInterfaceDescriptorData* data) { |
| 160 // r3 : number of arguments (on the stack, not including receiver) |
| 161 // r4 : the target to call |
| 162 // r5 : arguments list (FixedArray) |
| 163 // r7 : arguments list length (untagged) |
| 164 Register registers[] = {r4, r3, r5, r7}; |
| 165 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 166 } |
| 167 |
| 158 void CallForwardVarargsDescriptor::InitializePlatformSpecific( | 168 void CallForwardVarargsDescriptor::InitializePlatformSpecific( |
| 159 CallInterfaceDescriptorData* data) { | 169 CallInterfaceDescriptorData* data) { |
| 160 // r3 : number of arguments | 170 // r3 : number of arguments |
| 161 // r5 : start index (to support rest parameters) | 171 // r5 : start index (to support rest parameters) |
| 162 // r4 : the target to call | 172 // r4 : the target to call |
| 163 Register registers[] = {r4, r3, r5}; | 173 Register registers[] = {r4, r3, r5}; |
| 164 data->InitializePlatformSpecific(arraysize(registers), registers); | 174 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 165 } | 175 } |
| 166 | 176 |
| 177 void CallWithArrayLikeDescriptor::InitializePlatformSpecific( |
| 178 CallInterfaceDescriptorData* data) { |
| 179 // r4 : the target to call |
| 180 // r5 : the arguments list |
| 181 Register registers[] = {r4, r5}; |
| 182 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 183 } |
| 184 |
| 185 void ConstructVarargsDescriptor::InitializePlatformSpecific( |
| 186 CallInterfaceDescriptorData* data) { |
| 187 // r3 : number of arguments (on the stack, not including receiver) |
| 188 // r4 : the target to call |
| 189 // r6 : the new target |
| 190 // r5 : arguments list (FixedArray) |
| 191 // r7 : arguments list length (untagged) |
| 192 Register registers[] = {r4, r6, r3, r5, r7}; |
| 193 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 194 } |
| 195 |
| 167 void ConstructForwardVarargsDescriptor::InitializePlatformSpecific( | 196 void ConstructForwardVarargsDescriptor::InitializePlatformSpecific( |
| 168 CallInterfaceDescriptorData* data) { | 197 CallInterfaceDescriptorData* data) { |
| 169 // r3 : number of arguments | 198 // r3 : number of arguments |
| 170 // r6 : the new target | 199 // r6 : the new target |
| 171 // r5 : start index (to support rest parameters) | 200 // r5 : start index (to support rest parameters) |
| 172 // r4 : the target to call | 201 // r4 : the target to call |
| 173 Register registers[] = {r4, r6, r3, r5}; | 202 Register registers[] = {r4, r6, r3, r5}; |
| 174 data->InitializePlatformSpecific(arraysize(registers), registers); | 203 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 175 } | 204 } |
| 176 | 205 |
| 206 void ConstructWithArrayLikeDescriptor::InitializePlatformSpecific( |
| 207 CallInterfaceDescriptorData* data) { |
| 208 // r4 : the target to call |
| 209 // r6 : the new target |
| 210 // r5 : the arguments list |
| 211 Register registers[] = {r4, r6, r5}; |
| 212 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 213 } |
| 214 |
| 177 void ConstructStubDescriptor::InitializePlatformSpecific( | 215 void ConstructStubDescriptor::InitializePlatformSpecific( |
| 178 CallInterfaceDescriptorData* data) { | 216 CallInterfaceDescriptorData* data) { |
| 179 // r3 : number of arguments | 217 // r3 : number of arguments |
| 180 // r4 : the target to call | 218 // r4 : the target to call |
| 181 // r6 : the new target | 219 // r6 : the new target |
| 182 // r5 : allocation site or undefined | 220 // r5 : allocation site or undefined |
| 183 Register registers[] = {r4, r6, r3, r5}; | 221 Register registers[] = {r4, r6, r3, r5}; |
| 184 data->InitializePlatformSpecific(arraysize(registers), registers); | 222 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 185 } | 223 } |
| 186 | 224 |
| (...skipping 195 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 382 Register registers[] = { | 420 Register registers[] = { |
| 383 r4, // loaded new FP | 421 r4, // loaded new FP |
| 384 }; | 422 }; |
| 385 data->InitializePlatformSpecific(arraysize(registers), registers); | 423 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 386 } | 424 } |
| 387 | 425 |
| 388 } // namespace internal | 426 } // namespace internal |
| 389 } // namespace v8 | 427 } // namespace v8 |
| 390 | 428 |
| 391 #endif // V8_TARGET_ARCH_PPC | 429 #endif // V8_TARGET_ARCH_PPC |
| OLD | NEW |