DWZ 01/12: refactor: DWARFCompileUnit::Producer -> DWARFProducer

[jankratochvil]

Summary

https://reviews.llvm.org/D40466#inline-354567 suggested to make Producer a standalone enum.

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

 //===-- DWARFASTParserClang.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdlib.h>
 
 #include "DWARFASTParserClang.h"
-#include "DWARFCompileUnit.h"
 #include "DWARFDIE.h"
 #include "DWARFDIECollection.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDeclContext.h"
 #include "DWARFDefines.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDebugMap.h"

               byte_stride = element_type->GetByteSize();
             CompilerType array_element_type =
                 element_type->GetForwardCompilerType();
 
             if (ClangASTContext::IsCXXClassType(array_element_type) &&
                 array_element_type.GetCompleteType() == false) {
               ModuleSP module_sp = die.GetModule();
               if (module_sp) {
-                if (die.GetCU()->GetProducer() ==
-                    DWARFCompileUnit::eProducerClang)
+                if (die.GetCU()->GetProducer() == eProducerClang)
                   module_sp->ReportError(
                       "DWARF DW_TAG_array_type DIE at 0x%8.8x has a "
                       "class/union/struct element type DIE 0x%8.8x that is a "
                       "forward declaration, not a complete definition.\nTry "
                       "compiling the source file with -fstandalone-debug or "
                       "disable -gmodules",
                       die.GetOffset(), type_die_ref.die_offset);
                 else
ClangASTImporter::LayoutInfo layout_info;
               CompilerType base_class_type(
                   &m_ast, type_source_info->getType().getAsOpaquePtr());
               if (base_class_type.GetCompleteType() == false) {
                 auto module = dwarf->GetObjectFile()->GetModule();
                 module->ReportError(":: Class '%s' has a base class '%s' which "
                                     "does not have a complete definition.",
                                     die.GetName(),
                                     base_class_type.GetTypeName().GetCString());
-                if (die.GetCU()->GetProducer() ==
-                    DWARFCompileUnit::eProducerClang)
+                if (die.GetCU()->GetProducer() == eProducerClang)
                   module->ReportError(":: Try compiling the source file with "
                                       "-fstandalone-debug.");
 
                 // We have no choice other than to pretend that the base class
                 // is complete. If we don't do this, clang will crash when we
                 // call setBases() inside of
                 // "clang_type.SetBaseClassesForClassType()"
                 // below. Since we provide layout assistance, all ivars in this
case DW_TAG_APPLE_property: {
                     member_clang_type = m_ast.CreateArrayType(
                         member_array_element_type, 0, false);
                   }
                 }
               }
 
               if (ClangASTContext::IsCXXClassType(member_clang_type) &&
                   member_clang_type.GetCompleteType() == false) {
-                if (die.GetCU()->GetProducer() ==
-                    DWARFCompileUnit::eProducerClang)
+                if (die.GetCU()->GetProducer() == eProducerClang)
                   module_sp->ReportError(
                       "DWARF DIE at 0x%8.8x (class %s) has a member variable "
                       "0x%8.8x (%s) whose type is a forward declaration, not a "
                       "complete definition.\nTry compiling the source file "
                       "with -fstandalone-debug",
                       parent_die.GetOffset(), parent_die.GetName(),
                       die.GetOffset(), name);
                 else

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

 #include "lldb/lldb-enumerations.h"
 
 class NameToDIE;
 class SymbolFileDWARF;
 class SymbolFileDWARFDwo;
 
 typedef std::shared_ptr<DWARFCompileUnit> DWARFCompileUnitSP;
 
-class DWARFCompileUnit {
-public:
-  enum Producer {
-    eProducerInvalid = 0,
-    eProducerClang,
-    eProducerGCC,
-    eProducerLLVMGCC,
-    eProcucerOther
-  };
+enum DWARFProducer {
 
+class DWARFCompileUnit {
+public:
   static DWARFCompileUnitSP Extract(SymbolFileDWARF *dwarf2Data,
       lldb::offset_t *offset_ptr);
   ~DWARFCompileUnit();
 
   size_t ExtractDIEsIfNeeded(bool cu_die_only);
   DWARFDIE LookupAddress(const dw_addr_t address);
   size_t AppendDIEsWithTag(const dw_tag_t tag,
                            DWARFDIECollection &matching_dies,
void Index(NameToDIE &func_basenames, NameToDIE &func_fullnames,
              NameToDIE &func_methods, NameToDIE &func_selectors,
              NameToDIE &objc_class_selectors, NameToDIE &globals,
              NameToDIE &types, NameToDIE &namespaces);
 
   const DWARFDebugAranges &GetFunctionAranges();
 
   SymbolFileDWARF *GetSymbolFileDWARF() const { return m_dwarf2Data; }
 
-  Producer GetProducer();
+  DWARFProducer GetProducer();
 
   uint32_t GetProducerVersionMajor();
 
   uint32_t GetProducerVersionMinor();
 
   uint32_t GetProducerVersionUpdate();
 
   static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
std::unique_ptr<DWARFDebugAranges> m_func_aranges_ap; // A table similar to
                                                         // DW_TAG_subprogram
                                                         // DIEs
   dw_addr_t m_base_addr = 0;
   // Offset of the initial length field.
   dw_offset_t m_offset;
   dw_offset_t m_length;
   uint16_t m_version;
   uint8_t m_addr_size;
-  Producer m_producer = eProducerInvalid;
+  DWARFProducer m_producer = eProducerInvalid;
   uint32_t m_producer_version_major = 0;
   uint32_t m_producer_version_minor = 0;
   uint32_t m_producer_version_update = 0;
   lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
   bool m_is_dwarf64;
   lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
   dw_addr_t m_addr_base = 0;     // Value of DW_AT_addr_base
   dw_addr_t m_ranges_base = 0;   // Value of DW_AT_ranges_base

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

if (producer_cstr) {
       } else if (strstr(producer_cstr, "GNU"))
         m_producer = eProducerGCC;
     }
   }
   if (m_producer == eProducerInvalid)
     m_producer = eProcucerOther;
 }
 
-DWARFCompileUnit::Producer DWARFCompileUnit::GetProducer() {
+DWARFProducer DWARFCompileUnit::GetProducer() {
   if (m_producer == eProducerInvalid)
     ParseProducerInfo();
   return m_producer;
 }
 
 uint32_t DWARFCompileUnit::GetProducerVersionMajor() {
   if (m_producer_version_major == 0)
     ParseProducerInfo();