RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-11-23 19:59:57 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert my previous check-in that split up MachineModuleInfo. It turns out to

Browse Source 
slow the compiler down at -O0 some 30% or more. Ooops.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@53120 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling 2008-07-03 22:53:42 +00:00
parent a93ae711a9
commit 10fff6078a
8 changed files with 1522 additions and 1370 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

707
include/llvm/CodeGen/MachineDebugInfoDesc.h
View File

@ -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 <string>
#include <vector>
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<AnchorDesc *>(Anchor); }
void setAnchor(AnchorDesc *A) { Anchor = static_cast<DebugInfoDesc *>(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<CompileUnitDesc *>(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<DebugInfoDesc *>(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<TypeDesc *>(FromType);
}
void setFromType(TypeDesc *F) {
FromType = static_cast<DebugInfoDesc *>(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<DebugInfoDesc *> Elements; // Information used to compose type.
public:
explicit CompositeTypeDesc(unsigned T);
// Accessors
std::vector<DebugInfoDesc *> &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<CompileUnitDesc *>(File);
}
unsigned getLine() const { return Line; }
TypeDesc *getType() const {
return static_cast<TypeDesc*>(TyDesc);
}
void setContext(DebugInfoDesc *C) { Context = C; }
void setName(const std::string &N) { Name = N; }
void setFile(CompileUnitDesc *U) {
File = static_cast<DebugInfoDesc *>(U);
}
void setLine(unsigned L) { Line = L; }
void setType(TypeDesc *T) {
TyDesc = static_cast<DebugInfoDesc *>(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<CompileUnitDesc *>(File);
}
unsigned getLine() const { return Line; }
TypeDesc *getType() const {
return static_cast<TypeDesc *>(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<DebugInfoDesc *>(U);
}
void setLine(unsigned L) { Line = L; }
void setType(TypeDesc *T) {
TyDesc = static_cast<DebugInfoDesc *>(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

704
include/llvm/CodeGen/MachineModuleInfo.h
View File

@ -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<DebugInfoDesc *> &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<AnchorDesc *>(Anchor); }
void setAnchor(AnchorDesc *A) { Anchor = static_cast<DebugInfoDesc *>(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<CompileUnitDesc *>(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<DebugInfoDesc *>(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<TypeDesc *>(FromType);
}
void setFromType(TypeDesc *F) {
FromType = static_cast<DebugInfoDesc *>(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<DebugInfoDesc *> Elements;// Information used to compose type.
public:
explicit CompositeTypeDesc(unsigned T);
// Accessors
std::vector<DebugInfoDesc *> &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<CompileUnitDesc *>(File);
}
unsigned getLine() const { return Line; }
TypeDesc *getType() const {
return static_cast<TypeDesc *>(TyDesc);
}
void setContext(DebugInfoDesc *C) { Context = C; }
void setName(const std::string &N) { Name = N; }
void setFile(CompileUnitDesc *U) {
File = static_cast<DebugInfoDesc *>(U);
}
void setLine(unsigned L) { Line = L; }
void setType(TypeDesc *T) {
TyDesc = static_cast<DebugInfoDesc *>(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<CompileUnitDesc *>(File);
}
unsigned getLine() const { return Line; }
TypeDesc *getType() const {
return static_cast<TypeDesc *>(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<DebugInfoDesc *>(U);
}
void setLine(unsigned L) { Line = L; }
void setType(TypeDesc *T) {
TyDesc = static_cast<DebugInfoDesc *>(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<GlobalVariable*> &Result);
std::vector<GlobalVariable*>
getGlobalVariablesUsing(Module &M, const std::string &RootName);
/// getAnchoredDescriptors - Return a vector of anchored debug descriptors.
///
void getAnchoredDescriptors(Module &M, const AnchoredDesc *Desc,
std::vector<void*> &AnchoredDescs);
template <class T>std::vector<T *> getAnchoredDescriptors(Module &M) {
T Desc;
std::vector<GlobalVariable *> Globals =
getGlobalVariablesUsing(M, Desc.getAnchorString());
std::vector<T *> 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<T>(DR.Deserialize(GV)));
}
}
return AnchoredDescs;
}
/// RecordRegionStart - Indicate the start of a region.
///

23
lib/CodeGen/DwarfWriter.cpp
View File

@ -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<void*> GlobalVariables;
GlobalVariableDesc GVD;
MMI->getAnchoredDescriptors(*M, &GVD, GlobalVariables);
std::vector<GlobalVariableDesc *> GlobalVariables =
MMI->getAnchoredDescriptors<GlobalVariableDesc>(*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<void*> Subprograms;
SubprogramDesc SPD;
MMI->getAnchoredDescriptors(*M, &SPD, Subprograms);
std::vector<SubprogramDesc *> Subprograms =
MMI->getAnchoredDescriptors<SubprogramDesc>(*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:

575
lib/CodeGen/MachineDebugInfoDesc.cpp
View File

@ -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<ConstantStruct>(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<ConstantInt>(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

879
lib/CodeGen/MachineModuleInfo.cpp
View File

File diff suppressed because it is too large Load Diff

1
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
View File

@ -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"

2
lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp
View File

@ -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"

1
lib/VMCore/IntrinsicInst.cpp
View File

@ -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;