Mangling: refactoring: use meta-programming for value witness mangling/demangling/remangling

Also add the missing DestructiveInjectEnumTag entry.

Author: eeckstein

include/swift/Basic/Demangle.h

@@ -108,27 +108,9 @@ static inline char encodeSpecializationPass(SpecializationPass Pass) {
 }
 
 enum class ValueWitnessKind {
-  AllocateBuffer,
-  AssignWithCopy,
-  AssignWithTake,
-  DeallocateBuffer,
-  Destroy,
-  DestroyBuffer,
-  InitializeBufferWithCopyOfBuffer,
-  InitializeBufferWithCopy,
-  InitializeWithCopy,
-  InitializeBufferWithTake,
-  InitializeWithTake,
-  ProjectBuffer,
-  InitializeBufferWithTakeOfBuffer,
-  DestroyArray,
-  InitializeArrayWithCopy,
-  InitializeArrayWithTakeFrontToBack,
-  InitializeArrayWithTakeBackToFront,
-  StoreExtraInhabitant,
-  GetExtraInhabitantIndex,
-  GetEnumTag,
-  DestructiveProjectEnumData,
+#define VALUE_WITNESS(MANGLING, NAME) \
+  NAME,
+#include "swift/Basic/ValueWitnessMangling.def"
 };
 
 enum class Directness {

include/swift/Basic/ValueWitnessMangling.def

@@ -0,0 +1,39 @@
+//===-- ValueWitnessMangling.def - VW Mangling Metaprogramming --*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+/// VALUE_WITNESS(MANGLING, NAME)
+///   The 2-character MANGLING for a value witness NAME.
+
+VALUE_WITNESS(al, AllocateBuffer)
+VALUE_WITNESS(ca, AssignWithCopy)
+VALUE_WITNESS(ta, AssignWithTake)
+VALUE_WITNESS(de, DeallocateBuffer)
+VALUE_WITNESS(xx, Destroy)
+VALUE_WITNESS(XX, DestroyBuffer)
+VALUE_WITNESS(Xx, DestroyArray)
+VALUE_WITNESS(CP, InitializeBufferWithCopyOfBuffer)
+VALUE_WITNESS(Cp, InitializeBufferWithCopy)
+VALUE_WITNESS(cp, InitializeWithCopy)
+VALUE_WITNESS(Tk, InitializeBufferWithTake)
+VALUE_WITNESS(tk, InitializeWithTake)
+VALUE_WITNESS(pr, ProjectBuffer)
+VALUE_WITNESS(TK, InitializeBufferWithTakeOfBuffer)
+VALUE_WITNESS(Cc, InitializeArrayWithCopy)
+VALUE_WITNESS(Tt, InitializeArrayWithTakeFrontToBack)
+VALUE_WITNESS(tT, InitializeArrayWithTakeBackToFront)
+VALUE_WITNESS(xs, StoreExtraInhabitant)
+VALUE_WITNESS(xg, GetExtraInhabitantIndex)
+VALUE_WITNESS(ug, GetEnumTag)
+VALUE_WITNESS(up, DestructiveProjectEnumData)
+VALUE_WITNESS(ui, DestructiveInjectEnumTag)
+
+#undef VALUE_WITNESS

lib/Basic/Demangle.cpp

@@ -284,6 +284,8 @@ static StringRef toString(ValueWitnessKind k) {
     return "getEnumTag";
   case ValueWitnessKind::DestructiveProjectEnumData:
     return "destructiveProjectEnumData";
+  case ValueWitnessKind::DestructiveInjectEnumTag:
+    return "destructiveInjectEnumTag";
   }
   unreachable("bad value witness kind");
 }
