mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-01 19:29:22 +00:00
information output. However, many target specific tool chains prefer to encode only one compile unit in an object file. In this situation, the LLVM code generator will include debugging information entities in the compile unit that is marked as main compile unit. The code generator accepts maximum one main compile unit per module. If a module does not contain any main compile unit then the code generator will emit multiple compile units in the output object file. [Part 1] Update DebugInfo APIs to accept optional boolean value while creating DICompileUnit to mark the unit as "main" unit. By defaults all units are considered non-main. Update SourceLevelDebugging.html to document "main" compile unit. Update DebugInfo APIs to not accept and encode separate source file/directory entries while creating various llvm.dbg.* entities. There was a recent, yet to be documented, change to include this additional information so no documentation changes are required here. Update DwarfDebug to handle "main" compile unit. If "main" compile unit is seen then all DIEs are inserted into "main" compile unit. All other compile units are used to find source location for llvm.dbg.* values. If there is not any "main" compile unit then create unique compile unit DIEs for each llvm.dbg.compile_unit. [Part 2] Create separate llvm.dbg.compile_unit for each input file. Mark compile unit create for main_input_filename as "main" compile unit. Use appropriate compile unit, based on source location information collected from the tree node, while creating llvm.dbg.* values using DebugInfo APIs. --- This is Part 1. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@63400 91177308-0d34-0410-b5e6-96231b3b80d8
950 lines
33 KiB
C++
950 lines
33 KiB
C++
//===--- DebugInfo.cpp - Debug Information Helper Classes -----------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the helper classes used to build and interpret debug
|
|
// information in LLVM IR form.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Analysis/DebugInfo.h"
|
|
#include "llvm/Constants.h"
|
|
#include "llvm/DerivedTypes.h"
|
|
#include "llvm/Intrinsics.h"
|
|
#include "llvm/IntrinsicInst.h"
|
|
#include "llvm/Instructions.h"
|
|
#include "llvm/Module.h"
|
|
#include "llvm/Analysis/ValueTracking.h"
|
|
#include "llvm/Support/Streams.h"
|
|
using namespace llvm;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// DIDescriptor
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
DIDescriptor::DIDescriptor(GlobalVariable *gv, unsigned RequiredTag) {
|
|
GV = gv;
|
|
|
|
// If this is non-null, check to see if the Tag matches. If not, set to null.
|
|
if (GV && getTag() != RequiredTag)
|
|
GV = 0;
|
|
}
|
|
|
|
|
|
std::string DIDescriptor::getStringField(unsigned Elt) const {
|
|
if (GV == 0) return "";
|
|
Constant *C = GV->getInitializer();
|
|
if (C == 0 || Elt >= C->getNumOperands())
|
|
return "";
|
|
|
|
std::string Result;
|
|
// Fills in the string if it succeeds
|
|
if (!GetConstantStringInfo(C->getOperand(Elt), Result))
|
|
Result.clear();
|
|
return Result;
|
|
}
|
|
|
|
uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const {
|
|
if (GV == 0) return 0;
|
|
Constant *C = GV->getInitializer();
|
|
if (C == 0 || Elt >= C->getNumOperands())
|
|
return 0;
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(C->getOperand(Elt)))
|
|
return CI->getZExtValue();
|
|
return 0;
|
|
}
|
|
|
|
|
|
DIDescriptor DIDescriptor::getDescriptorField(unsigned Elt) const {
|
|
if (GV == 0) return DIDescriptor();
|
|
Constant *C = GV->getInitializer();
|
|
if (C == 0 || Elt >= C->getNumOperands())
|
|
return DIDescriptor();
|
|
C = C->getOperand(Elt);
|
|
return DIDescriptor(dyn_cast<GlobalVariable>(C->stripPointerCasts()));
|
|
}
|
|
|
|
GlobalVariable *DIDescriptor::getGlobalVariableField(unsigned Elt) const {
|
|
if (GV == 0) return 0;
|
|
Constant *C = GV->getInitializer();
|
|
if (C == 0 || Elt >= C->getNumOperands())
|
|
return 0;
|
|
C = C->getOperand(Elt);
|
|
|
|
return dyn_cast<GlobalVariable>(C->stripPointerCasts());
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Simple Descriptor Constructors and other Methods
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
DIAnchor::DIAnchor(GlobalVariable *GV)
|
|
: DIDescriptor(GV, dwarf::DW_TAG_anchor) {}
|
|
DIEnumerator::DIEnumerator(GlobalVariable *GV)
|
|
: DIDescriptor(GV, dwarf::DW_TAG_enumerator) {}
|
|
DISubrange::DISubrange(GlobalVariable *GV)
|
|
: DIDescriptor(GV, dwarf::DW_TAG_subrange_type) {}
|
|
DICompileUnit::DICompileUnit(GlobalVariable *GV)
|
|
: DIDescriptor(GV, dwarf::DW_TAG_compile_unit) {}
|
|
DIBasicType::DIBasicType(GlobalVariable *GV)
|
|
: DIType(GV, dwarf::DW_TAG_base_type) {}
|
|
DISubprogram::DISubprogram(GlobalVariable *GV)
|
|
: DIGlobal(GV, dwarf::DW_TAG_subprogram) {}
|
|
DIGlobalVariable::DIGlobalVariable(GlobalVariable *GV)
|
|
: DIGlobal(GV, dwarf::DW_TAG_variable) {}
|
|
DIBlock::DIBlock(GlobalVariable *GV)
|
|
: DIDescriptor(GV, dwarf::DW_TAG_lexical_block) {}
|
|
// needed by DIVariable::getType()
|
|
DIType::DIType(GlobalVariable *gv) : DIDescriptor(gv) {
|
|
if (!gv) return;
|
|
unsigned tag = getTag();
|
|
if (tag != dwarf::DW_TAG_base_type && !DIDerivedType::isDerivedType(tag) &&
|
|
!DICompositeType::isCompositeType(tag))
|
|
GV = 0;
|
|
}
|
|
|
|
/// isDerivedType - Return true if the specified tag is legal for
|
|
/// DIDerivedType.
|
|
bool DIType::isDerivedType(unsigned Tag) {
|
|
switch (Tag) {
|
|
case dwarf::DW_TAG_typedef:
|
|
case dwarf::DW_TAG_pointer_type:
|
|
case dwarf::DW_TAG_reference_type:
|
|
case dwarf::DW_TAG_const_type:
|
|
case dwarf::DW_TAG_volatile_type:
|
|
case dwarf::DW_TAG_restrict_type:
|
|
case dwarf::DW_TAG_member:
|
|
case dwarf::DW_TAG_inheritance:
|
|
return true;
|
|
default:
|
|
// FIXME: Even though it doesn't make sense, CompositeTypes are current
|
|
// modelled as DerivedTypes, this should return true for them as well.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
DIDerivedType::DIDerivedType(GlobalVariable *GV) : DIType(GV, true, true) {
|
|
if (GV && !isDerivedType(getTag()))
|
|
GV = 0;
|
|
}
|
|
|
|
/// isCompositeType - Return true if the specified tag is legal for
|
|
/// DICompositeType.
|
|
bool DIType::isCompositeType(unsigned TAG) {
|
|
switch (TAG) {
|
|
case dwarf::DW_TAG_array_type:
|
|
case dwarf::DW_TAG_structure_type:
|
|
case dwarf::DW_TAG_union_type:
|
|
case dwarf::DW_TAG_enumeration_type:
|
|
case dwarf::DW_TAG_vector_type:
|
|
case dwarf::DW_TAG_subroutine_type:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
DICompositeType::DICompositeType(GlobalVariable *GV)
|
|
: DIDerivedType(GV, true, true) {
|
|
if (GV && !isCompositeType(getTag()))
|
|
GV = 0;
|
|
}
|
|
|
|
/// isVariable - Return true if the specified tag is legal for DIVariable.
|
|
bool DIVariable::isVariable(unsigned Tag) {
|
|
switch (Tag) {
|
|
case dwarf::DW_TAG_auto_variable:
|
|
case dwarf::DW_TAG_arg_variable:
|
|
case dwarf::DW_TAG_return_variable:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
DIVariable::DIVariable(GlobalVariable *GV) : DIDescriptor(GV) {
|
|
if (GV && !isVariable(getTag()))
|
|
GV = 0;
|
|
}
|
|
|
|
unsigned DIArray::getNumElements() const {
|
|
assert (GV && "Invalid DIArray");
|
|
Constant *C = GV->getInitializer();
|
|
assert (C && "Invalid DIArray initializer");
|
|
return C->getNumOperands();
|
|
}
|
|
|
|
/// Verify - Verify that a compile unit is well formed.
|
|
bool DICompileUnit::Verify() const {
|
|
if (isNull())
|
|
return false;
|
|
if (getFilename().empty())
|
|
return false;
|
|
// It is possible that directory and produce string is empty.
|
|
return true;
|
|
}
|
|
|
|
/// Verify - Verify that a type descriptor is well formed.
|
|
bool DIType::Verify() const {
|
|
if (isNull())
|
|
return false;
|
|
if (getContext().isNull())
|
|
return false;
|
|
|
|
DICompileUnit CU = getCompileUnit();
|
|
if (!CU.isNull() && !CU.Verify())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/// Verify - Verify that a composite type descriptor is well formed.
|
|
bool DICompositeType::Verify() const {
|
|
if (isNull())
|
|
return false;
|
|
if (getContext().isNull())
|
|
return false;
|
|
|
|
DICompileUnit CU = getCompileUnit();
|
|
if (!CU.isNull() && !CU.Verify())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/// Verify - Verify that a subprogram descriptor is well formed.
|
|
bool DISubprogram::Verify() const {
|
|
if (isNull())
|
|
return false;
|
|
|
|
if (getContext().isNull())
|
|
return false;
|
|
|
|
DICompileUnit CU = getCompileUnit();
|
|
if (!CU.Verify())
|
|
return false;
|
|
|
|
DICompositeType Ty = getType();
|
|
if (!Ty.isNull() && !Ty.Verify())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/// Verify - Verify that a global variable descriptor is well formed.
|
|
bool DIGlobalVariable::Verify() const {
|
|
if (isNull())
|
|
return false;
|
|
|
|
if (getContext().isNull())
|
|
return false;
|
|
|
|
DICompileUnit CU = getCompileUnit();
|
|
if (!CU.Verify())
|
|
return false;
|
|
|
|
DIType Ty = getType();
|
|
if (!Ty.Verify())
|
|
return false;
|
|
|
|
if (!getGlobal())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/// Verify - Verify that a variable descriptor is well formed.
|
|
bool DIVariable::Verify() const {
|
|
if (isNull())
|
|
return false;
|
|
|
|
if (getContext().isNull())
|
|
return false;
|
|
|
|
DIType Ty = getType();
|
|
if (!Ty.Verify())
|
|
return false;
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// DIFactory: Basic Helpers
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
DIFactory::DIFactory(Module &m) : M(m) {
|
|
StopPointFn = FuncStartFn = RegionStartFn = RegionEndFn = DeclareFn = 0;
|
|
EmptyStructPtr = PointerType::getUnqual(StructType::get(NULL, NULL));
|
|
}
|
|
|
|
/// getCastToEmpty - Return this descriptor as a Constant* with type '{}*'.
|
|
/// This is only valid when the descriptor is non-null.
|
|
Constant *DIFactory::getCastToEmpty(DIDescriptor D) {
|
|
if (D.isNull()) return Constant::getNullValue(EmptyStructPtr);
|
|
return ConstantExpr::getBitCast(D.getGV(), EmptyStructPtr);
|
|
}
|
|
|
|
Constant *DIFactory::GetTagConstant(unsigned TAG) {
|
|
assert((TAG & LLVMDebugVersionMask) == 0 &&
|
|
"Tag too large for debug encoding!");
|
|
return ConstantInt::get(Type::Int32Ty, TAG | LLVMDebugVersion);
|
|
}
|
|
|
|
Constant *DIFactory::GetStringConstant(const std::string &String) {
|
|
// Check string cache for previous edition.
|
|
Constant *&Slot = StringCache[String];
|
|
|
|
// Return Constant if previously defined.
|
|
if (Slot) return Slot;
|
|
|
|
const PointerType *DestTy = PointerType::getUnqual(Type::Int8Ty);
|
|
|
|
// If empty string then use a sbyte* null instead.
|
|
if (String.empty())
|
|
return Slot = ConstantPointerNull::get(DestTy);
|
|
|
|
// Construct string as an llvm constant.
|
|
Constant *ConstStr = ConstantArray::get(String);
|
|
|
|
// Otherwise create and return a new string global.
|
|
GlobalVariable *StrGV = new GlobalVariable(ConstStr->getType(), true,
|
|
GlobalVariable::InternalLinkage,
|
|
ConstStr, ".str", &M);
|
|
StrGV->setSection("llvm.metadata");
|
|
return Slot = ConstantExpr::getBitCast(StrGV, DestTy);
|
|
}
|
|
|
|
/// GetOrCreateAnchor - Look up an anchor for the specified tag and name. If it
|
|
/// already exists, return it. If not, create a new one and return it.
|
|
DIAnchor DIFactory::GetOrCreateAnchor(unsigned TAG, const char *Name) {
|
|
const Type *EltTy = StructType::get(Type::Int32Ty, Type::Int32Ty, NULL);
|
|
|
|
// Otherwise, create the global or return it if already in the module.
|
|
Constant *C = M.getOrInsertGlobal(Name, EltTy);
|
|
assert(isa<GlobalVariable>(C) && "Incorrectly typed anchor?");
|
|
GlobalVariable *GV = cast<GlobalVariable>(C);
|
|
|
|
// If it has an initializer, it is already in the module.
|
|
if (GV->hasInitializer())
|
|
return SubProgramAnchor = DIAnchor(GV);
|
|
|
|
GV->setLinkage(GlobalValue::LinkOnceLinkage);
|
|
GV->setSection("llvm.metadata");
|
|
GV->setConstant(true);
|
|
M.addTypeName("llvm.dbg.anchor.type", EltTy);
|
|
|
|
// Otherwise, set the initializer.
|
|
Constant *Elts[] = {
|
|
GetTagConstant(dwarf::DW_TAG_anchor),
|
|
ConstantInt::get(Type::Int32Ty, TAG)
|
|
};
|
|
|
|
GV->setInitializer(ConstantStruct::get(Elts, 2));
|
|
return DIAnchor(GV);
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// DIFactory: Primary Constructors
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// GetOrCreateCompileUnitAnchor - Return the anchor for compile units,
|
|
/// creating a new one if there isn't already one in the module.
|
|
DIAnchor DIFactory::GetOrCreateCompileUnitAnchor() {
|
|
// If we already created one, just return it.
|
|
if (!CompileUnitAnchor.isNull())
|
|
return CompileUnitAnchor;
|
|
return CompileUnitAnchor = GetOrCreateAnchor(dwarf::DW_TAG_compile_unit,
|
|
"llvm.dbg.compile_units");
|
|
}
|
|
|
|
/// GetOrCreateSubprogramAnchor - Return the anchor for subprograms,
|
|
/// creating a new one if there isn't already one in the module.
|
|
DIAnchor DIFactory::GetOrCreateSubprogramAnchor() {
|
|
// If we already created one, just return it.
|
|
if (!SubProgramAnchor.isNull())
|
|
return SubProgramAnchor;
|
|
return SubProgramAnchor = GetOrCreateAnchor(dwarf::DW_TAG_subprogram,
|
|
"llvm.dbg.subprograms");
|
|
}
|
|
|
|
/// GetOrCreateGlobalVariableAnchor - Return the anchor for globals,
|
|
/// creating a new one if there isn't already one in the module.
|
|
DIAnchor DIFactory::GetOrCreateGlobalVariableAnchor() {
|
|
// If we already created one, just return it.
|
|
if (!GlobalVariableAnchor.isNull())
|
|
return GlobalVariableAnchor;
|
|
return GlobalVariableAnchor = GetOrCreateAnchor(dwarf::DW_TAG_variable,
|
|
"llvm.dbg.global_variables");
|
|
}
|
|
|
|
/// GetOrCreateArray - Create an descriptor for an array of descriptors.
|
|
/// This implicitly uniques the arrays created.
|
|
DIArray DIFactory::GetOrCreateArray(DIDescriptor *Tys, unsigned NumTys) {
|
|
SmallVector<Constant*, 16> Elts;
|
|
|
|
for (unsigned i = 0; i != NumTys; ++i)
|
|
Elts.push_back(getCastToEmpty(Tys[i]));
|
|
|
|
Constant *Init = ConstantArray::get(ArrayType::get(EmptyStructPtr,
|
|
Elts.size()),
|
|
&Elts[0], Elts.size());
|
|
// If we already have this array, just return the uniqued version.
|
|
DIDescriptor &Entry = SimpleConstantCache[Init];
|
|
if (!Entry.isNull()) return DIArray(Entry.getGV());
|
|
|
|
GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
|
|
GlobalValue::InternalLinkage,
|
|
Init, "llvm.dbg.array", &M);
|
|
GV->setSection("llvm.metadata");
|
|
Entry = DIDescriptor(GV);
|
|
return DIArray(GV);
|
|
}
|
|
|
|
/// GetOrCreateSubrange - Create a descriptor for a value range. This
|
|
/// implicitly uniques the values returned.
|
|
DISubrange DIFactory::GetOrCreateSubrange(int64_t Lo, int64_t Hi) {
|
|
Constant *Elts[] = {
|
|
GetTagConstant(dwarf::DW_TAG_subrange_type),
|
|
ConstantInt::get(Type::Int64Ty, Lo),
|
|
ConstantInt::get(Type::Int64Ty, Hi)
|
|
};
|
|
|
|
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
|
|
|
|
// If we already have this range, just return the uniqued version.
|
|
DIDescriptor &Entry = SimpleConstantCache[Init];
|
|
if (!Entry.isNull()) return DISubrange(Entry.getGV());
|
|
|
|
M.addTypeName("llvm.dbg.subrange.type", Init->getType());
|
|
|
|
GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
|
|
GlobalValue::InternalLinkage,
|
|
Init, "llvm.dbg.subrange", &M);
|
|
GV->setSection("llvm.metadata");
|
|
Entry = DIDescriptor(GV);
|
|
return DISubrange(GV);
|
|
}
|
|
|
|
|
|
|
|
/// CreateCompileUnit - Create a new descriptor for the specified compile
|
|
/// unit. Note that this does not unique compile units within the module.
|
|
DICompileUnit DIFactory::CreateCompileUnit(unsigned LangID,
|
|
const std::string &Filename,
|
|
const std::string &Directory,
|
|
const std::string &Producer,
|
|
bool isMain,
|
|
bool isOptimized,
|
|
const char *Flags) {
|
|
Constant *Elts[] = {
|
|
GetTagConstant(dwarf::DW_TAG_compile_unit),
|
|
getCastToEmpty(GetOrCreateCompileUnitAnchor()),
|
|
ConstantInt::get(Type::Int32Ty, LangID),
|
|
GetStringConstant(Filename),
|
|
GetStringConstant(Directory),
|
|
GetStringConstant(Producer),
|
|
ConstantInt::get(Type::Int1Ty, isMain),
|
|
ConstantInt::get(Type::Int1Ty, isOptimized),
|
|
GetStringConstant(Flags)
|
|
};
|
|
|
|
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
|
|
|
|
M.addTypeName("llvm.dbg.compile_unit.type", Init->getType());
|
|
GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
|
|
GlobalValue::InternalLinkage,
|
|
Init, "llvm.dbg.compile_unit", &M);
|
|
GV->setSection("llvm.metadata");
|
|
return DICompileUnit(GV);
|
|
}
|
|
|
|
/// CreateEnumerator - Create a single enumerator value.
|
|
DIEnumerator DIFactory::CreateEnumerator(const std::string &Name, uint64_t Val){
|
|
Constant *Elts[] = {
|
|
GetTagConstant(dwarf::DW_TAG_enumerator),
|
|
GetStringConstant(Name),
|
|
ConstantInt::get(Type::Int64Ty, Val)
|
|
};
|
|
|
|
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
|
|
|
|
M.addTypeName("llvm.dbg.enumerator.type", Init->getType());
|
|
GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
|
|
GlobalValue::InternalLinkage,
|
|
Init, "llvm.dbg.enumerator", &M);
|
|
GV->setSection("llvm.metadata");
|
|
return DIEnumerator(GV);
|
|
}
|
|
|
|
|
|
/// CreateBasicType - Create a basic type like int, float, etc.
|
|
DIBasicType DIFactory::CreateBasicType(DIDescriptor Context,
|
|
const std::string &Name,
|
|
DICompileUnit CompileUnit,
|
|
unsigned LineNumber,
|
|
uint64_t SizeInBits,
|
|
uint64_t AlignInBits,
|
|
uint64_t OffsetInBits, unsigned Flags,
|
|
unsigned Encoding) {
|
|
Constant *Elts[] = {
|
|
GetTagConstant(dwarf::DW_TAG_base_type),
|
|
getCastToEmpty(Context),
|
|
GetStringConstant(Name),
|
|
getCastToEmpty(CompileUnit),
|
|
ConstantInt::get(Type::Int32Ty, LineNumber),
|
|
ConstantInt::get(Type::Int64Ty, SizeInBits),
|
|
ConstantInt::get(Type::Int64Ty, AlignInBits),
|
|
ConstantInt::get(Type::Int64Ty, OffsetInBits),
|
|
ConstantInt::get(Type::Int32Ty, Flags),
|
|
ConstantInt::get(Type::Int32Ty, Encoding)
|
|
};
|
|
|
|
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
|
|
|
|
M.addTypeName("llvm.dbg.basictype.type", Init->getType());
|
|
GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
|
|
GlobalValue::InternalLinkage,
|
|
Init, "llvm.dbg.basictype", &M);
|
|
GV->setSection("llvm.metadata");
|
|
return DIBasicType(GV);
|
|
}
|
|
|
|
/// CreateDerivedType - Create a derived type like const qualified type,
|
|
/// pointer, typedef, etc.
|
|
DIDerivedType DIFactory::CreateDerivedType(unsigned Tag,
|
|
DIDescriptor Context,
|
|
const std::string &Name,
|
|
DICompileUnit CompileUnit,
|
|
unsigned LineNumber,
|
|
uint64_t SizeInBits,
|
|
uint64_t AlignInBits,
|
|
uint64_t OffsetInBits,
|
|
unsigned Flags,
|
|
DIType DerivedFrom) {
|
|
Constant *Elts[] = {
|
|
GetTagConstant(Tag),
|
|
getCastToEmpty(Context),
|
|
GetStringConstant(Name),
|
|
getCastToEmpty(CompileUnit),
|
|
ConstantInt::get(Type::Int32Ty, LineNumber),
|
|
ConstantInt::get(Type::Int64Ty, SizeInBits),
|
|
ConstantInt::get(Type::Int64Ty, AlignInBits),
|
|
ConstantInt::get(Type::Int64Ty, OffsetInBits),
|
|
ConstantInt::get(Type::Int32Ty, Flags),
|
|
getCastToEmpty(DerivedFrom)
|
|
};
|
|
|
|
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
|
|
|
|
M.addTypeName("llvm.dbg.derivedtype.type", Init->getType());
|
|
GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
|
|
GlobalValue::InternalLinkage,
|
|
Init, "llvm.dbg.derivedtype", &M);
|
|
GV->setSection("llvm.metadata");
|
|
return DIDerivedType(GV);
|
|
}
|
|
|
|
/// CreateCompositeType - Create a composite type like array, struct, etc.
|
|
DICompositeType DIFactory::CreateCompositeType(unsigned Tag,
|
|
DIDescriptor Context,
|
|
const std::string &Name,
|
|
DICompileUnit CompileUnit,
|
|
unsigned LineNumber,
|
|
uint64_t SizeInBits,
|
|
uint64_t AlignInBits,
|
|
uint64_t OffsetInBits,
|
|
unsigned Flags,
|
|
DIType DerivedFrom,
|
|
DIArray Elements) {
|
|
|
|
Constant *Elts[] = {
|
|
GetTagConstant(Tag),
|
|
getCastToEmpty(Context),
|
|
GetStringConstant(Name),
|
|
getCastToEmpty(CompileUnit),
|
|
ConstantInt::get(Type::Int32Ty, LineNumber),
|
|
ConstantInt::get(Type::Int64Ty, SizeInBits),
|
|
ConstantInt::get(Type::Int64Ty, AlignInBits),
|
|
ConstantInt::get(Type::Int64Ty, OffsetInBits),
|
|
ConstantInt::get(Type::Int32Ty, Flags),
|
|
getCastToEmpty(DerivedFrom),
|
|
getCastToEmpty(Elements)
|
|
};
|
|
|
|
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
|
|
|
|
M.addTypeName("llvm.dbg.composite.type", Init->getType());
|
|
GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
|
|
GlobalValue::InternalLinkage,
|
|
Init, "llvm.dbg.composite", &M);
|
|
GV->setSection("llvm.metadata");
|
|
return DICompositeType(GV);
|
|
}
|
|
|
|
|
|
/// CreateSubprogram - Create a new descriptor for the specified subprogram.
|
|
/// See comments in DISubprogram for descriptions of these fields. This
|
|
/// method does not unique the generated descriptors.
|
|
DISubprogram DIFactory::CreateSubprogram(DIDescriptor Context,
|
|
const std::string &Name,
|
|
const std::string &DisplayName,
|
|
const std::string &LinkageName,
|
|
DICompileUnit CompileUnit,
|
|
unsigned LineNo, DIType Type,
|
|
bool isLocalToUnit,
|
|
bool isDefinition) {
|
|
|
|
Constant *Elts[] = {
|
|
GetTagConstant(dwarf::DW_TAG_subprogram),
|
|
getCastToEmpty(GetOrCreateSubprogramAnchor()),
|
|
getCastToEmpty(Context),
|
|
GetStringConstant(Name),
|
|
GetStringConstant(DisplayName),
|
|
GetStringConstant(LinkageName),
|
|
getCastToEmpty(CompileUnit),
|
|
ConstantInt::get(Type::Int32Ty, LineNo),
|
|
getCastToEmpty(Type),
|
|
ConstantInt::get(Type::Int1Ty, isLocalToUnit),
|
|
ConstantInt::get(Type::Int1Ty, isDefinition)
|
|
};
|
|
|
|
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
|
|
|
|
M.addTypeName("llvm.dbg.subprogram.type", Init->getType());
|
|
GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
|
|
GlobalValue::InternalLinkage,
|
|
Init, "llvm.dbg.subprogram", &M);
|
|
GV->setSection("llvm.metadata");
|
|
return DISubprogram(GV);
|
|
}
|
|
|
|
/// CreateGlobalVariable - Create a new descriptor for the specified global.
|
|
DIGlobalVariable
|
|
DIFactory::CreateGlobalVariable(DIDescriptor Context, const std::string &Name,
|
|
const std::string &DisplayName,
|
|
const std::string &LinkageName,
|
|
DICompileUnit CompileUnit,
|
|
unsigned LineNo, DIType Type,bool isLocalToUnit,
|
|
bool isDefinition, llvm::GlobalVariable *Val) {
|
|
Constant *Elts[] = {
|
|
GetTagConstant(dwarf::DW_TAG_variable),
|
|
getCastToEmpty(GetOrCreateGlobalVariableAnchor()),
|
|
getCastToEmpty(Context),
|
|
GetStringConstant(Name),
|
|
GetStringConstant(DisplayName),
|
|
GetStringConstant(LinkageName),
|
|
getCastToEmpty(CompileUnit),
|
|
ConstantInt::get(Type::Int32Ty, LineNo),
|
|
getCastToEmpty(Type),
|
|
ConstantInt::get(Type::Int1Ty, isLocalToUnit),
|
|
ConstantInt::get(Type::Int1Ty, isDefinition),
|
|
ConstantExpr::getBitCast(Val, EmptyStructPtr)
|
|
};
|
|
|
|
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
|
|
|
|
M.addTypeName("llvm.dbg.global_variable.type", Init->getType());
|
|
GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
|
|
GlobalValue::InternalLinkage,
|
|
Init, "llvm.dbg.global_variable", &M);
|
|
GV->setSection("llvm.metadata");
|
|
return DIGlobalVariable(GV);
|
|
}
|
|
|
|
|
|
/// CreateVariable - Create a new descriptor for the specified variable.
|
|
DIVariable DIFactory::CreateVariable(unsigned Tag, DIDescriptor Context,
|
|
const std::string &Name,
|
|
DICompileUnit CompileUnit, unsigned LineNo,
|
|
DIType Type) {
|
|
Constant *Elts[] = {
|
|
GetTagConstant(Tag),
|
|
getCastToEmpty(Context),
|
|
GetStringConstant(Name),
|
|
getCastToEmpty(CompileUnit),
|
|
ConstantInt::get(Type::Int32Ty, LineNo),
|
|
getCastToEmpty(Type)
|
|
};
|
|
|
|
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
|
|
|
|
M.addTypeName("llvm.dbg.variable.type", Init->getType());
|
|
GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
|
|
GlobalValue::InternalLinkage,
|
|
Init, "llvm.dbg.variable", &M);
|
|
GV->setSection("llvm.metadata");
|
|
return DIVariable(GV);
|
|
}
|
|
|
|
|
|
/// CreateBlock - This creates a descriptor for a lexical block with the
|
|
/// specified parent context.
|
|
DIBlock DIFactory::CreateBlock(DIDescriptor Context) {
|
|
Constant *Elts[] = {
|
|
GetTagConstant(dwarf::DW_TAG_lexical_block),
|
|
getCastToEmpty(Context)
|
|
};
|
|
|
|
Constant *Init = ConstantStruct::get(Elts, sizeof(Elts)/sizeof(Elts[0]));
|
|
|
|
M.addTypeName("llvm.dbg.block.type", Init->getType());
|
|
GlobalVariable *GV = new GlobalVariable(Init->getType(), true,
|
|
GlobalValue::InternalLinkage,
|
|
Init, "llvm.dbg.block", &M);
|
|
GV->setSection("llvm.metadata");
|
|
return DIBlock(GV);
|
|
}
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// DIFactory: Routines for inserting code into a function
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// InsertStopPoint - Create a new llvm.dbg.stoppoint intrinsic invocation,
|
|
/// inserting it at the end of the specified basic block.
|
|
void DIFactory::InsertStopPoint(DICompileUnit CU, unsigned LineNo,
|
|
unsigned ColNo, BasicBlock *BB) {
|
|
|
|
// Lazily construct llvm.dbg.stoppoint function.
|
|
if (!StopPointFn)
|
|
StopPointFn = llvm::Intrinsic::getDeclaration(&M,
|
|
llvm::Intrinsic::dbg_stoppoint);
|
|
|
|
// Invoke llvm.dbg.stoppoint
|
|
Value *Args[] = {
|
|
llvm::ConstantInt::get(llvm::Type::Int32Ty, LineNo),
|
|
llvm::ConstantInt::get(llvm::Type::Int32Ty, ColNo),
|
|
getCastToEmpty(CU)
|
|
};
|
|
CallInst::Create(StopPointFn, Args, Args+3, "", BB);
|
|
}
|
|
|
|
/// InsertSubprogramStart - Create a new llvm.dbg.func.start intrinsic to
|
|
/// mark the start of the specified subprogram.
|
|
void DIFactory::InsertSubprogramStart(DISubprogram SP, BasicBlock *BB) {
|
|
// Lazily construct llvm.dbg.func.start.
|
|
if (!FuncStartFn)
|
|
FuncStartFn = llvm::Intrinsic::getDeclaration(&M,
|
|
llvm::Intrinsic::dbg_func_start);
|
|
|
|
// Call llvm.dbg.func.start which also implicitly sets a stoppoint.
|
|
CallInst::Create(FuncStartFn, getCastToEmpty(SP), "", BB);
|
|
}
|
|
|
|
/// InsertRegionStart - Insert a new llvm.dbg.region.start intrinsic call to
|
|
/// mark the start of a region for the specified scoping descriptor.
|
|
void DIFactory::InsertRegionStart(DIDescriptor D, BasicBlock *BB) {
|
|
// Lazily construct llvm.dbg.region.start function.
|
|
if (!RegionStartFn)
|
|
RegionStartFn = llvm::Intrinsic::getDeclaration(&M,
|
|
llvm::Intrinsic::dbg_region_start);
|
|
// Call llvm.dbg.func.start.
|
|
CallInst::Create(RegionStartFn, getCastToEmpty(D), "", BB);
|
|
}
|
|
|
|
|
|
/// InsertRegionEnd - Insert a new llvm.dbg.region.end intrinsic call to
|
|
/// mark the end of a region for the specified scoping descriptor.
|
|
void DIFactory::InsertRegionEnd(DIDescriptor D, BasicBlock *BB) {
|
|
// Lazily construct llvm.dbg.region.end function.
|
|
if (!RegionEndFn)
|
|
RegionEndFn = llvm::Intrinsic::getDeclaration(&M,
|
|
llvm::Intrinsic::dbg_region_end);
|
|
|
|
CallInst::Create(RegionEndFn, getCastToEmpty(D), "", BB);
|
|
}
|
|
|
|
/// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
|
|
void DIFactory::InsertDeclare(llvm::Value *Storage, DIVariable D,
|
|
BasicBlock *BB) {
|
|
// Cast the storage to a {}* for the call to llvm.dbg.declare.
|
|
Storage = new llvm::BitCastInst(Storage, EmptyStructPtr, "", BB);
|
|
|
|
if (!DeclareFn)
|
|
DeclareFn = llvm::Intrinsic::getDeclaration(&M,
|
|
llvm::Intrinsic::dbg_declare);
|
|
Value *Args[] = { Storage, getCastToEmpty(D) };
|
|
CallInst::Create(DeclareFn, Args, Args+2, "", BB);
|
|
}
|
|
|
|
namespace llvm {
|
|
/// Finds the stoppoint coressponding to this instruction, that is the
|
|
/// stoppoint that dominates this instruction
|
|
const DbgStopPointInst *findStopPoint(const Instruction *Inst)
|
|
{
|
|
if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(Inst))
|
|
return DSI;
|
|
|
|
const BasicBlock *BB = Inst->getParent();
|
|
BasicBlock::const_iterator I = Inst, B;
|
|
do {
|
|
B = BB->begin();
|
|
// A BB consisting only of a terminator can't have a stoppoint.
|
|
if (I != B) {
|
|
do {
|
|
--I;
|
|
if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(I))
|
|
return DSI;
|
|
} while (I != B);
|
|
}
|
|
// This BB didn't have a stoppoint: if there is only one
|
|
// predecessor, look for a stoppoint there.
|
|
// We could use getIDom(), but that would require dominator info.
|
|
BB = I->getParent()->getUniquePredecessor();
|
|
if (BB)
|
|
I = BB->getTerminator();
|
|
} while (BB != 0);
|
|
return 0;
|
|
}
|
|
|
|
/// Finds the stoppoint corresponding to first real (non-debug intrinsic)
|
|
/// instruction in this Basic Block, and returns the stoppoint for it.
|
|
const DbgStopPointInst *findBBStopPoint(const BasicBlock *BB)
|
|
{
|
|
for(BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
|
|
if (const DbgStopPointInst *DSI = dyn_cast<DbgStopPointInst>(I))
|
|
return DSI;
|
|
}
|
|
// Fallback to looking for stoppoint of unique predecessor.
|
|
// Useful if this BB contains no stoppoints, but unique predecessor does.
|
|
BB = BB->getUniquePredecessor();
|
|
if (BB)
|
|
return findStopPoint(BB->getTerminator());
|
|
return 0;
|
|
}
|
|
|
|
/// Finds the dbg.declare intrinsic corresponding to this value if any.
|
|
/// It looks through pointer casts too.
|
|
const DbgDeclareInst *findDbgDeclare(const Value *V, bool stripCasts)
|
|
{
|
|
if (stripCasts) {
|
|
V = V->stripPointerCasts();
|
|
// Look for the bitcast.
|
|
for (Value::use_const_iterator I = V->use_begin(), E =V->use_end();
|
|
I != E; ++I) {
|
|
if (isa<BitCastInst>(I))
|
|
return findDbgDeclare(*I, false);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Find dbg.declare among uses of the instruction.
|
|
for (Value::use_const_iterator I = V->use_begin(), E =V->use_end();
|
|
I != E; ++I) {
|
|
if (const DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(I))
|
|
return DDI;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/// dump - print compile unit.
|
|
void DICompileUnit::dump() const {
|
|
cerr << " [" << dwarf::LanguageString(getLanguage()) << "] ";
|
|
cerr << " [" << getDirectory() << "/" << getFilename() << " ]";
|
|
}
|
|
|
|
/// dump - print type.
|
|
void DIType::dump() const {
|
|
if (isNull()) return;
|
|
if (!getName().empty())
|
|
cerr << " [" << getName() << "] ";
|
|
unsigned Tag = getTag();
|
|
cerr << " [" << dwarf::TagString(Tag) << "] ";
|
|
// TODO : Print context
|
|
getCompileUnit().dump();
|
|
cerr << " ["
|
|
<< getLineNumber() << ", "
|
|
<< getSizeInBits() << ", "
|
|
<< getAlignInBits() << ", "
|
|
<< getOffsetInBits()
|
|
<< "] ";
|
|
if (isPrivate())
|
|
cerr << " [private] ";
|
|
else if (isProtected())
|
|
cerr << " [protected] ";
|
|
if (isForwardDecl())
|
|
cerr << " [fwd] ";
|
|
|
|
if (isBasicType(Tag))
|
|
DIBasicType(GV).dump();
|
|
else if (isDerivedType(Tag))
|
|
DIDerivedType(GV).dump();
|
|
else if (isCompositeType(Tag))
|
|
DICompositeType(GV).dump();
|
|
else {
|
|
cerr << "Invalid DIType\n";
|
|
return;
|
|
}
|
|
cerr << "\n";
|
|
}
|
|
|
|
/// dump - print basic type.
|
|
void DIBasicType::dump() const {
|
|
cerr << " [" << dwarf::AttributeEncodingString(getEncoding()) << "] ";
|
|
|
|
}
|
|
|
|
/// dump - print derived type.
|
|
void DIDerivedType::dump() const {
|
|
cerr << "\n\t Derived From: "; getTypeDerivedFrom().dump();
|
|
}
|
|
|
|
/// dump - print composite type.
|
|
void DICompositeType::dump() const {
|
|
DIArray A = getTypeArray();
|
|
if (A.isNull())
|
|
return;
|
|
cerr << " [" << A.getNumElements() << " elements]";
|
|
}
|
|
|
|
/// dump - print global.
|
|
void DIGlobal::dump() const {
|
|
|
|
if (!getName().empty())
|
|
cerr << " [" << getName() << "] ";
|
|
unsigned Tag = getTag();
|
|
cerr << " [" << dwarf::TagString(Tag) << "] ";
|
|
// TODO : Print context
|
|
getCompileUnit().dump();
|
|
cerr << " [" << getLineNumber() << "] ";
|
|
if (isLocalToUnit())
|
|
cerr << " [local] ";
|
|
if (isDefinition())
|
|
cerr << " [def] ";
|
|
|
|
if (isGlobalVariable(Tag))
|
|
DIGlobalVariable(GV).dump();
|
|
|
|
cerr << "\n";
|
|
}
|
|
|
|
/// dump - print subprogram.
|
|
void DISubprogram::dump() const {
|
|
DIGlobal::dump();
|
|
}
|
|
|
|
/// dump - print global variable.
|
|
void DIGlobalVariable::dump() const {
|
|
cerr << " ["; getGlobal()->dump(); cerr << "] ";
|
|
}
|
|
|
|
/// dump - print variable.
|
|
void DIVariable::dump() const {
|
|
if (!getName().empty())
|
|
cerr << " [" << getName() << "] ";
|
|
getCompileUnit().dump();
|
|
cerr << " [" << getLineNumber() << "] ";
|
|
getType().dump();
|
|
cerr << "\n";
|
|
}
|