6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-13 22:24:07 +00:00
Code Issues Projects Releases Wiki Activity

Debug Info: In DIBuilder, the derived-from field of a DW_TAG_pointer_type

Browse Source 
is updated to use DITypeRef.

Move isUnsignedDIType and getOriginalTypeSize from DebugInfo.h to be static
helper functions in DwarfCompileUnit. We already have a static helper function
"isTypeSigned" in DwarfCompileUnit, and a pointer to DwarfDebug is added to
resolve the derived-from field. All three functions need to go across link
for derived-from fields, so we need to get hold of a type identifier map.

A pointer to DwarfDebug is also added to DbgVariable in order to resolve the
derived-from field.

Debug info verifier is updated to check a derived-from field is a TypeRef.
Verifier will not go across link for derived-from fields, in debug info finder,
we go across the link to add derived-from fields to types.

Function getDICompositeType is only used by dragonegg and since dragonegg does
not generate identifier for types, we use an empty map to resolve the
derived-from field.

When printing a derived-from field, we use DITypeRef::getName to either return
the type identifier or getName of the DIType.

A paired commit at clang is required due to changes to DIBuilder.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@192018 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Manman Ren
2013-10-05 01:43:03 +00:00
parent af76b1601c
commit c664d76716
10 changed files with 271 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
View File

