[types] Use the TypeCache consistently for common types.

src/compiler/access-builder.cc

 // 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"
+
+#include "src/contexts.h"
+#include "src/frames.h"
+#include "src/heap/heap.h"
+#include "src/type-cache.h"
 #include "src/types-inl.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // static
 FieldAccess AccessBuilder::ForMap() {
   FieldAccess access = {kTaggedBase, HeapObject::kMapOffset,
                         MaybeHandle<Name>(), Type::Any(), kMachAnyTagged};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSObjectProperties() {
   FieldAccess access = {kTaggedBase, JSObject::kPropertiesOffset,
-                        MaybeHandle<Name>(), Type::Any(), kMachAnyTagged};
+                        MaybeHandle<Name>(), Type::Internal(), kMachAnyTagged};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSObjectElements() {
   FieldAccess access = {kTaggedBase, JSObject::kElementsOffset,
                         MaybeHandle<Name>(), Type::Internal(), kMachAnyTagged};
   return access;
 }
@@ skipping 26 matching lines @@
 // static
 FieldAccess AccessBuilder::ForJSDateField(JSDate::FieldIndex index) {
   FieldAccess access = {kTaggedBase,
                         JSDate::kValueOffset + index * kPointerSize,
                         MaybeHandle<Name>(), Type::Number(), kMachAnyTagged};
   return access;
 }
 
 
 // static
-FieldAccess AccessBuilder::ForFixedArrayLength(Zone* zone) {
-  FieldAccess access = {
-      kTaggedBase, FixedArray::kLengthOffset, MaybeHandle<Name>(),
-      Type::Intersect(Type::Range(0, FixedArray::kMaxLength, zone),
-                      Type::TaggedSigned(), zone),
-      kMachAnyTagged};
+FieldAccess AccessBuilder::ForFixedArrayLength() {
+  FieldAccess access = {kTaggedBase, FixedArray::kLengthOffset,
+                        MaybeHandle<Name>(),
+                        TypeCache::Get().kFixedArrayLengthType, kMachAnyTagged};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForDescriptorArrayEnumCache() {
   FieldAccess access = {kTaggedBase, DescriptorArray::kEnumCacheOffset,
                         Handle<Name>(), Type::TaggedPointer(), kMachAnyTagged};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForDescriptorArrayEnumCacheBridgeCache() {
   FieldAccess access = {kTaggedBase,
                         DescriptorArray::kEnumCacheBridgeCacheOffset,
                         Handle<Name>(), Type::TaggedPointer(), kMachAnyTagged};
   return access;
 }
 
 
 // static
-FieldAccess AccessBuilder::ForMapBitField3(Zone* zone) {
-  FieldAccess access = {
-      kTaggedBase, Map::kBitField3Offset, Handle<Name>(),
-      Type::Intersect(Type::Signed32(), Type::UntaggedSigned32(), zone),
-      kMachInt32};
+FieldAccess AccessBuilder::ForMapBitField3() {
+  FieldAccess access = {kTaggedBase, Map::kBitField3Offset, Handle<Name>(),
+                        TypeCache::Get().kInt32, kMachInt32};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForMapDescriptors() {
   FieldAccess access = {kTaggedBase, Map::kDescriptorsOffset, Handle<Name>(),
                         Type::TaggedPointer(), kMachAnyTagged};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForMapInstanceType() {
   FieldAccess access = {kTaggedBase, Map::kInstanceTypeOffset, Handle<Name>(),
-                        Type::UntaggedUnsigned8(), kMachUint8};
+                        TypeCache::Get().kUint8, kMachUint8};
   return access;
 }
 
 
 // static
-FieldAccess AccessBuilder::ForStringLength(Zone* zone) {
-  FieldAccess access = {
-      kTaggedBase, String::kLengthOffset, Handle<Name>(),
-      Type::Intersect(Type::Range(0, String::kMaxLength, zone),
-                      Type::TaggedSigned(), zone),
-      kMachAnyTagged};
+FieldAccess AccessBuilder::ForStringLength() {
+  FieldAccess access = {kTaggedBase, String::kLengthOffset, Handle<Name>(),
+                        TypeCache::Get().kStringLengthType, kMachAnyTagged};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForGlobalObjectGlobalProxy() {
   FieldAccess access = {kTaggedBase, GlobalObject::kGlobalProxyOffset,
                         Handle<Name>(), Type::Receiver(), kMachAnyTagged};
   return access;
 }
@@ skipping 154 matching lines @@
     }
   }
   UNREACHABLE();
   ElementAccess access = {kUntaggedBase, 0, Type::None(), kMachNone};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForStatsCounter() {
-  FieldAccess access = {kUntaggedBase, 0, MaybeHandle<Name>(), Type::Signed32(),
-                        kMachInt32};
+  FieldAccess access = {kUntaggedBase, 0, MaybeHandle<Name>(),
+                        TypeCache::Get().kInt32, kMachInt32};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForFrameCallerFramePtr() {
   FieldAccess access = {kUntaggedBase, StandardFrameConstants::kCallerFPOffset,
                         MaybeHandle<Name>(), Type::Internal(), kMachPtr};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForFrameMarker() {
   FieldAccess access = {kUntaggedBase, StandardFrameConstants::kMarkerOffset,
                         MaybeHandle<Name>(), Type::Tagged(), kMachAnyTagged};
   return access;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8