Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame^] | 1 | // Copyright 2012 the V8 project authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include "src/v8.h" |
| 6 | |
| 7 | #include "src/interface-descriptors.h" |
| 8 | |
| 9 | namespace v8 { |
| 10 | namespace internal { |
| 11 | |
| 12 | void CallInterfaceDescriptorData::Initialize( |
| 13 | int register_parameter_count, Register* registers, |
| 14 | Representation* register_param_representations, |
| 15 | PlatformInterfaceDescriptor* platform_descriptor) { |
| 16 | platform_specific_descriptor_ = platform_descriptor; |
| 17 | register_param_count_ = register_parameter_count; |
| 18 | |
| 19 | // An interface descriptor must have a context register. |
| 20 | DCHECK(register_parameter_count > 0 && |
| 21 | registers[0].is(CallInterfaceDescriptor::ContextRegister())); |
| 22 | |
| 23 | // InterfaceDescriptor owns a copy of the registers array. |
| 24 | register_params_.Reset(NewArray<Register>(register_parameter_count)); |
| 25 | for (int i = 0; i < register_parameter_count; i++) { |
| 26 | register_params_[i] = registers[i]; |
| 27 | } |
| 28 | |
| 29 | // If a representations array is specified, then the descriptor owns that as |
| 30 | // well. |
| 31 | if (register_param_representations != NULL) { |
| 32 | register_param_representations_.Reset( |
| 33 | NewArray<Representation>(register_parameter_count)); |
| 34 | for (int i = 0; i < register_parameter_count; i++) { |
| 35 | // If there is a context register, the representation must be tagged. |
| 36 | DCHECK( |
| 37 | i != 0 || |
| 38 | register_param_representations[i].Equals(Representation::Tagged())); |
| 39 | register_param_representations_[i] = register_param_representations[i]; |
| 40 | } |
| 41 | } |
| 42 | } |
| 43 | |
| 44 | |
| 45 | const char* CallInterfaceDescriptor::DebugName(Isolate* isolate) { |
| 46 | CallInterfaceDescriptorData* start = isolate->call_descriptor_data(0); |
| 47 | size_t index = data_ - start; |
| 48 | DCHECK(index < CallDescriptors::NUMBER_OF_DESCRIPTORS); |
| 49 | CallDescriptors::Key key = static_cast<CallDescriptors::Key>(index); |
| 50 | switch (key) { |
| 51 | #define DEF_CASE(NAME) \ |
| 52 | case CallDescriptors::NAME: \ |
| 53 | return #NAME " Descriptor"; |
| 54 | INTERFACE_DESCRIPTOR_LIST(DEF_CASE) |
| 55 | #undef DEF_CASE |
| 56 | case CallDescriptors::NUMBER_OF_DESCRIPTORS: |
| 57 | break; |
| 58 | } |
| 59 | return ""; |
| 60 | } |
| 61 | |
| 62 | |
| 63 | void LoadDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
| 64 | Register registers[] = {ContextRegister(), ReceiverRegister(), |
| 65 | NameRegister()}; |
| 66 | data->Initialize(arraysize(registers), registers, NULL); |
| 67 | } |
| 68 | |
| 69 | |
| 70 | void StoreDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
| 71 | Register registers[] = {ContextRegister(), ReceiverRegister(), NameRegister(), |
| 72 | ValueRegister()}; |
| 73 | data->Initialize(arraysize(registers), registers, NULL); |
| 74 | } |
| 75 | |
| 76 | |
| 77 | void ElementTransitionAndStoreDescriptor::Initialize( |
| 78 | CallInterfaceDescriptorData* data) { |
| 79 | Register registers[] = {ContextRegister(), ValueRegister(), MapRegister(), |
| 80 | NameRegister(), ReceiverRegister()}; |
| 81 | data->Initialize(arraysize(registers), registers, NULL); |
| 82 | } |
| 83 | |
| 84 | |
| 85 | void InstanceofDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
| 86 | Register registers[] = {ContextRegister(), left(), right()}; |
| 87 | data->Initialize(arraysize(registers), registers, NULL); |
| 88 | } |
| 89 | |
| 90 | |
| 91 | void MathPowTaggedDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
| 92 | Register registers[] = {ContextRegister(), exponent()}; |
| 93 | data->Initialize(arraysize(registers), registers, NULL); |
| 94 | } |
| 95 | |
| 96 | |
| 97 | void MathPowIntegerDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
| 98 | Register registers[] = {ContextRegister(), exponent()}; |
| 99 | data->Initialize(arraysize(registers), registers, NULL); |
| 100 | } |
| 101 | |
| 102 | |
| 103 | void VectorLoadICTrampolineDescriptor::Initialize( |
| 104 | CallInterfaceDescriptorData* data) { |
| 105 | Register registers[] = {ContextRegister(), ReceiverRegister(), NameRegister(), |
| 106 | SlotRegister()}; |
| 107 | data->Initialize(arraysize(registers), registers, NULL); |
| 108 | } |
| 109 | |
| 110 | |
| 111 | void VectorLoadICDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
| 112 | Register registers[] = {ContextRegister(), ReceiverRegister(), NameRegister(), |
| 113 | SlotRegister(), VectorRegister()}; |
| 114 | Representation representations[] = { |
| 115 | Representation::Tagged(), Representation::Tagged(), |
| 116 | Representation::Tagged(), Representation::Smi(), |
| 117 | Representation::Tagged()}; |
| 118 | data->Initialize(arraysize(registers), registers, representations); |
| 119 | } |
| 120 | |
| 121 | |
| 122 | void ApiGetterDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
| 123 | Register registers[] = {ContextRegister(), function_address()}; |
| 124 | Representation representations[] = {Representation::Tagged(), |
| 125 | Representation::External()}; |
| 126 | data->Initialize(arraysize(registers), registers, representations); |
| 127 | } |
| 128 | |
| 129 | |
| 130 | void ArgumentsAccessReadDescriptor::Initialize( |
| 131 | CallInterfaceDescriptorData* data) { |
| 132 | Register registers[] = {ContextRegister(), index(), parameter_count()}; |
| 133 | data->Initialize(arraysize(registers), registers, NULL); |
| 134 | } |
| 135 | |
| 136 | |
| 137 | void ContextOnlyDescriptor::Initialize(CallInterfaceDescriptorData* data) { |
| 138 | Register registers[] = {ContextRegister()}; |
| 139 | data->Initialize(arraysize(registers), registers, NULL); |
| 140 | } |
| 141 | |
| 142 | } |
| 143 | } // namespace v8::internal |