handler-configuration-inl.h 7.03 KB
Newer Older
1 2 3 4 5 6 7 8 9
// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_IC_HANDLER_CONFIGURATION_INL_H_
#define V8_IC_HANDLER_CONFIGURATION_INL_H_

#include "src/ic/handler-configuration.h"

10
#include "src/handles/handles-inl.h"
11
#include "src/objects/data-handler-inl.h"
12
#include "src/objects/field-index-inl.h"
13
#include "src/objects/objects-inl.h"
14
#include "src/objects/smi.h"
15 16 17

// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"
18 19 20 21

namespace v8 {
namespace internal {

22 23
OBJECT_CONSTRUCTORS_IMPL(LoadHandler, DataHandler)

24
CAST_ACCESSOR(LoadHandler)
25

26
// Decodes kind from Smi-handler.
27
LoadHandler::Kind LoadHandler::GetHandlerKind(Smi smi_handler) {
28
  return KindBits::decode(smi_handler.value());
29 30
}

31 32
Handle<Smi> LoadHandler::LoadNormal(Isolate* isolate) {
  int config = KindBits::encode(kNormal);
33 34 35
  return handle(Smi::FromInt(config), isolate);
}

36 37 38 39 40
Handle<Smi> LoadHandler::LoadGlobal(Isolate* isolate) {
  int config = KindBits::encode(kGlobal);
  return handle(Smi::FromInt(config), isolate);
}

41 42 43 44 45
Handle<Smi> LoadHandler::LoadInterceptor(Isolate* isolate) {
  int config = KindBits::encode(kInterceptor);
  return handle(Smi::FromInt(config), isolate);
}

46 47 48 49 50
Handle<Smi> LoadHandler::LoadSlow(Isolate* isolate) {
  int config = KindBits::encode(kSlow);
  return handle(Smi::FromInt(config), isolate);
}

51 52
Handle<Smi> LoadHandler::LoadField(Isolate* isolate, FieldIndex field_index) {
  int config = KindBits::encode(kField) |
53 54
               IsInobjectBits::encode(field_index.is_inobject()) |
               IsDoubleBits::encode(field_index.is_double()) |
55
               FieldIndexBits::encode(field_index.index());
56 57 58
  return handle(Smi::FromInt(config), isolate);
}

59 60
Handle<Smi> LoadHandler::LoadConstantFromPrototype(Isolate* isolate) {
  int config = KindBits::encode(kConstantFromPrototype);
61 62 63
  return handle(Smi::FromInt(config), isolate);
}

64
Handle<Smi> LoadHandler::LoadAccessor(Isolate* isolate, int descriptor) {
65
  int config = KindBits::encode(kAccessor) | DescriptorBits::encode(descriptor);
66 67 68
  return handle(Smi::FromInt(config), isolate);
}

69 70 71 72 73
Handle<Smi> LoadHandler::LoadProxy(Isolate* isolate) {
  int config = KindBits::encode(kProxy);
  return handle(Smi::FromInt(config), isolate);
}

74 75 76
Handle<Smi> LoadHandler::LoadNativeDataProperty(Isolate* isolate,
                                                int descriptor) {
  int config = KindBits::encode(kNativeDataProperty) |
77
               DescriptorBits::encode(descriptor);
78 79 80
  return handle(Smi::FromInt(config), isolate);
}

81 82 83 84 85 86 87
Handle<Smi> LoadHandler::LoadApiGetter(Isolate* isolate,
                                       bool holder_is_receiver) {
  int config = KindBits::encode(
      holder_is_receiver ? kApiGetter : kApiGetterHolderIsPrototype);
  return handle(Smi::FromInt(config), isolate);
}

88 89 90 91 92 93
Handle<Smi> LoadHandler::LoadModuleExport(Isolate* isolate, int index) {
  int config =
      KindBits::encode(kModuleExport) | ExportsIndexBits::encode(index);
  return handle(Smi::FromInt(config), isolate);
}

94 95
Handle<Smi> LoadHandler::LoadNonExistent(Isolate* isolate) {
  int config = KindBits::encode(kNonExistent);
96 97 98
  return handle(Smi::FromInt(config), isolate);
}

99 100 101
Handle<Smi> LoadHandler::LoadElement(Isolate* isolate,
                                     ElementsKind elements_kind,
                                     bool convert_hole_to_undefined,
102 103 104 105 106 107 108 109
                                     bool is_js_array,
                                     KeyedAccessLoadMode load_mode) {
  int config =
      KindBits::encode(kElement) |
      AllowOutOfBoundsBits::encode(load_mode == LOAD_IGNORE_OUT_OF_BOUNDS) |
      ElementsKindBits::encode(elements_kind) |
      ConvertHoleBits::encode(convert_hole_to_undefined) |
      IsJsArrayBits::encode(is_js_array);
110 111 112
  return handle(Smi::FromInt(config), isolate);
}

113
Handle<Smi> LoadHandler::LoadIndexedString(Isolate* isolate,
114 115 116 117
                                           KeyedAccessLoadMode load_mode) {
  int config =
      KindBits::encode(kIndexedString) |
      AllowOutOfBoundsBits::encode(load_mode == LOAD_IGNORE_OUT_OF_BOUNDS);
118 119 120
  return handle(Smi::FromInt(config), isolate);
}

121 122
OBJECT_CONSTRUCTORS_IMPL(StoreHandler, DataHandler)

123
CAST_ACCESSOR(StoreHandler)
124

125
Handle<Smi> StoreHandler::StoreGlobalProxy(Isolate* isolate) {
126
  int config = KindBits::encode(kGlobalProxy);
127 128 129
  return handle(Smi::FromInt(config), isolate);
}

130
Handle<Smi> StoreHandler::StoreNormal(Isolate* isolate) {
131
  int config = KindBits::encode(kNormal);
132 133 134
  return handle(Smi::FromInt(config), isolate);
}

135 136 137 138 139
Handle<Smi> StoreHandler::StoreInterceptor(Isolate* isolate) {
  int config = KindBits::encode(kInterceptor);
  return handle(Smi::FromInt(config), isolate);
}

140 141 142 143
Handle<Smi> StoreHandler::StoreSlow(Isolate* isolate,
                                    KeyedAccessStoreMode store_mode) {
  int config =
      KindBits::encode(kSlow) | KeyedAccessStoreModeBits::encode(store_mode);
144 145 146
  return handle(Smi::FromInt(config), isolate);
}

147 148 149 150 151
Handle<Smi> StoreHandler::StoreProxy(Isolate* isolate) {
  int config = KindBits::encode(kProxy);
  return handle(Smi::FromInt(config), isolate);
}

152 153
Handle<Smi> StoreHandler::StoreField(Isolate* isolate, Kind kind,
                                     int descriptor, FieldIndex field_index,
154
                                     Representation representation) {
155
  DCHECK(!representation.IsNone());
156
  DCHECK(kind == kField || kind == kConstField);
157

158 159
  int config = KindBits::encode(kind) |
               IsInobjectBits::encode(field_index.is_inobject()) |
160
               RepresentationBits::encode(representation.kind()) |
161 162
               DescriptorBits::encode(descriptor) |
               FieldIndexBits::encode(field_index.index());
163 164 165
  return handle(Smi::FromInt(config), isolate);
}

166 167 168 169
Handle<Smi> StoreHandler::StoreField(Isolate* isolate, int descriptor,
                                     FieldIndex field_index,
                                     PropertyConstness constness,
                                     Representation representation) {
170
  Kind kind = constness == PropertyConstness::kMutable ? kField : kConstField;
171
  return StoreField(isolate, kind, descriptor, field_index, representation);
172 173
}

174 175 176 177 178 179 180
Handle<Smi> StoreHandler::StoreNativeDataProperty(Isolate* isolate,
                                                  int descriptor) {
  int config = KindBits::encode(kNativeDataProperty) |
               DescriptorBits::encode(descriptor);
  return handle(Smi::FromInt(config), isolate);
}

181 182
Handle<Smi> StoreHandler::StoreAccessor(Isolate* isolate, int descriptor) {
  int config = KindBits::encode(kAccessor) | DescriptorBits::encode(descriptor);
183 184 185 186 187 188 189
  return handle(Smi::FromInt(config), isolate);
}

Handle<Smi> StoreHandler::StoreApiSetter(Isolate* isolate,
                                         bool holder_is_receiver) {
  int config = KindBits::encode(
      holder_is_receiver ? kApiSetter : kApiSetterHolderIsPrototype);
190 191 192
  return handle(Smi::FromInt(config), isolate);
}

193 194 195
}  // namespace internal
}  // namespace v8

196 197
#include "src/objects/object-macros-undef.h"

198
#endif  // V8_IC_HANDLER_CONFIGURATION_INL_H_