From 2e50689435cd32b128cb78ba7b6f3888917b6521 Mon Sep 17 00:00:00 2001 From: Bill Wendling Date: Thu, 3 Jul 2008 22:53:42 +0000 Subject: [PATCH] Revert my previous check-in that split up MachineModuleInfo. It turns out to slow the compiler down at -O0 some 30% or more. Ooops. llvm-svn: 53120 --- .../llvm/CodeGen/MachineDebugInfoDesc.h | 707 -------------- llvm/include/llvm/CodeGen/MachineModuleInfo.h | 704 +++++++++++++- llvm/lib/CodeGen/DwarfWriter.cpp | 23 +- llvm/lib/CodeGen/MachineDebugInfoDesc.cpp | 575 ------------ llvm/lib/CodeGen/MachineModuleInfo.cpp | 879 ++++++++++++++++-- .../CodeGen/SelectionDAG/SelectionDAGISel.cpp | 1 - .../SelectionDAG/SelectionDAGPrinter.cpp | 2 +- llvm/lib/VMCore/IntrinsicInst.cpp | 1 - 8 files changed, 1522 insertions(+), 1370 deletions(-) delete mode 100644 llvm/include/llvm/CodeGen/MachineDebugInfoDesc.h delete mode 100644 llvm/lib/CodeGen/MachineDebugInfoDesc.cpp diff --git a/llvm/include/llvm/CodeGen/MachineDebugInfoDesc.h b/llvm/include/llvm/CodeGen/MachineDebugInfoDesc.h deleted file mode 100644 index 55f8767c881d..000000000000 --- a/llvm/include/llvm/CodeGen/MachineDebugInfoDesc.h +++ /dev/null @@ -1,707 +0,0 @@ -//===-- llvm/CodeGen/MachineDebugInfoDesc.h ---------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// Debug descriptor information for a module. -// -//===----------------------------------------------------------------------===// - -#ifndef LLVM_CODEGEN_MACHINEDEBUGINFODESC_H -#define LLVM_CODEGEN_MACHINEDEBUGINFODESC_H - -#include "llvm/GlobalValue.h" -#include "llvm/Support/DataTypes.h" -#include -#include - -namespace llvm { - -//===----------------------------------------------------------------------===// -// Forward declarations. -class DIVisitor; -class GlobalVariable; - -//===----------------------------------------------------------------------===// -// Debug info description constants. - -enum { - LLVMDebugVersion = (6 << 16), // Current version of debug information. - LLVMDebugVersion5 = (5 << 16), // Constant for version 5. - LLVMDebugVersion4 = (4 << 16), // Constant for version 4. - LLVMDebugVersionMask = 0xffff0000 // Mask for version number. -}; - -//===----------------------------------------------------------------------===// -/// DebugInfoDesc - This class is the base class for debug info descriptors. - -class DebugInfoDesc { - // Content indicator. Dwarf values are used but that does not limit use to - // Dwarf writers. - unsigned Tag; -protected: - explicit DebugInfoDesc(unsigned T) : Tag(T | LLVMDebugVersion) {} -public: - virtual ~DebugInfoDesc(); - - // Accessors - unsigned getTag() const { return Tag & ~LLVMDebugVersionMask; } - unsigned getVersion() const { return Tag & LLVMDebugVersionMask; } - void setTag(unsigned T) { Tag = T | LLVMDebugVersion; } - - /// TagFromGlobal - Returns the tag number from a debug info descriptor - /// GlobalVariable. Return DIIValid if operand is not an unsigned int. - static unsigned TagFromGlobal(GlobalVariable *GV); - - /// VersionFromGlobal - Returns the version number from a debug info - /// descriptor GlobalVariable. Return DIIValid if operand is not an unsigned - /// int. - static unsigned VersionFromGlobal(GlobalVariable *GV); - - /// DescFactory - Create an instance of debug info descriptor based on Tag. - /// Return NULL if not a recognized Tag. - static DebugInfoDesc *DescFactory(unsigned Tag); - - /// getLinkage - get linkage appropriate for this type of descriptor. - /// - virtual GlobalValue::LinkageTypes getLinkage() const; - - //===--------------------------------------------------------------------===// - // Subclasses should supply the following virtual methods. - - /// ApplyToFields - Target the vistor to the fields of the descriptor. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const = 0; - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const = 0; - -#ifndef NDEBUG - virtual void dump() = 0; -#endif - - //===--------------------------------------------------------------------===// - // Subclasses should supply the following static methods. - - // Implement isa/cast/dyncast. - static bool classof(const DebugInfoDesc *) { return true; } -}; - -//===----------------------------------------------------------------------===// -/// AnchorDesc - Descriptors of this class act as markers for identifying -/// descriptors of certain groups. -class AnchoredDesc; -class AnchorDesc : public DebugInfoDesc { - // Tag number of descriptors anchored by this object. - unsigned AnchorTag; -public: - AnchorDesc(); - explicit AnchorDesc(AnchoredDesc *D); - - // Accessors - unsigned getAnchorTag() const { return AnchorTag; } - - /// getLinkage - get linkage appropriate for this type of descriptor. - /// - virtual GlobalValue::LinkageTypes getLinkage() const; - - /// ApplyToFields - Target the visitor to the fields of the AnchorDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const; - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.anchor.type"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif - - // Implement isa/cast/dyncast. - static bool classof(const AnchorDesc *) { return true; } - static bool classof(const DebugInfoDesc *D); -}; - -//===----------------------------------------------------------------------===// -/// AnchoredDesc - This class manages anchors for a variety of top level -/// descriptors. -class AnchoredDesc : public DebugInfoDesc { - // Anchor for all descriptors of the same type. - DebugInfoDesc *Anchor; -protected: - explicit AnchoredDesc(unsigned T); -public: - // Accessors. - AnchorDesc *getAnchor() const { return static_cast(Anchor); } - void setAnchor(AnchorDesc *A) { Anchor = static_cast(A); } - - //===--------------------------------------------------------------------===// - // Subclasses should supply the following virtual methods. - - /// getAnchorString - Return a string used to label descriptor's anchor. - /// - virtual const char *getAnchorString() const = 0; - - /// ApplyToFields - Target the visitor to the fields of the AnchoredDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); -}; - -//===----------------------------------------------------------------------===// -/// CompileUnitDesc - This class packages debug information associated with a -/// source/header file. -class CompileUnitDesc : public AnchoredDesc { - unsigned Language; // Language number (ex. DW_LANG_C89.) - std::string FileName; // Source file name. - std::string Directory; // Source file directory. - std::string Producer; // Compiler string. -public: - CompileUnitDesc(); - - // Accessors - unsigned getLanguage() const { return Language; } - const std::string &getFileName() const { return FileName; } - const std::string &getDirectory() const { return Directory; } - const std::string &getProducer() const { return Producer; } - void setLanguage(unsigned L) { Language = L; } - void setFileName(const std::string &FN) { FileName = FN; } - void setDirectory(const std::string &D) { Directory = D; } - void setProducer(const std::string &P) { Producer = P; } - - // FIXME - Need translation unit getter/setter. - - /// ApplyToFields - Target the visitor to the fields of the CompileUnitDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const { - return "llvm.dbg.compile_unit"; - } - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.compile_unit.type"; - } - - /// getAnchorString - Return a string used to label this descriptor's anchor. - /// - const char *getAnchorString() const { - return "llvm.dbg.compile_units"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif - - // Implement isa/cast/dyncast. - static bool classof(const CompileUnitDesc *) { return true; } - static bool classof(const DebugInfoDesc *D); -}; - -//===----------------------------------------------------------------------===// -/// TypeDesc - This class packages debug information associated with a type. -/// -class TypeDesc : public DebugInfoDesc { - enum { - FlagPrivate = 1 << 0, - FlagProtected = 1 << 1 - }; - DebugInfoDesc *Context; // Context debug descriptor. - std::string Name; // Type name (may be empty.) - DebugInfoDesc *File; // Defined compile unit (may be NULL.) - unsigned Line; // Defined line# (may be zero.) - uint64_t Size; // Type bit size (may be zero.) - uint64_t Align; // Type bit alignment (may be zero.) - uint64_t Offset; // Type bit offset (may be zero.) - unsigned Flags; // Miscellaneous flags. -public: - explicit TypeDesc(unsigned T); - - // Accessors - DebugInfoDesc *getContext() const { return Context; } - const std::string &getName() const { return Name; } - CompileUnitDesc *getFile() const { - return static_cast(File); - } - unsigned getLine() const { return Line; } - uint64_t getSize() const { return Size; } - uint64_t getAlign() const { return Align; } - uint64_t getOffset() const { return Offset; } - bool isPrivate() const { - return (Flags & FlagPrivate) != 0; - } - bool isProtected() const { - return (Flags & FlagProtected) != 0; - } - void setContext(DebugInfoDesc *C) { Context = C; } - void setName(const std::string &N) { Name = N; } - void setFile(CompileUnitDesc *U) { - File = static_cast(U); - } - void setLine(unsigned L) { Line = L; } - void setSize(uint64_t S) { Size = S; } - void setAlign(uint64_t A) { Align = A; } - void setOffset(uint64_t O) { Offset = O; } - void setIsPrivate() { Flags |= FlagPrivate; } - void setIsProtected() { Flags |= FlagProtected; } - - /// ApplyToFields - Target the visitor to the fields of the TypeDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const { - return "llvm.dbg.type"; - } - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.type.type"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif -}; - -//===----------------------------------------------------------------------===// -/// BasicTypeDesc - This class packages debug information associated with a -/// basic type (eg. int, bool, double.) -class BasicTypeDesc : public TypeDesc { - unsigned Encoding; // Type encoding. -public: - BasicTypeDesc(); - - // Accessors - unsigned getEncoding() const { return Encoding; } - void setEncoding(unsigned E) { Encoding = E; } - - /// ApplyToFields - Target the visitor to the fields of the BasicTypeDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const { - return "llvm.dbg.basictype"; - } - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.basictype.type"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif - - // Implement isa/cast/dyncast. - static bool classof(const BasicTypeDesc *) { return true; } - static bool classof(const DebugInfoDesc *D); -}; - -//===----------------------------------------------------------------------===// -/// DerivedTypeDesc - This class packages debug information associated with a -/// derived types (eg., typedef, pointer, reference.) -class DerivedTypeDesc : public TypeDesc { - DebugInfoDesc *FromType; // Type derived from. -public: - explicit DerivedTypeDesc(unsigned T); - - // Accessors - TypeDesc *getFromType() const { - return static_cast(FromType); - } - void setFromType(TypeDesc *F) { - FromType = static_cast(F); - } - - /// ApplyToFields - Target the visitor to the fields of the DerivedTypeDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const { - return "llvm.dbg.derivedtype"; - } - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.derivedtype.type"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif - - // Implement isa/cast/dyncast. - static bool classof(const DerivedTypeDesc *) { return true; } - static bool classof(const DebugInfoDesc *D); -}; - -//===----------------------------------------------------------------------===// -/// CompositeTypeDesc - This class packages debug information associated with a -/// array/struct types (eg., arrays, struct, union, enums.) -class CompositeTypeDesc : public DerivedTypeDesc { - std::vector Elements; // Information used to compose type. -public: - explicit CompositeTypeDesc(unsigned T); - - // Accessors - std::vector &getElements() { return Elements; } - - /// ApplyToFields - Target the visitor to the fields of the CompositeTypeDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const { - return "llvm.dbg.compositetype"; - } - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.compositetype.type"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif - - // Implement isa/cast/dyncast. - static bool classof(const CompositeTypeDesc *) { return true; } - static bool classof(const DebugInfoDesc *D); -}; - -//===----------------------------------------------------------------------===// -/// SubrangeDesc - This class packages debug information associated with integer -/// value ranges. -class SubrangeDesc : public DebugInfoDesc { - int64_t Lo; // Low value of range. - int64_t Hi; // High value of range. -public: - SubrangeDesc(); - - // Accessors - int64_t getLo() const { return Lo; } - int64_t getHi() const { return Hi; } - void setLo(int64_t L) { Lo = L; } - void setHi(int64_t H) { Hi = H; } - - /// ApplyToFields - Target the visitor to the fields of the SubrangeDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const { - return "llvm.dbg.subrange"; - } - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.subrange.type"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif - - // Implement isa/cast/dyncast. - static bool classof(const SubrangeDesc *) { return true; } - static bool classof(const DebugInfoDesc *D); -}; - -//===----------------------------------------------------------------------===// -/// EnumeratorDesc - This class packages debug information associated with -/// named integer constants. -class EnumeratorDesc : public DebugInfoDesc { - std::string Name; // Enumerator name. - int64_t Value; // Enumerator value. -public: - EnumeratorDesc(); - - // Accessors - const std::string &getName() const { return Name; } - int64_t getValue() const { return Value; } - void setName(const std::string &N) { Name = N; } - void setValue(int64_t V) { Value = V; } - - /// ApplyToFields - Target the visitor to the fields of the EnumeratorDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const { - return "llvm.dbg.enumerator"; - } - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.enumerator.type"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif - - // Implement isa/cast/dyncast. - static bool classof(const EnumeratorDesc *) { return true; } - static bool classof(const DebugInfoDesc *D); -}; - -//===----------------------------------------------------------------------===// -/// VariableDesc - This class packages debug information associated with a -/// subprogram variable. -/// -class VariableDesc : public DebugInfoDesc { - DebugInfoDesc *Context; // Context debug descriptor. - std::string Name; // Type name (may be empty.) - DebugInfoDesc *File; // Defined compile unit (may be NULL.) - unsigned Line; // Defined line# (may be zero.) - DebugInfoDesc *TyDesc; // Type of variable. -public: - explicit VariableDesc(unsigned T); - - // Accessors - DebugInfoDesc *getContext() const { return Context; } - const std::string &getName() const { return Name; } - CompileUnitDesc *getFile() const { - return static_cast(File); - } - unsigned getLine() const { return Line; } - TypeDesc *getType() const { - return static_cast(TyDesc); - } - void setContext(DebugInfoDesc *C) { Context = C; } - void setName(const std::string &N) { Name = N; } - void setFile(CompileUnitDesc *U) { - File = static_cast(U); - } - void setLine(unsigned L) { Line = L; } - void setType(TypeDesc *T) { - TyDesc = static_cast(T); - } - - /// ApplyToFields - Target the visitor to the fields of the VariableDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const { - return "llvm.dbg.variable"; - } - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.variable.type"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif - - // Implement isa/cast/dyncast. - static bool classof(const VariableDesc *) { return true; } - static bool classof(const DebugInfoDesc *D); -}; - -//===----------------------------------------------------------------------===// -/// GlobalDesc - This class is the base descriptor for global functions and -/// variables. -class GlobalDesc : public AnchoredDesc { - DebugInfoDesc *Context; // Context debug descriptor. - std::string Name; // Global name. - std::string FullName; // Fully qualified name. - std::string LinkageName; // Name for binding to MIPS linkage. - DebugInfoDesc *File; // Defined compile unit (may be NULL.) - unsigned Line; // Defined line# (may be zero.) - DebugInfoDesc *TyDesc; // Type debug descriptor. - bool IsStatic; // Is the global a static. - bool IsDefinition; // Is the global defined in context. -protected: - explicit GlobalDesc(unsigned T); -public: - // Accessors - DebugInfoDesc *getContext() const { return Context; } - const std::string &getName() const { return Name; } - const std::string &getFullName() const { return FullName; } - const std::string &getLinkageName() const { return LinkageName; } - CompileUnitDesc *getFile() const { - return static_cast(File); - } - unsigned getLine() const { return Line; } - TypeDesc *getType() const { - return static_cast(TyDesc); - } - bool isStatic() const { return IsStatic; } - bool isDefinition() const { return IsDefinition; } - void setContext(DebugInfoDesc *C) { Context = C; } - void setName(const std::string &N) { Name = N; } - void setFullName(const std::string &N) { FullName = N; } - void setLinkageName(const std::string &N) { LinkageName = N; } - void setFile(CompileUnitDesc *U) { - File = static_cast(U); - } - void setLine(unsigned L) { Line = L; } - void setType(TypeDesc *T) { - TyDesc = static_cast(T); - } - void setIsStatic(bool IS) { IsStatic = IS; } - void setIsDefinition(bool ID) { IsDefinition = ID; } - - /// ApplyToFields - Target the visitor to the fields of the GlobalDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); -}; - -//===----------------------------------------------------------------------===// -/// GlobalVariableDesc - This class packages debug information associated with a -/// GlobalVariable. -class GlobalVariableDesc : public GlobalDesc { - GlobalVariable *Global; // llvm global. -public: - GlobalVariableDesc(); - - // Accessors. - GlobalVariable *getGlobalVariable() const { return Global; } - void setGlobalVariable(GlobalVariable *GV) { Global = GV; } - - /// ApplyToFields - Target the visitor to the fields of the - /// GlobalVariableDesc. - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const { - return "llvm.dbg.global_variable"; - } - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.global_variable.type"; - } - - /// getAnchorString - Return a string used to label this descriptor's anchor. - /// - const char *getAnchorString() const { - return "llvm.dbg.global_variables"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif - - // Implement isa/cast/dyncast. - static bool classof(const GlobalVariableDesc *) { return true; } - static bool classof(const DebugInfoDesc *D); -}; - -//===----------------------------------------------------------------------===// -/// SubprogramDesc - This class packages debug information associated with a -/// subprogram/function. -struct SubprogramDesc : public GlobalDesc { - SubprogramDesc(); - - /// ApplyToFields - Target the visitor to the fields of the SubprogramDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const { - return "llvm.dbg.subprogram"; - } - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.subprogram.type"; - } - - /// getAnchorString - Return a string used to label this descriptor's anchor. - /// - const char *getAnchorString() const { - return "llvm.dbg.subprograms"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif - - // Implement isa/cast/dyncast. - static bool classof(const SubprogramDesc *) { return true; } - static bool classof(const DebugInfoDesc *D); -}; - -//===----------------------------------------------------------------------===// -/// BlockDesc - This descriptor groups variables and blocks nested in a block. -/// -class BlockDesc : public DebugInfoDesc { - DebugInfoDesc *Context; // Context debug descriptor. -public: - BlockDesc(); - - // Accessors - DebugInfoDesc *getContext() const { return Context; } - void setContext(DebugInfoDesc *C) { Context = C; } - - /// ApplyToFields - Target the visitor to the fields of the BlockDesc. - /// - virtual void ApplyToFields(DIVisitor *Visitor); - - /// getDescString - Return a string used to compose global names and labels. - /// - virtual const char *getDescString() const { - return "llvm.dbg.block"; - } - - /// getTypeString - Return a string used to label this descriptor's type. - /// - virtual const char *getTypeString() const { - return "llvm.dbg.block.type"; - } - -#ifndef NDEBUG - virtual void dump(); -#endif - - // Implement isa/cast/dyncast. - static bool classof(const BlockDesc *) { return true; } - static bool classof(const DebugInfoDesc *D); -}; - -} // End llvm namespace - -#endif diff --git a/llvm/include/llvm/CodeGen/MachineModuleInfo.h b/llvm/include/llvm/CodeGen/MachineModuleInfo.h index 63d50a9e3a4d..54654fda5bd5 100644 --- a/llvm/include/llvm/CodeGen/MachineModuleInfo.h +++ b/llvm/include/llvm/CodeGen/MachineModuleInfo.h @@ -31,21 +31,19 @@ #ifndef LLVM_CODEGEN_MACHINEMODULEINFO_H #define LLVM_CODEGEN_MACHINEMODULEINFO_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/ADT/SmallPtrSet.h" #include "llvm/GlobalValue.h" #include "llvm/Pass.h" -#include "llvm/ADT/DenseMap.h" -#include "llvm/ADT/SmallPtrSet.h" -#include "llvm/ADT/SmallVector.h" -#include "llvm/ADT/UniqueVector.h" -#include "llvm/Support/DataTypes.h" -#include "llvm/Support/Dwarf.h" namespace llvm { //===----------------------------------------------------------------------===// // Forward declarations. -class AnchoredDesc; -class CompileUnitDesc; class Constant; class DebugInfoDesc; class GlobalVariable; @@ -55,7 +53,16 @@ class MachineMove; class Module; class PointerType; class StructType; -class VariableDesc; + +//===----------------------------------------------------------------------===// +// Debug info constants. + +enum { + LLVMDebugVersion = (6 << 16), // Current version of debug information. + LLVMDebugVersion5 = (5 << 16), // Constant for version 5. + LLVMDebugVersion4 = (4 << 16), // Constant for version 4. + LLVMDebugVersionMask = 0xffff0000 // Mask for version number. +}; //===----------------------------------------------------------------------===// /// DIVisitor - Subclasses of this class apply steps to each of the fields in @@ -82,6 +89,662 @@ public: virtual void Apply(std::vector &Field) = 0; }; +//===----------------------------------------------------------------------===// +/// DebugInfoDesc - This class is the base class for debug info descriptors. +/// +class DebugInfoDesc { +private: + unsigned Tag; // Content indicator. Dwarf values are + // used but that does not limit use to + // Dwarf writers. + +protected: + explicit DebugInfoDesc(unsigned T) : Tag(T | LLVMDebugVersion) {} + +public: + virtual ~DebugInfoDesc() {} + + // Accessors + unsigned getTag() const { return Tag & ~LLVMDebugVersionMask; } + unsigned getVersion() const { return Tag & LLVMDebugVersionMask; } + void setTag(unsigned T) { Tag = T | LLVMDebugVersion; } + + /// TagFromGlobal - Returns the tag number from a debug info descriptor + /// GlobalVariable. Return DIIValid if operand is not an unsigned int. + static unsigned TagFromGlobal(GlobalVariable *GV); + + /// VersionFromGlobal - Returns the version number from a debug info + /// descriptor GlobalVariable. Return DIIValid if operand is not an unsigned + /// int. + static unsigned VersionFromGlobal(GlobalVariable *GV); + + /// DescFactory - Create an instance of debug info descriptor based on Tag. + /// Return NULL if not a recognized Tag. + static DebugInfoDesc *DescFactory(unsigned Tag); + + /// getLinkage - get linkage appropriate for this type of descriptor. + /// + virtual GlobalValue::LinkageTypes getLinkage() const; + + //===--------------------------------------------------------------------===// + // Subclasses should supply the following static methods. + + // Implement isa/cast/dyncast. + static bool classof(const DebugInfoDesc *) { return true; } + + //===--------------------------------------------------------------------===// + // Subclasses should supply the following virtual methods. + + /// ApplyToFields - Target the vistor to the fields of the descriptor. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const = 0; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const = 0; + +#ifndef NDEBUG + virtual void dump() = 0; +#endif +}; + +//===----------------------------------------------------------------------===// +/// AnchorDesc - Descriptors of this class act as markers for identifying +/// descriptors of certain groups. +class AnchoredDesc; +class AnchorDesc : public DebugInfoDesc { +private: + unsigned AnchorTag; // Tag number of descriptors anchored + // by this object. + +public: + AnchorDesc(); + explicit AnchorDesc(AnchoredDesc *D); + + // Accessors + unsigned getAnchorTag() const { return AnchorTag; } + + // Implement isa/cast/dyncast. + static bool classof(const AnchorDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// getLinkage - get linkage appropriate for this type of descriptor. + /// + virtual GlobalValue::LinkageTypes getLinkage() const; + + /// ApplyToFields - Target the visitor to the fields of the AnchorDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// AnchoredDesc - This class manages anchors for a variety of top level +/// descriptors. +class AnchoredDesc : public DebugInfoDesc { +private: + DebugInfoDesc *Anchor; // Anchor for all descriptors of the + // same type. + +protected: + + explicit AnchoredDesc(unsigned T); + +public: + // Accessors. + AnchorDesc *getAnchor() const { return static_cast(Anchor); } + void setAnchor(AnchorDesc *A) { Anchor = static_cast(A); } + + //===--------------------------------------------------------------------===// + // Subclasses should supply the following virtual methods. + + /// getAnchorString - Return a string used to label descriptor's anchor. + /// + virtual const char *getAnchorString() const = 0; + + /// ApplyToFields - Target the visitor to the fields of the AnchoredDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); +}; + +//===----------------------------------------------------------------------===// +/// CompileUnitDesc - This class packages debug information associated with a +/// source/header file. +class CompileUnitDesc : public AnchoredDesc { +private: + unsigned Language; // Language number (ex. DW_LANG_C89.) + std::string FileName; // Source file name. + std::string Directory; // Source file directory. + std::string Producer; // Compiler string. + +public: + CompileUnitDesc(); + + + // Accessors + unsigned getLanguage() const { return Language; } + const std::string &getFileName() const { return FileName; } + const std::string &getDirectory() const { return Directory; } + const std::string &getProducer() const { return Producer; } + void setLanguage(unsigned L) { Language = L; } + void setFileName(const std::string &FN) { FileName = FN; } + void setDirectory(const std::string &D) { Directory = D; } + void setProducer(const std::string &P) { Producer = P; } + + // FIXME - Need translation unit getter/setter. + + // Implement isa/cast/dyncast. + static bool classof(const CompileUnitDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the CompileUnitDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + + /// getAnchorString - Return a string used to label this descriptor's anchor. + /// + static const char *const AnchorString; + virtual const char *getAnchorString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// TypeDesc - This class packages debug information associated with a type. +/// +class TypeDesc : public DebugInfoDesc { +private: + enum { + FlagPrivate = 1 << 0, + FlagProtected = 1 << 1 + }; + DebugInfoDesc *Context; // Context debug descriptor. + std::string Name; // Type name (may be empty.) + DebugInfoDesc *File; // Defined compile unit (may be NULL.) + unsigned Line; // Defined line# (may be zero.) + uint64_t Size; // Type bit size (may be zero.) + uint64_t Align; // Type bit alignment (may be zero.) + uint64_t Offset; // Type bit offset (may be zero.) + unsigned Flags; // Miscellaneous flags. + +public: + explicit TypeDesc(unsigned T); + + // Accessors + DebugInfoDesc *getContext() const { return Context; } + const std::string &getName() const { return Name; } + CompileUnitDesc *getFile() const { + return static_cast(File); + } + unsigned getLine() const { return Line; } + uint64_t getSize() const { return Size; } + uint64_t getAlign() const { return Align; } + uint64_t getOffset() const { return Offset; } + bool isPrivate() const { + return (Flags & FlagPrivate) != 0; + } + bool isProtected() const { + return (Flags & FlagProtected) != 0; + } + void setContext(DebugInfoDesc *C) { Context = C; } + void setName(const std::string &N) { Name = N; } + void setFile(CompileUnitDesc *U) { + File = static_cast(U); + } + void setLine(unsigned L) { Line = L; } + void setSize(uint64_t S) { Size = S; } + void setAlign(uint64_t A) { Align = A; } + void setOffset(uint64_t O) { Offset = O; } + void setIsPrivate() { Flags |= FlagPrivate; } + void setIsProtected() { Flags |= FlagProtected; } + + /// ApplyToFields - Target the visitor to the fields of the TypeDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// BasicTypeDesc - This class packages debug information associated with a +/// basic type (eg. int, bool, double.) +class BasicTypeDesc : public TypeDesc { +private: + unsigned Encoding; // Type encoding. + +public: + BasicTypeDesc(); + + // Accessors + unsigned getEncoding() const { return Encoding; } + void setEncoding(unsigned E) { Encoding = E; } + + // Implement isa/cast/dyncast. + static bool classof(const BasicTypeDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the BasicTypeDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + + +//===----------------------------------------------------------------------===// +/// DerivedTypeDesc - This class packages debug information associated with a +/// derived types (eg., typedef, pointer, reference.) +class DerivedTypeDesc : public TypeDesc { +private: + DebugInfoDesc *FromType; // Type derived from. + +public: + explicit DerivedTypeDesc(unsigned T); + + // Accessors + TypeDesc *getFromType() const { + return static_cast(FromType); + } + void setFromType(TypeDesc *F) { + FromType = static_cast(F); + } + + // Implement isa/cast/dyncast. + static bool classof(const DerivedTypeDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the DerivedTypeDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// CompositeTypeDesc - This class packages debug information associated with a +/// array/struct types (eg., arrays, struct, union, enums.) +class CompositeTypeDesc : public DerivedTypeDesc { +private: + std::vector Elements;// Information used to compose type. + +public: + explicit CompositeTypeDesc(unsigned T); + + // Accessors + std::vector &getElements() { return Elements; } + + // Implement isa/cast/dyncast. + static bool classof(const CompositeTypeDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the CompositeTypeDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// SubrangeDesc - This class packages debug information associated with integer +/// value ranges. +class SubrangeDesc : public DebugInfoDesc { +private: + int64_t Lo; // Low value of range. + int64_t Hi; // High value of range. + +public: + SubrangeDesc(); + + // Accessors + int64_t getLo() const { return Lo; } + int64_t getHi() const { return Hi; } + void setLo(int64_t L) { Lo = L; } + void setHi(int64_t H) { Hi = H; } + + // Implement isa/cast/dyncast. + static bool classof(const SubrangeDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the SubrangeDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// EnumeratorDesc - This class packages debug information associated with +/// named integer constants. +class EnumeratorDesc : public DebugInfoDesc { +private: + std::string Name; // Enumerator name. + int64_t Value; // Enumerator value. + +public: + EnumeratorDesc(); + + // Accessors + const std::string &getName() const { return Name; } + int64_t getValue() const { return Value; } + void setName(const std::string &N) { Name = N; } + void setValue(int64_t V) { Value = V; } + + // Implement isa/cast/dyncast. + static bool classof(const EnumeratorDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the EnumeratorDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// VariableDesc - This class packages debug information associated with a +/// subprogram variable. +/// +class VariableDesc : public DebugInfoDesc { +private: + DebugInfoDesc *Context; // Context debug descriptor. + std::string Name; // Type name (may be empty.) + DebugInfoDesc *File; // Defined compile unit (may be NULL.) + unsigned Line; // Defined line# (may be zero.) + DebugInfoDesc *TyDesc; // Type of variable. + +public: + explicit VariableDesc(unsigned T); + + // Accessors + DebugInfoDesc *getContext() const { return Context; } + const std::string &getName() const { return Name; } + CompileUnitDesc *getFile() const { + return static_cast(File); + } + unsigned getLine() const { return Line; } + TypeDesc *getType() const { + return static_cast(TyDesc); + } + void setContext(DebugInfoDesc *C) { Context = C; } + void setName(const std::string &N) { Name = N; } + void setFile(CompileUnitDesc *U) { + File = static_cast(U); + } + void setLine(unsigned L) { Line = L; } + void setType(TypeDesc *T) { + TyDesc = static_cast(T); + } + + // Implement isa/cast/dyncast. + static bool classof(const VariableDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the VariableDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// GlobalDesc - This class is the base descriptor for global functions and +/// variables. +class GlobalDesc : public AnchoredDesc { +private: + DebugInfoDesc *Context; // Context debug descriptor. + std::string Name; // Global name. + std::string FullName; // Fully qualified name. + std::string LinkageName; // Name for binding to MIPS linkage. + DebugInfoDesc *File; // Defined compile unit (may be NULL.) + unsigned Line; // Defined line# (may be zero.) + DebugInfoDesc *TyDesc; // Type debug descriptor. + bool IsStatic; // Is the global a static. + bool IsDefinition; // Is the global defined in context. + +protected: + explicit GlobalDesc(unsigned T); + +public: + // Accessors + DebugInfoDesc *getContext() const { return Context; } + const std::string &getName() const { return Name; } + const std::string &getFullName() const { return FullName; } + const std::string &getLinkageName() const { return LinkageName; } + CompileUnitDesc *getFile() const { + return static_cast(File); + } + unsigned getLine() const { return Line; } + TypeDesc *getType() const { + return static_cast(TyDesc); + } + bool isStatic() const { return IsStatic; } + bool isDefinition() const { return IsDefinition; } + void setContext(DebugInfoDesc *C) { Context = C; } + void setName(const std::string &N) { Name = N; } + void setFullName(const std::string &N) { FullName = N; } + void setLinkageName(const std::string &N) { LinkageName = N; } + void setFile(CompileUnitDesc *U) { + File = static_cast(U); + } + void setLine(unsigned L) { Line = L; } + void setType(TypeDesc *T) { + TyDesc = static_cast(T); + } + void setIsStatic(bool IS) { IsStatic = IS; } + void setIsDefinition(bool ID) { IsDefinition = ID; } + + /// ApplyToFields - Target the visitor to the fields of the GlobalDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); +}; + +//===----------------------------------------------------------------------===// +/// GlobalVariableDesc - This class packages debug information associated with a +/// GlobalVariable. +class GlobalVariableDesc : public GlobalDesc { +private: + GlobalVariable *Global; // llvm global. + +public: + GlobalVariableDesc(); + + // Accessors. + GlobalVariable *getGlobalVariable() const { return Global; } + void setGlobalVariable(GlobalVariable *GV) { Global = GV; } + + // Implement isa/cast/dyncast. + static bool classof(const GlobalVariableDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the + /// GlobalVariableDesc. + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + + /// getAnchorString - Return a string used to label this descriptor's anchor. + /// + static const char *const AnchorString; + virtual const char *getAnchorString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// SubprogramDesc - This class packages debug information associated with a +/// subprogram/function. +class SubprogramDesc : public GlobalDesc { +private: + +public: + SubprogramDesc(); + + // Accessors + + // Implement isa/cast/dyncast. + static bool classof(const SubprogramDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the SubprogramDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + + /// getAnchorString - Return a string used to label this descriptor's anchor. + /// + static const char *const AnchorString; + virtual const char *getAnchorString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + +//===----------------------------------------------------------------------===// +/// BlockDesc - This descriptor groups variables and blocks nested in a block. +/// +class BlockDesc : public DebugInfoDesc { +private: + DebugInfoDesc *Context; // Context debug descriptor. + +public: + BlockDesc(); + + // Accessors + DebugInfoDesc *getContext() const { return Context; } + void setContext(DebugInfoDesc *C) { Context = C; } + + // Implement isa/cast/dyncast. + static bool classof(const BlockDesc *) { return true; } + static bool classof(const DebugInfoDesc *D); + + /// ApplyToFields - Target the visitor to the fields of the BlockDesc. + /// + virtual void ApplyToFields(DIVisitor *Visitor); + + /// getDescString - Return a string used to compose global names and labels. + /// + virtual const char *getDescString() const; + + /// getTypeString - Return a string used to label this descriptor's type. + /// + virtual const char *getTypeString() const; + +#ifndef NDEBUG + virtual void dump(); +#endif +}; + //===----------------------------------------------------------------------===// /// DIDeserializer - This class is responsible for casting GlobalVariables /// into DebugInfoDesc objects. @@ -489,13 +1152,28 @@ public: /// getGlobalVariablesUsing - Return all of the GlobalVariables that use the /// named GlobalVariable. - void getGlobalVariablesUsing(Module &M, const std::string &RootName, - std::vector &Result); + std::vector + getGlobalVariablesUsing(Module &M, const std::string &RootName); /// getAnchoredDescriptors - Return a vector of anchored debug descriptors. /// - void getAnchoredDescriptors(Module &M, const AnchoredDesc *Desc, - std::vector &AnchoredDescs); + template std::vector getAnchoredDescriptors(Module &M) { + T Desc; + std::vector Globals = + getGlobalVariablesUsing(M, Desc.getAnchorString()); + std::vector AnchoredDescs; + for (unsigned i = 0, N = Globals.size(); i < N; ++i) { + GlobalVariable *GV = Globals[i]; + + // FIXME - In the short term, changes are too drastic to continue. + if (DebugInfoDesc::TagFromGlobal(GV) == Desc.getTag() && + DebugInfoDesc::VersionFromGlobal(GV) == LLVMDebugVersion) { + AnchoredDescs.push_back(cast(DR.Deserialize(GV))); + } + } + + return AnchoredDescs; + } /// RecordRegionStart - Indicate the start of a region. /// diff --git a/llvm/lib/CodeGen/DwarfWriter.cpp b/llvm/lib/CodeGen/DwarfWriter.cpp index 569702c59dff..a284ba19eb62 100644 --- a/llvm/lib/CodeGen/DwarfWriter.cpp +++ b/llvm/lib/CodeGen/DwarfWriter.cpp @@ -20,7 +20,6 @@ #include "llvm/Module.h" #include "llvm/Type.h" #include "llvm/CodeGen/AsmPrinter.h" -#include "llvm/CodeGen/MachineDebugInfoDesc.h" #include "llvm/CodeGen/MachineModuleInfo.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/MachineLocation.h" @@ -2631,23 +2630,25 @@ private: /// ConstructGlobalDIEs - Create DIEs for each of the externally visible /// global variables. void ConstructGlobalDIEs() { - std::vector GlobalVariables; - GlobalVariableDesc GVD; - MMI->getAnchoredDescriptors(*M, &GVD, GlobalVariables); + std::vector GlobalVariables = + MMI->getAnchoredDescriptors(*M); - for (unsigned i = 0, N = GlobalVariables.size(); i < N; ++i) - NewGlobalVariable((GlobalVariableDesc *)GlobalVariables[i]); + for (unsigned i = 0, N = GlobalVariables.size(); i < N; ++i) { + GlobalVariableDesc *GVD = GlobalVariables[i]; + NewGlobalVariable(GVD); + } } /// ConstructSubprogramDIEs - Create DIEs for each of the externally visible /// subprograms. void ConstructSubprogramDIEs() { - std::vector Subprograms; - SubprogramDesc SPD; - MMI->getAnchoredDescriptors(*M, &SPD, Subprograms); + std::vector Subprograms = + MMI->getAnchoredDescriptors(*M); - for (unsigned i = 0, N = Subprograms.size(); i < N; ++i) - NewSubprogram((SubprogramDesc*)Subprograms[i]); + for (unsigned i = 0, N = Subprograms.size(); i < N; ++i) { + SubprogramDesc *SPD = Subprograms[i]; + NewSubprogram(SPD); + } } public: diff --git a/llvm/lib/CodeGen/MachineDebugInfoDesc.cpp b/llvm/lib/CodeGen/MachineDebugInfoDesc.cpp deleted file mode 100644 index 23853862c28f..000000000000 --- a/llvm/lib/CodeGen/MachineDebugInfoDesc.cpp +++ /dev/null @@ -1,575 +0,0 @@ -//===-- llvm/CodeGen/MachineDebugInfoDesc.cpp -------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "llvm/CodeGen/MachineDebugInfoDesc.h" -#include "llvm/CodeGen/MachineModuleInfo.h" -#include "llvm/Constants.h" -#include "llvm/GlobalVariable.h" -#include "llvm/Support/Dwarf.h" -#include "llvm/Support/Streams.h" - -using namespace llvm; -using namespace llvm::dwarf; - -/// getUIntOperand - Return ith operand if it is an unsigned integer. -/// -static ConstantInt *getUIntOperand(const GlobalVariable *GV, unsigned i) { - // Make sure the GlobalVariable has an initializer. - if (!GV->hasInitializer()) return NULL; - - // Get the initializer constant. - ConstantStruct *CI = dyn_cast(GV->getInitializer()); - if (!CI) return NULL; - - // Check if there is at least i + 1 operands. - unsigned N = CI->getNumOperands(); - if (i >= N) return NULL; - - // Check constant. - return dyn_cast(CI->getOperand(i)); -} - -//===----------------------------------------------------------------------===// - -/// Supply a home for the DebugInfoDesc's v-table. -DebugInfoDesc::~DebugInfoDesc() {} - -/// TagFromGlobal - Returns the tag number from a debug info descriptor -/// GlobalVariable. Return DIIValid if operand is not an unsigned int. -unsigned DebugInfoDesc::TagFromGlobal(GlobalVariable *GV) { - ConstantInt *C = getUIntOperand(GV, 0); - return C ? ((unsigned)C->getZExtValue() & ~LLVMDebugVersionMask) : - (unsigned)DW_TAG_invalid; -} - -/// VersionFromGlobal - Returns the version number from a debug info -/// descriptor GlobalVariable. Return DIIValid if operand is not an unsigned -/// int. -unsigned DebugInfoDesc::VersionFromGlobal(GlobalVariable *GV) { - ConstantInt *C = getUIntOperand(GV, 0); - return C ? ((unsigned)C->getZExtValue() & LLVMDebugVersionMask) : - (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 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_lexical_block: return new BlockDesc(); - 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: - case DW_TAG_member: - case DW_TAG_inheritance: return new DerivedTypeDesc(Tag); - case DW_TAG_array_type: - case DW_TAG_structure_type: - case DW_TAG_union_type: - case DW_TAG_enumeration_type: - case DW_TAG_vector_type: - case DW_TAG_subroutine_type: return new CompositeTypeDesc(Tag); - case DW_TAG_subrange_type: return new SubrangeDesc(); - case DW_TAG_enumerator: return new EnumeratorDesc(); - case DW_TAG_return_variable: - case DW_TAG_arg_variable: - case DW_TAG_auto_variable: return new VariableDesc(Tag); - default: break; - } - return NULL; -} - -/// getLinkage - get linkage appropriate for this type of descriptor. -GlobalValue::LinkageTypes DebugInfoDesc::getLinkage() const { - return GlobalValue::InternalLinkage; -} - -/// ApplyToFields - Target the vistor to the fields of the descriptor. -void DebugInfoDesc::ApplyToFields(DIVisitor *Visitor) { - Visitor->Apply(Tag); -} - -//===----------------------------------------------------------------------===// - -AnchorDesc::AnchorDesc() - : DebugInfoDesc(DW_TAG_anchor), AnchorTag(0) {} - -AnchorDesc::AnchorDesc(AnchoredDesc *D) - : DebugInfoDesc(DW_TAG_anchor), AnchorTag(D->getTag()) {} - -// 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 { - return GlobalValue::LinkOnceLinkage; -} - -/// ApplyToFields - Target the visitor to the fields of the TransUnitDesc. -void AnchorDesc::ApplyToFields(DIVisitor *Visitor) { - DebugInfoDesc::ApplyToFields(Visitor); - Visitor->Apply(AnchorTag); -} - -/// getDescString - Return a string used to compose global names and labels. A -/// global variable name needs to be defined for each debug descriptor that is -/// anchored. NOTE: that each global variable named here also needs to be added -/// to the list of names left external in the internalizer. -/// -/// ExternalNames.insert("llvm.dbg.compile_units"); -/// ExternalNames.insert("llvm.dbg.global_variables"); -/// ExternalNames.insert("llvm.dbg.subprograms"); -const char *AnchorDesc::getDescString() const { - switch (AnchorTag) { - case DW_TAG_compile_unit: { - CompileUnitDesc CUD; - return CUD.getAnchorString(); - } - case DW_TAG_variable: { - GlobalVariableDesc GVD; - return GVD.getAnchorString(); - } - case DW_TAG_subprogram: { - SubprogramDesc SPD; - return SPD.getAnchorString(); - } - default: break; - } - - assert(0 && "Tag does not have a case for anchor string"); - return ""; -} - -#ifndef NDEBUG -void AnchorDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << "), " - << "AnchorTag(" << AnchorTag << ")\n"; -} -#endif - -//===----------------------------------------------------------------------===// - -AnchoredDesc::AnchoredDesc(unsigned T) - : DebugInfoDesc(T), Anchor(NULL) {} - -/// ApplyToFields - Target the visitor to the fields of the AnchoredDesc. -void AnchoredDesc::ApplyToFields(DIVisitor *Visitor) { - DebugInfoDesc::ApplyToFields(Visitor); - Visitor->Apply(Anchor); -} - -//===----------------------------------------------------------------------===// - -CompileUnitDesc::CompileUnitDesc() - : AnchoredDesc(DW_TAG_compile_unit), Language(0), FileName(""), - Directory(""), Producer("") {} - -// Implement isa/cast/dyncast. -bool CompileUnitDesc::classof(const DebugInfoDesc *D) { - return D->getTag() == DW_TAG_compile_unit; -} - -/// ApplyToFields - Target the visitor to the fields of the CompileUnitDesc. -/// -void CompileUnitDesc::ApplyToFields(DIVisitor *Visitor) { - AnchoredDesc::ApplyToFields(Visitor); - - // Handle cases out of sync with compiler. - if (getVersion() == 0) { - unsigned DebugVersion; - Visitor->Apply(DebugVersion); - } - - Visitor->Apply(Language); - Visitor->Apply(FileName); - Visitor->Apply(Directory); - Visitor->Apply(Producer); -} - -#ifndef NDEBUG -void CompileUnitDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << "), " - << "Anchor(" << getAnchor() << "), " - << "Language(" << Language << "), " - << "FileName(\"" << FileName << "\"), " - << "Directory(\"" << Directory << "\"), " - << "Producer(\"" << Producer << "\")\n"; -} -#endif - -//===----------------------------------------------------------------------===// - -TypeDesc::TypeDesc(unsigned T) - : DebugInfoDesc(T), Context(NULL), Name(""), File(NULL), Line(0), Size(0), - Align(0), Offset(0), Flags(0) {} - -/// ApplyToFields - Target the visitor to the fields of the TypeDesc. -/// -void TypeDesc::ApplyToFields(DIVisitor *Visitor) { - DebugInfoDesc::ApplyToFields(Visitor); - Visitor->Apply(Context); - Visitor->Apply(Name); - Visitor->Apply(File); - Visitor->Apply(Line); - Visitor->Apply(Size); - Visitor->Apply(Align); - Visitor->Apply(Offset); - if (getVersion() > LLVMDebugVersion4) Visitor->Apply(Flags); -} - -#ifndef NDEBUG -void TypeDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << "), " - << "Context(" << Context << "), " - << "Name(\"" << Name << "\"), " - << "File(" << File << "), " - << "Line(" << Line << "), " - << "Size(" << Size << "), " - << "Align(" << Align << "), " - << "Offset(" << Offset << "), " - << "Flags(" << Flags << ")\n"; -} -#endif - -//===----------------------------------------------------------------------===// - -BasicTypeDesc::BasicTypeDesc() - : 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) { - TypeDesc::ApplyToFields(Visitor); - Visitor->Apply(Encoding); -} - -#ifndef NDEBUG -void BasicTypeDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << "), " - << "Context(" << getContext() << "), " - << "Name(\"" << getName() << "\"), " - << "Size(" << getSize() << "), " - << "Encoding(" << Encoding << ")\n"; -} -#endif - -//===----------------------------------------------------------------------===// - -DerivedTypeDesc::DerivedTypeDesc(unsigned T) - : TypeDesc(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: - case DW_TAG_member: - case DW_TAG_inheritance: - return true; - default: break; - } - return false; -} - -/// ApplyToFields - Target the visitor to the fields of the DerivedTypeDesc. -void DerivedTypeDesc::ApplyToFields(DIVisitor *Visitor) { - TypeDesc::ApplyToFields(Visitor); - Visitor->Apply(FromType); -} - -#ifndef NDEBUG -void DerivedTypeDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << "), " - << "Context(" << getContext() << "), " - << "Name(\"" << getName() << "\"), " - << "Size(" << getSize() << "), " - << "File(" << getFile() << "), " - << "Line(" << getLine() << "), " - << "FromType(" << FromType << ")\n"; -} -#endif - -//===----------------------------------------------------------------------===// - -CompositeTypeDesc::CompositeTypeDesc(unsigned T) - : DerivedTypeDesc(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: - case DW_TAG_vector_type: - case DW_TAG_subroutine_type: - return true; - default: break; - } - return false; -} - -/// ApplyToFields - Target the visitor to the fields of the CompositeTypeDesc. -/// -void CompositeTypeDesc::ApplyToFields(DIVisitor *Visitor) { - DerivedTypeDesc::ApplyToFields(Visitor); - Visitor->Apply(Elements); -} - -#ifndef NDEBUG -void CompositeTypeDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << "), " - << "Context(" << getContext() << "), " - << "Name(\"" << getName() << "\"), " - << "Size(" << getSize() << "), " - << "File(" << getFile() << "), " - << "Line(" << getLine() << "), " - << "FromType(" << getFromType() << "), " - << "Elements.size(" << Elements.size() << ")\n"; -} -#endif - -//===----------------------------------------------------------------------===// - -SubrangeDesc::SubrangeDesc() - : 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) { - DebugInfoDesc::ApplyToFields(Visitor); - Visitor->Apply(Lo); - Visitor->Apply(Hi); -} - -#ifndef NDEBUG -void SubrangeDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << "), " - << "Lo(" << Lo << "), " - << "Hi(" << Hi << ")\n"; -} -#endif - -//===----------------------------------------------------------------------===// - -EnumeratorDesc::EnumeratorDesc() - : DebugInfoDesc(DW_TAG_enumerator), Name(""), Value(0) {} - -// Implement isa/cast/dyncast. -bool EnumeratorDesc::classof(const DebugInfoDesc *D) { - return D->getTag() == DW_TAG_enumerator; -} - -/// ApplyToFields - Target the visitor to the fields of the EnumeratorDesc. -void EnumeratorDesc::ApplyToFields(DIVisitor *Visitor) { - DebugInfoDesc::ApplyToFields(Visitor); - Visitor->Apply(Name); - Visitor->Apply(Value); -} - -#ifndef NDEBUG -void EnumeratorDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << "), " - << "Name(" << Name << "), " - << "Value(" << Value << ")\n"; -} -#endif - -//===----------------------------------------------------------------------===// - -VariableDesc::VariableDesc(unsigned T) - : DebugInfoDesc(T), Context(NULL), Name(""), File(NULL), Line(0), TyDesc(0) -{} - -// Implement isa/cast/dyncast. -bool VariableDesc::classof(const DebugInfoDesc *D) { - unsigned T = D->getTag(); - switch (T) { - case DW_TAG_auto_variable: - case DW_TAG_arg_variable: - case DW_TAG_return_variable: - return true; - default: break; - } - return false; -} - -/// ApplyToFields - Target the visitor to the fields of the VariableDesc. -void VariableDesc::ApplyToFields(DIVisitor *Visitor) { - DebugInfoDesc::ApplyToFields(Visitor); - Visitor->Apply(Context); - Visitor->Apply(Name); - Visitor->Apply(File); - Visitor->Apply(Line); - Visitor->Apply(TyDesc); -} - -#ifndef NDEBUG -void VariableDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << "), " - << "Context(" << Context << "), " - << "Name(\"" << Name << "\"), " - << "File(" << File << "), " - << "Line(" << Line << "), " - << "TyDesc(" << TyDesc << ")\n"; -} -#endif - -//===----------------------------------------------------------------------===// - -GlobalDesc::GlobalDesc(unsigned T) - : AnchoredDesc(T), Context(0), Name(""), FullName(""), LinkageName(""), - File(NULL), Line(0), TyDesc(NULL), IsStatic(false), IsDefinition(false) {} - -/// ApplyToFields - Target the visitor to the fields of the global. -/// -void GlobalDesc::ApplyToFields(DIVisitor *Visitor) { - AnchoredDesc::ApplyToFields(Visitor); - Visitor->Apply(Context); - Visitor->Apply(Name); - Visitor->Apply(FullName); - Visitor->Apply(LinkageName); - Visitor->Apply(File); - Visitor->Apply(Line); - Visitor->Apply(TyDesc); - Visitor->Apply(IsStatic); - Visitor->Apply(IsDefinition); -} - -//===----------------------------------------------------------------------===// - -GlobalVariableDesc::GlobalVariableDesc() - : 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) { - GlobalDesc::ApplyToFields(Visitor); - Visitor->Apply(Global); -} - -#ifndef NDEBUG -void GlobalVariableDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << "), " - << "Anchor(" << getAnchor() << "), " - << "Name(\"" << getName() << "\"), " - << "FullName(\"" << getFullName() << "\"), " - << "LinkageName(\"" << getLinkageName() << "\"), " - << "File(" << getFile() << ")," - << "Line(" << getLine() << ")," - << "Type(" << getType() << "), " - << "IsStatic(" << (isStatic() ? "true" : "false") << "), " - << "IsDefinition(" << (isDefinition() ? "true" : "false") << "), " - << "Global(" << Global << ")\n"; -} -#endif - -//===----------------------------------------------------------------------===// - -SubprogramDesc::SubprogramDesc() - : 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) { - GlobalDesc::ApplyToFields(Visitor); -} - -#ifndef NDEBUG -void SubprogramDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << "), " - << "Anchor(" << getAnchor() << "), " - << "Name(\"" << getName() << "\"), " - << "FullName(\"" << getFullName() << "\"), " - << "LinkageName(\"" << getLinkageName() << "\"), " - << "File(" << getFile() << ")," - << "Line(" << getLine() << ")," - << "Type(" << getType() << "), " - << "IsStatic(" << (isStatic() ? "true" : "false") << "), " - << "IsDefinition(" << (isDefinition() ? "true" : "false") << ")\n"; -} -#endif - -//===----------------------------------------------------------------------===// - -BlockDesc::BlockDesc() - : DebugInfoDesc(DW_TAG_lexical_block), Context(NULL) {} - -// Implement isa/cast/dyncast. -bool BlockDesc::classof(const DebugInfoDesc *D) { - return D->getTag() == DW_TAG_lexical_block; -} - -/// ApplyToFields - Target the visitor to the fields of the BlockDesc. -void BlockDesc::ApplyToFields(DIVisitor *Visitor) { - DebugInfoDesc::ApplyToFields(Visitor); - - Visitor->Apply(Context); -} - -#ifndef NDEBUG -void BlockDesc::dump() { - cerr << getDescString() << " " - << "Version(" << getVersion() << "), " - << "Tag(" << getTag() << ")," - << "Context(" << Context << ")\n"; -} -#endif diff --git a/llvm/lib/CodeGen/MachineModuleInfo.cpp b/llvm/lib/CodeGen/MachineModuleInfo.cpp index bdd771bb2b1e..b33a2d3e369a 100644 --- a/llvm/lib/CodeGen/MachineModuleInfo.cpp +++ b/llvm/lib/CodeGen/MachineModuleInfo.cpp @@ -14,7 +14,6 @@ #include "llvm/CodeGen/MachineFunctionPass.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineLocation.h" -#include "llvm/CodeGen/MachineDebugInfoDesc.h" #include "llvm/Target/TargetInstrInfo.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetOptions.h" @@ -53,9 +52,10 @@ getGlobalVariablesUsing(Value *V, std::vector &Result) { /// getGlobalVariablesUsing - Return all of the GlobalVariables that use the /// named GlobalVariable. -static void -getGlobalVariablesUsing(Module &M, const std::string &RootName, - std::vector &Result) { +static std::vector +getGlobalVariablesUsing(Module &M, const std::string &RootName) { + std::vector Result; // GlobalVariables matching criteria. + std::vector FieldTypes; FieldTypes.push_back(Type::Int32Ty); FieldTypes.push_back(Type::Int32Ty); @@ -65,8 +65,11 @@ getGlobalVariablesUsing(Module &M, const std::string &RootName, StructType::get(FieldTypes)); // If present and linkonce then scan for users. - if (UseRoot && UseRoot->hasLinkOnceLinkage()) + if (UseRoot && UseRoot->hasLinkOnceLinkage()) { getGlobalVariablesUsing(UseRoot, Result); + } + + return Result; } /// isStringValue - Return true if the given value can be coerced to a string. @@ -131,6 +134,24 @@ static bool isGlobalVariable(Value *V) { return false; } +/// getUIntOperand - Return ith operand if it is an unsigned integer. +/// +static ConstantInt *getUIntOperand(GlobalVariable *GV, unsigned i) { + // Make sure the GlobalVariable has an initializer. + if (!GV->hasInitializer()) return NULL; + + // Get the initializer constant. + ConstantStruct *CI = dyn_cast(GV->getInitializer()); + if (!CI) return NULL; + + // Check if there is at least i + 1 operands. + unsigned N = CI->getNumOperands(); + if (i >= N) return NULL; + + // Check constant. + return dyn_cast(CI->getOperand(i)); +} + //===----------------------------------------------------------------------===// /// ApplyToFields - Target the visitor to each field of the debug information @@ -250,7 +271,10 @@ private: public: DISerializeVisitor(DISerializer &S, std::vector &E) - : DIVisitor(), SR(S), Elements(E) {} + : DIVisitor() + , SR(S) + , Elements(E) + {} /// Apply - Set the value of each of the fields. /// @@ -303,7 +327,7 @@ public: ArrayType *AT = ArrayType::get(EmptyTy, N); std::vector ArrayElements; - for (unsigned i = 0; i < N; ++i) { + for (unsigned i = 0, N = Field.size(); i < N; ++i) { if (DebugInfoDesc *Element = Field[i]) { GlobalVariable *GVE = SR.Serialize(Element); Constant *CE = ConstantExpr::getBitCast(GVE, EmptyTy); @@ -334,7 +358,10 @@ private: public: DIGetTypesVisitor(DISerializer &S, std::vector &F) - : DIVisitor(), SR(S), Fields(F) {} + : DIVisitor() + , SR(S) + , Fields(F) + {} /// Apply - Set the value of each of the fields. /// @@ -457,6 +484,763 @@ public: //===----------------------------------------------------------------------===// +/// TagFromGlobal - Returns the tag number from a debug info descriptor +/// GlobalVariable. Return DIIValid if operand is not an unsigned int. +unsigned DebugInfoDesc::TagFromGlobal(GlobalVariable *GV) { + ConstantInt *C = getUIntOperand(GV, 0); + return C ? ((unsigned)C->getZExtValue() & ~LLVMDebugVersionMask) : + (unsigned)DW_TAG_invalid; +} + +/// VersionFromGlobal - Returns the version number from a debug info +/// descriptor GlobalVariable. Return DIIValid if operand is not an unsigned +/// int. +unsigned DebugInfoDesc::VersionFromGlobal(GlobalVariable *GV) { + ConstantInt *C = getUIntOperand(GV, 0); + return C ? ((unsigned)C->getZExtValue() & LLVMDebugVersionMask) : + (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 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_lexical_block: return new BlockDesc(); + 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: + case DW_TAG_member: + case DW_TAG_inheritance: return new DerivedTypeDesc(Tag); + case DW_TAG_array_type: + case DW_TAG_structure_type: + case DW_TAG_union_type: + case DW_TAG_enumeration_type: + case DW_TAG_vector_type: + case DW_TAG_subroutine_type: return new CompositeTypeDesc(Tag); + case DW_TAG_subrange_type: return new SubrangeDesc(); + case DW_TAG_enumerator: return new EnumeratorDesc(); + case DW_TAG_return_variable: + case DW_TAG_arg_variable: + case DW_TAG_auto_variable: return new VariableDesc(Tag); + default: break; + } + return NULL; +} + +/// getLinkage - get linkage appropriate for this type of descriptor. +/// +GlobalValue::LinkageTypes DebugInfoDesc::getLinkage() const { + return GlobalValue::InternalLinkage; +} + +/// ApplyToFields - Target the vistor to the fields of the descriptor. +/// +void DebugInfoDesc::ApplyToFields(DIVisitor *Visitor) { + Visitor->Apply(Tag); +} + +//===----------------------------------------------------------------------===// + +AnchorDesc::AnchorDesc() +: DebugInfoDesc(DW_TAG_anchor) +, AnchorTag(0) +{} +AnchorDesc::AnchorDesc(AnchoredDesc *D) +: DebugInfoDesc(DW_TAG_anchor) +, AnchorTag(D->getTag()) +{} + +// 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 { + return GlobalValue::LinkOnceLinkage; +} + +/// ApplyToFields - Target the visitor to the fields of the TransUnitDesc. +/// +void AnchorDesc::ApplyToFields(DIVisitor *Visitor) { + DebugInfoDesc::ApplyToFields(Visitor); + + Visitor->Apply(AnchorTag); +} + +/// getDescString - Return a string used to compose global names and labels. A +/// A global variable name needs to be defined for each debug descriptor that is +/// anchored. NOTE: that each global variable named here also needs to be added +/// to the list of names left external in the internalizer. +/// ExternalNames.insert("llvm.dbg.compile_units"); +/// ExternalNames.insert("llvm.dbg.global_variables"); +/// ExternalNames.insert("llvm.dbg.subprograms"); +const char *AnchorDesc::getDescString() const { + switch (AnchorTag) { + case DW_TAG_compile_unit: return CompileUnitDesc::AnchorString; + case DW_TAG_variable: return GlobalVariableDesc::AnchorString; + case DW_TAG_subprogram: return SubprogramDesc::AnchorString; + default: break; + } + + assert(0 && "Tag does not have a case for anchor string"); + return ""; +} + +/// getTypeString - Return a string used to label this descriptors type. +/// +const char *AnchorDesc::getTypeString() const { + return "llvm.dbg.anchor.type"; +} + +#ifndef NDEBUG +void AnchorDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << "), " + << "AnchorTag(" << AnchorTag << ")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + +AnchoredDesc::AnchoredDesc(unsigned T) +: DebugInfoDesc(T) +, Anchor(NULL) +{} + +/// ApplyToFields - Target the visitor to the fields of the AnchoredDesc. +/// +void AnchoredDesc::ApplyToFields(DIVisitor *Visitor) { + DebugInfoDesc::ApplyToFields(Visitor); + + Visitor->Apply(Anchor); +} + +//===----------------------------------------------------------------------===// + +CompileUnitDesc::CompileUnitDesc() +: AnchoredDesc(DW_TAG_compile_unit) +, Language(0) +, FileName("") +, Directory("") +, Producer("") +{} + +// Implement isa/cast/dyncast. +bool CompileUnitDesc::classof(const DebugInfoDesc *D) { + return D->getTag() == DW_TAG_compile_unit; +} + +/// ApplyToFields - Target the visitor to the fields of the CompileUnitDesc. +/// +void CompileUnitDesc::ApplyToFields(DIVisitor *Visitor) { + AnchoredDesc::ApplyToFields(Visitor); + + // Handle cases out of sync with compiler. + if (getVersion() == 0) { + unsigned DebugVersion; + Visitor->Apply(DebugVersion); + } + + Visitor->Apply(Language); + Visitor->Apply(FileName); + Visitor->Apply(Directory); + Visitor->Apply(Producer); +} + +/// getDescString - Return a string used to compose global names and labels. +/// +const char *CompileUnitDesc::getDescString() const { + return "llvm.dbg.compile_unit"; +} + +/// getTypeString - Return a string used to label this descriptors type. +/// +const char *CompileUnitDesc::getTypeString() const { + return "llvm.dbg.compile_unit.type"; +} + +/// getAnchorString - Return a string used to label this descriptor's anchor. +/// +const char *const CompileUnitDesc::AnchorString = "llvm.dbg.compile_units"; +const char *CompileUnitDesc::getAnchorString() const { + return AnchorString; +} + +#ifndef NDEBUG +void CompileUnitDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << "), " + << "Anchor(" << getAnchor() << "), " + << "Language(" << Language << "), " + << "FileName(\"" << FileName << "\"), " + << "Directory(\"" << Directory << "\"), " + << "Producer(\"" << Producer << "\")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + +TypeDesc::TypeDesc(unsigned T) +: DebugInfoDesc(T) +, Context(NULL) +, Name("") +, File(NULL) +, Line(0) +, Size(0) +, Align(0) +, Offset(0) +, Flags(0) +{} + +/// ApplyToFields - Target the visitor to the fields of the TypeDesc. +/// +void TypeDesc::ApplyToFields(DIVisitor *Visitor) { + DebugInfoDesc::ApplyToFields(Visitor); + + Visitor->Apply(Context); + Visitor->Apply(Name); + Visitor->Apply(File); + Visitor->Apply(Line); + Visitor->Apply(Size); + Visitor->Apply(Align); + Visitor->Apply(Offset); + if (getVersion() > LLVMDebugVersion4) Visitor->Apply(Flags); +} + +/// getDescString - Return a string used to compose global names and labels. +/// +const char *TypeDesc::getDescString() const { + return "llvm.dbg.type"; +} + +/// getTypeString - Return a string used to label this descriptor's type. +/// +const char *TypeDesc::getTypeString() const { + return "llvm.dbg.type.type"; +} + +#ifndef NDEBUG +void TypeDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << "), " + << "Context(" << Context << "), " + << "Name(\"" << Name << "\"), " + << "File(" << File << "), " + << "Line(" << Line << "), " + << "Size(" << Size << "), " + << "Align(" << Align << "), " + << "Offset(" << Offset << "), " + << "Flags(" << Flags << ")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + +BasicTypeDesc::BasicTypeDesc() +: 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) { + TypeDesc::ApplyToFields(Visitor); + + Visitor->Apply(Encoding); +} + +/// getDescString - Return a string used to compose global names and labels. +/// +const char *BasicTypeDesc::getDescString() const { + return "llvm.dbg.basictype"; +} + +/// getTypeString - Return a string used to label this descriptor's type. +/// +const char *BasicTypeDesc::getTypeString() const { + return "llvm.dbg.basictype.type"; +} + +#ifndef NDEBUG +void BasicTypeDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << "), " + << "Context(" << getContext() << "), " + << "Name(\"" << getName() << "\"), " + << "Size(" << getSize() << "), " + << "Encoding(" << Encoding << ")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + +DerivedTypeDesc::DerivedTypeDesc(unsigned T) +: TypeDesc(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: + case DW_TAG_member: + case DW_TAG_inheritance: + return true; + default: break; + } + return false; +} + +/// ApplyToFields - Target the visitor to the fields of the DerivedTypeDesc. +/// +void DerivedTypeDesc::ApplyToFields(DIVisitor *Visitor) { + TypeDesc::ApplyToFields(Visitor); + + Visitor->Apply(FromType); +} + +/// getDescString - Return a string used to compose global names and labels. +/// +const char *DerivedTypeDesc::getDescString() const { + return "llvm.dbg.derivedtype"; +} + +/// getTypeString - Return a string used to label this descriptor's type. +/// +const char *DerivedTypeDesc::getTypeString() const { + return "llvm.dbg.derivedtype.type"; +} + +#ifndef NDEBUG +void DerivedTypeDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << "), " + << "Context(" << getContext() << "), " + << "Name(\"" << getName() << "\"), " + << "Size(" << getSize() << "), " + << "File(" << getFile() << "), " + << "Line(" << getLine() << "), " + << "FromType(" << FromType << ")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + +CompositeTypeDesc::CompositeTypeDesc(unsigned T) +: DerivedTypeDesc(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: + case DW_TAG_vector_type: + case DW_TAG_subroutine_type: + return true; + default: break; + } + return false; +} + +/// ApplyToFields - Target the visitor to the fields of the CompositeTypeDesc. +/// +void CompositeTypeDesc::ApplyToFields(DIVisitor *Visitor) { + DerivedTypeDesc::ApplyToFields(Visitor); + + Visitor->Apply(Elements); +} + +/// getDescString - Return a string used to compose global names and labels. +/// +const char *CompositeTypeDesc::getDescString() const { + return "llvm.dbg.compositetype"; +} + +/// getTypeString - Return a string used to label this descriptor's type. +/// +const char *CompositeTypeDesc::getTypeString() const { + return "llvm.dbg.compositetype.type"; +} + +#ifndef NDEBUG +void CompositeTypeDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << "), " + << "Context(" << getContext() << "), " + << "Name(\"" << getName() << "\"), " + << "Size(" << getSize() << "), " + << "File(" << getFile() << "), " + << "Line(" << getLine() << "), " + << "FromType(" << getFromType() << "), " + << "Elements.size(" << Elements.size() << ")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + +SubrangeDesc::SubrangeDesc() +: 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) { + DebugInfoDesc::ApplyToFields(Visitor); + + Visitor->Apply(Lo); + Visitor->Apply(Hi); +} + +/// getDescString - Return a string used to compose global names and labels. +/// +const char *SubrangeDesc::getDescString() const { + return "llvm.dbg.subrange"; +} + +/// getTypeString - Return a string used to label this descriptor's type. +/// +const char *SubrangeDesc::getTypeString() const { + return "llvm.dbg.subrange.type"; +} + +#ifndef NDEBUG +void SubrangeDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << "), " + << "Lo(" << Lo << "), " + << "Hi(" << Hi << ")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + +EnumeratorDesc::EnumeratorDesc() +: DebugInfoDesc(DW_TAG_enumerator) +, Name("") +, Value(0) +{} + +// Implement isa/cast/dyncast. +bool EnumeratorDesc::classof(const DebugInfoDesc *D) { + return D->getTag() == DW_TAG_enumerator; +} + +/// ApplyToFields - Target the visitor to the fields of the EnumeratorDesc. +/// +void EnumeratorDesc::ApplyToFields(DIVisitor *Visitor) { + DebugInfoDesc::ApplyToFields(Visitor); + + Visitor->Apply(Name); + Visitor->Apply(Value); +} + +/// getDescString - Return a string used to compose global names and labels. +/// +const char *EnumeratorDesc::getDescString() const { + return "llvm.dbg.enumerator"; +} + +/// getTypeString - Return a string used to label this descriptor's type. +/// +const char *EnumeratorDesc::getTypeString() const { + return "llvm.dbg.enumerator.type"; +} + +#ifndef NDEBUG +void EnumeratorDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << "), " + << "Name(" << Name << "), " + << "Value(" << Value << ")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + +VariableDesc::VariableDesc(unsigned T) +: DebugInfoDesc(T) +, Context(NULL) +, Name("") +, File(NULL) +, Line(0) +, TyDesc(0) +{} + +// Implement isa/cast/dyncast. +bool VariableDesc::classof(const DebugInfoDesc *D) { + unsigned T = D->getTag(); + switch (T) { + case DW_TAG_auto_variable: + case DW_TAG_arg_variable: + case DW_TAG_return_variable: + return true; + default: break; + } + return false; +} + +/// ApplyToFields - Target the visitor to the fields of the VariableDesc. +/// +void VariableDesc::ApplyToFields(DIVisitor *Visitor) { + DebugInfoDesc::ApplyToFields(Visitor); + + Visitor->Apply(Context); + Visitor->Apply(Name); + Visitor->Apply(File); + Visitor->Apply(Line); + Visitor->Apply(TyDesc); +} + +/// getDescString - Return a string used to compose global names and labels. +/// +const char *VariableDesc::getDescString() const { + return "llvm.dbg.variable"; +} + +/// getTypeString - Return a string used to label this descriptor's type. +/// +const char *VariableDesc::getTypeString() const { + return "llvm.dbg.variable.type"; +} + +#ifndef NDEBUG +void VariableDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << "), " + << "Context(" << Context << "), " + << "Name(\"" << Name << "\"), " + << "File(" << File << "), " + << "Line(" << Line << "), " + << "TyDesc(" << TyDesc << ")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + +GlobalDesc::GlobalDesc(unsigned T) +: AnchoredDesc(T) +, Context(0) +, Name("") +, FullName("") +, LinkageName("") +, File(NULL) +, Line(0) +, TyDesc(NULL) +, IsStatic(false) +, IsDefinition(false) +{} + +/// ApplyToFields - Target the visitor to the fields of the global. +/// +void GlobalDesc::ApplyToFields(DIVisitor *Visitor) { + AnchoredDesc::ApplyToFields(Visitor); + + Visitor->Apply(Context); + Visitor->Apply(Name); + Visitor->Apply(FullName); + Visitor->Apply(LinkageName); + Visitor->Apply(File); + Visitor->Apply(Line); + Visitor->Apply(TyDesc); + Visitor->Apply(IsStatic); + Visitor->Apply(IsDefinition); +} + +//===----------------------------------------------------------------------===// + +GlobalVariableDesc::GlobalVariableDesc() +: 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) { + GlobalDesc::ApplyToFields(Visitor); + + Visitor->Apply(Global); +} + +/// getDescString - Return a string used to compose global names and labels. +/// +const char *GlobalVariableDesc::getDescString() const { + return "llvm.dbg.global_variable"; +} + +/// getTypeString - Return a string used to label this descriptors type. +/// +const char *GlobalVariableDesc::getTypeString() const { + return "llvm.dbg.global_variable.type"; +} + +/// getAnchorString - Return a string used to label this descriptor's anchor. +/// +const char *const GlobalVariableDesc::AnchorString = "llvm.dbg.global_variables"; +const char *GlobalVariableDesc::getAnchorString() const { + return AnchorString; +} + +#ifndef NDEBUG +void GlobalVariableDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << "), " + << "Anchor(" << getAnchor() << "), " + << "Name(\"" << getName() << "\"), " + << "FullName(\"" << getFullName() << "\"), " + << "LinkageName(\"" << getLinkageName() << "\"), " + << "File(" << getFile() << ")," + << "Line(" << getLine() << ")," + << "Type(" << getType() << "), " + << "IsStatic(" << (isStatic() ? "true" : "false") << "), " + << "IsDefinition(" << (isDefinition() ? "true" : "false") << "), " + << "Global(" << Global << ")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + +SubprogramDesc::SubprogramDesc() +: 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) { + GlobalDesc::ApplyToFields(Visitor); +} + +/// getDescString - Return a string used to compose global names and labels. +/// +const char *SubprogramDesc::getDescString() const { + return "llvm.dbg.subprogram"; +} + +/// getTypeString - Return a string used to label this descriptors type. +/// +const char *SubprogramDesc::getTypeString() const { + return "llvm.dbg.subprogram.type"; +} + +/// getAnchorString - Return a string used to label this descriptor's anchor. +/// +const char *const SubprogramDesc::AnchorString = "llvm.dbg.subprograms"; +const char *SubprogramDesc::getAnchorString() const { + return AnchorString; +} + +#ifndef NDEBUG +void SubprogramDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << "), " + << "Anchor(" << getAnchor() << "), " + << "Name(\"" << getName() << "\"), " + << "FullName(\"" << getFullName() << "\"), " + << "LinkageName(\"" << getLinkageName() << "\"), " + << "File(" << getFile() << ")," + << "Line(" << getLine() << ")," + << "Type(" << getType() << "), " + << "IsStatic(" << (isStatic() ? "true" : "false") << "), " + << "IsDefinition(" << (isDefinition() ? "true" : "false") << ")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + +BlockDesc::BlockDesc() +: DebugInfoDesc(DW_TAG_lexical_block) +, Context(NULL) +{} + +// Implement isa/cast/dyncast. +bool BlockDesc::classof(const DebugInfoDesc *D) { + return D->getTag() == DW_TAG_lexical_block; +} + +/// ApplyToFields - Target the visitor to the fields of the BlockDesc. +/// +void BlockDesc::ApplyToFields(DIVisitor *Visitor) { + DebugInfoDesc::ApplyToFields(Visitor); + + Visitor->Apply(Context); +} + +/// getDescString - Return a string used to compose global names and labels. +/// +const char *BlockDesc::getDescString() const { + return "llvm.dbg.block"; +} + +/// getTypeString - Return a string used to label this descriptors type. +/// +const char *BlockDesc::getTypeString() const { + return "llvm.dbg.block.type"; +} + +#ifndef NDEBUG +void BlockDesc::dump() { + cerr << getDescString() << " " + << "Version(" << getVersion() << "), " + << "Tag(" << getTag() << ")," + << "Context(" << Context << ")\n"; +} +#endif + +//===----------------------------------------------------------------------===// + DebugInfoDesc *DIDeserializer::Deserialize(Value *V) { return Deserialize(getGlobalVariable(V)); } @@ -505,7 +1289,8 @@ const PointerType *DISerializer::getEmptyStructPtrType() { if (EmptyStructPtrTy) return EmptyStructPtrTy; // Construct the pointer to empty structure type. - const StructType *EmptyStructTy = StructType::get(NULL, NULL); + const StructType *EmptyStructTy = + StructType::get(std::vector()); // Construct the pointer to empty structure type. EmptyStructPtrTy = PointerType::getUnqual(EmptyStructTy); @@ -522,7 +1307,6 @@ const StructType *DISerializer::getTagType(DebugInfoDesc *DD) { if (!Ty) { // Set up fields vector. std::vector Fields; - // Get types of fields. DIGetTypesVisitor GTAM(*this, Fields); GTAM.ApplyToFields(DD); @@ -580,9 +1364,8 @@ GlobalVariable *DISerializer::Serialize(DebugInfoDesc *DD) { const StructType *Ty = getTagType(DD); // Create the GlobalVariable early to prevent infinite recursion. - GlobalVariable *GV = - new GlobalVariable(Ty, true, DD->getLinkage(), - NULL, DD->getDescString(), M); + GlobalVariable *GV = new GlobalVariable(Ty, true, DD->getLinkage(), + NULL, DD->getDescString(), M); GV->setSection("llvm.metadata"); // Insert new GlobalVariable in DescGlobals map. @@ -590,11 +1373,10 @@ GlobalVariable *DISerializer::Serialize(DebugInfoDesc *DD) { // Set up elements vector std::vector Elements; - // Add fields. DISerializeVisitor SRAM(*this, Elements); SRAM.ApplyToFields(DD); - + // Set the globals initializer. GV->setInitializer(ConstantStruct::get(Ty, Elements)); @@ -707,8 +1489,8 @@ bool DIVerifier::isVerified(GlobalVariable *GV) { //===----------------------------------------------------------------------===// DebugScope::~DebugScope() { - for (unsigned i = 0, e = Scopes.size(); i < e; ++i) delete Scopes[i]; - for (unsigned i = 0, e = Variables.size(); i < e; ++i) delete Variables[i]; + for (unsigned i = 0, N = Scopes.size(); i < N; ++i) delete Scopes[i]; + for (unsigned j = 0, M = Variables.size(); j < M; ++j) delete Variables[j]; } //===----------------------------------------------------------------------===// @@ -811,12 +1593,11 @@ void MachineModuleInfo::AnalyzeModule(Module &M) { /// SetupCompileUnits - Set up the unique vector of compile units. /// void MachineModuleInfo::SetupCompileUnits(Module &M) { - std::vector CUList; - CompileUnitDesc CUD; - getAnchoredDescriptors(M, &CUD, CUList); + std::vectorCU = getAnchoredDescriptors(M); - for (unsigned i = 0, e = CUList.size(); i < e; i++) - CompileUnits.insert((CompileUnitDesc*)CUList[i]); + for (unsigned i = 0, N = CU.size(); i < N; i++) { + CompileUnits.insert(CU[i]); + } } /// getCompileUnits - Return a vector of debug compile units. @@ -825,31 +1606,12 @@ const UniqueVector MachineModuleInfo::getCompileUnits()const{ return CompileUnits; } -/// getAnchoredDescriptors - Return a vector of anchored debug descriptors. -/// -void -MachineModuleInfo::getAnchoredDescriptors(Module &M, const AnchoredDesc *Desc, - std::vector &AnchoredDescs) { - std::vector Globals; - getGlobalVariablesUsing(M, Desc->getAnchorString(), Globals); - - for (unsigned i = 0, e = Globals.size(); i < e; ++i) { - GlobalVariable *GV = Globals[i]; - - // FIXME - In the short term, changes are too drastic to continue. - if (DebugInfoDesc::TagFromGlobal(GV) == Desc->getTag() && - DebugInfoDesc::VersionFromGlobal(GV) == LLVMDebugVersion) - AnchoredDescs.push_back(DR.Deserialize(GV)); - } -} - /// getGlobalVariablesUsing - Return all of the GlobalVariables that use the /// named GlobalVariable. -void +std::vector MachineModuleInfo::getGlobalVariablesUsing(Module &M, - const std::string &RootName, - std::vector &Globals) { - return ::getGlobalVariablesUsing(M, RootName, Globals); + const std::string &RootName) { + return ::getGlobalVariablesUsing(M, RootName); } /// RecordSourceLine - Records location information and associates it with a @@ -935,10 +1697,9 @@ DebugScope *MachineModuleInfo::getOrCreateScope(DebugInfoDesc *ScopeDesc) { /// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the /// specified MachineBasicBlock. -LandingPadInfo & -MachineModuleInfo::getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad) { +LandingPadInfo &MachineModuleInfo::getOrCreateLandingPadInfo + (MachineBasicBlock *LandingPad) { unsigned N = LandingPads.size(); - for (unsigned i = 0; i < N; ++i) { LandingPadInfo &LP = LandingPads[i]; if (LP.LandingPadBlock == LandingPad) @@ -974,7 +1735,7 @@ void MachineModuleInfo::addPersonality(MachineBasicBlock *LandingPad, LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); LP.Personality = Personality; - for (unsigned i = 0, e = Personalities.size(); i < e; ++i) + for (unsigned i = 0; i < Personalities.size(); ++i) if (Personalities[i] == Personality) return; @@ -995,12 +1756,9 @@ void MachineModuleInfo::addCatchTypeInfo(MachineBasicBlock *LandingPad, void MachineModuleInfo::addFilterTypeInfo(MachineBasicBlock *LandingPad, std::vector &TyInfo) { LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); - unsigned TyInfoSize = TyInfo.size(); - std::vector IdsInFilter(TyInfoSize); - - for (unsigned I = 0; I != TyInfoSize; ++I) + std::vector IdsInFilter (TyInfo.size()); + for (unsigned I = 0, E = TyInfo.size(); I != E; ++I) IdsInFilter[I] = getTypeIDFor(TyInfo[I]); - LP.TypeIds.push_back(getFilterIDFor(IdsInFilter)); } @@ -1025,7 +1783,7 @@ void MachineModuleInfo::TidyLandingPads() { continue; } - for (unsigned j = 0; j != LandingPads[i].BeginLabels.size(); ) { + for (unsigned j=0; j != LandingPads[i].BeginLabels.size(); ) { unsigned BeginLabel = MappedLabel(LandingPad.BeginLabels[j]); unsigned EndLabel = MappedLabel(LandingPad.EndLabels[j]); @@ -1059,9 +1817,8 @@ void MachineModuleInfo::TidyLandingPads() { /// getTypeIDFor - Return the type id for the specified typeinfo. This is /// function wide. unsigned MachineModuleInfo::getTypeIDFor(GlobalVariable *TI) { - for (unsigned i = 0, e = TypeInfos.size(); i != e; ++i) - if (TypeInfos[i] == TI) - return i + 1; + for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i) + if (TypeInfos[i] == TI) return i + 1; TypeInfos.push_back(TI); return TypeInfos.size(); @@ -1091,10 +1848,8 @@ try_next:; // Add the new filter. int FilterID = -(1 + FilterIds.size()); FilterIds.reserve(FilterIds.size() + TyIds.size() + 1); - for (unsigned I = 0, N = TyIds.size(); I != N; ++I) FilterIds.push_back(TyIds[I]); - FilterEnds.push_back(FilterIds.size()); FilterIds.push_back(0); // terminator return FilterID; @@ -1113,15 +1868,16 @@ unsigned MachineModuleInfo::getPersonalityIndex() const { const Function* Personality = NULL; // Scan landing pads. If there is at least one non-NULL personality - use it. - for (unsigned i = 0, e = LandingPads.size(); i != e; ++i) + for (unsigned i = 0; i != LandingPads.size(); ++i) if (LandingPads[i].Personality) { Personality = LandingPads[i].Personality; break; } - for (unsigned i = 0, e = Personalities.size(); i < e; ++i) + for (unsigned i = 0; i < Personalities.size(); ++i) { if (Personalities[i] == Personality) return i; + } // This should never happen assert(0 && "Personality function should be set!"); @@ -1193,3 +1949,4 @@ bool DebugLabelFolder::runOnMachineFunction(MachineFunction &MF) { FunctionPass *createDebugLabelFoldingPass() { return new DebugLabelFolder(); } } + diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp index 4f67dd4a2275..0565e16eee09 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp @@ -27,7 +27,6 @@ #include "llvm/IntrinsicInst.h" #include "llvm/ParameterAttributes.h" #include "llvm/CodeGen/Collector.h" -#include "llvm/CodeGen/MachineDebugInfoDesc.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/MachineInstrBuilder.h" diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp index c0311911d330..db119a649549 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp @@ -18,7 +18,7 @@ #include "llvm/CodeGen/ScheduleDAG.h" #include "llvm/CodeGen/MachineConstantPool.h" #include "llvm/CodeGen/MachineFunction.h" -#include "llvm/CodeGen/MachineDebugInfoDesc.h" +#include "llvm/CodeGen/MachineModuleInfo.h" #include "llvm/Target/TargetRegisterInfo.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Support/GraphWriter.h" diff --git a/llvm/lib/VMCore/IntrinsicInst.cpp b/llvm/lib/VMCore/IntrinsicInst.cpp index 6bd9431767e0..312a47f2c70c 100644 --- a/llvm/lib/VMCore/IntrinsicInst.cpp +++ b/llvm/lib/VMCore/IntrinsicInst.cpp @@ -29,7 +29,6 @@ #include "llvm/Constants.h" #include "llvm/GlobalVariable.h" #include "llvm/Analysis/ValueTracking.h" -#include "llvm/CodeGen/MachineDebugInfoDesc.h" #include "llvm/CodeGen/MachineModuleInfo.h" using namespace llvm;