LanguageType string table lookups

[dawn]

Summary

The LanguageType enums are used as indexes into array language_names and g_languages in LanguageRuntime::GetNameForLanguageType, Language::SetLanguageFromCString and Language::AsCString. This patch fixes the enum LanguageType values and language string table lookups for user defined languages (with DWARF values above DW_LANG_lo_user = 0x8000), by using a conversion routine to convert the DWARF value to it's corresponding LanguageType enum.

Details:

• Fix enum LanguageType values so that they can be used as indexes.
• Add DWARFCompileUnit::LanguageTypeFromDWARF to convert from DWARF DW_LANG_* values to enum LanguageType values.

Note: Support for the RenderScript was added in svn commit 234002, but I don't see how it could have ever worked, since the LanguageType values are used as indexes into string tables. The DWARF value was hardcoded as part of this fix since it doesn't exist in llvm.

[abidh]

lgmt

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

1073 ↗

(On Diff #27781)

It would be good to add a comment here warning user to handle the language between lo_user and hi_user explicitly.

[clayborg]

lgtm

lldb/trunk/include/lldb/lldb-enumerations.h

enum LanguageType
         eLanguageTypeC11             = 0x001d,   ///< ISO C:2011.
         eLanguageTypeSwift           = 0x001e,   ///< Swift.
         eLanguageTypeJulia           = 0x001f,   ///< Julia.
         eLanguageTypeDylan           = 0x0020,   ///< Dylan.
         eLanguageTypeC_plus_plus_14  = 0x0021,   ///< ISO C++:2014.
         eLanguageTypeFortran03       = 0x0022,   ///< ISO Fortran 2003.
         eLanguageTypeFortran08       = 0x0023,   ///< ISO Fortran 2008.
         // Vendor Extensions
-        eLanguageTypeExtRenderScript = 0x8e57,   ///< RenderScript
+        // Note: LanguageRuntime::GetNameForLanguageType
+        // assumes these can be used as indexes into array language_names, and
+        // Language::SetLanguageFromCString and Language::AsCString
+        // assume these can be used as indexes into array g_languages.
+        eLanguageTypeMipsAssembler   = 0x0024,   ///< Mips_Assembler.
+        eLanguageTypeExtRenderScript = 0x0025,   ///< RenderScript.
         eNumLanguageTypes
     };
     
     enum InstrumentationRuntimeType
     {
         eInstrumentationRuntimeTypeAddressSanitizer = 0x0000,
         eNumInstrumentationRuntimeTypes
     };

lldb/trunk/source/Core/Language.cpp

g_languages[] =
     { { "c"       , "C99"         , "ISO C:1999"          } },
     { { "ada"     , "Ada95"       , "ISO Ada:1995"        } },
     { { "f95"     , "Fortran95"   , "ISO Fortran 95"      } },
     { { "PLI"     , NULL          , "ANSI PL/I:1976"      } },
     { { "objc"    , NULL          , "Objective-C"         } },
     { { "objc++"  , NULL          , "Objective-C++"       } },
     { { "upc"     , NULL          , "Unified Parallel C"  } },
     { { "d"       , NULL          , "D"                   } },
-    { { "python"  , NULL          , "Python"              } }
+    { { "python"  , NULL          , "Python"              } },
+    { { "opencl"  , "OpenCL"          , "OpenCL"           } },
+    { { "go"      , "Go"              , "Go"               } },
+    { { "modula3" , "Modula3"         , "Modula 3"         } },
+    { { "haskell" , "Haskell"         , "Haskell"          } },
+    { { "c++03"   , "C_plus_plus_03"  , "ISO C++:2003"     } },
+    { { "c++11"   , "C_plus_plus_11"  , "ISO C++:2011"     } },
+    { { "ocaml"   , "OCaml"           , "OCaml"            } },
+    { { "rust"    , "Rust"            , "Rust"             } },
+    { { "c11"     , "C11"             , "ISO C:2011"       } },
+    { { "swift"   , "Swift"           , "Swift"            } },
+    { { "julia"   , "Julia"           , "Julia"            } },
+    { { "dylan"   , "Dylan"           , "Dylan"            } },
+    { { "c++14"   , "C_plus_plus_14"  , "ISO C++:2014"     } },
+    { { "f03"     , "Fortran03"       , "ISO Fortran 2003" } },
+    { { "f08"     , "Fortran08"       , "ISO Fortran 2008" } },
+    // Vendor Extensions
+    { { "mipsassem"    , "Mips_Assembler" , "Mips Assembler" } },
+    { { "renderscript" , "RenderScript"   , "RenderScript"   } }
 };
 
 static const size_t g_num_languages = llvm::array_lengthof(g_languages);
 
 Language::Language(LanguageType language) :
     m_language (language)
 {
 }

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

