Add Swift enumerator value for CodeView::SourceLanguage

[lanza]

Summary

Swift now generates PDBs for debugging on Windows. llvm and lldb
need a language enumerator value too properly handle the output
emitted by swiftc.

include/llvm/DebugInfo/CodeView/CodeView.h

enum SourceLanguage : uint8_t {
   CSharp = 0x0a,
   VB = 0x0b,
   ILAsm = 0x0c,
   Java = 0x0d,
   JScript = 0x0e,
   MSIL = 0x0f,
   HLSL = 0x10,
 
-  /// The DMD compiler emits 'D' for the CV source language. Microsoft doesn't
-  /// have an enumerator for it yet.
+  /// The DMD & Swift compilers emit 'D' and 'S', respectively, for the CV
+  /// source language. Microsoft does not have enumerators for them yet.
   D = 'D',
+  Swift = 'S',
 };
 
 /// These values correspond to the CV_call_e enumeration, and are documented
 /// at the following locations:
 ///   https://msdn.microsoft.com/en-us/library/b2fc64ek.aspx
 ///   https://msdn.microsoft.com/en-us/library/windows/desktop/ms680207(v=vs.85).aspx
 ///
 enum class CallingConvention : uint8_t {

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

case dwarf::DW_LANG_Pascal83:
     return SourceLanguage::Pascal;
   case dwarf::DW_LANG_Cobol74:
   case dwarf::DW_LANG_Cobol85:
     return SourceLanguage::Cobol;
   case dwarf::DW_LANG_Java:
     return SourceLanguage::Java;
   case dwarf::DW_LANG_D:
     return SourceLanguage::D;
+  case dwarf::DW_LANG_Swift:
+    return SourceLanguage::Swift;
   default:
     // There's no CodeView representation for this language, and CV doesn't
     // have an "unknown" option for the language field, so we'll use MASM,
     // as it's very low level.
     return SourceLanguage::Masm;
   }
 }
 

lib/DebugInfo/PDB/PDBExtras.cpp

switch (Lang) {
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, CSharp, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, VB, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, ILAsm, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, Java, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, JScript, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, MSIL, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, HLSL, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, D, OS)
+    CASE_OUTPUT_ENUM_CLASS_NAME(PDB_Lang, Swift, OS)
   }
   return OS;
 }
 
 raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_SymType &Tag) {
   switch (Tag) {
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_SymType, Exe, OS)
     CASE_OUTPUT_ENUM_CLASS_NAME(PDB_SymType, Compiland, OS)

lib/DebugInfo/PDB/PDBSymbolCompiland.cpp

std::string PDBSymbolCompiland::getSourceFileFullPath() const {
 
   // At this point, we have to walk through all source files of this compiland,
   // and determine the right source file if any that is used to generate this
   // compiland based on language indicated in compilanddetails language field.
   auto Details = findOneChild<PDBSymbolCompilandDetails>();
   PDB_Lang Lang = Details ? Details->getLanguage() : PDB_Lang::Cpp;
   auto SrcFiles = Session.getSourceFilesForCompiland(*this);
   if (SrcFiles) {
-    bool LangC = (Lang == PDB_Lang::Cpp || Lang == PDB_Lang::C);
     while (auto File = SrcFiles->getNext()) {
       std::string FileName = File->getFileName();
       auto file_extension = sys::path::extension(FileName);
       if (StringSwitch<bool>(file_extension.lower())
-              .Case(".cpp", LangC)
-              .Case(".c", LangC)
-              .Case(".cc", LangC)
-              .Case(".cxx", LangC)
+              .Case(".cpp", Lang == PDB_Lang::Cpp) //
+              .Case(".c", Lang == PDB_Lang::C)
+              .Case(".cc", Lang == PDB_Lang::Cpp)
+              .Case(".cxx", Lang == PDB_Lang::Cpp)
               .Case(".asm", Lang == PDB_Lang::Masm)
+              .Case(".swift", Lang == PDB_Lang::Swift)
               .Default(false))
         return File->getFileName();
     }
   }
 
   return SourceFileFullPath;
 }

tools/llvm-pdbutil/MinimalSymbolDumper.cpp

switch (Lang) {
     RETURN_CASE(SourceLanguage, Cvtpgd, "cvtpgd");
     RETURN_CASE(SourceLanguage, CSharp, "c#");
     RETURN_CASE(SourceLanguage, ILAsm, "il asm");
     RETURN_CASE(SourceLanguage, Java, "java");
     RETURN_CASE(SourceLanguage, JScript, "javascript");
     RETURN_CASE(SourceLanguage, MSIL, "msil");
     RETURN_CASE(SourceLanguage, HLSL, "hlsl");
     RETURN_CASE(SourceLanguage, D, "d");
+    RETURN_CASE(SourceLanguage, Swift, "swift");
   }
   return formatUnknownEnum(Lang);
 }
 
 static std::string formatMachineType(CPUType Cpu) {
   switch (Cpu) {
     RETURN_CASE(CPUType, Intel8080, "intel 8080");
     RETURN_CASE(CPUType, Intel8086, "intel 8086");