@ -520,7 +520,7 @@ void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
if (Tag == dwarf::DW_TAG_pointer_type) {
DIDerivedType DTy = DIDerivedType(Ty);
TmpTy = DTy.getTypeDerivedFrom();
TmpTy = DD->resolve(DTy.getTypeDerivedFrom());
isPointer = true;
}
@ -587,9 +587,10 @@ void CompileUnit::addBlockByrefAddress(const DbgVariable &DV, DIE *Die,
}
/// isTypeSigned - Return true if the type is signed.
static bool isTypeSigned(DIType Ty, int *SizeInBits) {
static bool isTypeSigned(DwarfDebug *DD, DIType Ty, int *SizeInBits) {
if (Ty.isDerivedType())
return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
return isTypeSigned(DD, DD->resolve(DIDerivedType(Ty).getTypeDerivedFrom()),
SizeInBits);
if (Ty.isBasicType())
if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
|| DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
@ -599,6 +600,51 @@ static bool isTypeSigned(DIType Ty, int *SizeInBits) {
return false;
}
/// Return true if type encoding is unsigned.
static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) {
DIDerivedType DTy(Ty);
if (DTy.isDerivedType())
return isUnsignedDIType(DD, DD->resolve(DTy.getTypeDerivedFrom()));
DIBasicType BTy(Ty);
if (BTy.isBasicType()) {
unsigned Encoding = BTy.getEncoding();
if (Encoding == dwarf::DW_ATE_unsigned ||
Encoding == dwarf::DW_ATE_unsigned_char ||
Encoding == dwarf::DW_ATE_boolean)
return true;
}
return false;
}
/// If this type is derived from a base type then return base type size.
static uint64_t getOriginalTypeSize(DwarfDebug *DD, DIDerivedType Ty) {
unsigned Tag = Ty.getTag();
if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
Tag != dwarf::DW_TAG_restrict_type)
return Ty.getSizeInBits();
DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom());
// If this type is not derived from any type then take conservative approach.
if (!BaseType.isValid())
return Ty.getSizeInBits();
// If this is a derived type, go ahead and get the base type, unless it's a
// reference then it's just the size of the field. Pointer types have no need
// of this since they're a different type of qualification on the type.
if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
return Ty.getSizeInBits();
if (BaseType.isDerivedType())
return getOriginalTypeSize(DD, DIDerivedType(BaseType));
return BaseType.getSizeInBits();
}
/// addConstantValue - Add constant value entry in variable DIE.
void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
DIType Ty) {
@ -607,7 +653,7 @@ void CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
// udata/sdata over dataN as suggested by the DWARF spec)
assert(MO.isImm() && "Invalid machine operand!");
int SizeInBits = -1;
bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
bool SignedConstant = isTypeSigned(DD, Ty, &SizeInBits);
uint16_t Form;
// If we're a signed constant definitely use sdata.
@ -923,7 +969,7 @@ void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
uint16_t Tag = Buffer.getTag();
// Map to main type, void will not have a type.
DIType FromTy = DTy.getTypeDerivedFrom();
DIType FromTy = DD->resolve(DTy.getTypeDerivedFrom());
if (FromTy)
addType(&Buffer, FromTy);
@ -998,7 +1044,7 @@ void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
Buffer.addChild(ElemDie);
}
}
DIType DTy = CTy.getTypeDerivedFrom();
DIType DTy = DD->resolve(CTy.getTypeDerivedFrom());
if (DTy) {
addType(&Buffer, DTy);
addFlag(&Buffer, dwarf::DW_AT_enum_class);
@ -1064,7 +1110,8 @@ void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
DIDerivedType DDTy(Element);
if (DDTy.getTag() == dwarf::DW_TAG_friend) {
ElemDie = new DIE(dwarf::DW_TAG_friend);
addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
addType(ElemDie, DD->resolve(DDTy.getTypeDerivedFrom()),
dwarf::DW_AT_friend);
} else if (DDTy.isStaticMember())
ElemDie = createStaticMemberDIE(DDTy);
else
@ -1205,7 +1252,7 @@ CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP) {
addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
if (Value *Val = VP.getValue()) {
if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
addConstantValue(ParamDIE, CI, VP.getType().isUnsignedDIType());
addConstantValue(ParamDIE, CI, isUnsignedDIType(DD, VP.getType()));
else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
// For declaration non-type template parameters (such as global values and
// functions)
@ -1499,7 +1546,7 @@ void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
// emitting AT_const_value multiple times, we only add AT_const_value when
// it is not a static member.
if (!IsStaticMember)
addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
addConstantValue(VariableDIE, CI, isUnsignedDIType(DD, GTy));
} else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
addToAccelTable = true;
// GV is a merged global.
@ -1559,7 +1606,7 @@ void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
// Emit the element type.
addType(&Buffer, CTy->getTypeDerivedFrom());
addType(&Buffer, DD->resolve(CTy->getTypeDerivedFrom()));
// Get an anonymous type for index type.
// FIXME: This type should be passed down from the front end
@ -1663,7 +1710,7 @@ DIE *CompileUnit::constructVariableDIE(DbgVariable *DV,
addConstantFPValue(VariableDie, DVInsn->getOperand(0));
else if (DVInsn->getOperand(0).isCImm())
addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
DV->getType().isUnsignedDIType());
isUnsignedDIType(DD, DV->getType()));
DV->setDIE(VariableDie);
return VariableDie;
@ -1691,7 +1738,7 @@ DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
if (!Name.empty())
addString(MemberDie, dwarf::DW_AT_name, Name);
addType(MemberDie, DT.getTypeDerivedFrom());
addType(MemberDie, DD->resolve(DT.getTypeDerivedFrom()));
addSourceLine(MemberDie, DT);
@ -1699,11 +1746,12 @@ DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
uint64_t Size = DT.getSizeInBits();
uint64_t FieldSize = DT.getOriginalTypeSize();
uint64_t FieldSize = getOriginalTypeSize(DD, DT);
if (Size != FieldSize) {
// Handle bitfield.
addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
addUInt(MemberDie, dwarf::DW_AT_byte_size, 0,
getOriginalTypeSize(DD, DT)>>3);
addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
uint64_t Offset = DT.getOffsetInBits();
@ -1778,7 +1826,7 @@ DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
return NULL;
DIE *StaticMemberDIE = new DIE(DT.getTag());
DIType Ty = DT.getTypeDerivedFrom();
DIType Ty = DD->resolve(DT.getTypeDerivedFrom());
addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
addType(StaticMemberDIE, Ty);
@ -1799,7 +1847,7 @@ DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
dwarf::DW_ACCESS_public);
if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
addConstantValue(StaticMemberDIE, CI, isUnsignedDIType(DD, Ty));
if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
addConstantFPValue(StaticMemberDIE, CFP);