Merge pull request #14125 from xedin/metaprogam-bultin-meta

[Mangled name -> metadata] Add built-in types support

Author: xedin

include/swift/Runtime/BuiltinTypes.def

@@ -0,0 +1,39 @@
+//===--- BuiltinTypes.def - Compiler declaration metaprogramming --*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines macros used for macro-metaprogramming with compiler-known
+// built-in types.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef BUILTIN_TYPE
+#  define BUILTIN_TYPE(Symbol, Name)
+#endif
+
+BUILTIN_TYPE(Bi8_, "Builtin.Int8")
+BUILTIN_TYPE(Bi16_, "Builtin.Int16")
+BUILTIN_TYPE(Bi32_, "Builtin.Int32")
+BUILTIN_TYPE(Bi64_, "Builtin.Int64")
+BUILTIN_TYPE(Bi128_, "Builtin.Int128")
+BUILTIN_TYPE(Bi256_, "Builtin.Int256")
+BUILTIN_TYPE(Bi512_, "Builtin.Int512")
+
+BUILTIN_TYPE(Bo, "Builtin.NativeObject")
+BUILTIN_TYPE(Bb, "Builtin.BridgeObject")
+BUILTIN_TYPE(Bp, "Builtin.RawPointer")
+BUILTIN_TYPE(BB, "Builtin.UnsafeValueBuffer")
+
+#if SWIFT_OBJC_INTEROP
+BUILTIN_TYPE(BO, "Builtin.UnknownObject")
+#endif
+
+#undef BUILTIN_TYPE

include/swift/Runtime/Metadata.h

@@ -984,32 +984,10 @@ using OpaqueMetadata = TargetOpaqueMetadata<InProcess>;
 // The "Int" metadata are used for arbitrary POD data with the
 // matching characteristics.
 using FullOpaqueMetadata = FullMetadata<OpaqueMetadata>;
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(Bi8_);      // Builtin.Int8
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(Bi16_);     // Builtin.Int16
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(Bi32_);     // Builtin.Int32
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(Bi64_);     // Builtin.Int64
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(Bi128_);    // Builtin.Int128
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(Bi256_);    // Builtin.Int256
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(Bi512_);    // Builtin.Int512
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(Bo);        // Builtin.NativeObject
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(Bb);        // Builtin.BridgeObject
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(Bp);        // Builtin.RawPointer
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(BB);        // Builtin.UnsafeValueBuffer
-#if SWIFT_OBJC_INTEROP
-SWIFT_RUNTIME_EXPORT
-const FullOpaqueMetadata METADATA_SYM(BO);        // Builtin.UnknownObject
-#endif
+#define BUILTIN_TYPE(Symbol, Name) \
+    SWIFT_RUNTIME_EXPORT \
+    const FullOpaqueMetadata METADATA_SYM(Symbol);
+#include "swift/Runtime/BuiltinTypes.def"
 
 /// The prefix on a heap metadata.
 struct HeapMetadataHeaderPrefix {

stdlib/public/runtime/Demangle.cpp

@@ -126,6 +126,15 @@ _applyGenericArguments(const Metadata * const *genericArgs,
   return genericNode;
 }
 
+static Demangle::NodePointer
+_buildDemanglerForBuiltinType(const Metadata *type, Demangle::Demangler &Dem) {
+#define BUILTIN_TYPE(Symbol, Name) \
+  if (type == &METADATA_SYM(Symbol).base) \
+    return Dem.createNode(Node::Kind::BuiltinTypeName, Name);
+#include "swift/Runtime/BuiltinTypes.def"
+  return nullptr;
+}
+
 // Build a demangled type tree for a nominal type.
 static Demangle::NodePointer
 _buildDemanglingForNominalType(const Metadata *type, Demangle::Demangler &Dem) {
@@ -451,9 +460,14 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
     }
     return tupleNode;
   }
