Ticket #5495: debug_info_type_match.patch

File debug_info_type_match.patch, 14.5 KB (added by anevilyak, 8 years ago)
  • src/apps/debugger/model/TypeLookupConstraints.cpp

     
     1/*
     2 * Copyright 2011, Rene Gollent, rene@gollent.com.
     3 * Distributed under the terms of the MIT License.
     4 */
     5
     6
     7#include "TypeLookupConstraints.h"
     8
     9
     10TypeLookupConstraints::TypeLookupConstraints()
     11    :
     12    fTypeKindGiven(false),
     13    fSubtypeKindGiven(false)
     14{
     15}
     16
     17
     18TypeLookupConstraints::TypeLookupConstraints(type_kind typeKind)
     19    :
     20    fTypeKind(typeKind),
     21    fTypeKindGiven(true),
     22    fSubtypeKindGiven(false)
     23{
     24}
     25
     26
     27TypeLookupConstraints::TypeLookupConstraints(type_kind typeKind,
     28    int32 subTypeKind)
     29    :
     30    fTypeKind(typeKind),
     31    fSubtypeKind(subTypeKind),
     32    fTypeKindGiven(true),
     33    fSubtypeKindGiven(true)
     34{
     35}
     36
     37
     38bool
     39TypeLookupConstraints::HasTypeKind() const
     40{
     41    return fTypeKindGiven;
     42}
     43
     44
     45bool
     46TypeLookupConstraints::HasSubtypeKind() const
     47{
     48    return fSubtypeKindGiven;
     49}
     50
     51
     52type_kind
     53TypeLookupConstraints::TypeKind() const
     54{
     55    return fTypeKind;
     56}
     57
     58
     59int32
     60TypeLookupConstraints::SubtypeKind() const
     61{
     62    return fSubtypeKind;
     63}
     64
     65
     66void
     67TypeLookupConstraints::SetTypeKind(type_kind typeKind)
     68{
     69    fTypeKind = typeKind;
     70    fTypeKindGiven = true;
     71}
     72
     73
     74void
     75TypeLookupConstraints::SetSubtypeKind(int32 subtypeKind)
     76{
     77    fSubtypeKind = subtypeKind;
     78    fSubtypeKindGiven = true;
     79}
  • src/apps/debugger/model/TypeLookupConstraints.h

     
     1/*
     2 * Copyright 2011, Rene Gollent, rene@gollent.com.
     3 * Distributed under the terms of the MIT License.
     4 */
     5#ifndef TYPE_LOOKUP_CONSTRAINTS_H
     6#define TYPE_LOOKUP_CONSTRAINTS_H
     7
     8
     9#include "Type.h"
     10
     11
     12class TypeLookupConstraints {
     13public:
     14                    TypeLookupConstraints();
     15                        // no constraints
     16                    TypeLookupConstraints(type_kind typeKind);
     17                        // constrain on type only
     18                    TypeLookupConstraints(type_kind typeKind,
     19                        int32 subtypeKind);
     20
     21    bool            HasTypeKind() const;
     22    bool            HasSubtypeKind() const;
     23    type_kind       TypeKind() const;
     24    int32           SubtypeKind() const;
     25
     26    void            SetTypeKind(type_kind typeKind);
     27    void            SetSubtypeKind(int32 subtypeKind);
     28
     29private:
     30    type_kind       fTypeKind;
     31    int32           fSubtypeKind;
     32    bool            fTypeKindGiven;
     33    bool            fSubtypeKindGiven;
     34};
     35
     36#endif // TYPE_LOOKUP_CONSTRAINTS_H
  • src/apps/debugger/model/Type.h

     
    2929};
    3030
    3131
     32enum compound_type_kind {
     33    COMPOUND_TYPE_CLASS,
     34    COMPOUND_TYPE_STRUCT,
     35    COMPOUND_TYPE_UNION,
     36    COMPOUND_TYPE_INTERFACE
     37};
     38
     39
    3240enum address_type_kind {
    3341    DERIVED_TYPE_POINTER,
    3442    DERIVED_TYPE_REFERENCE
  • src/apps/debugger/debug_info/DwarfImageDebugInfo.h

     
    5151    virtual status_t            GetFunctions(
    5252                                    BObjectList<FunctionDebugInfo>& functions);
    5353    virtual status_t            GetType(GlobalTypeCache* cache,
    54                                     const BString& name, Type*& _type);
     54                                    const BString& name,
     55                                    const TypeLookupConstraints& constraints,
     56                                    Type*& _type);
    5557
    5658    virtual AddressSectionType  GetAddressSectionType(target_addr_t address);
    5759
  • src/apps/debugger/debug_info/ImageDebugInfo.cpp

     
    7878
    7979status_t
    8080ImageDebugInfo::GetType(GlobalTypeCache* cache, const BString& name,
    81     Type*& _type)
     81    const TypeLookupConstraints& constraints, Type*& _type)
    8282{
    8383    for (int32 i = 0; SpecificImageDebugInfo* specificInfo
    8484            = fSpecificInfos.ItemAt(i); i++) {
    85         status_t error = specificInfo->GetType(cache, name, _type);
     85        status_t error = specificInfo->GetType(cache, name, constraints,
     86            _type);
    8687        if (error == B_OK || error == B_NO_MEMORY)
    8788            return error;
    8889    }
  • src/apps/debugger/debug_info/TeamDebugInfo.cpp

     
    2929#include "SpecificImageDebugInfo.h"
    3030#include "StringUtils.h"
    3131#include "Type.h"
     32#include "TypeLookupConstraints.h"
    3233
    3334
    3435// #pragma mark - FunctionHashDefinition
     
    362363
    363364status_t
    364365TeamDebugInfo::GetType(GlobalTypeCache* cache, const BString& name,
    365     Type*& _type)
     366    const TypeLookupConstraints& constraints, Type*& _type)
    366367{
    367368    // maybe the type is already cached
    368369    AutoLocker<GlobalTypeCache> cacheLocker(cache);
     
    390391    // get the type
    391392    status_t error = B_ENTRY_NOT_FOUND;
    392393    for (int32 i = 0; ImageDebugInfo* imageDebugInfo = images.ItemAt(i); i++) {
    393         error = imageDebugInfo->GetType(cache, name, type);
     394        error = imageDebugInfo->GetType(cache, name, constraints, type);
    394395        if (error == B_OK) {
    395396            _type = type;
    396397            break;
  • src/apps/debugger/debug_info/DebuggerImageDebugInfo.h

     
    2828    virtual status_t            GetFunctions(
    2929                                    BObjectList<FunctionDebugInfo>& functions);
    3030    virtual status_t            GetType(GlobalTypeCache* cache,
    31                                     const BString& name, Type*& _type);
     31                                    const BString& name,
     32                                    const TypeLookupConstraints& constraints,
     33                                    Type*& _type);
    3234    virtual AddressSectionType  GetAddressSectionType(target_addr_t address);
    3335    virtual status_t            CreateFrame(Image* image,
    3436                                    FunctionInstance* functionInstance,
  • src/apps/debugger/debug_info/SpecificImageDebugInfo.h

     
    2929class StackFrame;
    3030class Statement;
    3131class Type;
     32class TypeLookupConstraints;
    3233class ValueLocation;
    3334
    3435
     
    4243                                    // returns references
    4344
    4445    virtual status_t            GetType(GlobalTypeCache* cache,
    45                                     const BString& name, Type*& _type) = 0;
     46                                    const BString& name,
     47                                    const TypeLookupConstraints& constraints,
     48                                    Type*& _type) = 0;
    4649                                    // returns a reference
    4750    virtual AddressSectionType  GetAddressSectionType(target_addr_t address)
    4851                                    = 0;
  • src/apps/debugger/debug_info/DwarfTypes.cpp

     
    5050}   // unnamed namespace
    5151
    5252
     53type_kind dwarf_tag_to_type_kind(int32 tag)
     54{
     55    switch (tag) {
     56        case DW_TAG_class_type:
     57        case DW_TAG_structure_type:
     58        case DW_TAG_union_type:
     59        case DW_TAG_interface_type:
     60        {
     61            return TYPE_COMPOUND;
     62        }
     63        case DW_TAG_base_type:
     64        {
     65            return TYPE_PRIMITIVE;
     66        }
     67        case DW_TAG_pointer_type:
     68        case DW_TAG_reference_type:
     69        {
     70            return TYPE_ADDRESS;
     71        }
     72        case DW_TAG_const_type:
     73        case DW_TAG_packed_type:
     74        case DW_TAG_volatile_type:
     75        case DW_TAG_restrict_type:
     76        case DW_TAG_shared_type:
     77        {
     78            return TYPE_MODIFIED;
     79        }
     80        case DW_TAG_typedef:
     81        {
     82            return TYPE_TYPEDEF;
     83        }
     84        case DW_TAG_array_type:
     85        {
     86            return TYPE_ARRAY;
     87        }
     88        case DW_TAG_enumeration_type:
     89        {
     90            return TYPE_ENUMERATION;
     91        }
     92        case DW_TAG_subrange_type:
     93        {
     94            return TYPE_SUBRANGE;
     95        }
     96        case DW_TAG_unspecified_type:
     97        {
     98            return TYPE_UNSPECIFIED;
     99        }
     100        case DW_TAG_subroutine_type:
     101        {
     102            return TYPE_FUNCTION;
     103        }
     104        case DW_TAG_ptr_to_member_type:
     105        {
     106            return TYPE_POINTER_TO_MEMBER;
     107        }
     108    }
     109
     110    return TYPE_UNSPECIFIED;
     111}
     112
     113
     114int32 dwarf_tag_to_subtype_kind(int32 tag)
     115{
     116    switch (tag) {
     117        case DW_TAG_class_type:
     118        {
     119            return COMPOUND_TYPE_CLASS;
     120        }
     121        case DW_TAG_structure_type:
     122        {
     123            return COMPOUND_TYPE_STRUCT;
     124        }
     125        case DW_TAG_union_type:
     126        {
     127            return COMPOUND_TYPE_UNION;
     128        }
     129        case DW_TAG_interface_type:
     130        {
     131            return COMPOUND_TYPE_INTERFACE;
     132        }
     133        case DW_TAG_pointer_type:
     134        {
     135            return DERIVED_TYPE_POINTER;
     136        }
     137        case DW_TAG_reference_type:
     138        {
     139            return DERIVED_TYPE_REFERENCE;
     140        }
     141    }
     142
     143    return -1;
     144}
     145
     146
    53147// #pragma mark - DwarfTypeContext
    54148
    55149
  • src/apps/debugger/debug_info/DwarfImageDebugInfo.cpp

     
    4646#include "TargetAddressRangeList.h"
    4747#include "TeamMemory.h"
    4848#include "Tracing.h"
     49#include "TypeLookupConstraints.h"
    4950#include "UnsupportedLanguage.h"
    5051#include "Variable.h"
    5152
     
    383384
    384385status_t
    385386DwarfImageDebugInfo::GetType(GlobalTypeCache* cache,
    386     const BString& name, Type*& _type)
     387    const BString& name, const TypeLookupConstraints& constraints,
     388    Type*& _type)
    387389{
    388390    int32 registerCount = fArchitecture->CountRegisters();
    389391    const Register* registers = fArchitecture->Registers();
     
    412414            if (typeEntry->IsDeclaration())
    413415                continue;
    414416
     417            if (constraints.HasTypeKind() &&
     418                dwarf_tag_to_type_kind(typeEntry->Tag())
     419                    != constraints.TypeKind())
     420                continue;
     421            if (constraints.HasSubtypeKind() &&
     422                dwarf_tag_to_subtype_kind(typeEntry->Tag())
     423                    != constraints.SubtypeKind())
     424                continue;
     425
    415426            BString typeEntryName;
    416427            DwarfUtils::GetFullyQualifiedDIEName(typeEntry, typeEntryName);
    417428            if (typeEntryName != name)
  • src/apps/debugger/debug_info/DwarfTypeFactory.cpp

     
    2727#include "SourceLanguageInfo.h"
    2828#include "StringUtils.h"
    2929#include "Tracing.h"
     30#include "TypeLookupConstraints.h"
    3031#include "ValueLocation.h"
    3132
    3233
     
    314315
    315316    // If the type entry indicates a declaration only, we try to look the
    316317    // type up globally first.
     318    TypeLookupConstraints constraints(
     319        dwarf_tag_to_type_kind(typeEntry->Tag()));
     320    int32 subtypeKind = dwarf_tag_to_subtype_kind(typeEntry->Tag());
     321    if (subtypeKind >= 0)
     322        constraints.SetSubtypeKind(subtypeKind);
    317323    if (typeEntry->IsDeclaration() && name.Length() > 0
    318         && fTypeLookup->GetType(fTypeCache, name, globalType)
     324        && fTypeLookup->GetType(fTypeCache, name,
     325            constraints, globalType)
    319326            == B_OK) {
    320327        DwarfType* globalDwarfType
    321328            = dynamic_cast<DwarfType*>(globalType);
  • src/apps/debugger/debug_info/GlobalTypeLookup.h

     
    1515
    1616class BString;
    1717class Type;
     18class TypeLookupConstraints;
    1819
    19 
    2020enum global_type_cache_scope {
    2121    GLOBAL_TYPE_CACHE_SCOPE_GLOBAL,
    2222    GLOBAL_TYPE_CACHE_SCOPE_COMPILATION_UNIT
     
    6262    virtual                     ~GlobalTypeLookup();
    6363
    6464    virtual status_t            GetType(GlobalTypeCache* cache,
    65                                     const BString& name, Type*& _type) = 0;
     65                                    const BString& name,
     66                                    const TypeLookupConstraints& constraints,
     67                                    Type*& _type) = 0;
    6668                                    // returns a reference
    6769};
    6870
  • src/apps/debugger/debug_info/ImageDebugInfo.h

     
    2626class LocatableFile;
    2727class SpecificImageDebugInfo;
    2828class Type;
     29class TypeLookupConstraints;
    2930
    3031
    3132class ImageDebugInfo : public BReferenceable {
     
    3940            status_t            FinishInit();
    4041
    4142            status_t            GetType(GlobalTypeCache* cache,
    42                                     const BString& name, Type*& _type);
     43                                    const BString& name,
     44                                    const TypeLookupConstraints& constraints,
     45                                    Type*& _type);
    4346                                    // returns a reference
    4447            AddressSectionType  GetAddressSectionType(target_addr_t address)
    4548                                    const;
  • src/apps/debugger/debug_info/DebuggerImageDebugInfo.cpp

     
    8080
    8181status_t
    8282DebuggerImageDebugInfo::GetType(GlobalTypeCache* cache,
    83     const BString& name, Type*& _type)
     83    const BString& name, const TypeLookupConstraints& constraints,
     84    Type*& _type)
    8485{
    8586    return B_UNSUPPORTED;
    8687}
  • src/apps/debugger/debug_info/TeamDebugInfo.h

     
    4343            status_t            Init();
    4444
    4545    virtual status_t            GetType(GlobalTypeCache* cache,
    46                                     const BString& name, Type*& _type);
     46                                    const BString& name,
     47                                    const TypeLookupConstraints& constraints,
     48                                    Type*& _type);
    4749
    4850            status_t            LoadImageDebugInfo(const ImageInfo& imageInfo,
    4951                                    LocatableFile* imageFile,
  • src/apps/debugger/debug_info/DwarfTypes.h

     
    4141class ValueLocation;
    4242
    4343
     44// conversion functions between model types and dwarf types
     45type_kind dwarf_tag_to_type_kind(int32 tag);
     46int32 dwarf_tag_to_subtype_kind(int32 tag);
     47
     48
    4449class DwarfTypeContext : public BReferenceable {
    4550public:
    4651                                DwarfTypeContext(Architecture* architecture,
  • src/apps/debugger/Jamfile

     
    134134    ThreadInfo.cpp
    135135    Type.cpp
    136136    TypeComponentPath.cpp
     137    TypeLookupConstraints.cpp
    137138    Variable.cpp
    138139
    139140    # settings