From ada60b4e3d16007f477fd198bc304f2965359d5d Mon Sep 17 00:00:00 2001 From: Rene Gollent Date: Mon, 3 Dec 2012 20:58:09 -0500 Subject: [PATCH] Rework handling of template parameters. - Keep a unified list in DIEClassBaseType so that the order of template parameters is preserved in cases when type and value parameters are mixed. Thanks Ingo for the hint. - Introduce new base Type TemplateParameter, which represents either a template type or template value parameter, a list of which is attached to CompoundType. - Add DwarfTemplateParameter implementing subclass of TemplateParameter and adjust DwarfTypeFactory accordingly for the above changes. --- .../debugger/debug_info/DwarfTypeFactory.cpp | 40 +++++++--- src/apps/debugger/debug_info/DwarfTypes.cpp | 77 ++++++++++++------- src/apps/debugger/debug_info/DwarfTypes.h | 34 ++++++-- src/apps/debugger/dwarf/DebugInfoEntries.cpp | 4 +- src/apps/debugger/dwarf/DebugInfoEntries.h | 9 +-- src/apps/debugger/model/Type.cpp | 8 ++ src/apps/debugger/model/Type.h | 23 ++++-- 7 files changed, 136 insertions(+), 59 deletions(-) diff --git a/src/apps/debugger/debug_info/DwarfTypeFactory.cpp b/src/apps/debugger/debug_info/DwarfTypeFactory.cpp index 594d7ed142..76d2e163b9 100644 --- a/src/apps/debugger/debug_info/DwarfTypeFactory.cpp +++ b/src/apps/debugger/debug_info/DwarfTypeFactory.cpp @@ -102,13 +102,13 @@ struct HasBaseTypesPredicate { }; -// #pragma mark - HasTemplateTypeParametersPredicate +// #pragma mark - HasTemplateParametersPredicate -struct HasTemplateTypeParametersPredicate { +struct HasTemplateParametersPredicate { inline bool operator()(DIEClassBaseType* entry) const { - return !entry->TemplateTypeParameters().IsEmpty(); + return !entry->TemplateParameters().IsEmpty(); } }; @@ -565,23 +565,41 @@ printf(" -> failed to add type to cache\n"); // parameters classTypeEntry = DwarfUtils::GetDIEByPredicate( dynamic_cast(typeEntry), - HasTemplateTypeParametersPredicate()); + HasTemplateParametersPredicate()); if (classTypeEntry != NULL) { for (DebugInfoEntryList::ConstIterator it - = classTypeEntry->TemplateTypeParameters() + = classTypeEntry->TemplateParameters() .GetIterator(); DebugInfoEntry* _typeEntry = it.Next();) { - DIETemplateTypeParameter* templateTypeEntry = - dynamic_cast(_typeEntry); + DIETemplateTypeParameter* templateTypeEntry + = dynamic_cast(_typeEntry); DwarfType* templateType; - if (CreateType(templateTypeEntry->GetType(), templateType) - != B_OK) { - continue; + if (templateTypeEntry != NULL) { + if (CreateType(templateTypeEntry->GetType(), templateType) + != B_OK) { + continue; + } + } else { + DIETemplateValueParameter* templateValueEntry + = dynamic_cast(_typeEntry); + if (CreateType(templateValueEntry->GetType(), templateType) + != B_OK) { + continue; + } } BReference templateTypeReference(templateType, true); - if (!type->AddTemplateTypeParameter(templateType)) { + DwarfTemplateParameter* parameter + = new(std::nothrow) DwarfTemplateParameter(_typeEntry, + templateType); + if (parameter == NULL) { + cacheLocker.Lock(); + fTypeCache->RemoveType(type); + return B_NO_MEMORY; + } + + if (!type->AddTemplateParameter(parameter)) { cacheLocker.Lock(); fTypeCache->RemoveType(type); return B_NO_MEMORY; diff --git a/src/apps/debugger/debug_info/DwarfTypes.cpp b/src/apps/debugger/debug_info/DwarfTypes.cpp index 96b1a57002..3c85e4b0ec 100644 --- a/src/apps/debugger/debug_info/DwarfTypes.cpp +++ b/src/apps/debugger/debug_info/DwarfTypes.cpp @@ -518,6 +518,45 @@ DwarfFunctionParameter::GetType() const } +// #pragma mark - DwarfTemplateParameter + + +DwarfTemplateParameter::DwarfTemplateParameter(DebugInfoEntry* entry, + DwarfType* type) + : + fEntry(entry), + fType(type) +{ + fType->AcquireReference(); + DIETemplateTypeParameter* typeParameter + = dynamic_cast(entry); + if (typeParameter != NULL) + fTemplateKind = TEMPLATE_TYPE_TYPE; + else { + DIETemplateValueParameter* valueParameter + = dynamic_cast(entry); + fTemplateKind = TEMPLATE_TYPE_VALUE; + const ConstantAttributeValue* constValue = valueParameter + ->ConstValue(); + switch (constValue->attributeClass) { + case ATTRIBUTE_CLASS_CONSTANT: + fValue.SetTo(constValue->constant); + break; + case ATTRIBUTE_CLASS_STRING: + fValue.SetTo(constValue->string); + break; + // TODO: ATTRIBUTE_CLASS_BLOCK_DATA + } + } +} + + +DwarfTemplateParameter::~DwarfTemplateParameter() +{ + fType->ReleaseReference(); +} + + // #pragma mark - DwarfPrimitiveType @@ -568,8 +607,10 @@ DwarfCompoundType::~DwarfCompoundType() for (int32 i = 0; DwarfDataMember* member = fDataMembers.ItemAt(i); i++) member->ReleaseReference(); - for (int32 i = 0; DwarfType* type = fTemplateTypeParameters.ItemAt(i); i++) - type->ReleaseReference(); + for (int32 i = 0; DwarfTemplateParameter* parameter + = fTemplateParameters.ItemAt(i); i++) { + parameter->ReleaseReference(); + } } @@ -609,32 +650,16 @@ DwarfCompoundType::DataMemberAt(int32 index) const int32 -DwarfCompoundType::CountTemplateTypeParameters() const +DwarfCompoundType::CountTemplateParameters() const { - return fTemplateTypeParameters.CountItems(); + return fTemplateParameters.CountItems(); } -Type* -DwarfCompoundType::TemplateTypeParameterAt(int32 index) const +TemplateParameter* +DwarfCompoundType::TemplateParameterAt(int32 index) const { - return fTemplateTypeParameters.ItemAt(index); -} - - -int32 -DwarfCompoundType::CountTemplateValueParameters() const -{ - // TODO: implement - return 0; -} - - -Type* -DwarfCompoundType::TemplateValueParameterAt(int32 index) const -{ - // TODO: implement - return NULL; + return fTemplateParameters.ItemAt(index); } @@ -770,12 +795,12 @@ DwarfCompoundType::AddDataMember(DwarfDataMember* member) bool -DwarfCompoundType::AddTemplateTypeParameter(DwarfType* type) +DwarfCompoundType::AddTemplateParameter(DwarfTemplateParameter* parameter) { - if (!fTemplateTypeParameters.AddItem(type)) + if (!fTemplateParameters.AddItem(parameter)) return false; - type->AcquireReference(); + parameter->AcquireReference(); return true; } diff --git a/src/apps/debugger/debug_info/DwarfTypes.h b/src/apps/debugger/debug_info/DwarfTypes.h index b718e38957..50983cc49d 100644 --- a/src/apps/debugger/debug_info/DwarfTypes.h +++ b/src/apps/debugger/debug_info/DwarfTypes.h @@ -17,6 +17,7 @@ class Architecture; class CompilationUnit; +class DebugInfoEntry; class DIEAddressingType; class DIEArrayType; class DIEBaseType; @@ -237,6 +238,25 @@ private: }; +class DwarfTemplateParameter : public TemplateParameter { +public: + DwarfTemplateParameter( + DebugInfoEntry* entry, + DwarfType* type); + ~DwarfTemplateParameter(); + + virtual template_type_kind Kind() const { return fTemplateKind; } + virtual Type* GetType() const { return fType; } + virtual BVariant Value() const { return fValue; } + +private: + DebugInfoEntry* fEntry; + template_type_kind fTemplateKind; + Type* fType; + BVariant fValue; +}; + + class DwarfPrimitiveType : public PrimitiveType, public DwarfType { public: DwarfPrimitiveType( @@ -271,11 +291,8 @@ public: virtual int32 CountDataMembers() const; virtual DataMember* DataMemberAt(int32 index) const; - virtual int32 CountTemplateTypeParameters() const; - virtual Type* TemplateTypeParameterAt(int32 index) const; - - virtual int32 CountTemplateValueParameters() const; - virtual Type* TemplateValueParameterAt(int32 index) const; + virtual int32 CountTemplateParameters() const; + virtual TemplateParameter* TemplateParameterAt(int32 index) const; virtual status_t ResolveBaseTypeLocation(BaseType* _baseType, const ValueLocation& parentLocation, @@ -291,12 +308,13 @@ public: bool AddInheritance(DwarfInheritance* inheritance); bool AddDataMember(DwarfDataMember* member); - bool AddTemplateTypeParameter(DwarfType* type); + bool AddTemplateParameter( + DwarfTemplateParameter* parameter); private: typedef BObjectList DataMemberList; typedef BObjectList InheritanceList; - typedef BObjectList TemplateTypeList; + typedef BObjectList TemplateParameterList; private: status_t _ResolveDataMemberLocation( @@ -310,7 +328,7 @@ private: DIECompoundType* fEntry; InheritanceList fInheritances; DataMemberList fDataMembers; - TemplateTypeList fTemplateTypeParameters; + TemplateParameterList fTemplateParameters; }; diff --git a/src/apps/debugger/dwarf/DebugInfoEntries.cpp b/src/apps/debugger/dwarf/DebugInfoEntries.cpp index 0579ae3b68..d4643a46e5 100644 --- a/src/apps/debugger/dwarf/DebugInfoEntries.cpp +++ b/src/apps/debugger/dwarf/DebugInfoEntries.cpp @@ -478,10 +478,8 @@ DIEClassBaseType::AddChild(DebugInfoEntry* child) fMemberFunctions.Add(child); return B_OK; case DW_TAG_template_type_parameter: - fTemplateTypeParameters.Add(child); - return B_OK; case DW_TAG_template_value_parameter: - fTemplateValueParameters.Add(child); + fTemplateParameters.Add(child); return B_OK; // TODO: Variants! default: diff --git a/src/apps/debugger/dwarf/DebugInfoEntries.h b/src/apps/debugger/dwarf/DebugInfoEntries.h index 9e1399bc20..757007fe54 100644 --- a/src/apps/debugger/dwarf/DebugInfoEntries.h +++ b/src/apps/debugger/dwarf/DebugInfoEntries.h @@ -353,10 +353,8 @@ public: const DebugInfoEntryList& BaseTypes() const { return fBaseTypes; } - const DebugInfoEntryList& TemplateTypeParameters() const - { return fTemplateTypeParameters; } - const DebugInfoEntryList& TemplateValueParameters() const - { return fTemplateValueParameters; } + const DebugInfoEntryList& TemplateParameters() const + { return fTemplateParameters; } virtual status_t AddChild(DebugInfoEntry* child); @@ -366,8 +364,7 @@ protected: DebugInfoEntryList fAccessDeclarations; DebugInfoEntryList fMemberFunctions; DebugInfoEntryList fInnerTypes; - DebugInfoEntryList fTemplateTypeParameters; - DebugInfoEntryList fTemplateValueParameters; + DebugInfoEntryList fTemplateParameters; }; diff --git a/src/apps/debugger/model/Type.cpp b/src/apps/debugger/model/Type.cpp index 83f098f1b0..cf81243118 100644 --- a/src/apps/debugger/model/Type.cpp +++ b/src/apps/debugger/model/Type.cpp @@ -72,6 +72,14 @@ FunctionParameter::~FunctionParameter() } +// #pragma mark - TemplateParameter + + +TemplateParameter::~TemplateParameter() +{ +} + + // #pragma mark - Type diff --git a/src/apps/debugger/model/Type.h b/src/apps/debugger/model/Type.h index c7abc78232..5c097da5e8 100644 --- a/src/apps/debugger/model/Type.h +++ b/src/apps/debugger/model/Type.h @@ -43,6 +43,12 @@ enum address_type_kind { }; +enum template_type_kind { + TEMPLATE_TYPE_TYPE, + TEMPLATE_TYPE_VALUE +}; + + enum { TYPE_MODIFIER_CONST = 0x01, TYPE_MODIFIER_VOLATILE = 0x02, @@ -105,6 +111,16 @@ public: }; +class TemplateParameter : public BReferenceable { +public: + virtual ~TemplateParameter(); + + virtual template_type_kind Kind() const = 0; + virtual Type* GetType() const = 0; + virtual BVariant Value() const = 0; +}; + + class Type : public BReferenceable { public: virtual ~Type(); @@ -158,12 +174,9 @@ public: virtual int32 CountDataMembers() const = 0; virtual DataMember* DataMemberAt(int32 index) const = 0; - virtual int32 CountTemplateTypeParameters() const = 0; - virtual Type* TemplateTypeParameterAt(int32 index) const = 0; + virtual int32 CountTemplateParameters() const = 0; + virtual TemplateParameter* TemplateParameterAt(int32 index) const = 0; - virtual int32 CountTemplateValueParameters() const = 0; - virtual Type* TemplateValueParameterAt(int32 index) const - = 0; virtual status_t ResolveBaseTypeLocation(BaseType* baseType, const ValueLocation& parentLocation,