Create utility functions for mapping between the numeric opcode of a SILValue/SILInstruction and its mnemonic name

Use it for the stats collection, but also for SIL printing.

Author: swiftix

include/swift/SIL/SILInstruction.h

@@ -68,6 +68,12 @@ enum class SILInstructionKind : std::underlying_type<ValueKind>::type {
 #include "SILNodes.def"
 };
 
+/// Map SILInstruction's mnemonic name to its SILInstructionKind.
+SILInstructionKind getSILInstructionKind(StringRef InstName);
+
+/// Map SILInstructionKind to a corresponding SILInstruction name.
+StringRef getSILInstructionName(SILInstructionKind Kind);
+
 /// This is the root class for all instructions that can be used as the contents
 /// of a Swift SILBasicBlock.
 class SILInstruction : public ValueBase,public llvm::ilist_node<SILInstruction>{

include/swift/SIL/SILValue.h

@@ -785,6 +785,12 @@ inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, SILValue V) {
   return OS;
 }
 
+/// Map a SILValue mnemonic name to its ValueKind.
+ValueKind getSILValueKind(StringRef Name);
+
+/// Map ValueKind to a corresponding mnemonic name.
+StringRef getSILValueName(ValueKind Kind);
+
 } // end namespace swift
 
 

lib/SIL/SILInstruction.cpp

@@ -172,6 +172,25 @@ void SILInstruction::dropAllReferences() {
 int SILInstruction::NumCreatedInstructions = 0;
 int SILInstruction::NumDeletedInstructions = 0;
 
+/// Map a SILInstruction name to its SILInstructionKind.
+SILInstructionKind swift::getSILInstructionKind(StringRef InstName) {
+  auto Kind = getSILValueKind(InstName);
+  if (Kind >= ValueKind::First_SILInstruction &&
+      Kind <= ValueKind::Last_SILInstruction)
+    return SILInstructionKind(Kind);
+
+#ifdef NDEBUG
+  llvm::errs() << "Unknown SIL instruction name\n";
+  abort();
+#endif
+  llvm_unreachable("Unknown SIL insruction name");
+}
+
+/// Map SILInstructionKind to a corresponding SILInstruction name.
+StringRef swift::getSILInstructionName(SILInstructionKind Kind) {
+  return getSILValueName(ValueKind(Kind));
+}
+
 namespace {
 class InstructionDestroyer
     : public SILInstructionVisitor<InstructionDestroyer> {

lib/SIL/SILPrinter.cpp

@@ -826,14 +826,7 @@ class SILPrinter : public SILVisitor<SILPrinter> {
   }
 
   void printInstOpCode(SILInstruction *I) {
-    // If we have a SILInstruction, print out the opcode.
-    switch (SILInstructionKind(I->getKind())) {
-#define INST(Id, Parent, TextualName, MemoryBehavior, ReleasingBehavior)       \
-  case SILInstructionKind::Id:                                                 \
-    *this << #TextualName " ";                                                 \
-    break;
-#include "swift/SIL/SILNodes.def"
-    }
+    *this << getSILValueName(I->getKind()) << " ";
   }
 
   void print(SILValue V) {

lib/SIL/SILValue.cpp

@@ -182,3 +182,40 @@ ValueOwnershipKind SILValue::getOwnershipKind() const {
   sil::ValueOwnershipKindClassifier Classifier;
   return Classifier.visit(const_cast<ValueBase *>(Value));
 }
+
+/// Map a SILValue mnemonic name to its ValueKind.
+ValueKind swift::getSILValueKind(StringRef Name) {
+#define INST(Id, Parent, TextualName, MemoryBehavior, ReleasingBehavior)       \
+  if (Name == #TextualName)                                                    \
+    return ValueKind::Id;
+
+#define VALUE(Id, Parent)                                                      \
+  if (Name == #Id)                                                             \
+    return ValueKind::Id;
+
+#include "swift/SIL/SILNodes.def"
+
+#ifdef NDEBUG
+  llvm::errs()
+    << "Unknown SILValue name\n";
+  abort();
+#endif
+  llvm_unreachable("Unknown SILValue name");
+}
+
+/// Map ValueKind to a corresponding mnemonic name.
+StringRef swift::getSILValueName(ValueKind Kind) {
+  switch (Kind) {
+#define INST(Id, Parent, TextualName, MemoryBehavior, ReleasingBehavior)       \
+  case ValueKind::Id:                                                          \
+    return #TextualName;                                                       \
+    break;
+
+#define VALUE(Id, Parent)                                                      \
+  case ValueKind::Id:                                                          \
+    return #Id;                                                                \
+    break;
+
+#include "swift/SIL/SILNodes.def"
+  }
+}

lib/SILOptimizer/Utils/OptimizerStatsUtils.cpp

@@ -84,34 +84,6 @@ constexpr unsigned SILInstructionsNum = int(ValueKind::Last_SILInstruction) + 1;
 /// A set of counters, one per SILInstruction kind.
 using InstructionCounts = SmallVector<int, SILInstructionsNum>;
 
-/// Map a SILInstruction name to its SILInstructionKind.
-SILInstructionKind getSILInstructionKind(StringRef InstName) {
-#define INST(Id, Parent, TextualName, MemoryBehavior, ReleasingBehavior)       \
-  if (InstName == #TextualName)                                                \
-    return SILInstructionKind::Id;
-
-#include "swift/SIL/SILNodes.def"
-
-#ifdef NDEBUG
-  llvm::errs()
-      << "Unknown instruction name used by the -sil-stats-only-instructions\n";
-  abort();
-#endif
-  llvm_unreachable(
-      "Unknown insruction name used by the -sil-stats-only-instructions");
-}
-
-/// Map SILInstructionKind to a corresponding SILInstruction name.
-const char *getSILInstructionName(SILInstructionKind Kind) {
-  switch (Kind) {
-#define INST(Id, Parent, TextualName, MemoryBehavior, ReleasingBehavior)       \
-  case SILInstructionKind::Id:                                                 \
-    return #TextualName;                                                       \
-    break;
-#include "swift/SIL/SILNodes.def"
-  }
-}
-
 /// A helper type to parse a comma separated list of SIL instruction names
 /// provided as argument of the -sil-stats-only-instructions options.
 class StatsOnlyInstructionsOpt {