maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Testcase and fix for bug 24074 

Summary:
In bug 24074, the type information is not shown
correctly. This commit  includes the following -
-> Changes for displaying correct type based on
   current lexical scope for the command "image
   lookup -t"
-> The corresponding testcase.

Reviewers: jingham, ovyalov, spyffe, richard.mitton, clayborg

Differential Revision: http://reviews.llvm.org/D12404

llvm-svn: 248366
This commit is contained in:
Ravitheja Addepally 2015-09-23 07:19:02 +00:00
parent 77b94d4416
commit 9fcf72ef9b
22 changed files with 749 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lldb/include/lldb/Core/Module.h
View File

@ -1193,7 +1193,7 @@ private:
const CompilerDeclContext *parent_decl_ctx,
bool append,
size_t max_matches,
TypeList& types);
TypeMap& types);
DISALLOW_COPY_AND_ASSIGN (Module);

21
lldb/include/lldb/Symbol/SymbolContext.h
View File

@ -299,6 +299,27 @@ public:
ConstString &language_object_name);
//------------------------------------------------------------------
/// If this symbol context represents a function that is a method,
/// return true and provide information about the method.
///
/// @param[out] language
/// If \b true is returned, the language for the method.
///
/// @param[out] is_instance_method
/// If \b true is returned, \b true if this is a instance method,
/// \b false if this is a static/class function.
///
/// @param[out] language_object_name
/// If \b true is returned, the name of the artificial variable
/// for the language ("this" for C++, "self" for ObjC).
///
/// @return
/// \b True if this symbol context represents a function that
/// is a method of a class, \b false otherwise.
//------------------------------------------------------------------
void
SortTypeList(TypeMap &type_map, TypeList &type_list) const;
//------------------------------------------------------------------
/// Find a name of the innermost function for the symbol context.
///
/// For instance, if the symbol context contains an inlined block,

2
lldb/include/lldb/Symbol/SymbolFile.h
View File