-  case MetadataKind::Opaque:
+  case MetadataKind::Opaque: {
+    if (auto builtinType = _buildDemanglerForBuiltinType(type, Dem))
+      return builtinType;
+
     // FIXME: Some opaque types do have manglings, but we don't have enough info
     // to figure them out.
+    break;
+  }
   case MetadataKind::HeapLocalVariable:
   case MetadataKind::HeapGenericLocalVariable:
   case MetadataKind::ErrorObject:

stdlib/public/runtime/KnownMetadata.cpp

@@ -156,20 +156,9 @@ const ValueWitnessTable swift::VALUE_WITNESS_SYM(EMPTY_TUPLE_MANGLING) =
     { &VALUE_WITNESS_SYM(TYPE) },                             \
     { { MetadataKind::Opaque } }                 \
   };
-OPAQUE_METADATA(Bi8_)
-OPAQUE_METADATA(Bi16_)
-OPAQUE_METADATA(Bi32_)
-OPAQUE_METADATA(Bi64_)
-OPAQUE_METADATA(Bi128_)
-OPAQUE_METADATA(Bi256_)
-OPAQUE_METADATA(Bi512_)
-OPAQUE_METADATA(Bo)
-OPAQUE_METADATA(Bb)
-OPAQUE_METADATA(Bp)
-OPAQUE_METADATA(BB)
-#if SWIFT_OBJC_INTEROP
-OPAQUE_METADATA(BO)
-#endif
+#define BUILTIN_TYPE(Symbol, Name) \
+  OPAQUE_METADATA(Symbol)
+#include "swift/Runtime/BuiltinTypes.def"
 
 /// The standard metadata for the empty tuple.
 const FullMetadata<TupleTypeMetadata> swift::

stdlib/public/runtime/MetadataLookup.cpp

@@ -584,7 +584,10 @@ class DecodedMetadataBuilder {
   }
 
   BuiltType createBuiltinType(StringRef mangledName) const {
-    // FIXME: Implement.
+#define BUILTIN_TYPE(Symbol, _) \
+    if (mangledName.equals(#Symbol)) \
+      return &METADATA_SYM(Symbol).base;
+#include "swift/Runtime/BuiltinTypes.def"
     return BuiltType();
   }
 

test/Runtime/demangleToMetadata.swift

@@ -1,6 +1,9 @@
-// RUN: %target-run-simple-swift
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -parse-stdlib %s -module-name main -o %t/a.out
+// RUN: %target-run %t/a.out
 // REQUIRES: executable_test
 
+import Swift
 import StdlibUnittest
 
 let DemangleToMetadataTests = TestSuite("DemangleToMetadata")
@@ -213,5 +216,19 @@ DemangleToMetadataTests.test("nested generic specializations") {
     _typeByMangledName("4main3CG2C5InnerC9InnermostVySiSS_Sd_s4Int8Vs5Int16Vs5Int32Vs5Int64VG")!)
 }
 
+DemangleToMetadataTests.test("demangle built-in types") {
+  expectEqual(Builtin.Int8.self,     _typeByMangledName("Bi8_")!)
+  expectEqual(Builtin.Int16.self,    _typeByMangledName("Bi16_")!)
+  expectEqual(Builtin.Int32.self,    _typeByMangledName("Bi32_")!)
+  expectEqual(Builtin.Int64.self,    _typeByMangledName("Bi64_")!)
+  expectEqual(Builtin.Int128.self,   _typeByMangledName("Bi128_")!)
+  expectEqual(Builtin.Int256.self,   _typeByMangledName("Bi256_")!)
+  expectEqual(Builtin.Int512.self,   _typeByMangledName("Bi512_")!)
+
+  expectEqual(Builtin.NativeObject.self, _typeByMangledName("Bo")!)
+  expectEqual(Builtin.BridgeObject.self, _typeByMangledName("Bb")!)
+  expectEqual(Builtin.UnsafeValueBuffer.self, _typeByMangledName("BB")!)
+}
+
 runAllTests()