#include "llvm/CodeGen/MachineLocation.h"
#include "llvm/Analysis/DebugInfo.h"
#include "llvm/Support/raw_ostream.h"
-#include "llvm/ADT/ValueMap.h"
+#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/StringMap.h"
unsigned getLabelID() const { return LabelID; }
};
-class DwarfDebug : public Dwarf {
+class DwarfDebug : public DwarfPrinter {
//===--------------------------------------------------------------------===//
// Attributes used to construct specific Dwarf sections.
//
///
SmallVector<std::pair<unsigned, unsigned>, 8> SourceIds;
- /// Lines - List of of source line correspondence.
+ /// Lines - List of source line correspondence.
std::vector<SrcLineInfo> Lines;
/// DIEValues - A list of all the unique values in use.
/// DbgScopeMap - Tracks the scopes in the current function.
///
- ValueMap<MDNode *, DbgScope *> DbgScopeMap;
+ DenseMap<MDNode *, DbgScope *> DbgScopeMap;
/// ConcreteScopes - Tracks the concrete scopees in the current function.
/// These scopes are also included in DbgScopeMap.
- ValueMap<MDNode *, DbgScope *> ConcreteScopes;
+ DenseMap<MDNode *, DbgScope *> ConcreteScopes;
/// AbstractScopes - Tracks the abstract scopes a module. These scopes are
/// not included DbgScopeMap.
- ValueMap<MDNode *, DbgScope *> AbstractScopes;
+ DenseMap<MDNode *, DbgScope *> AbstractScopes;
SmallVector<DbgScope *, 4>AbstractScopesList;
/// AbstractVariables - Collection on abstract variables.
- ValueMap<MDNode *, DbgVariable *> AbstractVariables;
+ DenseMap<MDNode *, DbgVariable *> AbstractVariables;
/// InliendSubprogramDIEs - Collection of subprgram DIEs that are marked
/// (at the end of the module) as DW_AT_inline.
SmallPtrSet<DIE *, 4> InlinedSubprogramDIEs;
+ DenseMap<DIE *, MDNode *> ContainingTypeMap;
+
/// AbstractSubprogramDIEs - Collection of abstruct subprogram DIEs.
SmallPtrSet<DIE *, 4> AbstractSubprogramDIEs;
- /// ScopedGVs - Tracks global variables that are not at file scope.
- /// For example void f() { static int b = 42; }
- SmallVector<WeakVH, 4> ScopedGVs;
+ /// TopLevelDIEs - Collection of top level DIEs.
+ SmallPtrSet<DIE *, 4> TopLevelDIEs;
+ SmallVector<DIE *, 4> TopLevelDIEsVector;
typedef SmallVector<DbgScope *, 2> ScopeVector;
typedef DenseMap<const MachineInstr *, ScopeVector>
/// InlineInfo - Keep track of inlined functions and their location. This
/// information is used to populate debug_inlined section.
typedef std::pair<unsigned, DIE *> InlineInfoLabels;
- ValueMap<MDNode *, SmallVector<InlineInfoLabels, 4> > InlineInfo;
+ DenseMap<MDNode *, SmallVector<InlineInfoLabels, 4> > InlineInfo;
SmallVector<MDNode *, 4> InlinedSPNodes;
/// CompileUnitOffsets - A vector of the offsets of the compile units. This is
/// addString - Add a string attribute data and value.
///
void addString(DIE *Die, unsigned Attribute, unsigned Form,
- const std::string &String);
+ const StringRef Str);
/// addLabel - Add a Dwarf label attribute data and value.
///
/// addObjectLabel - Add an non-Dwarf label attribute data and value.
///
void addObjectLabel(DIE *Die, unsigned Attribute, unsigned Form,
- const std::string &Label);
+ const MCSymbol *Sym);
/// addSectionOffset - Add a section offset label attribute data and value.
///
void addSourceLine(DIE *Die, const DIGlobal *G);
void addSourceLine(DIE *Die, const DISubprogram *SP);
void addSourceLine(DIE *Die, const DIType *Ty);
+ void addSourceLine(DIE *Die, const DINameSpace *NS);
/// addAddress - Add an address attribute to a die based on the location
/// provided.
void addBlockByrefAddress(DbgVariable *&DV, DIE *Die, unsigned Attribute,
const MachineLocation &Location);
+ /// addToContextOwner - Add Die into the list of its context owner's children.
+ void addToContextOwner(DIE *Die, DIDescriptor Context);
+
/// addType - Add a new type attribute to the specified entity.
- void addType(CompileUnit *DW_Unit, DIE *Entity, DIType Ty);
+ void addType(DIE *Entity, DIType Ty);
+
+
+ /// getOrCreateNameSpace - Create a DIE for DINameSpace.
+ DIE *getOrCreateNameSpace(DINameSpace NS);
+
+ /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
+ /// given DIType.
+ DIE *getOrCreateTypeDIE(DIType Ty);
+
+ void addPubTypes(DISubprogram SP);
/// constructTypeDIE - Construct basic type die from DIBasicType.
- void constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
+ void constructTypeDIE(DIE &Buffer,
DIBasicType BTy);
/// constructTypeDIE - Construct derived type die from DIDerivedType.
- void constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
+ void constructTypeDIE(DIE &Buffer,
DIDerivedType DTy);
/// constructTypeDIE - Construct type DIE from DICompositeType.
- void constructTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
+ void constructTypeDIE(DIE &Buffer,
DICompositeType CTy);
/// constructSubrangeDIE - Construct subrange DIE from DISubrange.
void constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy);
/// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
- void constructArrayTypeDIE(CompileUnit *DW_Unit, DIE &Buffer,
+ void constructArrayTypeDIE(DIE &Buffer,
DICompositeType *CTy);
/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
- DIE *constructEnumTypeDIE(CompileUnit *DW_Unit, DIEnumerator *ETy);
+ DIE *constructEnumTypeDIE(DIEnumerator *ETy);
/// createGlobalVariableDIE - Create new DIE using GV.
- DIE *createGlobalVariableDIE(CompileUnit *DW_Unit,
- const DIGlobalVariable &GV);
+ DIE *createGlobalVariableDIE(const DIGlobalVariable &GV);
/// createMemberDIE - Create new member DIE.
- DIE *createMemberDIE(CompileUnit *DW_Unit, const DIDerivedType &DT);
+ DIE *createMemberDIE(const DIDerivedType &DT);
/// createSubprogramDIE - Create new DIE using SP.
- DIE *createSubprogramDIE(CompileUnit *DW_Unit,
- const DISubprogram &SP,
- bool IsConstructor = false,
- bool IsInlined = false);
+ DIE *createSubprogramDIE(const DISubprogram &SP, bool MakeDecl = false);
/// findCompileUnit - Get the compile unit for the given descriptor.
///
- CompileUnit &findCompileUnit(DICompileUnit Unit) const;
-
- /// createDbgScopeVariable - Create a new scope variable.
- ///
- DIE *createDbgScopeVariable(DbgVariable *DV, CompileUnit *Unit);
+ CompileUnit *findCompileUnit(DICompileUnit Unit);
/// getUpdatedDbgScope - Find or create DbgScope assicated with
/// the instruction. Initialize scope and update scope hierarchy.
DIE *constructInlinedScopeDIE(DbgScope *Scope);
/// constructVariableDIE - Construct a DIE for the given DbgVariable.
- DIE *constructVariableDIE(DbgVariable *DV, DbgScope *S, CompileUnit *Unit);
+ DIE *constructVariableDIE(DbgVariable *DV, DbgScope *S);
/// constructScopeDIE - Construct a DIE for this scope.
DIE *constructScopeDIE(DbgScope *Scope);
///
void computeSizeAndOffsets();
- /// EmitDebugInfo / emitDebugInfoPerCU - Emit the debug info section.
+ /// EmitDebugInfo - Emit the debug info section.
///
- void emitDebugInfoPerCU(CompileUnit *Unit);
-
void emitDebugInfo();
/// emitAbbreviations - Emit the abbreviation section.
/// section.
void emitFunctionDebugFrame(const FunctionDebugFrameInfo &DebugFrameInfo);
- void emitDebugPubNamesPerCU(CompileUnit *Unit);
-
/// emitDebugPubNames - Emit visible names into a debug pubnames section.
///
void emitDebugPubNames();
+ /// emitDebugPubTypes - Emit visible types into a debug pubtypes section.
+ ///
+ void emitDebugPubTypes();
+
/// emitDebugStr - Emit visible names into a debug str section.
///
void emitDebugStr();
/// source file names. If none currently exists, create a new id and insert it
/// in the SourceIds map. This can update DirectoryNames and SourceFileNames maps
/// as well.
- unsigned GetOrCreateSourceID(const char *DirName,
- const char *FileName);
+ unsigned GetOrCreateSourceID(StringRef DirName, StringRef FileName);
- void constructCompileUnit(MDNode *N);
+ CompileUnit *constructCompileUnit(MDNode *N);
void constructGlobalVariableDIE(MDNode *N);
/// beginFunction - Gather pre-function debug information. Assumes being
/// emitted immediately after the function entry point.
- void beginFunction(MachineFunction *MF);
+ void beginFunction(const MachineFunction *MF);
/// endFunction - Gather and emit post-function debug information.
///
- void endFunction(MachineFunction *MF);
+ void endFunction(const MachineFunction *MF);
/// recordSourceLine - Records location information and associates it with a
/// label. Returns a unique label ID used to generate a label and provide
/// extractScopeInformation - Scan machine instructions in this function
/// and collect DbgScopes. Return true, if atleast one scope was found.
- bool extractScopeInformation(MachineFunction *MF);
+ bool extractScopeInformation();
/// collectVariableInfo - Populate DbgScope entries with variables' info.
void collectVariableInfo();
projects / oota-llvm.git / blobdiff