void DebugInfoFinder::processType(DIType DT) {
if (!addType(DT))
return;
processScope(DT.getContext().resolve(TypeIdentifierMap));
if (DT.isCompositeType()) {
DICompositeType DCT(DT);
processType(DCT.getTypeDerivedFrom().resolve(TypeIdentifierMap));
if (DT.isSubroutineType()) {
DITypeArray DTA = DISubroutineType(DT).getTypeArray();
for (unsigned i = 0, e = DTA.getNumElements(); i != e; ++i)
processType(DTA.getElement(i).resolve(TypeIdentifierMap));
return;
}
DIArray DA = DCT.getElements();
for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) {
DIDescriptor D = DA.getElement(i);
if (D.isType())
processType(DIType(D));
else if (D.isSubprogram())
processSubprogram(DISubprogram(D));
}
} else if (DT.isDerivedType()) {
DIDerivedType DDT(DT);
processType(DDT.getTypeDerivedFrom().resolve(TypeIdentifierMap));
}
}
/// getOriginalTypeSize - If this type is derived from a base type then
/// return base type size.
uint64_t DIDerivedType::getOriginalTypeSize() const {
unsigned Tag = 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) {
DIType BaseType = getTypeDerivedFrom();
// If this type is not derived from any type then take conservative
// approach.
if (!BaseType.isValid())
return 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)
return getSizeInBits();
else if (BaseType.isDerivedType())
return DIDerivedType(BaseType).getOriginalTypeSize();
else
return BaseType.getSizeInBits();
}
return getSizeInBits();
}
std::string StructInfo::getMemberName(ArrayRef<unsigned> indices)
{
if (!m_debugInfoStructType) {
return "<no name>";
}
llvm::Type *curType = m_structType;
DIType diType = *m_debugInfoStructType;
std::stringstream ss;
ss << getName();
for (unsigned index : indices)
{
if (StructType *structType = dyn_cast<StructType>(curType)) {
if (diType.isDerivedType() && !diType.isCompositeType()) {
diType = DIDerivedType(diType).getTypeDerivedFrom().resolve(*m_typeIdentifierMap);
}
if (!diType.isCompositeType()) {
llvm::errs() << "ERROR: C type is a StructType, but DWARF debug information is not a composite type." << '\n';
assert(false);
exit(1);
}
DICompositeType diCompositeType(diType);
DIDerivedType diMemberType(diCompositeType.getTypeArray().getElement(index));
ss << "." << diMemberType.getName().str();
curType = structType->getContainedType(index);
diType = diMemberType.getTypeDerivedFrom().resolve(*m_typeIdentifierMap);
}
else if (ArrayType *arrayType = dyn_cast<ArrayType>(curType)) {
assert(diType.isDerivedType());
//TODO
DIDerivedType diDerivedType(diType);
ss << "[" << std::dec << index << "]";
curType = arrayType->getElementType();
diType = diDerivedType.getTypeDerivedFrom().resolve(*m_typeIdentifierMap);
}
else {
assert(false && "Offset pointing in the middle of a basic data type");
return "<error>";
}
}
return ss.str();
}
/// getDICompositeType - Find underlying composite type.
DICompositeType llvm::getDICompositeType(DIType T) {
if (T.isCompositeType())
return DICompositeType(T);
if (T.isDerivedType())
return getDICompositeType(DIDerivedType(T).getTypeDerivedFrom());
return DICompositeType();
}
void DIEItem::FormatDIType(wxTextOutputStream& out, DIType type) const {
if (type.isCompositeType()) {
DICompositeType diCompType(type);
if (!type.getName().empty()) {
out << toWxStr(type.getName());
} else {
out << _("?Implement unnamed composite");
// TODO: Implement:
// DW_TAG_array_type
// DW_TAG_enumeration_type
// DW_TAG_structure_type
// DW_TAG_union_type
// DW_TAG_vector_type
// DW_TAG_subroutine_type
// DW_TAG_inheritance
}
} else if (type.isDerivedType()) {
DIDerivedType diDerivedType(type);
DIType diBase = diDerivedType.getTypeDerivedFrom();
switch (diDerivedType.getTag()) {
case dwarf::DW_TAG_inheritance:
FormatDIType(out, diBase);
break;
case dwarf::DW_TAG_pointer_type:
FormatDIType(out, diBase);
out << _("*");
break;
case dwarf::DW_TAG_array_type:
FormatDIType(out, diBase);
// TODO: Get the array size, use LLVM array notation.
out << _("[]");
break;
case dwarf::DW_TAG_member:
out << toWxStr(diDerivedType.getName());
break;
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_typedef:
// TODO: Implement
break;
}
} else if (type.isBasicType()) {
DIBasicType diBasicType(type);
const char * encodingName =
dwarf::AttributeEncodingString(diBasicType.getEncoding());
if (encodingName != NULL) {
out << toWxStr(encodingName);
}
}
}
/// \brief Return the size reported by the variable's type.
unsigned DIVariable::getSizeInBits(const DITypeIdentifierMap &Map) {
DIType Ty = getType().resolve(Map);
// Follow derived types until we reach a type that
// reports back a size.
while (Ty.isDerivedType() && !Ty.getSizeInBits()) {
DIDerivedType DT(&*Ty);
Ty = DT.getTypeDerivedFrom().resolve(Map);
}
assert(Ty.getSizeInBits() && "type with size 0");
return Ty.getSizeInBits();
}
/// PopulateDebugInfo - Populate the TypeNo, Aux[] and TagName from Ty.
///
void PIC16DbgInfo::PopulateDebugInfo (DIType Ty, unsigned short &TypeNo,
bool &HasAux, int Aux[],
std::string &TagName) {
if (Ty.isBasicType(Ty.getTag()))
PopulateBasicTypeInfo (Ty, TypeNo);
else if (Ty.isDerivedType(Ty.getTag()))
PopulateDerivedTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
else if (Ty.isCompositeType(Ty.getTag()))
PopulateCompositeTypeInfo (Ty, TypeNo, HasAux, Aux, TagName);
else {
TypeNo = PIC16Dbg::T_NULL;
HasAux = false;
}
return;
}
DICompositeType llvm::getDICompositeType(DIType T) {
if (T.isCompositeType())
return DICompositeType(T);
if (T.isDerivedType()) {
// This function is currently used by dragonegg and dragonegg does
// not generate identifier for types, so using an empty map to resolve
// DerivedFrom should be fine.
DITypeIdentifierMap EmptyMap;
return getDICompositeType(
DIDerivedType(T).getTypeDerivedFrom().resolve(EmptyMap));
}
return DICompositeType();
}
/// getOriginalTypeSize - If this type is derived from a base type then
/// return base type size.
uint64_t DIDerivedType::getOriginalTypeSize() const {
unsigned Tag = 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) {
DIType BaseType = getTypeDerivedFrom();
// If this type is not derived from any type then take conservative
// approach.
if (BaseType.isNull())
return getSizeInBits();
if (BaseType.isDerivedType())
return DIDerivedType(BaseType.getNode()).getOriginalTypeSize();
else
return BaseType.getSizeInBits();
}
return getSizeInBits();
}
/// processType - Process DIType.
void DebugInfoFinder::processType(DIType DT) {
if (!addType(DT))
return;
if (DT.isCompositeType()) {
DICompositeType DCT(DT);
processType(DCT.getTypeDerivedFrom());
DIArray DA = DCT.getTypeArray();
for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) {
DIDescriptor D = DA.getElement(i);
if (D.isType())
processType(DIType(D));
else if (D.isSubprogram())
processSubprogram(DISubprogram(D));
}
} else if (DT.isDerivedType()) {
DIDerivedType DDT(DT);
processType(DDT.getTypeDerivedFrom());
}
}
/// processType - Process DIType.
void DebugInfoFinder::processType(DIType DT) {
if (!addType(DT))
return;
addCompileUnit(DT.getCompileUnit());
if (DT.isCompositeType()) {
DICompositeType DCT(DT.getNode());
processType(DCT.getTypeDerivedFrom());
DIArray DA = DCT.getTypeArray();
if (!DA.isNull())
for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) {
DIDescriptor D = DA.getElement(i);
DIType TypeE = DIType(D.getNode());
if (!TypeE.isNull())
processType(TypeE);
else
processSubprogram(DISubprogram(D.getNode()));
}
} else if (DT.isDerivedType()) {
DIDerivedType DDT(DT.getNode());
if (!DDT.isNull())
processType(DDT.getTypeDerivedFrom());
}
}
