src/compiler/access-builder.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "src/compiler/access-builder.h"
   6 #include "src/types-inl.h"
   7
   8 namespace v8 {
   9 namespace internal {
  10 namespace compiler {
  11
  12 // static
  13 FieldAccess AccessBuilder::ForMap() {
  14   FieldAccess access = {kTaggedBase, HeapObject::kMapOffset,
  15                         MaybeHandle<Name>(), Type::Any(), kMachAnyTagged};
  16   return access;
  17 }
  18
  19
  20 // static
  21 FieldAccess AccessBuilder::ForJSObjectProperties() {
  22   FieldAccess access = {kTaggedBase, JSObject::kPropertiesOffset,
  23                         MaybeHandle<Name>(), Type::Any(), kMachAnyTagged};
  24   return access;
  25 }
  26
  27
  28 // static
  29 FieldAccess AccessBuilder::ForJSObjectElements() {
  30   FieldAccess access = {kTaggedBase, JSObject::kElementsOffset,
  31                         MaybeHandle<Name>(), Type::Internal(), kMachAnyTagged};
  32   return access;
  33 }
  34
  35
  36 // static
  37 FieldAccess AccessBuilder::ForJSFunctionContext() {
  38   FieldAccess access = {kTaggedBase, JSFunction::kContextOffset,
  39                         MaybeHandle<Name>(), Type::Internal(), kMachAnyTagged};
  40   return access;
  41 }
  42
  43
  44 // static
  45 FieldAccess AccessBuilder::ForJSFunctionSharedFunctionInfo() {
  46   FieldAccess access = {kTaggedBase, JSFunction::kSharedFunctionInfoOffset,
  47                         Handle<Name>(), Type::Any(), kMachAnyTagged};
  48   return access;
  49 }
  50
  51
  52 // static
  53 FieldAccess AccessBuilder::ForJSArrayBufferBackingStore() {
  54   FieldAccess access = {kTaggedBase, JSArrayBuffer::kBackingStoreOffset,
  55                         MaybeHandle<Name>(), Type::UntaggedPointer(), kMachPtr};
  56   return access;
  57 }
  58
  59
  60 // static
  61 FieldAccess AccessBuilder::ForJSDateField(JSDate::FieldIndex index) {
  62   FieldAccess access = {kTaggedBase,
  63                         JSDate::kValueOffset + index * kPointerSize,
  64                         MaybeHandle<Name>(), Type::Number(), kMachAnyTagged};
  65   return access;
  66 }
  67
  68
  69 // static
  70 FieldAccess AccessBuilder::ForFixedArrayLength() {
  71   // TODO(turbofan): 2^30 is a valid upper limit for the FixedArray::length
  72   // field, although it's not the best. If we had a Zone we could create an
  73   // appropriate range type instead.
  74   STATIC_ASSERT(FixedArray::kMaxLength <= 1 << 30);
  75   FieldAccess access = {
  76       kTaggedBase, FixedArray::kLengthOffset, MaybeHandle<Name>(),
  77       Type::Intersect(Type::Unsigned30(), Type::TaggedSigned()),
  78       kMachAnyTagged};
  79   return access;
  80 }
  81
  82
  83 // static
  84 FieldAccess AccessBuilder::ForExternalArrayPointer() {
  85   FieldAccess access = {kTaggedBase, ExternalArray::kExternalPointerOffset,
  86                         MaybeHandle<Name>(), Type::UntaggedPointer(), kMachPtr};
  87   return access;
  88 }
  89
  90
  91 // static
  92 FieldAccess AccessBuilder::ForDescriptorArrayEnumCache() {
  93   FieldAccess access = {kTaggedBase, DescriptorArray::kEnumCacheOffset,
  94                         Handle<Name>(), Type::TaggedPointer(), kMachAnyTagged};
  95   return access;
  96 }
  97
  98
  99 // static
 100 FieldAccess AccessBuilder::ForDescriptorArrayEnumCacheBridgeCache() {
 101   FieldAccess access = {kTaggedBase,
 102                         DescriptorArray::kEnumCacheBridgeCacheOffset,
 103                         Handle<Name>(), Type::TaggedPointer(), kMachAnyTagged};
 104   return access;
 105 }
 106
 107
 108 // static
 109 FieldAccess AccessBuilder::ForMapBitField3() {
 110   FieldAccess access = {kTaggedBase, Map::kBitField3Offset, Handle<Name>(),
 111                         Type::UntaggedUnsigned32(), kMachUint32};
 112   return access;
 113 }
 114
 115
 116 // static
 117 FieldAccess AccessBuilder::ForMapDescriptors() {
 118   FieldAccess access = {kTaggedBase, Map::kDescriptorsOffset, Handle<Name>(),
 119                         Type::TaggedPointer(), kMachAnyTagged};
 120   return access;
 121 }
 122
 123
 124 // static
 125 FieldAccess AccessBuilder::ForMapInstanceType() {
 126   FieldAccess access = {kTaggedBase, Map::kInstanceTypeOffset, Handle<Name>(),
 127                         Type::UntaggedUnsigned8(), kMachUint8};
 128   return access;
 129 }
 130
 131
 132 // static
 133 FieldAccess AccessBuilder::ForStringLength(Zone* zone) {
 134   FieldAccess access = {
 135       kTaggedBase, String::kLengthOffset, Handle<Name>(),
 136       Type::Intersect(Type::Range(0, String::kMaxLength, zone),
 137                       Type::TaggedSigned(), zone),
 138       kMachAnyTagged};
 139   return access;
 140 }
 141
 142
 143 // static
 144 FieldAccess AccessBuilder::ForValue() {
 145   FieldAccess access = {kTaggedBase, JSValue::kValueOffset, Handle<Name>(),
 146                         Type::Any(), kMachAnyTagged};
 147   return access;
 148 }
 149
 150
 151 // static
 152 FieldAccess AccessBuilder::ForContextSlot(size_t index) {
 153   int offset = Context::kHeaderSize + static_cast<int>(index) * kPointerSize;
 154   DCHECK_EQ(offset,
 155             Context::SlotOffset(static_cast<int>(index)) + kHeapObjectTag);
 156   FieldAccess access = {kTaggedBase, offset, Handle<Name>(), Type::Any(),
 157                         kMachAnyTagged};
 158   return access;
 159 }
 160
 161
 162 // static
 163 FieldAccess AccessBuilder::ForPropertyCellValue() {
 164   FieldAccess access = {kTaggedBase, PropertyCell::kValueOffset, Handle<Name>(),
 165                         Type::Any(), kMachAnyTagged};
 166   return access;
 167 }
 168
 169
 170 // static
 171 FieldAccess AccessBuilder::ForSharedFunctionInfoTypeFeedbackVector() {
 172   FieldAccess access = {kTaggedBase, SharedFunctionInfo::kFeedbackVectorOffset,
 173                         Handle<Name>(), Type::Any(), kMachAnyTagged};
 174   return access;
 175 }
 176
 177
 178 // static
 179 ElementAccess AccessBuilder::ForFixedArrayElement() {
 180   ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
 181                           kMachAnyTagged};
 182   return access;
 183 }
 184
 185
 186 // static
 187 ElementAccess AccessBuilder::ForTypedArrayElement(ExternalArrayType type,
 188                                                   bool is_external) {
 189   BaseTaggedness taggedness = is_external ? kUntaggedBase : kTaggedBase;
 190   int header_size = is_external ? 0 : FixedTypedArrayBase::kDataOffset;
 191   switch (type) {
 192     case kExternalInt8Array: {
 193       ElementAccess access = {taggedness, header_size, Type::Signed32(),
 194                               kMachInt8};
 195       return access;
 196     }
 197     case kExternalUint8Array:
 198     case kExternalUint8ClampedArray: {
 199       ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
 200                               kMachUint8};
 201       return access;
 202     }
 203     case kExternalInt16Array: {
 204       ElementAccess access = {taggedness, header_size, Type::Signed32(),
 205                               kMachInt16};
 206       return access;
 207     }
 208     case kExternalUint16Array: {
 209       ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
 210                               kMachUint16};
 211       return access;
 212     }
 213     case kExternalInt32Array: {
 214       ElementAccess access = {taggedness, header_size, Type::Signed32(),
 215                               kMachInt32};
 216       return access;
 217     }
 218     case kExternalUint32Array: {
 219       ElementAccess access = {taggedness, header_size, Type::Unsigned32(),
 220                               kMachUint32};
 221       return access;
 222     }
 223     case kExternalFloat32Array: {
 224       ElementAccess access = {taggedness, header_size, Type::Number(),
 225                               kMachFloat32};
 226       return access;
 227     }
 228     case kExternalFloat64Array: {
 229       ElementAccess access = {taggedness, header_size, Type::Number(),
 230                               kMachFloat64};
 231       return access;
 232     }
 233   }
 234   UNREACHABLE();
 235   ElementAccess access = {kUntaggedBase, 0, Type::None(), kMachNone};
 236   return access;
 237 }
 238
 239
 240 // static
 241 ElementAccess AccessBuilder::ForSeqStringChar(String::Encoding encoding) {
 242   switch (encoding) {
 243     case String::ONE_BYTE_ENCODING: {
 244       ElementAccess access = {kTaggedBase, SeqString::kHeaderSize,
 245                               Type::Unsigned32(), kMachUint8};
 246       return access;
 247     }
 248     case String::TWO_BYTE_ENCODING: {
 249       ElementAccess access = {kTaggedBase, SeqString::kHeaderSize,
 250                               Type::Unsigned32(), kMachUint16};
 251       return access;
 252     }
 253   }
 254   UNREACHABLE();
 255   ElementAccess access = {kUntaggedBase, 0, Type::None(), kMachNone};
 256   return access;
 257 }
 258
 259
 260 // static
 261 FieldAccess AccessBuilder::ForStatsCounter() {
 262   FieldAccess access = {kUntaggedBase, 0, MaybeHandle<Name>(), Type::Signed32(),
 263                         kMachInt32};
 264   return access;
 265 }
 266
 267
 268 // static
 269 FieldAccess AccessBuilder::ForFrameCallerFramePtr() {
 270   FieldAccess access = {kUntaggedBase, StandardFrameConstants::kCallerFPOffset,
 271                         MaybeHandle<Name>(), Type::Internal(), kMachPtr};
 272   return access;
 273 }
 274
 275
 276 // static
 277 FieldAccess AccessBuilder::ForFrameMarker() {
 278   FieldAccess access = {kUntaggedBase, StandardFrameConstants::kMarkerOffset,
 279                         MaybeHandle<Name>(), Type::Tagged(), kMachAnyTagged};
 280   return access;
 281 }
 282
 283 }  // namespace compiler
 284 }  // namespace internal
 285 }  // namespace v8