@ -141,7 +141,7 @@ public:
virtual uint32_t FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables);
virtual uint32_t FindFunctions (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, SymbolContextList& sc_list);
virtual uint32_t FindFunctions (const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list);
virtual uint32_t FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeList& types);
virtual uint32_t FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeMap& types);
// virtual uint32_t FindTypes (const SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, TypeList& types) = 0;
virtual TypeList * GetTypeList ();
virtual size_t GetTypes (lldb_private::SymbolContextScope *sc_scope,

3
lldb/include/lldb/Symbol/SymbolVendor.h
View File

@ -16,6 +16,7 @@
#include "lldb/Core/ModuleChild.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/TypeMap.h"
namespace lldb_private {
@ -125,7 +126,7 @@ public:
const CompilerDeclContext *parent_decl_ctx,
bool append,
size_t max_matches,
TypeList& types);
TypeMap& types);
virtual CompilerDeclContext
FindNamespace (const SymbolContext& sc,

13
lldb/include/lldb/Symbol/TypeList.h
View File

@ -13,7 +13,7 @@
#include "lldb/lldb-private.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Utility/Iterable.h"
#include <map>
#include <vector>
#include <functional>
namespace lldb_private {
@ -24,7 +24,7 @@ public:
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
TypeList();
TypeList();
virtual
~TypeList();
@ -44,17 +44,14 @@ public:
void
Insert (const lldb::TypeSP& type);
bool
InsertUnique (const lldb::TypeSP& type);
uint32_t
GetSize() const;
lldb::TypeSP
GetTypeAtIndex(uint32_t idx);
typedef std::multimap<lldb::user_id_t, lldb::TypeSP> collection;
typedef AdaptedIterable<collection, lldb::TypeSP, map_adapter> TypeIterable;
typedef std::vector<lldb::TypeSP> collection;
typedef AdaptedIterable<collection, lldb::TypeSP, vector_adapter> TypeIterable;
TypeIterable
Types ()
@ -68,8 +65,6 @@ public:
void
ForEach (std::function <bool(lldb::TypeSP &type_sp)> const &callback);
bool
RemoveTypeWithUID (lldb::user_id_t uid);
void
RemoveMismatchedTypes (const char *qualified_typename,

98
lldb/include/lldb/Symbol/TypeMap.h Normal file
View File

@ -0,0 +1,98 @@
//===-- TypeMap.h ----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_TypeMap_h_
#define liblldb_TypeMap_h_
#include "lldb/lldb-private.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Utility/Iterable.h"
#include <map>
#include <functional>
namespace lldb_private {
class TypeMap
{
public:
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
TypeMap();
virtual
~TypeMap();
void
Clear();
void
Dump(Stream *s, bool show_context);
// lldb::TypeSP
// FindType(lldb::user_id_t uid);
TypeMap
FindTypes(const ConstString &name);
void
Insert (const lldb::TypeSP& type);
bool
InsertUnique (const lldb::TypeSP& type);
uint32_t
GetSize() const;
lldb::TypeSP
GetTypeAtIndex(uint32_t idx);
typedef std::multimap<lldb::user_id_t, lldb::TypeSP> collection;
typedef AdaptedIterable<collection, lldb::TypeSP, map_adapter> TypeIterable;
TypeIterable
Types ()
{
return TypeIterable(m_types);
}
void
ForEach (std::function <bool(const lldb::TypeSP &type_sp)> const &callback) const;
void
ForEach (std::function <bool(lldb::TypeSP &type_sp)> const &callback);
bool
RemoveTypeWithUID (lldb::user_id_t uid);
void
RemoveMismatchedTypes (const char *qualified_typename,
bool exact_match);
void
RemoveMismatchedTypes (const std::string &type_scope,
const std::string &type_basename,
lldb::TypeClass type_class,
bool exact_match);
void
RemoveMismatchedTypes (lldb::TypeClass type_class);
private:
typedef collection::iterator iterator;
typedef collection::const_iterator const_iterator;
collection m_types;
DISALLOW_COPY_AND_ASSIGN (TypeMap);
};
} // namespace lldb_private
#endif // liblldb_TypeMap_h_

1
lldb/include/lldb/lldb-forward.h
View File

@ -254,6 +254,7 @@ class TypeAndOrName;
class TypeCategoryMap;
class TypeImpl;
class TypeList;
class TypeMap;
class TypeListImpl;
class TypeMemberImpl;
class TypeMemberFunctionImpl;

1
lldb/source/Commands/CommandObjectTarget.cpp
View File

@ -1918,7 +1918,6 @@ LookupTypeHere (CommandInterpreter &interpreter,
strm.PutCString("Best match found in ");
DumpFullpath (strm, &sym_ctx.module_sp->GetFileSpec(), 0);
strm.PutCString(":\n");
TypeSP type_sp (type_list.GetTypeAtIndex(0));
if (type_sp)
{

28
lldb/source/Core/Module.cpp
View File

@ -36,6 +36,7 @@
#include "lldb/Target/Target.h"
#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
#include "Plugins/Language/ObjC/ObjCLanguage.h"
#include "lldb/Symbol/TypeMap.h"
#include "Plugins/ObjectFile/JIT/ObjectFileJIT.h"
@ -940,7 +941,7 @@ Module::FindTypes_Impl (const SymbolContext& sc,
const CompilerDeclContext *parent_decl_ctx,
bool append,
size_t max_matches,
TypeList& types)
TypeMap& types)
{
Timer scoped_timer(__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
if (sc.module_sp.get() == NULL || sc.module_sp.get() == this)
@ -960,7 +961,11 @@ Module::FindTypesInNamespace (const SymbolContext& sc,
TypeList& type_list)
{
const bool append = true;
return FindTypes_Impl(sc, type_name, parent_decl_ctx, append, max_matches, type_list);
TypeMap types_map;
size_t num_types = FindTypes_Impl(sc, type_name, parent_decl_ctx, append, max_matches, types_map);
if (num_types > 0)
sc.SortTypeList(types_map, type_list);
return num_types;
}
lldb::TypeSP
@ -989,6 +994,7 @@ Module::FindTypes (const SymbolContext& sc,
std::string type_basename;
const bool append = true;
TypeClass type_class = eTypeClassAny;
TypeMap typesmap;
if (Type::GetTypeScopeAndBasename (type_name_cstr, type_scope, type_basename, type_class))
{
// Check if "name" starts with "::" which means the qualified type starts
@ -1002,10 +1008,10 @@ Module::FindTypes (const SymbolContext& sc,
exact_match = true;
}
ConstString type_basename_const_str (type_basename.c_str());
if (FindTypes_Impl(sc, type_basename_const_str, NULL, append, max_matches, types))
if (FindTypes_Impl(sc, type_basename_const_str, NULL, append, max_matches, typesmap))
{
types.RemoveMismatchedTypes (type_scope, type_basename, type_class, exact_match);
num_matches = types.GetSize();
typesmap.RemoveMismatchedTypes (type_scope, type_basename, type_class, exact_match);
num_matches = typesmap.GetSize();
}
}
else
@ -1015,18 +1021,18 @@ Module::FindTypes (const SymbolContext& sc,
{
// The "type_name_cstr" will have been modified if we have a valid type class
// prefix (like "struct", "class", "union", "typedef" etc).
FindTypes_Impl(sc, ConstString(type_name_cstr), NULL, append, max_matches, types);
types.RemoveMismatchedTypes (type_class);
num_matches = types.GetSize();
FindTypes_Impl(sc, ConstString(type_name_cstr), NULL, append, max_matches, typesmap);
typesmap.RemoveMismatchedTypes (type_class);
num_matches = typesmap.GetSize();
}
else
{
num_matches = FindTypes_Impl(sc, name, NULL, append, max_matches, types);
num_matches = FindTypes_Impl(sc, name, NULL, append, max_matches, typesmap);
}
}
if (num_matches > 0)
sc.SortTypeList(typesmap, types);
return num_matches;
}
SymbolVendor*

14
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
View File

@ -43,6 +43,7 @@
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Symbol/TypeMap.h"
#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
#include "Plugins/Language/ObjC/ObjCLanguage.h"
@ -2840,7 +2841,7 @@ SymbolFileDWARF::FindTypes (const SymbolContext& sc,
const CompilerDeclContext *parent_decl_ctx,
bool append,
uint32_t max_matches,
TypeList& types)
TypeMap& types)
{
DWARFDebugInfo* info = DebugInfo();
if (info == NULL)
@ -3054,6 +3055,17 @@ SymbolFileDWARF::GetTypeForDIE (const DWARFDIE &die)
CompileUnit* lldb_cu = GetCompUnitForDWARFCompUnit(die.GetCU());
assert (lldb_cu);
SymbolContext sc(lldb_cu);
const DWARFDebugInfoEntry* parent_die = die.GetParent().GetDIE();
while (parent_die != nullptr)
{
if (parent_die->Tag() == DW_TAG_subprogram)
break;
parent_die = parent_die->GetParent();
}
SymbolContext sc_backup = sc;
if (parent_die != nullptr && !GetFunction(DWARFDIE(die.GetCU(),parent_die), sc))
sc = sc_backup;
type_sp = ParseType(sc, die, NULL);
}
else if (type_ptr != DIE_IS_BEING_PARSED)

2
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
View File

@ -207,7 +207,7 @@ public:
const lldb_private::CompilerDeclContext *parent_decl_ctx,
bool append,
uint32_t max_matches,
lldb_private::TypeList& types) override;
lldb_private::TypeMap& types) override;
lldb_private::TypeList *
GetTypeList () override;

3
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
View File

@ -28,6 +28,7 @@
#include "lldb/Symbol/LineTable.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/TypeMap.h"
#include "lldb/Symbol/VariableList.h"
#include "LogChannelDWARF.h"
@ -1295,7 +1296,7 @@ SymbolFileDWARFDebugMap::FindTypes
const CompilerDeclContext *parent_decl_ctx,
bool append,
uint32_t max_matches,
TypeList& types
TypeMap& types
)
{
if (!append)

2
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h
View File

@ -79,7 +79,7 @@ public:
uint32_t FindGlobalVariables (const lldb_private::RegularExpression& regex, bool append, uint32_t max_matches, lldb_private::VariableList& variables) override;
uint32_t FindFunctions (const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, lldb_private::SymbolContextList& sc_list) override;
uint32_t FindFunctions (const lldb_private::RegularExpression& regex, bool include_inlines, bool append, lldb_private::SymbolContextList& sc_list) override;
uint32_t FindTypes (const lldb_private::SymbolContext& sc, const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, lldb_private::TypeList& types) override;
uint32_t FindTypes (const lldb_private::SymbolContext& sc, const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, lldb_private::TypeMap& types) override;
lldb_private::CompilerDeclContext
FindNamespace (const lldb_private::SymbolContext& sc,
const lldb_private::ConstString &name,

1
lldb/source/Symbol/CMakeLists.txt
View File

@ -24,6 +24,7 @@ add_lldb_library(lldbSymbol
Symtab.cpp
Type.cpp
TypeList.cpp
TypeMap.cpp
TypeSystem.cpp
UnwindPlan.cpp
UnwindTable.cpp

165
lldb/source/Symbol/SymbolContext.cpp
View File

@ -659,6 +659,171 @@ SymbolContext::GetFunctionMethodInfo (lldb::LanguageType &language,
return false;
}
class TypeMoveMatchingBlock
{
public:
TypeMoveMatchingBlock(Block * block, TypeMap &typem, TypeList &typel) :
curr_block(block),type_map(typem),type_list(typel)
{
}
bool
operator() (const lldb::TypeSP& type)
{
if (type && type->GetSymbolContextScope() != nullptr && curr_block == type->GetSymbolContextScope()->CalculateSymbolContextBlock())
{
type_list.Insert(type);
type_map.RemoveTypeWithUID(type->GetID());
return false;
}
return true;
}
private:
const Block * const curr_block;
TypeMap &type_map;
TypeList &type_list;
};
class TypeMoveMatchingFunction
{
public:
TypeMoveMatchingFunction(Function * block, TypeMap &typem, TypeList &typel) :
func(block),type_map(typem),type_list(typel)
{
}
bool
operator() (const lldb::TypeSP& type)
{
if (type && type->GetSymbolContextScope() != nullptr && func == type->GetSymbolContextScope()->CalculateSymbolContextFunction())
{
type_list.Insert(type);
type_map.RemoveTypeWithUID(type->GetID());
return false;
}
return true;
}
private:
const Function * const func;
TypeMap &type_map;
TypeList &type_list;
};
class TypeMoveMatchingCompileUnit
{
public:
TypeMoveMatchingCompileUnit(CompileUnit * cunit, TypeMap &typem, TypeList &typel) :
comp_unit(cunit),type_map(typem),type_list(typel)
{
}
bool
operator() (const lldb::TypeSP& type)
{
if (type && type->GetSymbolContextScope() != nullptr && comp_unit == type->GetSymbolContextScope()->CalculateSymbolContextCompileUnit())
{
type_list.Insert(type);
type_map.RemoveTypeWithUID(type->GetID());
return false;
}
return true;
}
private:
const CompileUnit * const comp_unit;
TypeMap &type_map;
TypeList &type_list;
};
class TypeMoveMatchingModule
{
public:
TypeMoveMatchingModule(lldb::ModuleSP modsp, TypeMap &typem, TypeList &typel) :
modulesp(modsp),type_map(typem),type_list(typel)
{
}
bool
operator() (const lldb::TypeSP& type)
{
if (type && type->GetSymbolContextScope() != nullptr && modulesp.get() == type->GetSymbolContextScope()->CalculateSymbolContextModule().get())
{
type_list.Insert(type);
type_map.RemoveTypeWithUID(type->GetID());
return false;
}
return true;
}
private:
lldb::ModuleSP modulesp;
TypeMap &type_map;
TypeList &type_list;
};
class TypeMaptoList
{
public:
TypeMaptoList(TypeMap &typem, TypeList &typel) :
type_map(typem),type_list(typel)
{
}
bool
operator() (const lldb::TypeSP& type)
{
if(type)
{
type_list.Insert(type);
type_map.RemoveTypeWithUID(type->GetID());
}
return true;
}
private:
TypeMap &type_map;
TypeList &type_list;
};
void
SymbolContext::SortTypeList(TypeMap &type_map, TypeList &type_list ) const
{
Block * curr_block = block;
bool isInlinedblock = false;
if(curr_block != nullptr && curr_block->GetContainingInlinedBlock() != nullptr)
isInlinedblock = true;
while (curr_block != nullptr && !isInlinedblock)
{
TypeMoveMatchingBlock callbackBlock (curr_block, type_map, type_list);
type_map.ForEach(callbackBlock);
curr_block = curr_block->GetParent();
}
if(function != nullptr && type_map.GetSize() > 0)
{
TypeMoveMatchingFunction callbackFunction (function, type_map, type_list);
type_map.ForEach(callbackFunction);
}
if(comp_unit != nullptr && type_map.GetSize() > 0)
{
TypeMoveMatchingCompileUnit callbackCompileUnit (comp_unit, type_map, type_list);
type_map.ForEach(callbackCompileUnit);
}
if(module_sp && type_map.GetSize() > 0)
{
TypeMoveMatchingModule callbackModule (module_sp, type_map, type_list);
type_map.ForEach(callbackModule);
}
if(type_map.GetSize() > 0)
{
TypeMaptoList callbackM2L (type_map, type_list);
type_map.ForEach(callbackM2L);
}
return ;
}
ConstString
SymbolContext::GetFunctionName (Mangled::NamePreference preference) const
{

4
lldb/source/Symbol/SymbolFile.cpp
View File

@ -15,7 +15,7 @@
#include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/TypeMap.h"
#include "lldb/Symbol/TypeSystem.h"
#include "lldb/Symbol/VariableList.h"
@ -135,7 +135,7 @@ SymbolFile::FindFunctions (const RegularExpression& regex, bool include_inlines,
}
uint32_t
SymbolFile::FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeList& types)
SymbolFile::FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeMap& types)
{
if (!append)
types.Clear();

2
lldb/source/Symbol/SymbolVendor.cpp
View File

@ -346,7 +346,7 @@ SymbolVendor::FindFunctions(const RegularExpression& regex, bool include_inlines
size_t
SymbolVendor::FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches, TypeList& types)
SymbolVendor::FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches, TypeMap& types)
{
ModuleSP module_sp(GetModule());
if (module_sp)

52
lldb/source/Symbol/TypeList.cpp
View File

@ -42,26 +42,7 @@ TypeList::Insert (const TypeSP& type_sp)
{
// Just push each type on the back for now. We will worry about uniquing later
if (type_sp)
m_types.insert(std::make_pair(type_sp->GetID(), type_sp));
}
bool
TypeList::InsertUnique (const TypeSP& type_sp)
{
if (type_sp)
{
user_id_t type_uid = type_sp->GetID();
iterator pos, end = m_types.end();
for (pos = m_types.find(type_uid); pos != end && pos->second->GetID() == type_uid; ++pos)
{
if (pos->second.get() == type_sp.get())
return false;
}
}
Insert (type_sp);
return true;
m_types.push_back(type_sp);
}
//----------------------------------------------------------------------
@ -116,7 +97,7 @@ TypeList::GetTypeAtIndex(uint32_t idx)
for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
{
if (i == 0)
return pos->second;
return *pos;
--i;
}
return TypeSP();
@ -127,7 +108,7 @@ TypeList::ForEach (std::function <bool(const lldb::TypeSP &type_sp)> const &call
{
for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
{
if (!callback(pos->second))
if (!callback(*pos))
break;
}
}
@ -137,32 +118,17 @@ TypeList::ForEach (std::function <bool(lldb::TypeSP &type_sp)> const &callback)
{
for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
{
if (!callback(pos->second))
if (!callback(*pos))
break;
}
}
bool
TypeList::RemoveTypeWithUID (user_id_t uid)
{
iterator pos = m_types.find(uid);
if (pos != m_types.end())
{
m_types.erase(pos);
return true;
}
return false;
}
void
TypeList::Dump(Stream *s, bool show_context)
{
for (iterator pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
{
pos->second->Dump(s, show_context);
pos->get()->Dump(s, show_context);
}
}
@ -197,7 +163,7 @@ TypeList::RemoveMismatchedTypes (const std::string &type_scope,
for (pos = m_types.begin(); pos != end; ++pos)
{
Type* the_type = pos->second.get();
Type* the_type = pos->get();
bool keep_match = false;
TypeClass match_type_class = eTypeClassAny;
@ -269,7 +235,7 @@ TypeList::RemoveMismatchedTypes (const std::string &type_scope,
if (keep_match)
{
matching_types.insert (*pos);
matching_types.push_back(*pos);
}
}
m_types.swap(matching_types);
@ -291,10 +257,10 @@ TypeList::RemoveMismatchedTypes (TypeClass type_class)
for (pos = m_types.begin(); pos != end; ++pos)
{
Type* the_type = pos->second.get();
Type* the_type = pos->get();
TypeClass match_type_class = the_type->GetForwardCompilerType ().GetTypeClass ();
if (match_type_class & type_class)
matching_types.insert (*pos);
matching_types.push_back (*pos);
}
m_types.swap(matching_types);
}

313
lldb/source/Symbol/TypeMap.cpp Normal file
View File

@ -0,0 +1,313 @@
//===-- TypeMap.cpp --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// C Includes
// C++ Includes
#include <vector>
// Other libraries and framework includes
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclGroup.h"
#include "clang/Basic/Builtins.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetInfo.h"
#include "llvm/Support/FormattedStream.h"
#include "llvm/Support/raw_ostream.h"
// Project includes
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/TypeMap.h"
using namespace lldb;
using namespace lldb_private;
using namespace clang;
TypeMap::TypeMap() :
m_types ()
{
}
//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
TypeMap::~TypeMap()
{
}
void
TypeMap::Insert (const TypeSP& type_sp)
{
// Just push each type on the back for now. We will worry about uniquing later
if (type_sp)
m_types.insert(std::make_pair(type_sp->GetID(), type_sp));
}
bool
TypeMap::InsertUnique (const TypeSP& type_sp)
{
if (type_sp)
{
user_id_t type_uid = type_sp->GetID();
iterator pos, end = m_types.end();
for (pos = m_types.find(type_uid); pos != end && pos->second->GetID() == type_uid; ++pos)
{
if (pos->second.get() == type_sp.get())
return false;
}
}
Insert (type_sp);
return true;
}
//----------------------------------------------------------------------
// Find a base type by its unique ID.
//----------------------------------------------------------------------
//TypeSP
//TypeMap::FindType(lldb::user_id_t uid)
//{
// iterator pos = m_types.find(uid);
// if (pos != m_types.end())
// return pos->second;
// return TypeSP();
//}
//----------------------------------------------------------------------
// Find a type by name.
//----------------------------------------------------------------------
//TypeMap
//TypeMap::FindTypes (const ConstString &name)
//{
// // Do we ever need to make a lookup by name map? Here we are doing
// // a linear search which isn't going to be fast.
// TypeMap types(m_ast.getTargetInfo()->getTriple().getTriple().c_str());
// iterator pos, end;
// for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
// if (pos->second->GetName() == name)
// types.Insert (pos->second);
// return types;
//}
void
TypeMap::Clear()
{
m_types.clear();
}
uint32_t
TypeMap::GetSize() const
{
return m_types.size();
}
// GetTypeAtIndex isn't used a lot for large type lists, currently only for
// type lists that are returned for "image dump -t TYPENAME" commands and other
// simple symbol queries that grab the first result...
TypeSP
TypeMap::GetTypeAtIndex(uint32_t idx)
{
iterator pos, end;
uint32_t i = idx;
for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
{
if (i == 0)
return pos->second;
--i;
}
return TypeSP();
}
void
TypeMap::ForEach (std::function <bool(const lldb::TypeSP &type_sp)> const &callback) const
{
for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
{
if (!callback(pos->second))
break;
}
}
void
TypeMap::ForEach (std::function <bool(lldb::TypeSP &type_sp)> const &callback)
{
for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
{
if (!callback(pos->second))
break;
}
}
bool
TypeMap::RemoveTypeWithUID (user_id_t uid)
{
iterator pos = m_types.find(uid);
if (pos != m_types.end())
{
m_types.erase(pos);
return true;
}
return false;
}
void
TypeMap::Dump(Stream *s, bool show_context)
{
for (iterator pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
{
pos->second->Dump(s, show_context);
}
}
void
TypeMap::RemoveMismatchedTypes (const char *qualified_typename,
bool exact_match)
{
std::string type_scope;
std::string type_basename;
TypeClass type_class = eTypeClassAny;
if (!Type::GetTypeScopeAndBasename (qualified_typename, type_scope, type_basename, type_class))
{
type_basename = qualified_typename;
type_scope.clear();
}
return RemoveMismatchedTypes (type_scope, type_basename, type_class, exact_match);
}
void
TypeMap::RemoveMismatchedTypes (const std::string &type_scope,
const std::string &type_basename,
TypeClass type_class,
bool exact_match)
{
// Our "collection" type currently is a std::map which doesn't
// have any good way to iterate and remove items from the map
// so we currently just make a new list and add all of the matching
// types to it, and then swap it into m_types at the end
collection matching_types;
iterator pos, end = m_types.end();
for (pos = m_types.begin(); pos != end; ++pos)
{
Type* the_type = pos->second.get();
bool keep_match = false;
TypeClass match_type_class = eTypeClassAny;
if (type_class != eTypeClassAny)
{
match_type_class = the_type->GetForwardCompilerType ().GetTypeClass ();
if ((match_type_class & type_class) == 0)
continue;
}
ConstString match_type_name_const_str (the_type->GetQualifiedName());
if (match_type_name_const_str)
{
const char *match_type_name = match_type_name_const_str.GetCString();
std::string match_type_scope;
std::string match_type_basename;
if (Type::GetTypeScopeAndBasename (match_type_name,
match_type_scope,
match_type_basename,
match_type_class))
{
if (match_type_basename == type_basename)
{
const size_t type_scope_size = type_scope.size();
const size_t match_type_scope_size = match_type_scope.size();
if (exact_match || (type_scope_size == match_type_scope_size))
{
keep_match = match_type_scope == type_scope;
}
else
{
if (match_type_scope_size > type_scope_size)
{
const size_t type_scope_pos = match_type_scope.rfind(type_scope);
if (type_scope_pos == match_type_scope_size - type_scope_size)
{
if (type_scope_pos >= 2)
{
// Our match scope ends with the type scope we were looking for,
// but we need to make sure what comes before the matching
// type scope is a namespace boundary in case we are trying to match:
// type_basename = "d"
// type_scope = "b::c::"
// We want to match:
// match_type_scope "a::b::c::"
// But not:
// match_type_scope "a::bb::c::"
// So below we make sure what comes before "b::c::" in match_type_scope
// is "::", or the namespace boundary
if (match_type_scope[type_scope_pos - 1] == ':' &&
match_type_scope[type_scope_pos - 2] == ':')
{
keep_match = true;
}
}
}
}
}
}
}
else
{
// The type we are currently looking at doesn't exists
// in a namespace or class, so it only matches if there
// is no type scope...
keep_match = type_scope.empty() && type_basename.compare(match_type_name) == 0;
}
}
if (keep_match)
{
matching_types.insert (*pos);
}
}
m_types.swap(matching_types);
}
void
TypeMap::RemoveMismatchedTypes (TypeClass type_class)
{
if (type_class == eTypeClassAny)
return;
// Our "collection" type currently is a std::map which doesn't
// have any good way to iterate and remove items from the map
// so we currently just make a new list and add all of the matching
// types to it, and then swap it into m_types at the end
collection matching_types;
iterator pos, end = m_types.end();
for (pos = m_types.begin(); pos != end; ++pos)
{
Type* the_type = pos->second.get();
TypeClass match_type_class = the_type->GetForwardCompilerType ().GetTypeClass ();
if (match_type_class & type_class)
matching_types.insert (*pos);
}
m_types.swap(matching_types);
}

5
lldb/test/lang/c/typedef/Makefile Normal file
View File

@ -0,0 +1,5 @@
LEVEL = ../../../make
C_SOURCES := main.c
include $(LEVEL)/Makefile.rules

51
lldb/test/lang/c/typedef/Testtypedef.py Normal file
View File

@ -0,0 +1,51 @@
"""Look up type information for typedefs of same name at different lexical scope and check for correct display."""
import os, time
import unittest2
import lldb
from lldbtest import *
import lldbutil
class TypedefTestCase(TestBase):
mydir = TestBase.compute_mydir(__file__)
@skipUnlessDarwin
@dsym_test
@expectedFailureClang("llvm.org/pr19238")
def test_with_dsym(self):
"""Test 'image lookup -t a' and check for correct display at different scopes."""
self.buildDsym()
self.image_lookup_for_multiple_typedefs()
@dwarf_test
@expectedFailureClang("llvm.org/pr19238")
def test_with_dwarf(self):
"""Test 'image lookup -t a' and check for correct display at different scopes."""
self.buildDwarf()
self.image_lookup_for_multiple_typedefs()
def image_lookup_for_multiple_typedefs(self):
"""Test 'image lookup -t a' at different scopes and check for correct display."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
typearray = ("float", "float", "char", "float", "int", "double", "float", "float")
arraylen = len(typearray)+1
for i in range(1,arraylen):
loc_line = line_number('main.c', '// Set break point ' + str(i) + '.')
lldbutil.run_break_set_by_file_and_line (self, "main.c",loc_line, num_expected_locations=1, loc_exact=True)
self.runCmd("run", RUN_SUCCEEDED)
for t in typearray:
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped', 'stop reason = breakpoint'])
self.expect("image lookup -t a", DATA_TYPES_DISPLAYED_CORRECTLY,
substrs = ['name = "' + t + '"'])
self.runCmd("continue")
if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main()

40
lldb/test/lang/c/typedef/main.c Normal file
View File

@ -0,0 +1,40 @@
//===-- main.c --------------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main (int argc, char const *argv[])
{
typedef float a;
int i = 0; // Set break point 1.
i++;
a floatvariable = 2.7; // Set break point 2.
{
typedef char a;
i++;
a charvariable = 'a'; // Set break point 3.
}
{
int c = 0;
c++; // Set break point 4.
for(i = 0 ; i < 1 ; i++)
{
typedef int a;
a b;
b = 7; // Set break point 5.
}
for(i = 0 ; i < 1 ; i++)
{
typedef double a;
a b;
b = 3.14; // Set break point 6.
}
c = 1; // Set break point 7.
}
floatvariable = 2.5;
floatvariable = 2.8; // Set break point 8.
return 0;
}