#ifndef LLVM_CODEGEN_MACHINEMODULEINFO_H
#define LLVM_CODEGEN_MACHINEMODULEINFO_H
-#include "llvm/GlobalValue.h"
-#include "llvm/Pass.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/Support/Dwarf.h"
+#include "llvm/Support/DataTypes.h"
#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/UniqueVector.h"
-#include "llvm/Support/DataTypes.h"
-#include "llvm/Support/Dwarf.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/CodeGen/MachineLocation.h"
+#include "llvm/GlobalValue.h"
+#include "llvm/Pass.h"
namespace llvm {
//===----------------------------------------------------------------------===//
// Forward declarations.
-class AnchoredDesc;
-class CompileUnitDesc;
class Constant;
-class DebugInfoDesc;
class GlobalVariable;
class MachineBasicBlock;
class MachineFunction;
-class MachineMove;
class Module;
class PointerType;
class StructType;
-class VariableDesc;
-
-//===----------------------------------------------------------------------===//
-/// DIVisitor - Subclasses of this class apply steps to each of the fields in
-/// the supplied DebugInfoDesc.
-class DIVisitor {
-public:
- DIVisitor() {}
- virtual ~DIVisitor() {}
-
- /// ApplyToFields - Target the visitor to each field of the debug information
- /// descriptor.
- void ApplyToFields(DebugInfoDesc *DD);
-
- /// Apply - Subclasses override each of these methods to perform the
- /// appropriate action for the type of field.
- virtual void Apply(int &Field) = 0;
- virtual void Apply(unsigned &Field) = 0;
- virtual void Apply(int64_t &Field) = 0;
- virtual void Apply(uint64_t &Field) = 0;
- virtual void Apply(bool &Field) = 0;
- virtual void Apply(std::string &Field) = 0;
- virtual void Apply(DebugInfoDesc *&Field) = 0;
- virtual void Apply(GlobalVariable *&Field) = 0;
- virtual void Apply(std::vector<DebugInfoDesc *> &Field) = 0;
-};
-
-//===----------------------------------------------------------------------===//
-/// DIDeserializer - This class is responsible for casting GlobalVariables
-/// into DebugInfoDesc objects.
-class DIDeserializer {
- // Previously defined gloabls.
- std::map<GlobalVariable*, DebugInfoDesc*> GlobalDescs;
-public:
- const std::map<GlobalVariable *, DebugInfoDesc *> &getGlobalDescs() const {
- return GlobalDescs;
- }
-
- /// Deserialize - Reconstitute a GlobalVariable into it's component
- /// DebugInfoDesc objects.
- DebugInfoDesc *Deserialize(Value *V);
- DebugInfoDesc *Deserialize(GlobalVariable *GV);
-};
-
-//===----------------------------------------------------------------------===//
-/// DISerializer - This class is responsible for casting DebugInfoDesc objects
-/// into GlobalVariables.
-class DISerializer {
- Module *M; // Definition space module.
- PointerType *StrPtrTy; // A "i8*" type. Created lazily.
- PointerType *EmptyStructPtrTy; // A "{ }*" type. Created lazily.
-
- // Types per Tag. Created lazily.
- std::map<unsigned, StructType *> TagTypes;
-
- // Previously defined descriptors.
- DenseMap<DebugInfoDesc *, GlobalVariable *> DescGlobals;
-
- // Previously defined strings.
- DenseMap<const char *, Constant*> StringCache;
-public:
- DISerializer()
- : M(NULL), StrPtrTy(NULL), EmptyStructPtrTy(NULL), TagTypes(),
- DescGlobals(), StringCache()
- {}
-
- // Accessors
- Module *getModule() const { return M; };
- void setModule(Module *module) { M = module; }
-
- /// getStrPtrType - Return a "i8*" type.
- ///
- const PointerType *getStrPtrType();
-
- /// getEmptyStructPtrType - Return a "{ }*" type.
- ///
- const PointerType *getEmptyStructPtrType();
-
- /// getTagType - Return the type describing the specified descriptor (via
- /// tag.)
- const StructType *getTagType(DebugInfoDesc *DD);
-
- /// getString - Construct the string as constant string global.
- ///
- Constant *getString(const std::string &String);
-
- /// Serialize - Recursively cast the specified descriptor into a
- /// GlobalVariable so that it can be serialized to a .bc or .ll file.
- GlobalVariable *Serialize(DebugInfoDesc *DD);
-
- /// addDescriptor - Directly connect DD with existing GV.
- void addDescriptor(DebugInfoDesc *DD, GlobalVariable *GV);
-};
-
-//===----------------------------------------------------------------------===//
-/// DIVerifier - This class is responsible for verifying the given network of
-/// GlobalVariables are valid as DebugInfoDesc objects.
-class DIVerifier {
- enum {
- Unknown = 0,
- Invalid,
- Valid
- };
- DenseMap<GlobalVariable *, unsigned> Validity; // Tracks prior results.
- std::map<unsigned, unsigned> Counts; // Count of fields per Tag type.
-public:
- DIVerifier()
- : Validity(), Counts()
- {}
-
- /// Verify - Return true if the GlobalVariable appears to be a valid
- /// serialization of a DebugInfoDesc.
- bool Verify(Value *V);
- bool Verify(GlobalVariable *GV);
-
- /// isVerified - Return true if the specified GV has already been
- /// verified as a debug information descriptor.
- bool isVerified(GlobalVariable *GV);
-};
//===----------------------------------------------------------------------===//
/// SourceLineInfo - This class is used to record source line correspondence.
unsigned getLabelID() const { return LabelID; }
};
-//===----------------------------------------------------------------------===//
-/// SourceFileInfo - This class is used to track source information.
-///
-class SourceFileInfo {
- unsigned DirectoryID; // Directory ID number.
- std::string Name; // File name (not including directory.)
-public:
- SourceFileInfo(unsigned D, const std::string &N) : DirectoryID(D), Name(N) {}
-
- // Accessors
- unsigned getDirectoryID() const { return DirectoryID; }
- const std::string &getName() const { return Name; }
-
- /// operator== - Used by UniqueVector to locate entry.
- ///
- bool operator==(const SourceFileInfo &SI) const {
- return getDirectoryID() == SI.getDirectoryID() && getName() == SI.getName();
- }
-
- /// operator< - Used by UniqueVector to locate entry.
- ///
- bool operator<(const SourceFileInfo &SI) const {
- return getDirectoryID() < SI.getDirectoryID() ||
- (getDirectoryID() == SI.getDirectoryID() && getName() < SI.getName());
- }
-};
-
-//===----------------------------------------------------------------------===//
-/// DebugVariable - This class is used to track local variable information.
-///
-class DebugVariable {
-private:
- VariableDesc *Desc; // Variable Descriptor.
- unsigned FrameIndex; // Variable frame index.
-
-public:
- DebugVariable(VariableDesc *D, unsigned I)
- : Desc(D)
- , FrameIndex(I)
- {}
-
- // Accessors.
- VariableDesc *getDesc() const { return Desc; }
- unsigned getFrameIndex() const { return FrameIndex; }
-};
-
-//===----------------------------------------------------------------------===//
-/// DebugScope - This class is used to track scope information.
-///
-class DebugScope {
-private:
- DebugScope *Parent; // Parent to this scope.
- DebugInfoDesc *Desc; // Debug info descriptor for scope.
- // Either subprogram or block.
- unsigned StartLabelID; // Label ID of the beginning of scope.
- unsigned EndLabelID; // Label ID of the end of scope.
- std::vector<DebugScope *> Scopes; // Scopes defined in scope.
- std::vector<DebugVariable *> Variables;// Variables declared in scope.
-
-public:
- DebugScope(DebugScope *P, DebugInfoDesc *D)
- : Parent(P)
- , Desc(D)
- , StartLabelID(0)
- , EndLabelID(0)
- , Scopes()
- , Variables()
- {}
- ~DebugScope();
-
- // Accessors.
- DebugScope *getParent() const { return Parent; }
- DebugInfoDesc *getDesc() const { return Desc; }
- unsigned getStartLabelID() const { return StartLabelID; }
- unsigned getEndLabelID() const { return EndLabelID; }
- std::vector<DebugScope *> &getScopes() { return Scopes; }
- std::vector<DebugVariable *> &getVariables() { return Variables; }
- void setStartLabelID(unsigned S) { StartLabelID = S; }
- void setEndLabelID(unsigned E) { EndLabelID = E; }
-
- /// AddScope - Add a scope to the scope.
- ///
- void AddScope(DebugScope *S) { Scopes.push_back(S); }
-
- /// AddVariable - Add a variable to the scope.
- ///
- void AddVariable(DebugVariable *V) { Variables.push_back(V); }
-};
-
//===----------------------------------------------------------------------===//
/// LandingPadInfo - This structure is used to retain landing pad info for
/// the current function.
///
class MachineModuleInfo : public ImmutablePass {
private:
- // Use the same deserializer/verifier for the module.
- DIDeserializer DR;
- DIVerifier VR;
-
- // CompileUnits - Uniquing vector for compile units.
- UniqueVector<CompileUnitDesc *> CompileUnits;
-
- // Directories - Uniquing vector for directories.
- UniqueVector<std::string> Directories;
-
- // SourceFiles - Uniquing vector for source files.
- UniqueVector<SourceFileInfo> SourceFiles;
-
// Lines - List of of source line correspondence.
std::vector<SourceLineInfo> Lines;
// another label.
std::vector<unsigned> LabelIDList;
- // ScopeMap - Tracks the scopes in the current function.
- std::map<DebugInfoDesc *, DebugScope *> ScopeMap;
-
- // RootScope - Top level scope for the current function.
- //
- DebugScope *RootScope;
-
// FrameMoves - List of moves done by a function's prolog. Used to construct
// frame maps by debug and exception handling consumers.
std::vector<MachineMove> FrameMoves;
bool CallsEHReturn;
bool CallsUnwindInit;
+
+ /// DbgInfoAvailable - True if debugging information is available
+ /// in this module.
+ bool DbgInfoAvailable;
public:
static char ID; // Pass identification, replacement for typeid
///
void EndFunction();
- /// getDescFor - Convert a Value to a debug information descriptor.
- ///
- // FIXME - use new Value type when available.
- DebugInfoDesc *getDescFor(Value *V);
-
- /// Verify - Verify that a Value is debug information descriptor.
- ///
- bool Verify(Value *V) { return VR.Verify(V); }
-
- /// isVerified - Return true if the specified GV has already been
- /// verified as a debug information descriptor.
- bool isVerified(GlobalVariable *GV) { return VR.isVerified(GV); }
-
/// AnalyzeModule - Scan the module for global debug information.
///
void AnalyzeModule(Module &M);
/// hasDebugInfo - Returns true if valid debug info is present.
///
- bool hasDebugInfo() const { return !CompileUnits.empty(); }
-
+ bool hasDebugInfo() const { return DbgInfoAvailable; }
+ void setDebugInfoAvailability(bool avail) { DbgInfoAvailable = true; }
+
bool callsEHReturn() const { return CallsEHReturn; }
void setCallsEHReturn(bool b) { CallsEHReturn = b; }
return LabelID ? LabelIDList[LabelID - 1] : 0;
}
- /// RecordSource - Register a source file with debug info. Returns an source
- /// ID.
- unsigned RecordSource(const std::string &Directory,
- const std::string &Source);
- unsigned RecordSource(const CompileUnitDesc *CompileUnit);
-
- /// getDirectories - Return the UniqueVector of std::string representing
- /// directories.
- const UniqueVector<std::string> &getDirectories() const {
- return Directories;
- }
-
- /// getSourceFiles - Return the UniqueVector of source files.
- ///
- const UniqueVector<SourceFileInfo> &getSourceFiles() const {
- return SourceFiles;
- }
-
/// getSourceLines - Return a vector of source lines.
///
const std::vector<SourceLineInfo> &getSourceLines() const {
return Lines;
}
- /// SetupCompileUnits - Set up the unique vector of compile units.
- ///
- void SetupCompileUnits(Module &M);
-
- /// getCompileUnits - Return a vector of debug compile units.
- ///
- const UniqueVector<CompileUnitDesc *> getCompileUnits() const;
-
- /// getGlobalVariablesUsing - Return all of the GlobalVariables that use the
- /// named GlobalVariable.
- void getGlobalVariablesUsing(Module &M, const std::string &RootName,
- std::vector<GlobalVariable*> &Result);
-
- /// getAnchoredDescriptors - Return a vector of anchored debug descriptors.
- ///
- void getAnchoredDescriptors(Module &M, const AnchoredDesc *Desc,
- std::vector<void*> &AnchoredDescs);
-
- /// RecordRegionStart - Indicate the start of a region.
- ///
- unsigned RecordRegionStart(Value *V);
-
- /// RecordRegionEnd - Indicate the end of a region.
- ///
- unsigned RecordRegionEnd(Value *V);
-
- /// RecordVariable - Indicate the declaration of a local variable.
- ///
- void RecordVariable(GlobalValue *GV, unsigned FrameIndex);
-
- /// getRootScope - Return current functions root scope.
- ///
- DebugScope *getRootScope() { return RootScope; }
-
- /// getOrCreateScope - Returns the scope associated with the given descriptor.
- ///
- DebugScope *getOrCreateScope(DebugInfoDesc *ScopeDesc);
-
/// getFrameMoves - Returns a reference to a list of moves done in the current
/// function's prologue. Used to construct frame maps for debug and exception
/// handling comsumers.
/// of one is required to emit exception handling info.
Function *getPersonality() const;
- DIDeserializer *getDIDeserializer() { return &DR; }
}; // End class MachineModuleInfo
} // End llvm namespace
projects / oota-llvm.git / blobdiff