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()); } }