Switch back to using actual dwarf tags. Simplifies code without loss to other

debug forms.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26455 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/CodeGen/MachineDebugInfo.h b/include/llvm/CodeGen/MachineDebugInfo.h
index 3132dcfedab844e05190cf3a7c5cba1ea45f5211..495506c67135db530a53d4f4d4a46635efdf7ca6 100644 (file)
--- a/include/llvm/CodeGen/MachineDebugInfo.h
+++ b/include/llvm/CodeGen/MachineDebugInfo.h
@@ -56,25 +56,6 @@ class StructType;
 
 enum {
   LLVMDebugVersion = 1,                 // Current version of debug information.
-  DIInvalid = ~0U,                      // Invalid result indicator.
-  
-  // DebugInfoDesc type identifying tags.
-  DI_TAG_anchor = 0,
-  DI_TAG_compile_unit,
-  DI_TAG_global_variable,
-  DI_TAG_subprogram,
-  DI_TAG_basictype,
-  DI_TAG_typedef,
-  DI_TAG_pointer,
-  DI_TAG_reference,
-  DI_TAG_array,
-  DI_TAG_struct,
-  DI_TAG_union,
-  DI_TAG_enum,
-  DI_TAG_subrange,
-  DI_TAG_const,
-  DI_TAG_volatile,
-  DI_TAG_restrict
 };
 
 //===----------------------------------------------------------------------===//
@@ -166,23 +147,15 @@ private:
   std::string Name;                     // Anchor type string.
   
 public:
-  AnchorDesc()
-  : DebugInfoDesc(DI_TAG_anchor)
-  , Name("")
-  {}
-  AnchorDesc(const std::string &N)
-  : DebugInfoDesc(DI_TAG_anchor)
-  , Name(N)
-  {}
+  AnchorDesc();
+  AnchorDesc(const std::string &N);
   
   // Accessors
   const std::string &getName() const { return Name; }
 
   // Implement isa/cast/dyncast.
   static bool classof(const AnchorDesc *) { return true; }
-  static bool classof(const DebugInfoDesc *D) {
-    return D->getTag() == DI_TAG_anchor;
-  }
+  static bool classof(const DebugInfoDesc *D);
 
   /// getLinkage - get linkage appropriate for this type of descriptor.
   ///
@@ -259,9 +232,7 @@ public:
 
   // Implement isa/cast/dyncast.
   static bool classof(const CompileUnitDesc *) { return true; }
-  static bool classof(const DebugInfoDesc *D) {
-    return D->getTag() == DI_TAG_compile_unit;
-  }
+  static bool classof(const DebugInfoDesc *D);
   
   /// DebugVersionFromGlobal - Returns the version number from a compile unit
   /// GlobalVariable.  Return DIIValid if operand is not an unsigned int.
@@ -348,9 +319,7 @@ public:
 
   // Implement isa/cast/dyncast.
   static bool classof(const BasicTypeDesc *) { return true; }
-  static bool classof(const DebugInfoDesc *D) {
-    return D->getTag() == DI_TAG_basictype;
-  }
+  static bool classof(const DebugInfoDesc *D);
   
   /// ApplyToFields - Target the visitor to the fields of the  BasicTypeDesc.
   ///
@@ -386,20 +355,7 @@ public:
 
   // Implement isa/cast/dyncast.
   static bool classof(const DerivedTypeDesc *) { return true; }
-  static bool classof(const DebugInfoDesc *D) {
-    unsigned T =  D->getTag();
-    switch (T) {
-    case DI_TAG_typedef:
-    case DI_TAG_pointer:
-    case DI_TAG_reference:
-    case DI_TAG_const:
-    case DI_TAG_volatile:
-    case DI_TAG_restrict:
-      return true;
-    default: break;
-    }
-    return false;
-  }
+  static bool classof(const DebugInfoDesc *D);
   
   /// ApplyToFields - Target the visitor to the fields of the  DerivedTypeDesc.
   ///
@@ -433,18 +389,7 @@ public:
 
   // Implement isa/cast/dyncast.
   static bool classof(const CompositeTypeDesc *) { return true; }
-  static bool classof(const DebugInfoDesc *D) {
-    unsigned T =  D->getTag();
-    switch (T) {
-    case DI_TAG_array:
-    case DI_TAG_struct:
-    case DI_TAG_union:
-    case DI_TAG_enum:
-      return true;
-    default: break;
-    }
-    return false;
-  }
+  static bool classof(const DebugInfoDesc *D);
   
   /// ApplyToFields - Target the visitor to the fields of the CompositeTypeDesc.
   ///
