| OLD | NEW |
| 1 // Copyright 2015 the V8 project authors. All rights reserved. | 1 // Copyright 2015 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_S390 | 5 #if V8_TARGET_ARCH_S390 |
| 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 127 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 138 } | 138 } |
| 139 | 139 |
| 140 void CallTrampolineDescriptor::InitializePlatformSpecific( | 140 void CallTrampolineDescriptor::InitializePlatformSpecific( |
| 141 CallInterfaceDescriptorData* data) { | 141 CallInterfaceDescriptorData* data) { |
| 142 // r2 : number of arguments | 142 // r2 : number of arguments |
| 143 // r3 : the target to call | 143 // r3 : the target to call |
| 144 Register registers[] = {r3, r2}; | 144 Register registers[] = {r3, r2}; |
| 145 data->InitializePlatformSpecific(arraysize(registers), registers); | 145 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 146 } | 146 } |
| 147 | 147 |
| 148 void CallVarargsDescriptor::InitializePlatformSpecific( |
| 149 CallInterfaceDescriptorData* data) { |
| 150 // r2 : number of arguments (on the stack, not including receiver) |
| 151 // r3 : the target to call |
| 152 // r4 : arguments list (FixedArray) |
| 153 // r6 : arguments list length (untagged) |
| 154 Register registers[] = {r3, r2, r4, r6}; |
| 155 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 156 } |
| 157 |
| 148 void CallForwardVarargsDescriptor::InitializePlatformSpecific( | 158 void CallForwardVarargsDescriptor::InitializePlatformSpecific( |
| 149 CallInterfaceDescriptorData* data) { | 159 CallInterfaceDescriptorData* data) { |
| 150 // r2 : number of arguments | 160 // r2 : number of arguments |
| 151 // r4 : start index (to support rest parameters) | 161 // r4 : start index (to support rest parameters) |
| 152 // r3 : the target to call | 162 // r3 : the target to call |
| 153 Register registers[] = {r3, r2, r4}; | 163 Register registers[] = {r3, r2, r4}; |
| 154 data->InitializePlatformSpecific(arraysize(registers), registers); | 164 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 155 } | 165 } |
| 156 | 166 |
| 167 void CallWithArrayLikeDescriptor::InitializePlatformSpecific( |
| 168 CallInterfaceDescriptorData* data) { |
| 169 // r3 : the target to call |
| 170 // r4 : the arguments list |
| 171 Register registers[] = {r3, r4}; |
| 172 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 173 } |
| 174 |
| 175 void ConstructVarargsDescriptor::InitializePlatformSpecific( |
| 176 CallInterfaceDescriptorData* data) { |
| 177 // r2 : number of arguments (on the stack, not including receiver) |
| 178 // r3 : the target to call |
| 179 // r5 : the new target |
| 180 // r4 : arguments list (FixedArray) |
| 181 // r6 : arguments list length (untagged) |
| 182 Register registers[] = {r3, r5, r2, r4, r6}; |
| 183 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 184 } |
| 185 |
| 157 void ConstructForwardVarargsDescriptor::InitializePlatformSpecific( | 186 void ConstructForwardVarargsDescriptor::InitializePlatformSpecific( |
| 158 CallInterfaceDescriptorData* data) { | 187 CallInterfaceDescriptorData* data) { |
| 159 // r2 : number of arguments | 188 // r2 : number of arguments |
| 160 // r5 : the new target | 189 // r5 : the new target |
| 161 // r4 : start index (to support rest parameters) | 190 // r4 : start index (to support rest parameters) |
| 162 // r3 : the target to call | 191 // r3 : the target to call |
| 163 Register registers[] = {r3, r5, r2, r4}; | 192 Register registers[] = {r3, r5, r2, r4}; |
| 164 data->InitializePlatformSpecific(arraysize(registers), registers); | 193 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 165 } | 194 } |
| 166 | 195 |
| 196 void ConstructWithArrayLikeDescriptor::InitializePlatformSpecific( |
| 197 CallInterfaceDescriptorData* data) { |
| 198 // r3 : the target to call |
| 199 // r5 : the new target |
| 200 // r4 : the arguments list |
| 201 Register registers[] = {r3, r5, r4}; |
| 202 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 203 } |
| 204 |
| 167 void ConstructStubDescriptor::InitializePlatformSpecific( | 205 void ConstructStubDescriptor::InitializePlatformSpecific( |
| 168 CallInterfaceDescriptorData* data) { | 206 CallInterfaceDescriptorData* data) { |
| 169 // r2 : number of arguments | 207 // r2 : number of arguments |
| 170 // r3 : the target to call | 208 // r3 : the target to call |
| 171 // r5 : the new target | 209 // r5 : the new target |
| 172 // r4 : allocation site or undefined | 210 // r4 : allocation site or undefined |
| 173 Register registers[] = {r3, r5, r2, r4}; | 211 Register registers[] = {r3, r5, r2, r4}; |
| 174 data->InitializePlatformSpecific(arraysize(registers), registers); | 212 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 175 } | 213 } |
| 176 | 214 |
| (...skipping 188 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 365 Register registers[] = { | 403 Register registers[] = { |
| 366 r3, // loaded new FP | 404 r3, // loaded new FP |
| 367 }; | 405 }; |
| 368 data->InitializePlatformSpecific(arraysize(registers), registers); | 406 data->InitializePlatformSpecific(arraysize(registers), registers); |
| 369 } | 407 } |
| 370 | 408 |
| 371 } // namespace internal | 409 } // namespace internal |
| 372 } // namespace v8 | 410 } // namespace v8 |
| 373 | 411 |
| 374 #endif // V8_TARGET_ARCH_S390 | 412 #endif // V8_TARGET_ARCH_S390 |
| OLD | NEW |