//
     GetProducerVersionMajor();
 
     uint32_t
     GetProducerVersionMinor();
     
     uint32_t
     GetProducerVersionUpdate();
 
+    static lldb::LanguageType
+    LanguageTypeFromDWARF(uint64_t val);
+
     lldb::LanguageType
     GetLanguageType();
 
     bool
     IsDWARF64() const;
 
 protected:
     SymbolFileDWARF*    m_dwarf2Data;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

 DWARFCompileUnit::GetProducerVersionUpdate()
 {
     if (m_producer_version_update == 0)
         ParseProducerInfo ();
     return m_producer_version_update;
 }
 
 LanguageType
+DWARFCompileUnit::LanguageTypeFromDWARF(uint64_t val) 
+{
+    // Note: user languages between lo_user and hi_user
+    // must be handled explicitly here.
+    switch (val)
+    {
+    case DW_LANG_Mips_Assembler:
+        return eLanguageTypeMipsAssembler;
+    case 0x8e57: // FIXME: needs to be added to llvm
+        return eLanguageTypeExtRenderScript;
+    default:
+        return static_cast<LanguageType>(val);
+    }
+}
+
+LanguageType
 DWARFCompileUnit::GetLanguageType()
 {
     if (m_language_type != eLanguageTypeUnknown)
         return m_language_type;
 
     const DWARFDebugInfoEntry *die = GetCompileUnitDIEOnly();
     if (die)
-        m_language_type = static_cast<LanguageType>(
-            die->GetAttributeValueAsUnsigned(m_dwarf2Data, this, DW_AT_language, eLanguageTypeUnknown));
+        m_language_type = LanguageTypeFromDWARF(
+            die->GetAttributeValueAsUnsigned(m_dwarf2Data, this, DW_AT_language, 0));
     return m_language_type;
 }
 
 bool
 DWARFCompileUnit::IsDWARF64() const
 {
     return m_is_dwarf64;
 }
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (dwarf_cu)
                                 const char *cu_comp_dir{cu_die->GetAttributeValueAsString(this, dwarf_cu, DW_AT_comp_dir, nullptr)};
                                 cu_file_spec.PrependPathComponent(removeHostnameFromPathname(cu_comp_dir));
                             }
 
                             std::string remapped_file;
                             if (module_sp->RemapSourceFile(cu_file_spec.GetCString(), remapped_file))
                                 cu_file_spec.SetFile(remapped_file, false);
 
-                            LanguageType cu_language = (LanguageType)cu_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_language, 0);
+                            LanguageType cu_language = DWARFCompileUnit::LanguageTypeFromDWARF(cu_die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_language, 0));
 
                             cu_sp.reset(new CompileUnit (module_sp,
                                                          dwarf_cu,
                                                          cu_file_spec, 
                                                          MakeUserID(dwarf_cu->GetOffset()),
                                                          cu_language));
                             if (cu_sp)
                             {

 SymbolFileDWARF::ParseCompileUnitLanguage (const SymbolContext& sc)
 {
     assert (sc.comp_unit);
     DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
     if (dwarf_cu)
     {
         const DWARFDebugInfoEntry *die = dwarf_cu->GetCompileUnitDIEOnly();
         if (die)
-        {
-            const uint32_t language = die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_language, 0);
-            if (language)
-                return (lldb::LanguageType)language;
-        }
+            return DWARFCompileUnit::LanguageTypeFromDWARF(die->GetAttributeValueAsUnsigned(this, dwarf_cu, DW_AT_language, 0));
     }
     return eLanguageTypeUnknown;
 }
 
 size_t
 SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc)
 {
     assert (sc.comp_unit);

lldb/trunk/source/Target/LanguageRuntime.cpp

struct language_name_pair language_names[] =
     {   "c11",              eLanguageTypeC11            },
     {   "swift",            eLanguageTypeSwift          },
     {   "julia",            eLanguageTypeJulia          },
     {   "dylan",            eLanguageTypeDylan          },
     {   "c++14",            eLanguageTypeC_plus_plus_14 },
     {   "fortran03",        eLanguageTypeFortran03      },
     {   "fortran08",        eLanguageTypeFortran08      },
     // Vendor Extensions
+    {   "mipsassem",        eLanguageTypeMipsAssembler  },
     {   "renderscript",     eLanguageTypeExtRenderScript},
     // Now synonyms, in arbitrary order
     {   "objc",             eLanguageTypeObjC           },
     {   "objc++",           eLanguageTypeObjC_plus_plus }
 };
 
 static uint32_t num_languages = sizeof(language_names) / sizeof (struct language_name_pair);