@@ -482,9 +427,7 @@ public:
 
   // Implement isa/cast/dyncast.
   static bool classof(const SubrangeDesc *) { return true; }
-  static bool classof(const DebugInfoDesc *D) {
-    return D->getTag() == DI_TAG_subrange;
-  }
+  static bool classof(const DebugInfoDesc *D);
   
   /// ApplyToFields - Target the visitor to the fields of the SubrangeDesc.
   ///
@@ -554,9 +497,7 @@ public:
  
   // Implement isa/cast/dyncast.
   static bool classof(const GlobalVariableDesc *) { return true; }
-  static bool classof(const DebugInfoDesc *D) {
-    return D->getTag() == DI_TAG_global_variable; 
-  }
+  static bool classof(const DebugInfoDesc *D);
   
   /// ApplyToFields - Target the visitor to the fields of the
   /// GlobalVariableDesc.
@@ -594,9 +535,7 @@ public:
   
   // Implement isa/cast/dyncast.
   static bool classof(const SubprogramDesc *) { return true; }
-  static bool classof(const DebugInfoDesc *D) {
-    return D->getTag() == DI_TAG_subprogram;
-  }
+  static bool classof(const DebugInfoDesc *D);
   
   /// ApplyToFields - Target the visitor to the fields of the  SubprogramDesc.
   ///
@@ -873,7 +812,12 @@ public:
                              getGlobalVariablesUsing(M, Desc.getAnchorString());
     std::vector<T *> AnchoredDescs;
     for (unsigned i = 0, N = Globals.size(); i < N; ++i) {
-      AnchoredDescs.push_back(cast<T>(DR.Deserialize(Globals[i])));
+      GlobalVariable *GV = Globals[i];
+      // FIXME - Tag check only necessary for bring up (changed tag values.)
+      unsigned Tag = DebugInfoDesc::TagFromGlobal(GV);
+      if (Tag == Desc.getTag()) {
+        AnchoredDescs.push_back(cast<T>(DR.Deserialize(GV)));
+      }
     }
 
     return AnchoredDescs;

