Revert "[tablegen] Emit string literals instead of char arrays"

This reverts commit ce23515.

That commit broke some builds on Windows:
http://lab.llvm.org:8011/builders/clang-x64-windows-msvc/builds/13870

Author: broadwaylamb

llvm/cmake/modules/TableGen.cmake

@@ -58,14 +58,6 @@ function(tablegen project ofn)
     endif()
   endif()
 
-  # MSVC can't support long string literals ("long" > 65534 bytes)[1], so if there's
-  # a possibility of generated tables being consumed by MSVC, generate arrays of
-  # char literals, instead. If we're cross-compiling, then conservatively assume
-  # that the source might be consumed by MSVC.
-  # [1] https://docs.microsoft.com/en-us/cpp/cpp/compiler-limits?view=vs-2017
-  if (MSVC)
-    list(APPEND LLVM_TABLEGEN_FLAGS "--long-string-literals=0")
-  endif()
   if (CMAKE_GENERATOR MATCHES "Visual Studio")
     # Visual Studio has problems with llvm-tblgen's native --write-if-changed
     # behavior. Since it doesn't do restat optimizations anyway, just don't

llvm/utils/TableGen/AsmWriterEmitter.cpp

@@ -381,7 +381,7 @@ void AsmWriterEmitter::EmitPrintInstruction(raw_ostream &O) {
 
   // Emit the string table itself.
   O << "  static const char AsmStrs[] = {\n";
-  StringTable.emit_string_literals(O);
+  StringTable.emit(O, printChar);
   O << "  };\n\n";
 
   // Emit the lookup tables in pieces to minimize wasted bytes.
@@ -538,7 +538,7 @@ emitRegisterNameString(raw_ostream &O, StringRef AltName,
 
   StringTable.layout();
   O << "  static const char AsmStrs" << AltName << "[] = {\n";
-  StringTable.emit_string_literals(O);
+  StringTable.emit(O, printChar);
   O << "  };\n\n";
 
   O << "  static const " << getMinimalTypeForRange(StringTable.size() - 1, 32)

llvm/utils/TableGen/InstrInfoEmitter.cpp

@@ -570,7 +570,7 @@ void InstrInfoEmitter::run(raw_ostream &OS) {
   // Emit the array of instruction names.
   InstrNames.layout();
   OS << "extern const char " << TargetName << "InstrNameData[] = {\n";
-  InstrNames.emit_string_literals(OS);
+  InstrNames.emit(OS, printChar);
   OS << "};\n\n";
 
   OS << "extern const unsigned " << TargetName <<"InstrNameIndices[] = {";

llvm/utils/TableGen/RegisterInfoEmitter.cpp

@@ -993,7 +993,7 @@ RegisterInfoEmitter::runMCDesc(raw_ostream &OS, CodeGenTarget &Target,
   // Emit the string table.
   RegStrings.layout();
   OS << "extern const char " << TargetName << "RegStrings[] = {\n";
-  RegStrings.emit_string_literals(OS);
+  RegStrings.emit(OS, printChar);
   OS << "};\n\n";
 
   OS << "extern const MCRegisterDesc " << TargetName
@@ -1066,7 +1066,7 @@ RegisterInfoEmitter::runMCDesc(raw_ostream &OS, CodeGenTarget &Target,
 
   RegClassStrings.layout();
   OS << "extern const char " << TargetName << "RegClassStrings[] = {\n";
-  RegClassStrings.emit_string_literals(OS);
+  RegClassStrings.emit(OS, printChar);
   OS << "};\n\n";
 
   OS << "extern const MCRegisterClass " << TargetName

llvm/utils/TableGen/SequenceToOffsetTable.h

@@ -15,7 +15,6 @@
 #ifndef LLVM_UTILS_TABLEGEN_SEQUENCETOOFFSETTABLE_H
 #define LLVM_UTILS_TABLEGEN_SEQUENCETOOFFSETTABLE_H
 
-#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
@@ -24,61 +23,6 @@
 #include <map>
 
 namespace llvm {
-extern llvm::cl::opt<bool> EmitLongStrLiterals;
-
-// Helper function for SequenceToOffsetTable<string>.
-static inline void printStrLitEscChar(raw_ostream &OS, char C) {
-  const char *Escapes[] = {
-      "\\000", "\\001", "\\002", "\\003", "\\004", "\\005", "\\006", "\\007",
-      "\\010", "\\t",   "\\n",   "\\013", "\\014", "\\r",   "\\016", "\\017",
-      "\\020", "\\021", "\\022", "\\023", "\\024", "\\025", "\\026", "\\027",
-      "\\030", "\\031", "\\032", "\\033", "\\034", "\\035", "\\036", "\\037",
-      " ",     "!",     "\\\"",  "#",     "$",     "%",     "&",     "'",
-      "(",     ")",     "*",     "+",     ",",     "-",     ".",     "/",
-      "0",     "1",     "2",     "3",     "4",     "5",     "6",     "7",
-      "8",     "9",     ":",     ";",     "<",     "=",     ">",     "?",
-      "@",     "A",     "B",     "C",     "D",     "E",     "F",     "G",
-      "H",     "I",     "J",     "K",     "L",     "M",     "N",     "O",
-      "P",     "Q",     "R",     "S",     "T",     "U",     "V",     "W",
-      "X",     "Y",     "Z",     "[",     "\\\\",  "]",     "^",     "_",
-      "`",     "a",     "b",     "c",     "d",     "e",     "f",     "g",
-      "h",     "i",     "j",     "k",     "l",     "m",     "n",     "o",
-      "p",     "q",     "r",     "s",     "t",     "u",     "v",     "w",
-      "x",     "y",     "z",     "{",     "|",     "}",     "~",     "\\177",
-      "\\200", "\\201", "\\202", "\\203", "\\204", "\\205", "\\206", "\\207",
-      "\\210", "\\211", "\\212", "\\213", "\\214", "\\215", "\\216", "\\217",
-      "\\220", "\\221", "\\222", "\\223", "\\224", "\\225", "\\226", "\\227",
-      "\\230", "\\231", "\\232", "\\233", "\\234", "\\235", "\\236", "\\237",
-      "\\240", "\\241", "\\242", "\\243", "\\244", "\\245", "\\246", "\\247",
-      "\\250", "\\251", "\\252", "\\253", "\\254", "\\255", "\\256", "\\257",
-      "\\260", "\\261", "\\262", "\\263", "\\264", "\\265", "\\266", "\\267",
-      "\\270", "\\271", "\\272", "\\273", "\\274", "\\275", "\\276", "\\277",
-      "\\300", "\\301", "\\302", "\\303", "\\304", "\\305", "\\306", "\\307",
-      "\\310", "\\311", "\\312", "\\313", "\\314", "\\315", "\\316", "\\317",
-      "\\320", "\\321", "\\322", "\\323", "\\324", "\\325", "\\326", "\\327",
-      "\\330", "\\331", "\\332", "\\333", "\\334", "\\335", "\\336", "\\337",
-      "\\340", "\\341", "\\342", "\\343", "\\344", "\\345", "\\346", "\\347",
-      "\\350", "\\351", "\\352", "\\353", "\\354", "\\355", "\\356", "\\357",
-      "\\360", "\\361", "\\362", "\\363", "\\364", "\\365", "\\366", "\\367",
-      "\\370", "\\371", "\\372", "\\373", "\\374", "\\375", "\\376", "\\377"};
-
-  static_assert(sizeof Escapes / sizeof Escapes[0] ==
-                    std::numeric_limits<unsigned char>::max() + 1,
-                "unsupported character type");
-  OS << Escapes[static_cast<unsigned char>(C)];
-}
-
-static inline void printChar(raw_ostream &OS, char C) {
-  unsigned char UC(C);
-  if (isalnum(UC) || ispunct(UC)) {
-    OS << '\'';
-    if (C == '\\' || C == '\'')
-      OS << '\\';
-    OS << C << '\'';
-  } else {
-    OS << unsigned(UC);
-  }
-}
 
 /// SequenceToOffsetTable - Collect a number of terminated sequences of T.
 /// Compute the layout of a table that contains all the sequences, possibly by
@@ -164,24 +108,6 @@ class SequenceToOffsetTable {
     return I->second + (I->first.size() - Seq.size());
   }
 
-  /// `emit_string_literals` - Print out the table as the body of an array
-  /// initializer, where each element is a C string literal terminated by
-  /// `Term`. Calls the the given `Print` function to format individual
-  /// elements.
-  void emit_string_literals(raw_ostream &OS) const {
-    assert(Entries && "Call layout() before emit_string_literals()");
-    if (!EmitLongStrLiterals) {
-      return emit(OS, printChar, "0");
-    }
-    for (auto I : Seqs) {
-      OS << "  /* " << I.second << " */ \"";
-      for (auto C: I.first) {
-        printStrLitEscChar(OS, C);
-      }
-      OS << "\\0\"\n";
-    }
-  }
-
   /// emit - Print out the table as the body of an array initializer.
   /// Use the Print function to print elements.
   void emit(raw_ostream &OS,
@@ -201,6 +127,19 @@ class SequenceToOffsetTable {
   }
 };
 
+// Helper function for SequenceToOffsetTable<string>.
+static inline void printChar(raw_ostream &OS, char C) {
+  unsigned char UC(C);
+  if (isalnum(UC) || ispunct(UC)) {
+    OS << '\'';
+    if (C == '\\' || C == '\'')
+      OS << '\\';
+    OS << C << '\'';
+  } else {
+    OS << unsigned(UC);
+  }
+}
+
 } // end namespace llvm
 
 #endif

llvm/utils/TableGen/TableGen.cpp

@@ -60,12 +60,6 @@ namespace llvm {
 /// Storage for TimeRegionsOpt as a global so that backends aren't required to
 /// include CommandLine.h
 bool TimeRegions = false;
-cl::opt<bool> EmitLongStrLiterals(
-    "long-string-literals",
-    cl::desc("when emitting large string tables, prefer string literals over "
-             "comma-separated char literals. This can be a readability and "
-             "compile-time performance win, but upsets some compilers"),
-    cl::Hidden, cl::init(true));
 } // end namespace llvm
 
 namespace {