access-builder.cc 13.1 KB
Newer Older
1 2 3 4 5
// Copyright 2014 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.

#include "src/compiler/access-builder.h"
6 7 8

#include "src/contexts.h"
#include "src/frames.h"
9
#include "src/handles-inl.h"
10 11
#include "src/heap/heap.h"
#include "src/type-cache.h"
12 13 14 15 16 17 18

namespace v8 {
namespace internal {
namespace compiler {

// static
FieldAccess AccessBuilder::ForMap() {
19
  FieldAccess access = {kTaggedBase, HeapObject::kMapOffset,
20 21
                        MaybeHandle<Name>(), Type::Any(),
                        MachineType::AnyTagged()};
22
  return access;
23 24 25
}


26 27 28
// static
FieldAccess AccessBuilder::ForHeapNumberValue() {
  FieldAccess access = {kTaggedBase, HeapNumber::kValueOffset,
29
                        MaybeHandle<Name>(), TypeCache::Get().kFloat64,
30
                        MachineType::Float64()};
31 32 33 34
  return access;
}


35 36
// static
FieldAccess AccessBuilder::ForJSObjectProperties() {
37
  FieldAccess access = {kTaggedBase, JSObject::kPropertiesOffset,
38 39
                        MaybeHandle<Name>(), Type::Internal(),
                        MachineType::AnyTagged()};
40
  return access;
41 42 43 44 45
}


// static
FieldAccess AccessBuilder::ForJSObjectElements() {
46
  FieldAccess access = {kTaggedBase, JSObject::kElementsOffset,
47 48
                        MaybeHandle<Name>(), Type::Internal(),
                        MachineType::AnyTagged()};
49
  return access;
50 51 52
}


53 54 55 56 57
// static
FieldAccess AccessBuilder::ForJSObjectInObjectProperty(Handle<Map> map,
                                                       int index) {
  int const offset = map->GetInObjectPropertyOffset(index);
  FieldAccess access = {kTaggedBase, offset, MaybeHandle<Name>(),
58
                        Type::Tagged(), MachineType::AnyTagged()};
59 60 61 62
  return access;
}


63 64 65 66 67 68 69 70
// static
FieldAccess AccessBuilder::ForJSFunctionPrototypeOrInitialMap() {
  FieldAccess access = {kTaggedBase, JSFunction::kPrototypeOrInitialMapOffset,
                        MaybeHandle<Name>(), Type::Any(),
                        MachineType::AnyTagged()};
  return access;
}

71 72
// static
FieldAccess AccessBuilder::ForJSFunctionContext() {
73
  FieldAccess access = {kTaggedBase, JSFunction::kContextOffset,
74 75
                        MaybeHandle<Name>(), Type::Internal(),
                        MachineType::AnyTagged()};
76
  return access;
77 78 79
}


80 81
// static
FieldAccess AccessBuilder::ForJSFunctionSharedFunctionInfo() {
82
  FieldAccess access = {kTaggedBase, JSFunction::kSharedFunctionInfoOffset,
83
                        Handle<Name>(), Type::Any(), MachineType::AnyTagged()};
84
  return access;
85 86 87
}


88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
// static
FieldAccess AccessBuilder::ForJSFunctionLiterals() {
  FieldAccess access = {kTaggedBase, JSFunction::kLiteralsOffset,
                        Handle<Name>(), Type::Internal(),
                        MachineType::AnyTagged()};
  return access;
}

// static
FieldAccess AccessBuilder::ForJSFunctionCodeEntry() {
  FieldAccess access = {kTaggedBase, JSFunction::kCodeEntryOffset,
                        Handle<Name>(), Type::UntaggedPointer(),
                        MachineType::Pointer()};
  return access;
}

// static
FieldAccess AccessBuilder::ForJSFunctionNextFunctionLink() {
  FieldAccess access = {kTaggedBase, JSFunction::kNextFunctionLinkOffset,
                        Handle<Name>(), Type::Any(), MachineType::AnyTagged()};
  return access;
}

111 112 113 114
// static
FieldAccess AccessBuilder::ForJSArrayLength(ElementsKind elements_kind) {
  TypeCache const& type_cache = TypeCache::Get();
  FieldAccess access = {kTaggedBase, JSArray::kLengthOffset, Handle<Name>(),
115 116
                        type_cache.kJSArrayLengthType,
                        MachineType::AnyTagged()};
117 118 119 120 121 122 123 124 125
  if (IsFastDoubleElementsKind(elements_kind)) {
    access.type = type_cache.kFixedDoubleArrayLengthType;
  } else if (IsFastElementsKind(elements_kind)) {
    access.type = type_cache.kFixedArrayLengthType;
  }
  return access;
}


126 127
// static
FieldAccess AccessBuilder::ForJSArrayBufferBackingStore() {
128
  FieldAccess access = {kTaggedBase, JSArrayBuffer::kBackingStoreOffset,
129 130
                        MaybeHandle<Name>(), Type::UntaggedPointer(),
                        MachineType::Pointer()};
131
  return access;
132 133 134
}


135 136 137
// static
FieldAccess AccessBuilder::ForJSArrayBufferBitField() {
  FieldAccess access = {kTaggedBase, JSArrayBuffer::kBitFieldOffset,
138 139
                        MaybeHandle<Name>(), TypeCache::Get().kInt8,
                        MachineType::Int8()};
140 141 142 143 144 145 146 147
  return access;
}


// static
FieldAccess AccessBuilder::ForJSArrayBufferViewBuffer() {
  FieldAccess access = {kTaggedBase, JSArrayBufferView::kBufferOffset,
                        MaybeHandle<Name>(), Type::TaggedPointer(),
148
                        MachineType::AnyTagged()};
149 150 151 152
  return access;
}


153 154
// static
FieldAccess AccessBuilder::ForJSDateField(JSDate::FieldIndex index) {
155 156 157
  FieldAccess access = {
      kTaggedBase, JSDate::kValueOffset + index * kPointerSize,
      MaybeHandle<Name>(), Type::Number(), MachineType::AnyTagged()};
158
  return access;
159 160 161
}


162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
// static
FieldAccess AccessBuilder::ForJSIteratorResultDone() {
  FieldAccess access = {kTaggedBase, JSIteratorResult::kDoneOffset,
                        MaybeHandle<Name>(), Type::Any(),
                        MachineType::AnyTagged()};
  return access;
}


// static
FieldAccess AccessBuilder::ForJSIteratorResultValue() {
  FieldAccess access = {kTaggedBase, JSIteratorResult::kValueOffset,
                        MaybeHandle<Name>(), Type::Any(),
                        MachineType::AnyTagged()};
  return access;
}


180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
// static
FieldAccess AccessBuilder::ForJSRegExpFlags() {
  FieldAccess access = {kTaggedBase, JSRegExp::kFlagsOffset,
                        MaybeHandle<Name>(), Type::Tagged(),
                        MachineType::AnyTagged()};
  return access;
}


// static
FieldAccess AccessBuilder::ForJSRegExpSource() {
  FieldAccess access = {kTaggedBase, JSRegExp::kSourceOffset,
                        MaybeHandle<Name>(), Type::Tagged(),
                        MachineType::AnyTagged()};
  return access;
}


198
// static
199
FieldAccess AccessBuilder::ForFixedArrayLength() {
200 201 202
  FieldAccess access = {
      kTaggedBase, FixedArray::kLengthOffset, MaybeHandle<Name>(),
      TypeCache::Get().kFixedArrayLengthType, MachineType::AnyTagged()};
203
  return access;
204 205 206
}


207 208
// static
FieldAccess AccessBuilder::ForDescriptorArrayEnumCache() {
209
  FieldAccess access = {kTaggedBase, DescriptorArray::kEnumCacheOffset,
210 211
                        Handle<Name>(), Type::TaggedPointer(),
                        MachineType::AnyTagged()};
212
  return access;
213 214 215 216 217
}


// static
FieldAccess AccessBuilder::ForDescriptorArrayEnumCacheBridgeCache() {
218 219 220
  FieldAccess access = {
      kTaggedBase, DescriptorArray::kEnumCacheBridgeCacheOffset, Handle<Name>(),
      Type::TaggedPointer(), MachineType::AnyTagged()};
221
  return access;
222 223 224
}


225 226 227 228 229 230 231 232
// static
FieldAccess AccessBuilder::ForMapBitField() {
  FieldAccess access = {kTaggedBase, Map::kBitFieldOffset, Handle<Name>(),
                        TypeCache::Get().kUint8, MachineType::Uint8()};
  return access;
}


233
// static
234 235
FieldAccess AccessBuilder::ForMapBitField3() {
  FieldAccess access = {kTaggedBase, Map::kBitField3Offset, Handle<Name>(),
236
                        TypeCache::Get().kInt32, MachineType::Int32()};
237
  return access;
238 239 240 241 242
}


// static
FieldAccess AccessBuilder::ForMapDescriptors() {
243
  FieldAccess access = {kTaggedBase, Map::kDescriptorsOffset, Handle<Name>(),
244
                        Type::TaggedPointer(), MachineType::AnyTagged()};
245
  return access;
246 247 248
}


249 250
// static
FieldAccess AccessBuilder::ForMapInstanceType() {
251
  FieldAccess access = {kTaggedBase, Map::kInstanceTypeOffset, Handle<Name>(),
252
                        TypeCache::Get().kUint8, MachineType::Uint8()};
253
  return access;
254 255 256
}


257 258 259
// static
FieldAccess AccessBuilder::ForMapPrototype() {
  FieldAccess access = {kTaggedBase, Map::kPrototypeOffset, Handle<Name>(),
260
                        Type::TaggedPointer(), MachineType::AnyTagged()};
261 262 263 264
  return access;
}


265
// static
266 267
FieldAccess AccessBuilder::ForStringLength() {
  FieldAccess access = {kTaggedBase, String::kLengthOffset, Handle<Name>(),
268 269
                        TypeCache::Get().kStringLengthType,
                        MachineType::AnyTagged()};
270
  return access;
271 272 273
}


274
// static
275 276
FieldAccess AccessBuilder::ForJSGlobalObjectGlobalProxy() {
  FieldAccess access = {kTaggedBase, JSGlobalObject::kGlobalProxyOffset,
277 278
                        Handle<Name>(), Type::Receiver(),
                        MachineType::AnyTagged()};
279 280 281 282
  return access;
}


283
// static
284 285
FieldAccess AccessBuilder::ForJSGlobalObjectNativeContext() {
  FieldAccess access = {kTaggedBase, JSGlobalObject::kNativeContextOffset,
286 287
                        Handle<Name>(), Type::Internal(),
                        MachineType::AnyTagged()};
288 289 290 291
  return access;
}


292 293
// static
FieldAccess AccessBuilder::ForValue() {
294
  FieldAccess access = {kTaggedBase, JSValue::kValueOffset, Handle<Name>(),
295
                        Type::Any(), MachineType::AnyTagged()};
296
  return access;
297 298 299
}


300 301
// static
FieldAccess AccessBuilder::ForArgumentsLength() {
302 303
  FieldAccess access = {kTaggedBase, JSArgumentsObject::kLengthOffset,
                        Handle<Name>(), Type::Any(), MachineType::AnyTagged()};
304 305 306 307
  return access;
}


308 309
// static
FieldAccess AccessBuilder::ForArgumentsCallee() {
310 311
  FieldAccess access = {kTaggedBase, JSSloppyArgumentsObject::kCalleeOffset,
                        Handle<Name>(), Type::Any(), MachineType::AnyTagged()};
312 313 314 315
  return access;
}


316 317 318 319
// static
FieldAccess AccessBuilder::ForFixedArraySlot(size_t index) {
  int offset = FixedArray::OffsetOfElementAt(static_cast<int>(index));
  FieldAccess access = {kTaggedBase, offset, Handle<Name>(), Type::Any(),
320
                        MachineType::AnyTagged()};
321 322 323 324
  return access;
}


325 326 327 328 329
// static
FieldAccess AccessBuilder::ForContextSlot(size_t index) {
  int offset = Context::kHeaderSize + static_cast<int>(index) * kPointerSize;
  DCHECK_EQ(offset,
            Context::SlotOffset(static_cast<int>(index)) + kHeapObjectTag);
330
  FieldAccess access = {kTaggedBase, offset, Handle<Name>(), Type::Any(),
331
                        MachineType::AnyTagged()};
332
  return access;
333 334 335
}


336
// static
337
FieldAccess AccessBuilder::ForPropertyCellValue() {
338 339 340 341 342 343
  return ForPropertyCellValue(Type::Tagged());
}


// static
FieldAccess AccessBuilder::ForPropertyCellValue(Type* type) {
344
  FieldAccess access = {kTaggedBase, PropertyCell::kValueOffset, Handle<Name>(),
345
                        type, MachineType::AnyTagged()};
346
  return access;
347 348 349
}


350
// static
351 352
FieldAccess AccessBuilder::ForSharedFunctionInfoTypeFeedbackVector() {
  FieldAccess access = {kTaggedBase, SharedFunctionInfo::kFeedbackVectorOffset,
353
                        Handle<Name>(), Type::Any(), MachineType::AnyTagged()};
354
  return access;
355 356 357
}


358 359
// static
ElementAccess AccessBuilder::ForFixedArrayElement() {
360
  ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Tagged(),
361
                          MachineType::AnyTagged()};
362
  return access;
363 364 365
}


366 367 368
// static
ElementAccess AccessBuilder::ForFixedDoubleArrayElement() {
  ElementAccess access = {kTaggedBase, FixedDoubleArray::kHeaderSize,
369
                          TypeCache::Get().kFloat64, MachineType::Float64()};
370 371 372 373
  return access;
}


374 375 376 377 378 379
// static
ElementAccess AccessBuilder::ForTypedArrayElement(ExternalArrayType type,
                                                  bool is_external) {
  BaseTaggedness taggedness = is_external ? kUntaggedBase : kTaggedBase;
  int header_size = is_external ? 0 : FixedTypedArrayBase::kDataOffset;
  switch (type) {
380 381
    case kExternalInt8Array: {
      ElementAccess access = {taggedness, header_size, Type::Signed32(),
382
                              MachineType::Int8()};
383 384
      return access;
    }
385
    case kExternalUint8Array:
386 387
    case kExternalUint8ClampedArray: {
      ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
388
                              MachineType::Uint8()};
389 390 391 392
      return access;
    }
    case kExternalInt16Array: {
      ElementAccess access = {taggedness, header_size, Type::Signed32(),
393
                              MachineType::Int16()};
394 395 396 397
      return access;
    }
    case kExternalUint16Array: {
      ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
398
                              MachineType::Uint16()};
399 400 401 402
      return access;
    }
    case kExternalInt32Array: {
      ElementAccess access = {taggedness, header_size, Type::Signed32(),
403
                              MachineType::Int32()};
404 405 406 407
      return access;
    }
    case kExternalUint32Array: {
      ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
408
                              MachineType::Uint32()};
409 410 411 412
      return access;
    }
    case kExternalFloat32Array: {
      ElementAccess access = {taggedness, header_size, Type::Number(),
413
                              MachineType::Float32()};
414 415 416 417
      return access;
    }
    case kExternalFloat64Array: {
      ElementAccess access = {taggedness, header_size, Type::Number(),
418
                              MachineType::Float64()};
419 420
      return access;
    }
421 422
  }
  UNREACHABLE();
423
  ElementAccess access = {kUntaggedBase, 0, Type::None(), MachineType::None()};
424
  return access;
425 426
}

427

428
// static
429
FieldAccess AccessBuilder::ForStatsCounter() {
430
  FieldAccess access = {kUntaggedBase, 0, MaybeHandle<Name>(),
431
                        TypeCache::Get().kInt32, MachineType::Int32()};
432
  return access;
433 434
}

435 436 437
}  // namespace compiler
}  // namespace internal
}  // namespace v8