@@ -409,54 +411,19 @@ class Demangler {
   }
 
   Optional<ValueWitnessKind> demangleValueWitnessKind() {
+    char Code[2];
     if (!Mangled)
       return None;
-    char c1 = Mangled.next();
+    Code[0] = Mangled.next();
     if (!Mangled)
       return None;
-    char c2 = Mangled.next();
-    if (c1 == 'a' && c2 == 'l')
-      return ValueWitnessKind::AllocateBuffer;
-    if (c1 == 'c' && c2 == 'a')
-      return ValueWitnessKind::AssignWithCopy;
-    if (c1 == 't' && c2 == 'a')
-      return ValueWitnessKind::AssignWithTake;
-    if (c1 == 'd' && c2 == 'e')
-      return ValueWitnessKind::DeallocateBuffer;
-    if (c1 == 'x' && c2 == 'x')
-      return ValueWitnessKind::Destroy;
-    if (c1 == 'X' && c2 == 'X')
-      return ValueWitnessKind::DestroyBuffer;
-    if (c1 == 'C' && c2 == 'P')
-      return ValueWitnessKind::InitializeBufferWithCopyOfBuffer;
-    if (c1 == 'C' && c2 == 'p')
-      return ValueWitnessKind::InitializeBufferWithCopy;
-    if (c1 == 'c' && c2 == 'p')
-      return ValueWitnessKind::InitializeWithCopy;
-    if (c1 == 'C' && c2 == 'c')
-      return ValueWitnessKind::InitializeArrayWithCopy;
-    if (c1 == 'T' && c2 == 'K')
-      return ValueWitnessKind::InitializeBufferWithTakeOfBuffer;
-    if (c1 == 'T' && c2 == 'k')
-      return ValueWitnessKind::InitializeBufferWithTake;
-    if (c1 == 't' && c2 == 'k')
-      return ValueWitnessKind::InitializeWithTake;
-    if (c1 == 'T' && c2 == 't')
-      return ValueWitnessKind::InitializeArrayWithTakeFrontToBack;
-    if (c1 == 't' && c2 == 'T')
-      return ValueWitnessKind::InitializeArrayWithTakeBackToFront;
-    if (c1 == 'p' && c2 == 'r')
-      return ValueWitnessKind::ProjectBuffer;
-    if (c1 == 'X' && c2 == 'x')
-      return ValueWitnessKind::DestroyArray;
-    if (c1 == 'x' && c2 == 's')
-      return ValueWitnessKind::StoreExtraInhabitant;
-    if (c1 == 'x' && c2 == 'g')
-      return ValueWitnessKind::GetExtraInhabitantIndex;
-    if (c1 == 'u' && c2 == 'g')
-      return ValueWitnessKind::GetEnumTag;
-    if (c1 == 'u' && c2 == 'p')
-      return ValueWitnessKind::DestructiveProjectEnumData;
+    Code[1] = Mangled.next();
+
+    StringRef CodeStr(Code, 2);
+#define VALUE_WITNESS(MANGLING, NAME) \
+  if (CodeStr == #MANGLING) return ValueWitnessKind::NAME;
+#include "swift/Basic/ValueWitnessMangling.def"
+
     return None;
   }
 

lib/Basic/Remangle.cpp

@@ -653,33 +653,13 @@ void Remangler::mangleDirectness(Node *node) {
 }
 
 void Remangler::mangleValueWitness(Node *node) {
-  auto getString = [](ValueWitnessKind kind) -> StringRef {
-    switch (kind) {
-    case ValueWitnessKind::AllocateBuffer: return "al";
-    case ValueWitnessKind::AssignWithCopy: return "ca";
-    case ValueWitnessKind::AssignWithTake: return "ta";
-    case ValueWitnessKind::DeallocateBuffer: return "de";
-    case ValueWitnessKind::Destroy: return "xx";
-    case ValueWitnessKind::DestroyBuffer: return "XX";
-    case ValueWitnessKind::InitializeBufferWithCopyOfBuffer: return "CP";
-    case ValueWitnessKind::InitializeBufferWithCopy: return "Cp";
-    case ValueWitnessKind::InitializeWithCopy: return "cp";
-    case ValueWitnessKind::InitializeBufferWithTake: return "Tk";
-    case ValueWitnessKind::InitializeWithTake: return "tk";
-    case ValueWitnessKind::ProjectBuffer: return "pr";
-    case ValueWitnessKind::InitializeBufferWithTakeOfBuffer: return "TK";
-    case ValueWitnessKind::DestroyArray: return "Xx";
-    case ValueWitnessKind::InitializeArrayWithCopy: return "Cc";
-    case ValueWitnessKind::InitializeArrayWithTakeFrontToBack: return "Tt";
-    case ValueWitnessKind::InitializeArrayWithTakeBackToFront: return "tT";
-    case ValueWitnessKind::StoreExtraInhabitant: return "xs";
-    case ValueWitnessKind::GetExtraInhabitantIndex: return "xg";
-    case ValueWitnessKind::GetEnumTag: return "ug";
-    case ValueWitnessKind::DestructiveProjectEnumData: return "up";
-    }
-    unreachable("bad value witness kind");
-  };
-  Out << 'w' << getString(ValueWitnessKind(node->getIndex()));
+  const char *Code = nullptr;
+  switch (ValueWitnessKind(node->getIndex())) {
+#define VALUE_WITNESS(MANGLING, NAME) \
+    case ValueWitnessKind::NAME: Code = #MANGLING; break;
+#include "swift/Basic/ValueWitnessMangling.def"
+  }
+  Out << 'w' << Code;
   mangleSingleChildNode(node); // type
 }
 

lib/IRGen/Linking.cpp

@@ -34,29 +34,10 @@ static StringRef mangleValueWitness(ValueWitness witness) {
   // opposed to objects) in the arguments.  That doesn't serve any
   // direct purpose, but it's neat.
   switch (witness) {
-  case ValueWitness::AllocateBuffer: return "al";
-  case ValueWitness::AssignWithCopy: return "ca";
-  case ValueWitness::AssignWithTake: return "ta";
-  case ValueWitness::DeallocateBuffer: return "de";
-  case ValueWitness::Destroy: return "xx";
-  case ValueWitness::DestroyBuffer: return "XX";
-  case ValueWitness::DestroyArray: return "Xx";
-  case ValueWitness::InitializeBufferWithCopyOfBuffer: return "CP";
-  case ValueWitness::InitializeBufferWithCopy: return "Cp";
-  case ValueWitness::InitializeWithCopy: return "cp";
-  case ValueWitness::InitializeBufferWithTake: return "Tk";
-  case ValueWitness::InitializeWithTake: return "tk";
-  case ValueWitness::ProjectBuffer: return "pr";
-  case ValueWitness::InitializeBufferWithTakeOfBuffer: return "TK";
-  case ValueWitness::InitializeArrayWithCopy: return "Cc";
-  case ValueWitness::InitializeArrayWithTakeFrontToBack: return "Tt";
-  case ValueWitness::InitializeArrayWithTakeBackToFront: return "tT";
-  case ValueWitness::StoreExtraInhabitant: return "xs";
-  case ValueWitness::GetExtraInhabitantIndex: return "xg";
-  case ValueWitness::GetEnumTag: return "ug";
-  case ValueWitness::DestructiveProjectEnumData: return "up";
-  case ValueWitness::DestructiveInjectEnumTag: return "ui";
-      
+#define VALUE_WITNESS(MANGLING, NAME) \
+    case ValueWitness::NAME: return #MANGLING;
+#include "swift/Basic/ValueWitnessMangling.def"
+
   case ValueWitness::Size:
   case ValueWitness::Flags:
   case ValueWitness::Stride: