Home | History | Annotate | Download | only in DataFormatters 
      1 //===-- FormatNavigator.h ----------------------------------------*- C++ -*-===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 #ifndef lldb_FormatNavigator_h_
     11 #define lldb_FormatNavigator_h_
     12 
     13 // C Includes
     14 // C++ Includes
     15 
     16 // Other libraries and framework includes
     17 #include "clang/AST/DeclCXX.h"
     18 #include "clang/AST/Type.h"
     19 #include "clang/AST/DeclObjC.h"
     20 
     21 // Project includes
     22 #include "lldb/lldb-public.h"
     23 
     24 #include "lldb/Core/Log.h"
     25 #include "lldb/Core/RegularExpression.h"
     26 #include "lldb/Core/ValueObject.h"
     27 
     28 #include "lldb/DataFormatters/FormatClasses.h"
     29 
     30 #include "lldb/Symbol/ClangASTContext.h"
     31 #include "lldb/Symbol/ClangASTType.h"
     32 
     33 #include "lldb/Target/ObjCLanguageRuntime.h"
     34 #include "lldb/Target/Process.h"
     35 #include "lldb/Target/StackFrame.h"
     36 #include "lldb/Target/TargetList.h"
     37 
     38 namespace lldb_private {
     39 
     40 // this file (and its. cpp) contain the low-level implementation of LLDB Data Visualization
     41 // class DataVisualization is the high-level front-end of this feature
     42 // clients should refer to that class as the entry-point into the data formatters
     43 // unless they have a good reason to bypass it and prefer to use this file's objects directly
     44 class IFormatChangeListener
     45 {
     46 public:
     47     virtual void
     48     Changed () = 0;
     49 
     50     virtual
     51     ~IFormatChangeListener () {}
     52 
     53     virtual uint32_t
     54     GetCurrentRevision () = 0;
     55 
     56 };
     57 
     58 static inline bool
     59 IsWhitespace (char c)
     60 {
     61     return ( (c == ' ') || (c == '\t') || (c == '\v') || (c == '\f') );
     62 }
     63 
     64 static inline bool
     65 HasPrefix (const char* str1, const char* str2)
     66 {
     67     return ( ::strstr(str1, str2) == str1 );
     68 }
     69 
     70 // if the user tries to add formatters for, say, "struct Foo"
     71 // those will not match any type because of the way we strip qualifiers from typenames
     72 // this method looks for the case where the user is adding a "class","struct","enum" or "union" Foo
     73 // and strips the unnecessary qualifier
     74 static inline ConstString
     75 GetValidTypeName_Impl (const ConstString& type)
     76 {
     77     int strip_len = 0;
     78 
     79     if (type == false)
     80         return type;
     81 
     82     const char* type_cstr = type.AsCString();
     83 
     84     if ( HasPrefix(type_cstr, "class ") )
     85         strip_len = 6;
     86     else if ( HasPrefix(type_cstr, "enum ") )
     87         strip_len = 5;
     88     else if ( HasPrefix(type_cstr, "struct ") )
     89         strip_len = 7;
     90     else if ( HasPrefix(type_cstr, "union ") )
     91         strip_len = 6;
     92 
     93     if (strip_len == 0)
     94         return type;
     95 
     96     type_cstr += strip_len;
     97     while (IsWhitespace(*type_cstr) && ++type_cstr)
     98         ;
     99 
    100     return ConstString(type_cstr);
    101 }
    102 
    103 template<typename KeyType, typename ValueType>
    104 class FormatNavigator;
    105 
    106 template<typename KeyType, typename ValueType>
    107 class FormatMap
    108 {
    109 public:
    110 
    111     typedef typename ValueType::SharedPointer ValueSP;
    112     typedef std::map<KeyType, ValueSP> MapType;
    113     typedef typename MapType::iterator MapIterator;
    114     typedef bool(*CallbackType)(void*, KeyType, const ValueSP&);
    115 
    116     FormatMap(IFormatChangeListener* lst) :
    117     m_map(),
    118     m_map_mutex(Mutex::eMutexTypeRecursive),
    119     listener(lst)
    120     {
    121     }
    122 
    123     void
    124     Add(KeyType name,
    125         const ValueSP& entry)
    126     {
    127         if (listener)
    128             entry->GetRevision() = listener->GetCurrentRevision();
    129         else
    130             entry->GetRevision() = 0;
    131 
    132         Mutex::Locker locker(m_map_mutex);
    133         m_map[name] = entry;
    134         if (listener)
    135             listener->Changed();
    136     }
    137 
    138     bool
    139     Delete (KeyType name)
    140     {
    141         Mutex::Locker locker(m_map_mutex);
    142         MapIterator iter = m_map.find(name);
    143         if (iter == m_map.end())
    144             return false;
    145         m_map.erase(name);
    146         if (listener)
    147             listener->Changed();
    148         return true;
    149     }
    150 
    151     void
    152     Clear ()
    153     {
    154         Mutex::Locker locker(m_map_mutex);
    155         m_map.clear();
    156         if (listener)
    157             listener->Changed();
    158     }
    159 
    160     bool
    161     Get(KeyType name,
    162         ValueSP& entry)
    163     {
    164         Mutex::Locker locker(m_map_mutex);
    165         MapIterator iter = m_map.find(name);
    166         if (iter == m_map.end())
    167             return false;
    168         entry = iter->second;
    169         return true;
    170     }
    171 
    172     void
    173     LoopThrough (CallbackType callback, void* param)
    174     {
    175         if (callback)
    176         {
    177             Mutex::Locker locker(m_map_mutex);
    178             MapIterator pos, end = m_map.end();
    179             for (pos = m_map.begin(); pos != end; pos++)
    180             {
    181                 KeyType type = pos->first;
    182                 if (!callback(param, type, pos->second))
    183                     break;
    184             }
    185         }
    186     }
    187 
    188     uint32_t
    189     GetCount ()
    190     {
    191         return m_map.size();
    192     }
    193 
    194     ValueSP
    195     GetValueAtIndex (size_t index)
    196     {
    197         Mutex::Locker locker(m_map_mutex);
    198         MapIterator iter = m_map.begin();
    199         MapIterator end = m_map.end();
    200         while (index > 0)
    201         {
    202             iter++;
    203             index--;
    204             if (end == iter)
    205                 return ValueSP();
    206         }
    207         return iter->second;
    208     }
    209 
    210     KeyType
    211     GetKeyAtIndex (size_t index)
    212     {
    213         Mutex::Locker locker(m_map_mutex);
    214         MapIterator iter = m_map.begin();
    215         MapIterator end = m_map.end();
    216         while (index > 0)
    217         {
    218             iter++;
    219             index--;
    220             if (end == iter)
    221                 return KeyType();
    222         }
    223         return iter->first;
    224     }
    225 
    226 protected:
    227     MapType m_map;
    228     Mutex m_map_mutex;
    229     IFormatChangeListener* listener;
    230 
    231     MapType&
    232     map ()
    233     {
    234         return m_map;
    235     }
    236 
    237     Mutex&
    238     mutex ()
    239     {
    240         return m_map_mutex;
    241     }
    242 
    243     friend class FormatNavigator<KeyType, ValueType>;
    244     friend class FormatManager;
    245 
    246 };
    247 
    248 template<typename KeyType, typename ValueType>
    249 class FormatNavigator
    250 {
    251 protected:
    252     typedef FormatMap<KeyType,ValueType> BackEndType;
    253 
    254 public:
    255     typedef typename BackEndType::MapType MapType;
    256     typedef typename MapType::iterator MapIterator;
    257     typedef typename MapType::key_type MapKeyType;
    258     typedef typename MapType::mapped_type MapValueType;
    259     typedef typename BackEndType::CallbackType CallbackType;
    260     typedef typename std::shared_ptr<FormatNavigator<KeyType, ValueType> > SharedPointer;
    261 
    262     friend class TypeCategoryImpl;
    263 
    264     FormatNavigator(std::string name,
    265                     IFormatChangeListener* lst) :
    266     m_format_map(lst),
    267     m_name(name),
    268     m_id_cs(ConstString("id"))
    269     {
    270     }
    271 
    272     void
    273     Add (const MapKeyType &type, const MapValueType& entry)
    274     {
    275         Add_Impl(type, entry, (KeyType*)NULL);
    276     }
    277 
    278     bool
    279     Delete (ConstString type)
    280     {
    281         return Delete_Impl(type, (KeyType*)NULL);
    282     }
    283 
    284     bool
    285     Get(ValueObject& valobj,
    286         MapValueType& entry,
    287         lldb::DynamicValueType use_dynamic,
    288         uint32_t* why = NULL)
    289     {
    290         uint32_t value = lldb_private::eFormatterChoiceCriterionDirectChoice;
    291         ClangASTType ast_type(valobj.GetClangType());
    292         bool ret = Get(valobj, ast_type, entry, use_dynamic, value);
    293         if (ret)
    294             entry = MapValueType(entry);
    295         else
    296             entry = MapValueType();
    297         if (why)
    298             *why = value;
    299         return ret;
    300     }
    301 
    302     bool
    303     Get (ConstString type, MapValueType& entry)
    304     {
    305         return Get_Impl(type, entry, (KeyType*)NULL);
    306     }
    307 
    308     bool
    309     GetExact (ConstString type, MapValueType& entry)
    310     {
    311         return GetExact_Impl(type, entry, (KeyType*)NULL);
    312     }
    313 
    314     MapValueType
    315     GetAtIndex (size_t index)
    316     {
    317         return m_format_map.GetValueAtIndex(index);
    318     }
    319 
    320     lldb::TypeNameSpecifierImplSP
    321     GetTypeNameSpecifierAtIndex (size_t index)
    322     {
    323         return GetTypeNameSpecifierAtIndex_Impl(index, (KeyType*)NULL);
    324     }
    325 
    326     void
    327     Clear ()
    328     {
    329         m_format_map.Clear();
    330     }
    331 
    332     void
    333     LoopThrough (CallbackType callback, void* param)
    334     {
    335         m_format_map.LoopThrough(callback,param);
    336     }
    337 
    338     uint32_t
    339     GetCount ()
    340     {
    341         return m_format_map.GetCount();
    342     }
    343 
    344 protected:
    345 
    346     BackEndType m_format_map;
    347 
    348     std::string m_name;
    349 
    350     DISALLOW_COPY_AND_ASSIGN(FormatNavigator);
    351 
    352     ConstString m_id_cs;
    353 
    354     void
    355     Add_Impl (const MapKeyType &type, const MapValueType& entry, lldb::RegularExpressionSP *dummy)
    356     {
    357        m_format_map.Add(type,entry);
    358     }
    359 
    360     void Add_Impl (const ConstString &type, const MapValueType& entry, ConstString *dummy)
    361     {
    362        m_format_map.Add(GetValidTypeName_Impl(type), entry);
    363     }
    364 
    365     bool
    366     Delete_Impl (ConstString type, ConstString *dummy)
    367     {
    368        return m_format_map.Delete(type);
    369     }
    370 
    371     bool
    372     Delete_Impl (ConstString type, lldb::RegularExpressionSP *dummy)
    373     {
    374        Mutex& x_mutex = m_format_map.mutex();
    375         lldb_private::Mutex::Locker locker(x_mutex);
    376        MapIterator pos, end = m_format_map.map().end();
    377        for (pos = m_format_map.map().begin(); pos != end; pos++)
    378        {
    379            lldb::RegularExpressionSP regex = pos->first;
    380            if ( ::strcmp(type.AsCString(),regex->GetText()) == 0)
    381            {
    382                m_format_map.map().erase(pos);
    383                if (m_format_map.listener)
    384                    m_format_map.listener->Changed();
    385                return true;
    386            }
    387        }
    388        return false;
    389     }
    390 
    391     bool
    392     Get_Impl (ConstString type, MapValueType& entry, ConstString *dummy)
    393     {
    394        return m_format_map.Get(type, entry);
    395     }
    396 
    397     bool
    398     GetExact_Impl (ConstString type, MapValueType& entry, ConstString *dummy)
    399     {
    400         return Get_Impl(type,entry, (KeyType*)0);
    401     }
    402 
    403     lldb::TypeNameSpecifierImplSP
    404     GetTypeNameSpecifierAtIndex_Impl (size_t index, ConstString *dummy)
    405     {
    406         ConstString key = m_format_map.GetKeyAtIndex(index);
    407         if (key)
    408             return lldb::TypeNameSpecifierImplSP(new TypeNameSpecifierImpl(key.AsCString(),
    409                                                                            false));
    410         else
    411             return lldb::TypeNameSpecifierImplSP();
    412     }
    413 
    414     lldb::TypeNameSpecifierImplSP
    415     GetTypeNameSpecifierAtIndex_Impl (size_t index, lldb::RegularExpressionSP *dummy)
    416     {
    417         lldb::RegularExpressionSP regex = m_format_map.GetKeyAtIndex(index);
    418         if (regex.get() == NULL)
    419             return lldb::TypeNameSpecifierImplSP();
    420         return lldb::TypeNameSpecifierImplSP(new TypeNameSpecifierImpl(regex->GetText(),
    421                                                                        true));
    422     }
    423 
    424     bool
    425     Get_Impl (ConstString key, MapValueType& value, lldb::RegularExpressionSP *dummy)
    426     {
    427        const char* key_cstr = key.AsCString();
    428        if (!key_cstr)
    429            return false;
    430        Mutex& x_mutex = m_format_map.mutex();
    431        lldb_private::Mutex::Locker locker(x_mutex);
    432        MapIterator pos, end = m_format_map.map().end();
    433        for (pos = m_format_map.map().begin(); pos != end; pos++)
    434        {
    435            lldb::RegularExpressionSP regex = pos->first;
    436            if (regex->Execute(key_cstr))
    437            {
    438                value = pos->second;
    439                return true;
    440            }
    441        }
    442        return false;
    443     }
    444 
    445     bool
    446     GetExact_Impl (ConstString key, MapValueType& value, lldb::RegularExpressionSP *dummy)
    447     {
    448         Mutex& x_mutex = m_format_map.mutex();
    449         lldb_private::Mutex::Locker locker(x_mutex);
    450         MapIterator pos, end = m_format_map.map().end();
    451         for (pos = m_format_map.map().begin(); pos != end; pos++)
    452         {
    453             lldb::RegularExpressionSP regex = pos->first;
    454             if (strcmp(regex->GetText(),key.AsCString()) == 0)
    455             {
    456                 value = pos->second;
    457                 return true;
    458             }
    459         }
    460         return false;
    461     }
    462 
    463     bool
    464     Get_BitfieldMatch (ValueObject& valobj,
    465                        ConstString typeName,
    466                        MapValueType& entry,
    467                        uint32_t& reason)
    468     {
    469         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
    470         // for bitfields, append size to the typename so one can custom format them
    471         StreamString sstring;
    472         sstring.Printf("%s:%d",typeName.AsCString(),valobj.GetBitfieldBitSize());
    473         ConstString bitfieldname = ConstString(sstring.GetData());
    474         if (log)
    475             log->Printf("[Get_BitfieldMatch] appended bitfield info, final result is %s", bitfieldname.GetCString());
    476         if (Get(bitfieldname, entry))
    477         {
    478             if (log)
    479                 log->Printf("[Get_BitfieldMatch] bitfield direct match found, returning");
    480             return true;
    481         }
    482         else
    483         {
    484             reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField;
    485             if (log)
    486                 log->Printf("[Get_BitfieldMatch] no bitfield direct match");
    487             return false;
    488         }
    489     }
    490 
    491     bool Get_ObjC (ValueObject& valobj,
    492                    MapValueType& entry)
    493     {
    494         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
    495         lldb::ProcessSP process_sp = valobj.GetProcessSP();
    496         ObjCLanguageRuntime* runtime = process_sp->GetObjCLanguageRuntime();
    497         if (runtime == NULL)
    498         {
    499             if (log)
    500                 log->Printf("[Get_ObjC] no valid ObjC runtime, skipping dynamic");
    501             return false;
    502         }
    503         ObjCLanguageRuntime::ClassDescriptorSP objc_class_sp (runtime->GetClassDescriptor(valobj));
    504         if (!objc_class_sp)
    505         {
    506             if (log)
    507                 log->Printf("[Get_ObjC] invalid ISA, skipping dynamic");
    508             return false;
    509         }
    510         ConstString name (objc_class_sp->GetClassName());
    511         if (log)
    512             log->Printf("[Get_ObjC] dynamic type inferred is %s - looking for direct dynamic match", name.GetCString());
    513         if (Get(name, entry))
    514         {
    515             if (log)
    516                 log->Printf("[Get_ObjC] direct dynamic match found, returning");
    517             return true;
    518         }
    519         if (log)
    520             log->Printf("[Get_ObjC] no dynamic match");
    521         return false;
    522     }
    523 
    524     bool
    525     Get_Impl (ValueObject& valobj,
    526               ClangASTType clang_type,
    527               MapValueType& entry,
    528               lldb::DynamicValueType use_dynamic,
    529               uint32_t& reason)
    530     {
    531         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
    532 
    533         if (!clang_type.IsValid())
    534         {
    535             if (log)
    536                 log->Printf("[Get_Impl] type is invalid, returning");
    537             return false;
    538         }
    539 
    540         clang_type = clang_type.RemoveFastQualifiers();
    541 
    542         ConstString typeName(clang_type.GetConstTypeName());
    543 
    544         if (valobj.GetBitfieldBitSize() > 0)
    545         {
    546             if (Get_BitfieldMatch(valobj, typeName, entry, reason))
    547                 return true;
    548         }
    549 
    550         if (log)
    551             log->Printf("[Get_Impl] trying to get %s for VO name %s of type %s",
    552                         m_name.c_str(),
    553                         valobj.GetName().AsCString(),
    554                         typeName.AsCString());
    555 
    556         if (Get(typeName, entry))
    557         {
    558             if (log)
    559                 log->Printf("[Get] direct match found, returning");
    560             return true;
    561         }
    562         if (log)
    563             log->Printf("[Get_Impl] no direct match");
    564 
    565         // strip pointers and references and see if that helps
    566         if (clang_type.IsReferenceType())
    567         {
    568             if (log)
    569                 log->Printf("[Get_Impl] stripping reference");
    570             if (Get_Impl(valobj, clang_type.GetNonReferenceType(), entry, use_dynamic, reason) && !entry->SkipsReferences())
    571             {
    572                 reason |= lldb_private::eFormatterChoiceCriterionStrippedPointerReference;
    573                 return true;
    574             }
    575         }
    576         else if (clang_type.IsPointerType())
    577         {
    578             if (log)
    579                 log->Printf("[Get_Impl] stripping pointer");
    580             if (Get_Impl(valobj, clang_type.GetPointeeType(), entry, use_dynamic, reason) && !entry->SkipsPointers())
    581             {
    582                 reason |= lldb_private::eFormatterChoiceCriterionStrippedPointerReference;
    583                 return true;
    584             }
    585         }
    586 
    587         bool canBeObjCDynamic = valobj.GetClangType().IsPossibleDynamicType (NULL,
    588                                                                              false, // no C++
    589                                                                              true); // yes ObjC
    590 
    591         if (canBeObjCDynamic)
    592         {
    593             if (use_dynamic != lldb::eNoDynamicValues)
    594             {
    595                 if (log)
    596                     log->Printf("[Get_Impl] allowed to figure out dynamic ObjC type");
    597                 if (Get_ObjC(valobj,entry))
    598                 {
    599                     reason |= lldb_private::eFormatterChoiceCriterionDynamicObjCDiscovery;
    600                     return true;
    601                 }
    602             }
    603             if (log)
    604                 log->Printf("[Get_Impl] dynamic disabled or failed - stripping ObjC pointer");
    605             if (Get_Impl(valobj, clang_type.GetPointeeType(), entry, use_dynamic, reason) && !entry->SkipsPointers())
    606             {
    607                 reason |= lldb_private::eFormatterChoiceCriterionStrippedPointerReference;
    608                 return true;
    609             }
    610         }
    611 
    612         // try to strip typedef chains
    613         if (clang_type.IsTypedefType())
    614         {
    615             if (log)
    616                 log->Printf("[Get_Impl] stripping typedef");
    617             if ((Get_Impl(valobj, clang_type.GetTypedefedType(), entry, use_dynamic, reason)) && entry->Cascades())
    618             {
    619                 reason |= lldb_private::eFormatterChoiceCriterionNavigatedTypedefs;
    620                 return true;
    621             }
    622         }
    623 
    624         // out of luck here
    625         return false;
    626     }
    627 
    628     // we are separately passing in valobj and type because the valobj is fixed (and is used for ObjC discovery and bitfield size)
    629     // but the type can change (e.g. stripping pointers, ...)
    630     bool Get (ValueObject& valobj,
    631               ClangASTType clang_type,
    632               MapValueType& entry,
    633               lldb::DynamicValueType use_dynamic,
    634               uint32_t& reason)
    635     {
    636         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES));
    637 
    638         if (Get_Impl (valobj, clang_type, entry, use_dynamic, reason))
    639             return true;
    640 
    641         // try going to the unqualified type
    642         do {
    643             if (log)
    644                 log->Printf("[Get] trying the unqualified type");
    645             if (!clang_type.IsValid())
    646                 break;
    647 
    648             ClangASTType unqual_clang_ast_type = clang_type.GetFullyUnqualifiedType();
    649             if (!unqual_clang_ast_type.IsValid())
    650             {
    651                 if (log)
    652                     log->Printf("[Get] could not get the unqual_clang_ast_type");
    653                 break;
    654             }
    655             if (unqual_clang_ast_type.GetOpaqueQualType() != clang_type.GetOpaqueQualType())
    656             {
    657                 if (log)
    658                     log->Printf("[Get] unqualified type is there and is not the same, let's try");
    659                 if (Get_Impl (valobj, unqual_clang_ast_type,entry, use_dynamic, reason))
    660                     return true;
    661             }
    662             else if (log)
    663                 log->Printf("[Get] unqualified type same as original type");
    664         } while(false);
    665 
    666         // if all else fails, go to static type
    667         if (valobj.IsDynamic())
    668         {
    669             if (log)
    670                 log->Printf("[Get] going to static value");
    671             lldb::ValueObjectSP static_value_sp(valobj.GetStaticValue());
    672             if (static_value_sp)
    673             {
    674                 if (log)
    675                     log->Printf("[Get] has a static value - actually use it");
    676                 if (Get(*static_value_sp.get(), static_value_sp->GetClangType(), entry, use_dynamic, reason))
    677                 {
    678                     reason |= lldb_private::eFormatterChoiceCriterionWentToStaticValue;
    679                     return true;
    680                 }
    681             }
    682         }
    683 
    684         return false;
    685     }
    686 };
    687 
    688 } // namespace lldb_private
    689 
    690 #endif	// lldb_FormatNavigator_h_
    691