[turbofan] Make FieldAccess::name usable in practice.

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(),
-                        MachineType::AnyTagged()};
+  FieldAccess access = {kTaggedBase, HeapObject::kMapOffset, "HeapObject::map",
+                        Type::Any(), MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForHeapNumberValue() {
   FieldAccess access = {kTaggedBase, HeapNumber::kValueOffset,
-                        MaybeHandle<Name>(), TypeCache().Get().kFloat64,
+                        "HeapNumber::value", TypeCache().Get().kFloat64,
                         MachineType::Float64()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSObjectProperties() {
   FieldAccess access = {kTaggedBase, JSObject::kPropertiesOffset,
-                        MaybeHandle<Name>(), Type::Internal(),
+                        "JSObject::properties", Type::Internal(),
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSObjectElements() {
   FieldAccess access = {kTaggedBase, JSObject::kElementsOffset,
-                        MaybeHandle<Name>(), Type::Internal(),
+                        "JSObject::elements", Type::Internal(),
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSObjectInObjectProperty(Handle<Map> map,
                                                        int index) {
   int const offset = map->GetInObjectPropertyOffset(index);
-  FieldAccess access = {kTaggedBase, offset, MaybeHandle<Name>(),
+  FieldAccess access = {kTaggedBase, offset, "JSObject::field[n]",
                         Type::Tagged(), MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSFunctionContext() {
   FieldAccess access = {kTaggedBase, JSFunction::kContextOffset,
-                        MaybeHandle<Name>(), Type::Internal(),
+                        "JSFunction::context", Type::Internal(),
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSFunctionSharedFunctionInfo() {
   FieldAccess access = {kTaggedBase, JSFunction::kSharedFunctionInfoOffset,
-                        Handle<Name>(), Type::Any(), MachineType::AnyTagged()};
+                        "JSFunction::shared", Type::Any(),
+                        MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSArrayLength(ElementsKind elements_kind) {
   TypeCache const& type_cache = TypeCache::Get();
-  FieldAccess access = {kTaggedBase, JSArray::kLengthOffset, Handle<Name>(),
+  FieldAccess access = {kTaggedBase, JSArray::kLengthOffset, "JSArray::length",
                         type_cache.kJSArrayLengthType,
                         MachineType::AnyTagged()};
   if (IsFastDoubleElementsKind(elements_kind)) {
     access.type = type_cache.kFixedDoubleArrayLengthType;
   } else if (IsFastElementsKind(elements_kind)) {
     access.type = type_cache.kFixedArrayLengthType;
   }
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSArrayBufferBackingStore() {
   FieldAccess access = {kTaggedBase, JSArrayBuffer::kBackingStoreOffset,
-                        MaybeHandle<Name>(), Type::UntaggedPointer(),
+                        "JSArrayBuffer::backing_store", Type::UntaggedPointer(),
                         MachineType::Pointer()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSArrayBufferBitField() {
   FieldAccess access = {kTaggedBase, JSArrayBuffer::kBitFieldOffset,
-                        MaybeHandle<Name>(), TypeCache::Get().kInt8,
+                        "JSArrayBuffer::bit_field", TypeCache::Get().kInt8,
                         MachineType::Int8()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSArrayBufferViewBuffer() {
   FieldAccess access = {kTaggedBase, JSArrayBufferView::kBufferOffset,
-                        MaybeHandle<Name>(), Type::TaggedPointer(),
+                        "JSArrayBufferView::buffer", Type::TaggedPointer(),
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSDateField(JSDate::FieldIndex index) {
   FieldAccess access = {
       kTaggedBase, JSDate::kValueOffset + index * kPointerSize,
-      MaybeHandle<Name>(), Type::Number(), MachineType::AnyTagged()};
+      "JSDate::field[n]", Type::Number(), MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForFixedArrayLength() {
   FieldAccess access = {
-      kTaggedBase, FixedArray::kLengthOffset, MaybeHandle<Name>(),
+      kTaggedBase, FixedArray::kLengthOffset, "FixedArray::length",
       TypeCache::Get().kFixedArrayLengthType, MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForDescriptorArrayEnumCache() {
   FieldAccess access = {kTaggedBase, DescriptorArray::kEnumCacheOffset,
-                        Handle<Name>(), Type::TaggedPointer(),
+                        "DescriptorArray::enum_cache", Type::TaggedPointer(),
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForDescriptorArrayEnumCacheBridgeCache() {
-  FieldAccess access = {
-      kTaggedBase, DescriptorArray::kEnumCacheBridgeCacheOffset, Handle<Name>(),
-      Type::TaggedPointer(), MachineType::AnyTagged()};
+  FieldAccess access = {kTaggedBase,
+                        DescriptorArray::kEnumCacheBridgeCacheOffset,
+                        "DescriptorArray::enum_cache_bridge_cache",
+                        Type::TaggedPointer(), MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForMapBitField3() {
-  FieldAccess access = {kTaggedBase, Map::kBitField3Offset, Handle<Name>(),
+  FieldAccess access = {kTaggedBase, Map::kBitField3Offset, "Map::bit_field3",
                         TypeCache::Get().kInt32, MachineType::Int32()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForMapDescriptors() {
-  FieldAccess access = {kTaggedBase, Map::kDescriptorsOffset, Handle<Name>(),
-                        Type::TaggedPointer(), MachineType::AnyTagged()};
+  FieldAccess access = {kTaggedBase, Map::kDescriptorsOffset,
+                        "Map::descriptors", Type::TaggedPointer(),
+                        MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForMapInstanceType() {
-  FieldAccess access = {kTaggedBase, Map::kInstanceTypeOffset, Handle<Name>(),
-                        TypeCache::Get().kUint8, MachineType::Uint8()};
+  FieldAccess access = {kTaggedBase, Map::kInstanceTypeOffset,
+                        "Map::instance_type", TypeCache::Get().kUint8,
+                        MachineType::Uint8()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForMapPrototype() {
-  FieldAccess access = {kTaggedBase, Map::kPrototypeOffset, Handle<Name>(),
+  FieldAccess access = {kTaggedBase, Map::kPrototypeOffset, "Map::prototype",
                         Type::TaggedPointer(), MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForStringLength() {
-  FieldAccess access = {kTaggedBase, String::kLengthOffset, Handle<Name>(),
+  FieldAccess access = {kTaggedBase, String::kLengthOffset, "String::length",
                         TypeCache::Get().kStringLengthType,
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSGlobalObjectGlobalProxy() {
   FieldAccess access = {kTaggedBase, JSGlobalObject::kGlobalProxyOffset,
-                        Handle<Name>(), Type::Receiver(),
+                        "JSGlobalObject::global_proxy", Type::Receiver(),
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForJSGlobalObjectNativeContext() {
   FieldAccess access = {kTaggedBase, JSGlobalObject::kNativeContextOffset,
-                        Handle<Name>(), Type::Internal(),
+                        "JSGlobalObject::native_context", Type::Internal(),
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForValue() {
-  FieldAccess access = {kTaggedBase, JSValue::kValueOffset, Handle<Name>(),
+  FieldAccess access = {kTaggedBase, JSValue::kValueOffset, "JSValue::value",
                         Type::Any(), MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForArgumentsLength() {
   int offset =
       JSObject::kHeaderSize + Heap::kArgumentsLengthIndex * kPointerSize;
-  FieldAccess access = {kTaggedBase, offset, Handle<Name>(), Type::Any(),
+  FieldAccess access = {kTaggedBase, offset, "Arguments::length", Type::Any(),
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForArgumentsCallee() {
   int offset =
       JSObject::kHeaderSize + Heap::kArgumentsCalleeIndex * kPointerSize;
-  FieldAccess access = {kTaggedBase, offset, Handle<Name>(), Type::Any(),
+  FieldAccess access = {kTaggedBase, offset, "Arguments::callee", Type::Any(),
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForFixedArraySlot(size_t index) {
   int offset = FixedArray::OffsetOfElementAt(static_cast<int>(index));
-  FieldAccess access = {kTaggedBase, offset, Handle<Name>(), Type::Any(),
+  FieldAccess access = {kTaggedBase, offset, "FixedArray::slot[n]", Type::Any(),
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // 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);
-  FieldAccess access = {kTaggedBase, offset, Handle<Name>(), Type::Any(),
+  FieldAccess access = {kTaggedBase, offset, "Context::slot[n]", Type::Any(),
                         MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForPropertyCellValue() {
   return ForPropertyCellValue(Type::Tagged());
 }
 
 
 // static
 FieldAccess AccessBuilder::ForPropertyCellValue(Type* type) {
-  FieldAccess access = {kTaggedBase, PropertyCell::kValueOffset, Handle<Name>(),
-                        type, MachineType::AnyTagged()};
+  FieldAccess access = {kTaggedBase, PropertyCell::kValueOffset,
+                        "PropertyCall::value", type, MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForSharedFunctionInfoTypeFeedbackVector() {
   FieldAccess access = {kTaggedBase, SharedFunctionInfo::kFeedbackVectorOffset,
-                        Handle<Name>(), Type::Any(), MachineType::AnyTagged()};
+                        "SharedFunctionInfo::feedback_vector", Type::Any(),
+                        MachineType::AnyTagged()};
   return access;
 }
 
 
 // static
 ElementAccess AccessBuilder::ForFixedArrayElement() {
   ElementAccess access = {kTaggedBase, FixedArray::kHeaderSize, Type::Tagged(),
                           MachineType::AnyTagged()};
   return access;
 }
@@ skipping 56 matching lines @@
     }
   }
   UNREACHABLE();
   ElementAccess access = {kUntaggedBase, 0, Type::None(), MachineType::None()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForStatsCounter() {
-  FieldAccess access = {kUntaggedBase, 0, MaybeHandle<Name>(),
+  FieldAccess access = {kUntaggedBase, 0, "##StatsCounter##",
                         TypeCache::Get().kInt32, MachineType::Int32()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForFrameCallerFramePtr() {
   FieldAccess access = {kUntaggedBase, StandardFrameConstants::kCallerFPOffset,
-                        MaybeHandle<Name>(), Type::Internal(),
+                        "##FrameCallerFP##", Type::Internal(),
                         MachineType::Pointer()};
   return access;
 }
 
 
 // static
 FieldAccess AccessBuilder::ForFrameMarker() {
   FieldAccess access = {kUntaggedBase, StandardFrameConstants::kMarkerOffset,
-                        MaybeHandle<Name>(), Type::Tagged(),
+                        "##FrameMarker##", Type::Tagged(),
                         MachineType::AnyTagged()};
   return access;
 }
 
+
+// static
+const char* AccessBuilder::GetNameForTracing(Handle<Name> name, Zone* zone) {
+#ifdef OBJECT_PRINT
+  if (FLAG_trace_turbo || FLAG_trace_turbo_graph) {
+    std::ostringstream os;
+    name->Print(os);
+    char* result = zone->NewArray<char>(os.str().length() + 1);
+    Vector<char> vector(result, os.str().length() + 1);
+    SNPrintF(vector, "%s", os.str().c_str());
+    return result;
+  }
+#endif
+  return nullptr;
+}
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8