diff --git a/include/llvm/Support/Dwarf.h b/include/llvm/Support/Dwarf.h
index 56972e494e87e9526e8cecfa8665d091ca44a520..0c955ee1d46bd6de3691549c4200f2b8df11e36b 100644 (file)
--- a/include/llvm/Support/Dwarf.h
+++ b/include/llvm/Support/Dwarf.h
@@ -24,6 +24,16 @@ namespace dwarf {
 // Dwarf constants as gleaned from the DWARF Debugging Information Format V.3
 // reference manual http://dwarf.freestandards.org .
 //
+
+// Do not mix the following two enumerations sets.  DW_TAG_invalid changes the
+// enumeration base type.
+
+enum llvm_dwarf_constants {
+  // llvm mock tags
+  DW_TAG_invalid = ~0U,                 // Tag for invalid results.
+  DW_TAG_anchor = 0,                    // Tag for descriptor anchors.
+};
+
 enum dwarf_constants {
   DWARF_VERSION = 2,
   

diff --git a/lib/CodeGen/DwarfWriter.cpp b/lib/CodeGen/DwarfWriter.cpp
index 5ce4349a966291aa2a52fdcfe74c61074782884d..58dc6dd8135fd9be6882557b8435a07e59771594 100644 (file)
--- a/lib/CodeGen/DwarfWriter.cpp
+++ b/lib/CodeGen/DwarfWriter.cpp
@@ -1070,42 +1070,20 @@ DIE *DwarfWriter::NewType(DIE *Context, TypeDesc *TyDesc) {
     unsigned Encoding = BasicTy->getEncoding();
     Ty->AddUInt  (DW_AT_encoding,  DW_FORM_data1, Encoding);
   } else if (DerivedTypeDesc *DerivedTy = dyn_cast<DerivedTypeDesc>(TyDesc)) {
-    // Determine which derived type.
-    unsigned T = 0;
-    switch (DerivedTy->getTag()) {
-    case DI_TAG_typedef:   T = DW_TAG_typedef;         break;
-    case DI_TAG_pointer:   T = DW_TAG_pointer_type;    break;
-    case DI_TAG_reference: T = DW_TAG_reference_type;  break;
-    case DI_TAG_const:     T = DW_TAG_const_type;      break;
-    case DI_TAG_volatile:  T = DW_TAG_volatile_type;   break;
-    case DI_TAG_restrict:  T = DW_TAG_restrict_type;   break;
-    default: assert( 0 && "Unknown tag on derived type");
-    }
-    
     // Create specific DIE.
-    Slot = Ty = new DIE(T);
+    Slot = Ty = new DIE(DerivedTy->getTag());
     
     // Map to main type, void will not have a type.
     if (TypeDesc *FromTy = DerivedTy->getFromType()) {
        Ty->AddDIEntry(DW_AT_type, DW_FORM_ref4, NewType(Context, FromTy));
     }
   } else if (CompositeTypeDesc *CompTy = dyn_cast<CompositeTypeDesc>(TyDesc)) {
-    // Determine which composite type.
-    unsigned T = 0;
-    switch (CompTy->getTag()) {
-    case DI_TAG_array:     T = DW_TAG_array_type;       break;
-    case DI_TAG_struct:    T = DW_TAG_structure_type;   break;
-    case DI_TAG_union:     T = DW_TAG_union_type;       break;
-    case DI_TAG_enum:      T = DW_TAG_enumeration_type; break;
-    default: assert( 0 && "Unknown tag on composite type");
-    }
-    
     // Create specific DIE.
-    Slot = Ty = new DIE(T);
+    Slot = Ty = new DIE(CompTy->getTag());
     std::vector<DebugInfoDesc *> &Elements = CompTy->getElements();
     
     switch (CompTy->getTag()) {
-    case DI_TAG_array: {
+    case DW_TAG_array_type: {
       // Add element type.
       if (TypeDesc *FromTy = CompTy->getFromType()) {
          Ty->AddDIEntry(DW_AT_type, DW_FORM_ref4, NewType(Context, FromTy));
@@ -1139,13 +1117,13 @@ DIE *DwarfWriter::NewType(DIE *Context, TypeDesc *TyDesc) {
       
       break;
     }
-    case DI_TAG_struct: {
+    case DW_TAG_structure_type: {
       break;
     }
-    case DI_TAG_union: {
+    case DW_TAG_union_type: {
       break;
     }
-    case DI_TAG_enum: {
+    case DW_TAG_enumeration_type: {
       break;
     }
     default: break;

diff --git a/lib/CodeGen/MachineDebugInfo.cpp b/lib/CodeGen/MachineDebugInfo.cpp
index 98d07d3e2f889796794918d954505d5fa9d56742..46163a777e69e3a8fdea185c56d2930a54e113a4 100644 (file)
--- a/lib/CodeGen/MachineDebugInfo.cpp
+++ b/lib/CodeGen/MachineDebugInfo.cpp
@@ -20,6 +20,7 @@
 #include <iostream>
 
 using namespace llvm;
+using namespace llvm::dwarf;
 
 // Handle the Pass registration stuff necessary to use TargetData's.
 namespace {
@@ -492,29 +493,29 @@ public:
 /// GlobalVariable.  
 unsigned DebugInfoDesc::TagFromGlobal(GlobalVariable *GV) {
   ConstantUInt *C = getUIntOperand(GV, 0);
-  return C ? (unsigned)C->getValue() : (unsigned)DIInvalid;
+  return C ? (unsigned)C->getValue() : (unsigned)DW_TAG_invalid;
 }
 
 /// DescFactory - Create an instance of debug info descriptor based on Tag.
 /// Return NULL if not a recognized Tag.
 DebugInfoDesc *DebugInfoDesc::DescFactory(unsigned Tag) {
   switch (Tag) {
-  case DI_TAG_anchor:          return new AnchorDesc();
-  case DI_TAG_compile_unit:    return new CompileUnitDesc();
-  case DI_TAG_global_variable: return new GlobalVariableDesc();
-  case DI_TAG_subprogram:      return new SubprogramDesc();
-  case DI_TAG_basictype:       return new BasicTypeDesc();
-  case DI_TAG_typedef:
-  case DI_TAG_pointer:         
-  case DI_TAG_reference:
-  case DI_TAG_const:
-  case DI_TAG_volatile:         
-  case DI_TAG_restrict:        return new DerivedTypeDesc(Tag);
-  case DI_TAG_array:
-  case DI_TAG_struct:
-  case DI_TAG_union:
-  case DI_TAG_enum:            return new CompositeTypeDesc(Tag);
-  case DI_TAG_subrange:        return new SubrangeDesc();
+  case DW_TAG_anchor:           return new AnchorDesc();
+  case DW_TAG_compile_unit:     return new CompileUnitDesc();
+  case DW_TAG_variable:         return new GlobalVariableDesc();
+  case DW_TAG_subprogram:       return new SubprogramDesc();
+  case DW_TAG_base_type:        return new BasicTypeDesc();
+  case DW_TAG_typedef:
+  case DW_TAG_pointer_type:         
+  case DW_TAG_reference_type:
+  case DW_TAG_const_type:
+  case DW_TAG_volatile_type:         
+  case DW_TAG_restrict_type:    return new DerivedTypeDesc(Tag);
+  case DW_TAG_array_type:
+  case DW_TAG_structure_type:
+  case DW_TAG_union_type:
+  case DW_TAG_enumeration_type: return new CompositeTypeDesc(Tag);
+  case DW_TAG_subrange_type:    return new SubrangeDesc();
   default: break;
   }
   return NULL;
@@ -534,6 +535,20 @@ void DebugInfoDesc::ApplyToFields(DIVisitor *Visitor) {
 
 //===----------------------------------------------------------------------===//
 
+AnchorDesc::AnchorDesc()
+: DebugInfoDesc(DW_TAG_anchor)
+, Name("")
+{}
+AnchorDesc::AnchorDesc(const std::string &N)
+: DebugInfoDesc(DW_TAG_anchor)
+, Name(N)
+{}
+
+// Implement isa/cast/dyncast.
+bool AnchorDesc::classof(const DebugInfoDesc *D) {
+  return D->getTag() == DW_TAG_anchor;
+}
+  
 /// getLinkage - get linkage appropriate for this type of descriptor.
 ///
 GlobalValue::LinkageTypes AnchorDesc::getLinkage() const {
@@ -586,7 +601,7 @@ void AnchoredDesc::ApplyToFields(DIVisitor *Visitor) {
 //===----------------------------------------------------------------------===//
 
 CompileUnitDesc::CompileUnitDesc()
-: AnchoredDesc(DI_TAG_compile_unit)
+: AnchoredDesc(DW_TAG_compile_unit)
 , DebugVersion(LLVMDebugVersion)
 , Language(0)
 , FileName("")
@@ -594,11 +609,16 @@ CompileUnitDesc::CompileUnitDesc()
 , Producer("")
 {}
 
+// Implement isa/cast/dyncast.
+bool CompileUnitDesc::classof(const DebugInfoDesc *D) {
+  return D->getTag() == DW_TAG_compile_unit;
+}
+
 /// DebugVersionFromGlobal - Returns the version number from a compile unit
 /// GlobalVariable.
 unsigned CompileUnitDesc::DebugVersionFromGlobal(GlobalVariable *GV) {
   ConstantUInt *C = getUIntOperand(GV, 2);
-  return C ? (unsigned)C->getValue() : (unsigned)DIInvalid;
+  return C ? (unsigned)C->getValue() : (unsigned)DW_TAG_invalid;
 }
   
 /// ApplyToFields - Target the visitor to the fields of the CompileUnitDesc.
@@ -693,10 +713,15 @@ void TypeDesc::dump() {
 //===----------------------------------------------------------------------===//
 
 BasicTypeDesc::BasicTypeDesc()
-: TypeDesc(DI_TAG_basictype)
+: TypeDesc(DW_TAG_base_type)
 , Encoding(0)
 {}
 
+// Implement isa/cast/dyncast.
+bool BasicTypeDesc::classof(const DebugInfoDesc *D) {
+  return D->getTag() == DW_TAG_base_type;
+}
+
 /// ApplyToFields - Target the visitor to the fields of the BasicTypeDesc.
 ///
 void BasicTypeDesc::ApplyToFields(DIVisitor *Visitor) {
@@ -735,6 +760,22 @@ DerivedTypeDesc::DerivedTypeDesc(unsigned T)
 , FromType(NULL)
 {}
 
+// Implement isa/cast/dyncast.
+bool DerivedTypeDesc::classof(const DebugInfoDesc *D) {
+  unsigned T =  D->getTag();
+  switch (T) {
+  case DW_TAG_typedef:
+  case DW_TAG_pointer_type:
+  case DW_TAG_reference_type:
+  case DW_TAG_const_type:
+  case DW_TAG_volatile_type:
+  case DW_TAG_restrict_type:
+    return true;
+  default: break;
+  }
+  return false;
+}
+
 /// ApplyToFields - Target the visitor to the fields of the DerivedTypeDesc.
 ///
 void DerivedTypeDesc::ApplyToFields(DIVisitor *Visitor) {
@@ -775,6 +816,20 @@ CompositeTypeDesc::CompositeTypeDesc(unsigned T)
 , Elements()
 {}
   
+// Implement isa/cast/dyncast.
+bool CompositeTypeDesc::classof(const DebugInfoDesc *D) {
+  unsigned T =  D->getTag();
+  switch (T) {
+  case DW_TAG_array_type:
+  case DW_TAG_structure_type:
+  case DW_TAG_union_type:
+  case DW_TAG_enumeration_type:
+    return true;
+  default: break;
+  }
+  return false;
+}
+
 /// ApplyToFields - Target the visitor to the fields of the CompositeTypeDesc.
 ///
 void CompositeTypeDesc::ApplyToFields(DIVisitor *Visitor) {
@@ -812,11 +867,16 @@ void CompositeTypeDesc::dump() {
 //===----------------------------------------------------------------------===//
 
 SubrangeDesc::SubrangeDesc()
-: DebugInfoDesc(DI_TAG_subrange)
+: DebugInfoDesc(DW_TAG_subrange_type)
 , Lo(0)
 , Hi(0)
 {}
 
+// Implement isa/cast/dyncast.
+bool SubrangeDesc::classof(const DebugInfoDesc *D) {
+  return D->getTag() == DW_TAG_subrange_type;
+}
+
 /// ApplyToFields - Target the visitor to the fields of the SubrangeDesc.
 ///
 void SubrangeDesc::ApplyToFields(DIVisitor *Visitor) {
@@ -873,10 +933,15 @@ void GlobalDesc::ApplyToFields(DIVisitor *Visitor) {
 //===----------------------------------------------------------------------===//
 
 GlobalVariableDesc::GlobalVariableDesc()
-: GlobalDesc(DI_TAG_global_variable)
+: GlobalDesc(DW_TAG_variable)
 , Global(NULL)
 {}
 
+// Implement isa/cast/dyncast.
+bool GlobalVariableDesc::classof(const DebugInfoDesc *D) {
+  return D->getTag() == DW_TAG_variable; 
+}
+
 /// ApplyToFields - Target the visitor to the fields of the GlobalVariableDesc.
 ///
 void GlobalVariableDesc::ApplyToFields(DIVisitor *Visitor) {
@@ -921,9 +986,14 @@ void GlobalVariableDesc::dump() {
 //===----------------------------------------------------------------------===//
 
 SubprogramDesc::SubprogramDesc()
-: GlobalDesc(DI_TAG_subprogram)
+: GlobalDesc(DW_TAG_subprogram)
 {}
 
+// Implement isa/cast/dyncast.
+bool SubprogramDesc::classof(const DebugInfoDesc *D) {
+  return D->getTag() == DW_TAG_subprogram;
+}
+
 /// ApplyToFields - Target the visitor to the fields of the
 /// SubprogramDesc.
 void SubprogramDesc::ApplyToFields(DIVisitor *Visitor) {
@@ -977,7 +1047,7 @@ DebugInfoDesc *DIDeserializer::Deserialize(GlobalVariable *GV) {
   unsigned Tag = DebugInfoDesc::TagFromGlobal(GV);
   
   // Get the debug version if a compile unit.
-  if (Tag == DI_TAG_compile_unit) {
+  if (Tag == DW_TAG_compile_unit) {
     DebugVersion = CompileUnitDesc::DebugVersionFromGlobal(GV);
   }
   
@@ -1123,12 +1193,12 @@ bool DIVerifier::Verify(GlobalVariable *GV) {
   
   // Get the Tag
   unsigned Tag = DebugInfoDesc::TagFromGlobal(GV);
-  if (Tag == DIInvalid) return false;
+  if (Tag == DW_TAG_invalid) return false;
 
   // If a compile unit we need the debug version.
-  if (Tag == DI_TAG_compile_unit) {
+  if (Tag == DW_TAG_compile_unit) {
     DebugVersion = CompileUnitDesc::DebugVersionFromGlobal(GV);
-    if (DebugVersion == DIInvalid) return false;
+    if (DebugVersion == DW_TAG_invalid) return false;
   }
 
   // Construct an empty DebugInfoDesc.