[lldb][NFC] Fix all formatting errors in .cpp file headers
Summary:
A *.cpp file header in LLDB (and in LLDB) should like this:
```
//===-- TestUtilities.cpp -------------------------------------------------===//
```
However in LLDB most of our source files have arbitrary changes to this format and
these changes are spreading through LLDB as folks usually just use the existing
source files as templates for their new files (most notably the unnecessary
editor language indicator `-*- C++ -*-` is spreading and in every review
someone is pointing out that this is wrong, resulting in people pointing out that this
is done in the same way in other files).
This patch removes most of these inconsistencies including the editor language indicators,
all the different missing/additional '-' characters, files that center the file name, missing
trailing `===//` (mostly caused by clang-format breaking the line).
Reviewers: aprantl, espindola, jfb, shafik, JDevlieghere
Reviewed By: JDevlieghere
Subscribers: dexonsmith, wuzish, emaste, sdardis, nemanjai, kbarton, MaskRay, atanasyan, arphaman, jfb, abidh, jsji, JDevlieghere, usaxena95, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D73258
2020-01-24 15:23:27 +08:00
|
|
|
//===-- Module.cpp --------------------------------------------------------===//
|
2010-06-09 00:52:24 +08:00
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2010-06-09 00:52:24 +08:00
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
2016-03-12 04:20:38 +08:00
|
|
|
#include "lldb/Core/Module.h"
|
|
|
|
|
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Core/AddressRange.h"
|
2013-09-12 10:20:34 +08:00
|
|
|
#include "lldb/Core/AddressResolverFileLine.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Core/Debugger.h"
|
|
|
|
|
#include "lldb/Core/FileSpecList.h"
|
|
|
|
|
#include "lldb/Core/Mangled.h"
|
<rdar://problem/11757916>
Make breakpoint setting by file and line much more efficient by only looking for inlined breakpoint locations if we are setting a breakpoint in anything but a source implementation file. Implementing this complex for a many reasons. Turns out that parsing compile units lazily had some issues with respect to how we need to do things with DWARF in .o files. So the fixes in the checkin for this makes these changes:
- Add a new setting called "target.inline-breakpoint-strategy" which can be set to "never", "always", or "headers". "never" will never try and set any inlined breakpoints (fastest). "always" always looks for inlined breakpoint locations (slowest, but most accurate). "headers", which is the default setting, will only look for inlined breakpoint locations if the breakpoint is set in what are consudered to be header files, which is realy defined as "not in an implementation source file".
- modify the breakpoint setting by file and line to check the current "target.inline-breakpoint-strategy" setting and act accordingly
- Modify compile units to be able to get their language and other info lazily. This allows us to create compile units from the debug map and not have to fill all of the details in, and then lazily discover this information as we go on debuggging. This is needed to avoid parsing all .o files when setting breakpoints in implementation only files (no inlines). Otherwise we would need to parse the .o file, the object file (mach-o in our case) and the symbol file (DWARF in the object file) just to see what the compile unit was.
- modify the "SymbolFileDWARFDebugMap" to subclass lldb_private::Module so that the virtual "GetObjectFile()" and "GetSymbolVendor()" functions can be intercepted when the .o file contenst are later lazilly needed. Prior to this fix, when we first instantiated the "SymbolFileDWARFDebugMap" class, we would also make modules, object files and symbol files for every .o file in the debug map because we needed to fix up the sections in the .o files with information that is in the executable debug map. Now we lazily do this in the DebugMapModule::GetObjectFile()
Cleaned up header includes a bit as well.
llvm-svn: 162860
2012-08-30 05:13:06 +08:00
|
|
|
#include "lldb/Core/ModuleSpec.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Core/SearchFilter.h"
|
<rdar://problem/11757916>
Make breakpoint setting by file and line much more efficient by only looking for inlined breakpoint locations if we are setting a breakpoint in anything but a source implementation file. Implementing this complex for a many reasons. Turns out that parsing compile units lazily had some issues with respect to how we need to do things with DWARF in .o files. So the fixes in the checkin for this makes these changes:
- Add a new setting called "target.inline-breakpoint-strategy" which can be set to "never", "always", or "headers". "never" will never try and set any inlined breakpoints (fastest). "always" always looks for inlined breakpoint locations (slowest, but most accurate). "headers", which is the default setting, will only look for inlined breakpoint locations if the breakpoint is set in what are consudered to be header files, which is realy defined as "not in an implementation source file".
- modify the breakpoint setting by file and line to check the current "target.inline-breakpoint-strategy" setting and act accordingly
- Modify compile units to be able to get their language and other info lazily. This allows us to create compile units from the debug map and not have to fill all of the details in, and then lazily discover this information as we go on debuggging. This is needed to avoid parsing all .o files when setting breakpoints in implementation only files (no inlines). Otherwise we would need to parse the .o file, the object file (mach-o in our case) and the symbol file (DWARF in the object file) just to see what the compile unit was.
- modify the "SymbolFileDWARFDebugMap" to subclass lldb_private::Module so that the virtual "GetObjectFile()" and "GetSymbolVendor()" functions can be intercepted when the .o file contenst are later lazilly needed. Prior to this fix, when we first instantiated the "SymbolFileDWARFDebugMap" class, we would also make modules, object files and symbol files for every .o file in the debug map because we needed to fix up the sections in the .o files with information that is in the executable debug map. Now we lazily do this in the DebugMapModule::GetObjectFile()
Cleaned up header includes a bit as well.
llvm-svn: 162860
2012-08-30 05:13:06 +08:00
|
|
|
#include "lldb/Core/Section.h"
|
2016-11-02 00:11:14 +08:00
|
|
|
#include "lldb/Host/FileSystem.h"
|
2012-01-05 11:57:59 +08:00
|
|
|
#include "lldb/Host/Host.h"
|
2012-11-08 10:22:02 +08:00
|
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
|
|
|
#include "lldb/Interpreter/ScriptInterpreter.h"
|
<rdar://problem/11757916>
Make breakpoint setting by file and line much more efficient by only looking for inlined breakpoint locations if we are setting a breakpoint in anything but a source implementation file. Implementing this complex for a many reasons. Turns out that parsing compile units lazily had some issues with respect to how we need to do things with DWARF in .o files. So the fixes in the checkin for this makes these changes:
- Add a new setting called "target.inline-breakpoint-strategy" which can be set to "never", "always", or "headers". "never" will never try and set any inlined breakpoints (fastest). "always" always looks for inlined breakpoint locations (slowest, but most accurate). "headers", which is the default setting, will only look for inlined breakpoint locations if the breakpoint is set in what are consudered to be header files, which is realy defined as "not in an implementation source file".
- modify the breakpoint setting by file and line to check the current "target.inline-breakpoint-strategy" setting and act accordingly
- Modify compile units to be able to get their language and other info lazily. This allows us to create compile units from the debug map and not have to fill all of the details in, and then lazily discover this information as we go on debuggging. This is needed to avoid parsing all .o files when setting breakpoints in implementation only files (no inlines). Otherwise we would need to parse the .o file, the object file (mach-o in our case) and the symbol file (DWARF in the object file) just to see what the compile unit was.
- modify the "SymbolFileDWARFDebugMap" to subclass lldb_private::Module so that the virtual "GetObjectFile()" and "GetSymbolVendor()" functions can be intercepted when the .o file contenst are later lazilly needed. Prior to this fix, when we first instantiated the "SymbolFileDWARFDebugMap" class, we would also make modules, object files and symbol files for every .o file in the debug map because we needed to fix up the sections in the .o files with information that is in the executable debug map. Now we lazily do this in the DebugMapModule::GetObjectFile()
Cleaned up header includes a bit as well.
llvm-svn: 162860
2012-08-30 05:13:06 +08:00
|
|
|
#include "lldb/Symbol/CompileUnit.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Symbol/Function.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Symbol/ObjectFile.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Symbol/Symbol.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Symbol/SymbolContext.h"
|
TypeSystem is now a plugin interface and removed any "ClangASTContext &Class::GetClangASTContext()" functions.
This cleans up type systems to be more pluggable. Prior to this we had issues:
- Module, SymbolFile, and many others has "ClangASTContext &GetClangASTContext()" functions. All have been switched over to use "TypeSystem *GetTypeSystemForLanguage()"
- Cleaned up any places that were using the GetClangASTContext() functions to use TypeSystem
- Cleaned up Module so that it no longer has dedicated type system member variables:
lldb::ClangASTContextUP m_ast; ///< The Clang AST context for this module.
lldb::GoASTContextUP m_go_ast; ///< The Go AST context for this module.
Now we have a type system map:
typedef std::map<lldb::LanguageType, lldb::TypeSystemSP> TypeSystemMap;
TypeSystemMap m_type_system_map; ///< A map of any type systems associated with this module
- Many places in code were using ClangASTContext static functions to place with CompilerType objects and add modifiers (const, volatile, restrict) and to make typedefs, L and R value references and more. These have been made into CompilerType functions that are abstract:
class CompilerType
{
...
//----------------------------------------------------------------------
// Return a new CompilerType that is a L value reference to this type if
// this type is valid and the type system supports L value references,
// else return an invalid type.
//----------------------------------------------------------------------
CompilerType
GetLValueReferenceType () const;
//----------------------------------------------------------------------
// Return a new CompilerType that is a R value reference to this type if
// this type is valid and the type system supports R value references,
// else return an invalid type.
//----------------------------------------------------------------------
CompilerType
GetRValueReferenceType () const;
//----------------------------------------------------------------------
// Return a new CompilerType adds a const modifier to this type if
// this type is valid and the type system supports const modifiers,
// else return an invalid type.
//----------------------------------------------------------------------
CompilerType
AddConstModifier () const;
//----------------------------------------------------------------------
// Return a new CompilerType adds a volatile modifier to this type if
// this type is valid and the type system supports volatile modifiers,
// else return an invalid type.
//----------------------------------------------------------------------
CompilerType
AddVolatileModifier () const;
//----------------------------------------------------------------------
// Return a new CompilerType adds a restrict modifier to this type if
// this type is valid and the type system supports restrict modifiers,
// else return an invalid type.
//----------------------------------------------------------------------
CompilerType
AddRestrictModifier () const;
//----------------------------------------------------------------------
// Create a typedef to this type using "name" as the name of the typedef
// this type is valid and the type system supports typedefs, else return
// an invalid type.
//----------------------------------------------------------------------
CompilerType
CreateTypedef (const char *name, const CompilerDeclContext &decl_ctx) const;
};
Other changes include:
- Removed "CompilerType TypeSystem::GetIntTypeFromBitSize(...)" and CompilerType TypeSystem::GetFloatTypeFromBitSize(...) and replaced it with "CompilerType TypeSystem::GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, size_t bit_size);"
- Fixed code in Type.h to not request the full type for a type for no good reason, just request the forward type and let the type expand as needed
llvm-svn: 247953
2015-09-18 06:23:34 +08:00
|
|
|
#include "lldb/Symbol/SymbolFile.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Symbol/SymbolVendor.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Symbol/Symtab.h"
|
|
|
|
|
#include "lldb/Symbol/Type.h"
|
|
|
|
|
#include "lldb/Symbol/TypeList.h"
|
2015-10-08 17:45:41 +08:00
|
|
|
#include "lldb/Symbol/TypeMap.h"
|
TypeSystem is now a plugin interface and removed any "ClangASTContext &Class::GetClangASTContext()" functions.
This cleans up type systems to be more pluggable. Prior to this we had issues:
- Module, SymbolFile, and many others has "ClangASTContext &GetClangASTContext()" functions. All have been switched over to use "TypeSystem *GetTypeSystemForLanguage()"
- Cleaned up any places that were using the GetClangASTContext() functions to use TypeSystem
- Cleaned up Module so that it no longer has dedicated type system member variables:
lldb::ClangASTContextUP m_ast; ///< The Clang AST context for this module.
lldb::GoASTContextUP m_go_ast; ///< The Go AST context for this module.
Now we have a type system map:
typedef std::map<lldb::LanguageType, lldb::TypeSystemSP> TypeSystemMap;
TypeSystemMap m_type_system_map; ///< A map of any type systems associated with this module
- Many places in code were using ClangASTContext static functions to place with CompilerType objects and add modifiers (const, volatile, restrict) and to make typedefs, L and R value references and more. These have been made into CompilerType functions that are abstract:
class CompilerType
{
...
//----------------------------------------------------------------------
// Return a new CompilerType that is a L value reference to this type if
// this type is valid and the type system supports L value references,
// else return an invalid type.
//----------------------------------------------------------------------
CompilerType
GetLValueReferenceType () const;
//----------------------------------------------------------------------
// Return a new CompilerType that is a R value reference to this type if
// this type is valid and the type system supports R value references,
// else return an invalid type.
//----------------------------------------------------------------------
CompilerType
GetRValueReferenceType () const;
//----------------------------------------------------------------------
// Return a new CompilerType adds a const modifier to this type if
// this type is valid and the type system supports const modifiers,
// else return an invalid type.
//----------------------------------------------------------------------
CompilerType
AddConstModifier () const;
//----------------------------------------------------------------------
// Return a new CompilerType adds a volatile modifier to this type if
// this type is valid and the type system supports volatile modifiers,
// else return an invalid type.
//----------------------------------------------------------------------
CompilerType
AddVolatileModifier () const;
//----------------------------------------------------------------------
// Return a new CompilerType adds a restrict modifier to this type if
// this type is valid and the type system supports restrict modifiers,
// else return an invalid type.
//----------------------------------------------------------------------
CompilerType
AddRestrictModifier () const;
//----------------------------------------------------------------------
// Create a typedef to this type using "name" as the name of the typedef
// this type is valid and the type system supports typedefs, else return
// an invalid type.
//----------------------------------------------------------------------
CompilerType
CreateTypedef (const char *name, const CompilerDeclContext &decl_ctx) const;
};
Other changes include:
- Removed "CompilerType TypeSystem::GetIntTypeFromBitSize(...)" and CompilerType TypeSystem::GetFloatTypeFromBitSize(...) and replaced it with "CompilerType TypeSystem::GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding, size_t bit_size);"
- Fixed code in Type.h to not request the full type for a type for no good reason, just request the forward type and let the type expand as needed
llvm-svn: 247953
2015-09-18 06:23:34 +08:00
|
|
|
#include "lldb/Symbol/TypeSystem.h"
|
2015-09-02 09:06:46 +08:00
|
|
|
#include "lldb/Target/Language.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Target/Platform.h"
|
2012-02-05 10:38:54 +08:00
|
|
|
#include "lldb/Target/Process.h"
|
|
|
|
|
#include "lldb/Target/Target.h"
|
2017-03-04 09:30:05 +08:00
|
|
|
#include "lldb/Utility/DataBufferHeap.h"
|
2018-05-03 04:06:17 +08:00
|
|
|
#include "lldb/Utility/LLDBAssert.h"
|
2017-03-04 04:56:28 +08:00
|
|
|
#include "lldb/Utility/Log.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Utility/Logging.h"
|
2017-02-03 05:39:50 +08:00
|
|
|
#include "lldb/Utility/RegularExpression.h"
|
2017-05-12 12:51:55 +08:00
|
|
|
#include "lldb/Utility/Status.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Utility/Stream.h"
|
2017-02-03 05:39:50 +08:00
|
|
|
#include "lldb/Utility/StreamString.h"
|
2017-06-29 22:32:17 +08:00
|
|
|
#include "lldb/Utility/Timer.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2018-04-10 21:33:45 +08:00
|
|
|
#if defined(_WIN32)
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "lldb/Host/windows/PosixApi.h"
|
2017-04-07 05:28:29 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
|
|
|
|
|
#include "Plugins/Language/ObjC/ObjCLanguage.h"
|
2014-03-25 07:10:19 +08:00
|
|
|
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
|
#include "llvm/Support/Compiler.h"
|
2017-04-07 05:28:29 +08:00
|
|
|
#include "llvm/Support/FileSystem.h"
|
|
|
|
|
#include "llvm/Support/Signals.h"
|
2018-11-12 07:16:43 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2017-04-07 05:28:29 +08:00
|
|
|
|
2018-11-12 07:16:43 +08:00
|
|
|
#include <assert.h>
|
|
|
|
|
#include <cstdint>
|
|
|
|
|
#include <inttypes.h>
|
|
|
|
|
#include <map>
|
|
|
|
|
#include <stdarg.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <type_traits>
|
|
|
|
|
#include <utility>
|
2017-04-07 05:28:29 +08:00
|
|
|
|
|
|
|
|
namespace lldb_private {
|
|
|
|
|
class CompilerDeclContext;
|
|
|
|
|
}
|
|
|
|
|
namespace lldb_private {
|
|
|
|
|
class VariableList;
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
using namespace lldb;
|
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// Shared pointers to modules track module lifetimes in targets and in the
|
|
|
|
|
// global module, but this collection will track all module objects that are
|
|
|
|
|
// still alive
|
2011-08-09 08:01:09 +08:00
|
|
|
typedef std::vector<Module *> ModuleCollection;
|
|
|
|
|
|
|
|
|
|
static ModuleCollection &GetModuleCollection() {
|
2011-11-01 07:47:10 +08:00
|
|
|
// This module collection needs to live past any module, so we could either
|
2018-05-01 00:49:04 +08:00
|
|
|
// make it a shared pointer in each module or just leak is. Since it is only
|
|
|
|
|
// an empty vector by the time all the modules have gone away, we just leak
|
|
|
|
|
// it for now. If we decide this is a big problem we can introduce a
|
|
|
|
|
// Finalize method that will tear everything down in a predictable order.
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2016-03-12 04:20:38 +08:00
|
|
|
static ModuleCollection *g_module_collection = nullptr;
|
|
|
|
|
if (g_module_collection == nullptr)
|
2011-11-01 07:47:10 +08:00
|
|
|
g_module_collection = new ModuleCollection();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-11-01 07:47:10 +08:00
|
|
|
return *g_module_collection;
|
2011-08-09 08:01:09 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-08-09 08:01:09 +08:00
|
|
|
std::recursive_mutex &Module::GetAllocationModuleCollectionMutex() {
|
2012-01-28 02:08:35 +08:00
|
|
|
// NOTE: The mutex below must be leaked since the global module list in
|
2018-05-01 00:49:04 +08:00
|
|
|
// the ModuleList class will get torn at some point, and we can't know if it
|
|
|
|
|
// will tear itself down before the "g_module_collection_mutex" below will.
|
|
|
|
|
// So we leak a Mutex object below to safeguard against that
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2016-05-18 09:59:10 +08:00
|
|
|
static std::recursive_mutex *g_module_collection_mutex = nullptr;
|
2016-03-12 04:20:38 +08:00
|
|
|
if (g_module_collection_mutex == nullptr)
|
2016-05-18 09:59:10 +08:00
|
|
|
g_module_collection_mutex = new std::recursive_mutex; // NOTE: known leak
|
|
|
|
|
return *g_module_collection_mutex;
|
2011-08-09 08:01:09 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-08-09 08:01:09 +08:00
|
|
|
size_t Module::GetNumberAllocatedModules() {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
|
|
|
GetAllocationModuleCollectionMutex());
|
2011-08-09 08:01:09 +08:00
|
|
|
return GetModuleCollection().size();
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-08-09 08:01:09 +08:00
|
|
|
Module *Module::GetAllocatedModuleAtIndex(size_t idx) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
|
|
|
GetAllocationModuleCollectionMutex());
|
2011-08-09 08:01:09 +08:00
|
|
|
ModuleCollection &modules = GetModuleCollection();
|
|
|
|
|
if (idx < modules.size())
|
|
|
|
|
return modules[idx];
|
2016-03-12 04:20:38 +08:00
|
|
|
return nullptr;
|
2011-08-09 08:01:09 +08:00
|
|
|
}
|
|
|
|
|
|
2016-05-18 09:59:10 +08:00
|
|
|
Module::Module(const ModuleSpec &module_spec)
|
2016-11-02 00:11:14 +08:00
|
|
|
: m_object_offset(0), m_file_has_changed(false),
|
2016-05-18 09:59:10 +08:00
|
|
|
m_first_file_changed_log(false) {
|
|
|
|
|
// Scope for locker below...
|
2016-09-07 04:57:50 +08:00
|
|
|
{
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
|
|
|
GetAllocationModuleCollectionMutex());
|
2012-02-26 13:51:37 +08:00
|
|
|
GetModuleCollection().push_back(this);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2016-05-18 09:59:10 +08:00
|
|
|
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT |
|
|
|
|
|
LIBLLDB_LOG_MODULES));
|
2016-03-12 04:20:38 +08:00
|
|
|
if (log != nullptr)
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log, "%p Module::Module((%s) '%s%s%s%s')",
|
|
|
|
|
static_cast<void *>(this),
|
|
|
|
|
module_spec.GetArchitecture().GetArchitectureName(),
|
|
|
|
|
module_spec.GetFileSpec().GetPath().c_str(),
|
|
|
|
|
module_spec.GetObjectName().IsEmpty() ? "" : "(",
|
|
|
|
|
module_spec.GetObjectName().IsEmpty()
|
|
|
|
|
? ""
|
|
|
|
|
: module_spec.GetObjectName().AsCString(""),
|
|
|
|
|
module_spec.GetObjectName().IsEmpty() ? "" : ")");
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// First extract all module specifications from the file using the local file
|
|
|
|
|
// path. If there are no specifications, then don't fill anything in
|
2014-03-05 05:20:23 +08:00
|
|
|
ModuleSpecList modules_specs;
|
|
|
|
|
if (ObjectFile::GetModuleSpecifications(module_spec.GetFileSpec(), 0, 0,
|
|
|
|
|
modules_specs) == 0)
|
|
|
|
|
return;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-03-05 05:20:23 +08:00
|
|
|
// Now make sure that one of the module specifications matches what we just
|
|
|
|
|
// extract. We might have a module specification that specifies a file
|
2018-05-01 00:49:04 +08:00
|
|
|
// "/usr/lib/dyld" with UUID XXX, but we might have a local version of
|
|
|
|
|
// "/usr/lib/dyld" that has
|
2014-03-05 05:20:23 +08:00
|
|
|
// UUID YYY and we don't want those to match. If they don't match, just don't
|
|
|
|
|
// fill any ivars in so we don't accidentally grab the wrong file later since
|
|
|
|
|
// they don't match...
|
|
|
|
|
ModuleSpec matching_module_spec;
|
2018-08-08 02:00:30 +08:00
|
|
|
if (!modules_specs.FindMatchingModuleSpec(module_spec,
|
|
|
|
|
matching_module_spec)) {
|
|
|
|
|
if (log) {
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log, "Found local object file but the specs didn't match");
|
2018-08-08 02:00:30 +08:00
|
|
|
}
|
2014-03-05 05:20:23 +08:00
|
|
|
return;
|
2018-08-08 02:00:30 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-05-30 05:33:45 +08:00
|
|
|
if (module_spec.GetFileSpec())
|
2018-11-01 05:49:27 +08:00
|
|
|
m_mod_time = FileSystem::Instance().GetModificationTime(module_spec.GetFileSpec());
|
2014-05-30 05:33:45 +08:00
|
|
|
else if (matching_module_spec.GetFileSpec())
|
2016-11-02 00:11:14 +08:00
|
|
|
m_mod_time =
|
2018-11-01 05:49:27 +08:00
|
|
|
FileSystem::Instance().GetModificationTime(matching_module_spec.GetFileSpec());
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// Copy the architecture from the actual spec if we got one back, else use
|
|
|
|
|
// the one that was specified
|
2014-05-30 05:33:45 +08:00
|
|
|
if (matching_module_spec.GetArchitecture().IsValid())
|
|
|
|
|
m_arch = matching_module_spec.GetArchitecture();
|
|
|
|
|
else if (module_spec.GetArchitecture().IsValid())
|
2014-03-05 05:20:23 +08:00
|
|
|
m_arch = module_spec.GetArchitecture();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-07-02 05:22:11 +08:00
|
|
|
// Copy the file spec over and use the specified one (if there was one) so we
|
2014-05-30 05:33:45 +08:00
|
|
|
// don't use a path that might have gotten resolved a path in
|
|
|
|
|
// 'matching_module_spec'
|
|
|
|
|
if (module_spec.GetFileSpec())
|
|
|
|
|
m_file = module_spec.GetFileSpec();
|
|
|
|
|
else if (matching_module_spec.GetFileSpec())
|
|
|
|
|
m_file = matching_module_spec.GetFileSpec();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-05-30 05:33:45 +08:00
|
|
|
// Copy the platform file spec over
|
|
|
|
|
if (module_spec.GetPlatformFileSpec())
|
|
|
|
|
m_platform_file = module_spec.GetPlatformFileSpec();
|
|
|
|
|
else if (matching_module_spec.GetPlatformFileSpec())
|
|
|
|
|
m_platform_file = matching_module_spec.GetPlatformFileSpec();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-05-30 05:33:45 +08:00
|
|
|
// Copy the symbol file spec over
|
|
|
|
|
if (module_spec.GetSymbolFileSpec())
|
|
|
|
|
m_symfile_spec = module_spec.GetSymbolFileSpec();
|
|
|
|
|
else if (matching_module_spec.GetSymbolFileSpec())
|
|
|
|
|
m_symfile_spec = matching_module_spec.GetSymbolFileSpec();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2014-05-30 05:33:45 +08:00
|
|
|
// Copy the object name over
|
|
|
|
|
if (matching_module_spec.GetObjectName())
|
|
|
|
|
m_object_name = matching_module_spec.GetObjectName();
|
2014-03-05 05:20:23 +08:00
|
|
|
else
|
2014-05-30 05:33:45 +08:00
|
|
|
m_object_name = module_spec.GetObjectName();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// Always trust the object offset (file offset) and object modification time
|
|
|
|
|
// (for mod time in a BSD static archive) of from the matching module
|
|
|
|
|
// specification
|
2014-05-30 01:52:46 +08:00
|
|
|
m_object_offset = matching_module_spec.GetObjectOffset();
|
|
|
|
|
m_object_mod_time = matching_module_spec.GetObjectModificationTime();
|
2012-02-26 13:51:37 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2016-05-18 09:59:10 +08:00
|
|
|
Module::Module(const FileSpec &file_spec, const ArchSpec &arch,
|
|
|
|
|
const ConstString *object_name, lldb::offset_t object_offset,
|
2016-11-09 17:59:18 +08:00
|
|
|
const llvm::sys::TimePoint<> &object_mod_time)
|
2018-11-01 05:49:27 +08:00
|
|
|
: m_mod_time(FileSystem::Instance().GetModificationTime(file_spec)), m_arch(arch),
|
2016-11-02 00:11:14 +08:00
|
|
|
m_file(file_spec), m_object_offset(object_offset),
|
2016-11-09 17:59:18 +08:00
|
|
|
m_object_mod_time(object_mod_time), m_file_has_changed(false),
|
|
|
|
|
m_first_file_changed_log(false) {
|
2011-08-09 08:01:09 +08:00
|
|
|
// Scope for locker below...
|
|
|
|
|
{
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
|
|
|
GetAllocationModuleCollectionMutex());
|
2011-08-09 08:01:09 +08:00
|
|
|
GetModuleCollection().push_back(this);
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
if (object_name)
|
|
|
|
|
m_object_name = *object_name;
|
2014-04-04 12:06:10 +08:00
|
|
|
|
2016-05-18 09:59:10 +08:00
|
|
|
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT |
|
|
|
|
|
LIBLLDB_LOG_MODULES));
|
2016-03-12 04:20:38 +08:00
|
|
|
if (log != nullptr)
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log, "%p Module::Module((%s) '%s%s%s%s')",
|
|
|
|
|
static_cast<void *>(this), m_arch.GetArchitectureName(),
|
|
|
|
|
m_file.GetPath().c_str(), m_object_name.IsEmpty() ? "" : "(",
|
|
|
|
|
m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""),
|
|
|
|
|
m_object_name.IsEmpty() ? "" : ")");
|
2016-05-18 09:59:10 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Module::Module()
|
2016-11-02 00:11:14 +08:00
|
|
|
: m_object_offset(0), m_file_has_changed(false),
|
2016-05-18 09:59:10 +08:00
|
|
|
m_first_file_changed_log(false) {
|
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
|
|
|
GetAllocationModuleCollectionMutex());
|
|
|
|
|
GetModuleCollection().push_back(this);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2016-05-18 09:59:10 +08:00
|
|
|
Module::~Module() {
|
2018-05-01 00:49:04 +08:00
|
|
|
// Lock our module down while we tear everything down to make sure we don't
|
|
|
|
|
// get any access to the module while it is being destroyed
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2011-08-09 08:01:09 +08:00
|
|
|
// Scope for locker below...
|
2016-09-07 04:57:50 +08:00
|
|
|
{
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(
|
|
|
|
|
GetAllocationModuleCollectionMutex());
|
|
|
|
|
ModuleCollection &modules = GetModuleCollection();
|
|
|
|
|
ModuleCollection::iterator end = modules.end();
|
2014-03-25 07:10:19 +08:00
|
|
|
ModuleCollection::iterator pos = std::find(modules.begin(), end, this);
|
2012-10-09 06:41:53 +08:00
|
|
|
assert(pos != end);
|
|
|
|
|
modules.erase(pos);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2014-03-25 07:10:19 +08:00
|
|
|
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT |
|
2013-03-28 07:08:40 +08:00
|
|
|
LIBLLDB_LOG_MODULES));
|
2016-03-12 04:20:38 +08:00
|
|
|
if (log != nullptr)
|
2019-07-25 01:56:10 +08:00
|
|
|
LLDB_LOGF(log, "%p Module::~Module((%s) '%s%s%s%s')",
|
|
|
|
|
static_cast<void *>(this), m_arch.GetArchitectureName(),
|
|
|
|
|
m_file.GetPath().c_str(), m_object_name.IsEmpty() ? "" : "(",
|
|
|
|
|
m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""),
|
|
|
|
|
m_object_name.IsEmpty() ? "" : ")");
|
2013-05-23 04:13:22 +08:00
|
|
|
// Release any auto pointers before we start tearing down our member
|
|
|
|
|
// variables since the object file and symbol files might need to make
|
|
|
|
|
// function calls back into this module object. The ordering is important
|
|
|
|
|
// here because symbol files can require the module object file. So we tear
|
|
|
|
|
// down the symbol file first, then the object file.
|
2019-02-13 14:25:41 +08:00
|
|
|
m_sections_up.reset();
|
|
|
|
|
m_symfile_up.reset();
|
2011-09-19 02:59:15 +08:00
|
|
|
m_objfile_sp.reset();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2013-05-23 04:13:22 +08:00
|
|
|
ObjectFile *Module::GetMemoryObjectFile(const lldb::ProcessSP &process_sp,
|
2017-05-12 12:51:55 +08:00
|
|
|
lldb::addr_t header_addr, Status &error,
|
2014-03-05 18:12:43 +08:00
|
|
|
size_t size_to_read) {
|
2012-02-25 05:55:59 +08:00
|
|
|
if (m_objfile_sp) {
|
2013-05-23 04:13:22 +08:00
|
|
|
error.SetErrorString("object file already exists");
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2011-08-09 08:01:09 +08:00
|
|
|
if (process_sp) {
|
2016-05-18 09:59:10 +08:00
|
|
|
m_did_load_objfile = true;
|
2019-08-15 06:19:23 +08:00
|
|
|
auto data_up = std::make_unique<DataBufferHeap>(size_to_read, 0);
|
2017-05-12 12:51:55 +08:00
|
|
|
Status readmem_error;
|
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
|
|
|
const size_t bytes_read =
|
2019-02-13 14:25:41 +08:00
|
|
|
process_sp->ReadMemory(header_addr, data_up->GetBytes(),
|
|
|
|
|
data_up->GetByteSize(), readmem_error);
|
2020-02-28 03:17:10 +08:00
|
|
|
if (bytes_read < size_to_read)
|
|
|
|
|
data_up->SetByteSize(bytes_read);
|
|
|
|
|
if (data_up->GetByteSize() > 0) {
|
2019-02-13 14:25:41 +08:00
|
|
|
DataBufferSP data_sp(data_up.release());
|
2014-03-05 18:12:43 +08:00
|
|
|
m_objfile_sp = ObjectFile::FindPlugin(shared_from_this(), process_sp,
|
|
|
|
|
header_addr, data_sp);
|
2012-02-25 05:55:59 +08:00
|
|
|
if (m_objfile_sp) {
|
|
|
|
|
StreamString s;
|
2012-11-30 05:49:15 +08:00
|
|
|
s.Printf("0x%16.16" PRIx64, header_addr);
|
2016-11-17 05:15:24 +08:00
|
|
|
m_object_name.SetString(s.GetString());
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-04-21 03:50:20 +08:00
|
|
|
// Once we get the object file, update our module with the object
|
2018-05-01 00:49:04 +08:00
|
|
|
// file's architecture since it might differ in vendor/os if some
|
|
|
|
|
// parts were unknown.
|
2019-01-03 18:37:19 +08:00
|
|
|
m_arch = m_objfile_sp->GetArchitecture();
|
2019-02-21 07:12:56 +08:00
|
|
|
|
|
|
|
|
// Augment the arch with the target's information in case
|
|
|
|
|
// we are unable to extract the os/environment from memory.
|
|
|
|
|
m_arch.MergeFrom(process_sp->GetTarget().GetArchitecture());
|
2012-02-25 05:55:59 +08:00
|
|
|
} else {
|
|
|
|
|
error.SetErrorString("unable to find suitable object file plug-in");
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2012-02-25 05:55:59 +08:00
|
|
|
error.SetErrorStringWithFormat("unable to read header from memory: %s",
|
|
|
|
|
readmem_error.AsCString());
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
} else {
|
2012-02-25 05:55:59 +08:00
|
|
|
error.SetErrorString("invalid process");
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-02-25 05:55:59 +08:00
|
|
|
return m_objfile_sp.get();
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-05 02:53:10 +08:00
|
|
|
const lldb_private::UUID &Module::GetUUID() {
|
2018-05-03 04:06:17 +08:00
|
|
|
if (!m_did_set_uuid.load()) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2018-05-03 04:06:17 +08:00
|
|
|
if (!m_did_set_uuid.load()) {
|
2015-07-25 07:38:01 +08:00
|
|
|
ObjectFile *obj_file = GetObjectFile();
|
|
|
|
|
|
2016-03-12 04:20:38 +08:00
|
|
|
if (obj_file != nullptr) {
|
2019-02-12 00:14:02 +08:00
|
|
|
m_uuid = obj_file->GetUUID();
|
2018-05-03 04:06:17 +08:00
|
|
|
m_did_set_uuid = true;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
return m_uuid;
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-03 04:06:17 +08:00
|
|
|
void Module::SetUUID(const lldb_private::UUID &uuid) {
|
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
|
|
|
|
if (!m_did_set_uuid) {
|
|
|
|
|
m_uuid = uuid;
|
|
|
|
|
m_did_set_uuid = true;
|
|
|
|
|
} else {
|
2018-05-03 06:21:11 +08:00
|
|
|
lldbassert(0 && "Attempting to overwrite the existing module UUID");
|
2018-05-03 04:06:17 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-31 06:12:34 +08:00
|
|
|
llvm::Expected<TypeSystem &>
|
|
|
|
|
Module::GetTypeSystemForLanguage(LanguageType language) {
|
2015-10-09 05:04:34 +08:00
|
|
|
return m_type_system_map.GetTypeSystemForLanguage(language, this, true);
|
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
|
|
|
}
|
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
void Module::ParseAllDebugSymbols() {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-01-26 02:06:21 +08:00
|
|
|
size_t num_comp_units = GetNumCompileUnits();
|
2010-06-09 00:52:24 +08:00
|
|
|
if (num_comp_units == 0)
|
|
|
|
|
return;
|
|
|
|
|
|
2019-08-02 16:16:35 +08:00
|
|
|
SymbolFile *symbols = GetSymbolFile();
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2013-01-26 02:06:21 +08:00
|
|
|
for (size_t cu_idx = 0; cu_idx < num_comp_units; cu_idx++) {
|
2020-02-18 20:33:59 +08:00
|
|
|
SymbolContext sc;
|
|
|
|
|
sc.module_sp = shared_from_this();
|
2010-06-09 00:52:24 +08:00
|
|
|
sc.comp_unit = symbols->GetCompileUnitAtIndex(cu_idx).get();
|
2019-01-12 02:03:20 +08:00
|
|
|
if (!sc.comp_unit)
|
|
|
|
|
continue;
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2019-01-12 02:03:20 +08:00
|
|
|
symbols->ParseVariablesForContext(sc);
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2019-01-12 02:03:20 +08:00
|
|
|
symbols->ParseFunctions(*sc.comp_unit);
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2019-01-12 02:03:20 +08:00
|
|
|
sc.comp_unit->ForeachFunction([&sc, &symbols](const FunctionSP &f) {
|
2019-01-15 06:40:41 +08:00
|
|
|
symbols->ParseBlocksRecursive(*f);
|
|
|
|
|
|
2019-01-12 02:03:20 +08:00
|
|
|
// Parse the variables for this function and all its blocks
|
2019-01-15 06:40:41 +08:00
|
|
|
sc.function = f.get();
|
2019-01-12 02:03:20 +08:00
|
|
|
symbols->ParseVariablesForContext(sc);
|
|
|
|
|
return false;
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
// Parse all types for this compile unit
|
|
|
|
|
symbols->ParseTypes(*sc.comp_unit);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Module::CalculateSymbolContext(SymbolContext *sc) {
|
2012-01-30 04:56:30 +08:00
|
|
|
sc->module_sp = shared_from_this();
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
2011-08-13 05:40:01 +08:00
|
|
|
ModuleSP Module::CalculateSymbolContextModule() { return shared_from_this(); }
|
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
void Module::DumpSymbolContext(Stream *s) {
|
2014-04-04 12:06:10 +08:00
|
|
|
s->Printf(", Module{%p}", static_cast<void *>(this));
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
size_t Module::GetNumCompileUnits() {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2017-05-15 21:02:37 +08:00
|
|
|
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
|
|
|
|
|
Timer scoped_timer(func_cat, "Module::GetNumCompileUnits (module = %p)",
|
2014-04-04 12:06:10 +08:00
|
|
|
static_cast<void *>(this));
|
2019-08-02 16:16:35 +08:00
|
|
|
if (SymbolFile *symbols = GetSymbolFile())
|
2010-06-09 00:52:24 +08:00
|
|
|
return symbols->GetNumCompileUnits();
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-26 02:06:21 +08:00
|
|
|
CompUnitSP Module::GetCompileUnitAtIndex(size_t index) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2013-01-26 02:06:21 +08:00
|
|
|
size_t num_comp_units = GetNumCompileUnits();
|
2010-06-09 00:52:24 +08:00
|
|
|
CompUnitSP cu_sp;
|
|
|
|
|
|
|
|
|
|
if (index < num_comp_units) {
|
2019-08-02 16:16:35 +08:00
|
|
|
if (SymbolFile *symbols = GetSymbolFile())
|
2010-06-09 00:52:24 +08:00
|
|
|
cu_sp = symbols->GetCompileUnitAtIndex(index);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
return cu_sp;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
bool Module::ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2017-05-15 21:02:37 +08:00
|
|
|
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
|
|
|
|
|
Timer scoped_timer(func_cat,
|
2016-08-10 07:06:08 +08:00
|
|
|
"Module::ResolveFileAddress (vm_addr = 0x%" PRIx64 ")",
|
|
|
|
|
vm_addr);
|
2013-07-10 09:23:25 +08:00
|
|
|
SectionList *section_list = GetSectionList();
|
|
|
|
|
if (section_list)
|
|
|
|
|
return so_addr.ResolveAddressUsingFileSections(vm_addr, section_list);
|
2010-06-09 00:52:24 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2013-09-24 23:34:13 +08:00
|
|
|
uint32_t Module::ResolveSymbolContextForAddress(
|
2018-10-26 04:45:19 +08:00
|
|
|
const Address &so_addr, lldb::SymbolContextItem resolve_scope,
|
|
|
|
|
SymbolContext &sc, bool resolve_tail_call_address) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2010-06-09 00:52:24 +08:00
|
|
|
uint32_t resolved_flags = 0;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-02-23 12:12:47 +08:00
|
|
|
// Clear the result symbol context in case we don't find anything, but don't
|
|
|
|
|
// clear the target
|
|
|
|
|
sc.Clear(false);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
// Get the section from the section/offset address.
|
2012-02-24 09:59:29 +08:00
|
|
|
SectionSP section_sp(so_addr.GetSection());
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
// Make sure the section matches this module before we try and match anything
|
2012-02-24 09:59:29 +08:00
|
|
|
if (section_sp && section_sp->GetModule().get() == this) {
|
2018-05-01 00:49:04 +08:00
|
|
|
// If the section offset based address resolved itself, then this is the
|
|
|
|
|
// right module.
|
2012-01-30 04:56:30 +08:00
|
|
|
sc.module_sp = shared_from_this();
|
2010-06-09 00:52:24 +08:00
|
|
|
resolved_flags |= eSymbolContextModule;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-08-02 16:16:35 +08:00
|
|
|
SymbolFile *symfile = GetSymbolFile();
|
|
|
|
|
if (!symfile)
|
2013-09-17 06:00:17 +08:00
|
|
|
return resolved_flags;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// Resolve the compile unit, function, block, line table or line entry if
|
|
|
|
|
// requested.
|
2010-06-09 00:52:24 +08:00
|
|
|
if (resolve_scope & eSymbolContextCompUnit ||
|
|
|
|
|
resolve_scope & eSymbolContextFunction ||
|
|
|
|
|
resolve_scope & eSymbolContextBlock ||
|
2016-06-22 04:00:36 +08:00
|
|
|
resolve_scope & eSymbolContextLineEntry ||
|
|
|
|
|
resolve_scope & eSymbolContextVariable) {
|
2010-06-09 00:52:24 +08:00
|
|
|
resolved_flags |=
|
2019-08-02 16:16:35 +08:00
|
|
|
symfile->ResolveSymbolContext(so_addr, resolve_scope, sc);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// Resolve the symbol if requested, but don't re-look it up if we've
|
|
|
|
|
// already found it.
|
2012-01-30 04:56:30 +08:00
|
|
|
if (resolve_scope & eSymbolContextSymbol &&
|
2010-06-09 00:52:24 +08:00
|
|
|
!(resolved_flags & eSymbolContextSymbol)) {
|
2019-08-02 16:16:35 +08:00
|
|
|
Symtab *symtab = symfile->GetSymtab();
|
2013-09-17 06:00:17 +08:00
|
|
|
if (symtab && so_addr.IsSectionOffset()) {
|
|
|
|
|
Symbol *matching_symbol = nullptr;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
symtab->ForEachSymbolContainingFileAddress(
|
|
|
|
|
so_addr.GetFileAddress(),
|
|
|
|
|
[&matching_symbol](Symbol *symbol) -> bool {
|
|
|
|
|
if (symbol->GetType() != eSymbolTypeInvalid) {
|
2016-01-26 08:58:09 +08:00
|
|
|
matching_symbol = symbol;
|
2010-06-09 00:52:24 +08:00
|
|
|
return false; // Stop iterating
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2016-01-26 08:58:09 +08:00
|
|
|
return true; // Keep iterating
|
2016-09-07 04:57:50 +08:00
|
|
|
});
|
2010-06-09 00:52:24 +08:00
|
|
|
sc.symbol = matching_symbol;
|
|
|
|
|
if (!sc.symbol && resolve_scope & eSymbolContextFunction &&
|
2016-06-22 04:00:36 +08:00
|
|
|
!(resolved_flags & eSymbolContextFunction)) {
|
2013-09-17 06:00:17 +08:00
|
|
|
bool verify_unique = false; // No need to check again since
|
|
|
|
|
// ResolveSymbolContext failed to find a
|
|
|
|
|
// symbol at this address.
|
|
|
|
|
if (ObjectFile *obj_file = sc.module_sp->GetObjectFile())
|
|
|
|
|
sc.symbol =
|
|
|
|
|
obj_file->ResolveSymbolForAddress(so_addr, verify_unique);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
2010-09-01 07:51:36 +08:00
|
|
|
if (sc.symbol) {
|
|
|
|
|
if (sc.symbol->IsSynthetic()) {
|
2018-05-01 00:49:04 +08:00
|
|
|
// We have a synthetic symbol so lets check if the object file from
|
|
|
|
|
// the symbol file in the symbol vendor is different than the
|
|
|
|
|
// object file for the module, and if so search its symbol table to
|
|
|
|
|
// see if we can come up with a better symbol. For example dSYM
|
|
|
|
|
// files on MacOSX have an unstripped symbol table inside of them.
|
2013-09-24 23:34:13 +08:00
|
|
|
ObjectFile *symtab_objfile = symtab->GetObjectFile();
|
2013-10-12 06:03:48 +08:00
|
|
|
if (symtab_objfile && symtab_objfile->IsStripped()) {
|
2019-08-02 16:16:35 +08:00
|
|
|
ObjectFile *symfile_objfile = symfile->GetObjectFile();
|
|
|
|
|
if (symfile_objfile != symtab_objfile) {
|
|
|
|
|
Symtab *symfile_symtab = symfile_objfile->GetSymtab();
|
|
|
|
|
if (symfile_symtab) {
|
|
|
|
|
Symbol *symbol =
|
|
|
|
|
symfile_symtab->FindSymbolContainingFileAddress(
|
|
|
|
|
so_addr.GetFileAddress());
|
|
|
|
|
if (symbol && !symbol->IsSynthetic()) {
|
|
|
|
|
sc.symbol = symbol;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-10-12 06:03:48 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-09-17 06:00:17 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-09-17 06:00:17 +08:00
|
|
|
resolved_flags |= eSymbolContextSymbol;
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
}
|
2013-09-17 06:00:17 +08:00
|
|
|
|
|
|
|
|
// For function symbols, so_addr may be off by one. This is a convention
|
2018-05-01 00:49:04 +08:00
|
|
|
// consistent with FDE row indices in eh_frame sections, but requires extra
|
|
|
|
|
// logic here to permit symbol lookup for disassembly and unwind.
|
2013-09-17 06:00:17 +08:00
|
|
|
if (resolve_scope & eSymbolContextSymbol &&
|
|
|
|
|
!(resolved_flags & eSymbolContextSymbol) && resolve_tail_call_address &&
|
2013-09-24 23:34:13 +08:00
|
|
|
so_addr.IsSectionOffset()) {
|
2013-09-17 06:00:17 +08:00
|
|
|
Address previous_addr = so_addr;
|
2013-09-19 04:03:31 +08:00
|
|
|
previous_addr.Slide(-1);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-09-24 23:34:13 +08:00
|
|
|
bool do_resolve_tail_call_address = false; // prevent recursion
|
|
|
|
|
const uint32_t flags = ResolveSymbolContextForAddress(
|
|
|
|
|
previous_addr, resolve_scope, sc, do_resolve_tail_call_address);
|
2013-09-17 06:00:17 +08:00
|
|
|
if (flags & eSymbolContextSymbol) {
|
|
|
|
|
AddressRange addr_range;
|
|
|
|
|
if (sc.GetAddressRange(eSymbolContextFunction | eSymbolContextSymbol, 0,
|
|
|
|
|
false, addr_range)) {
|
|
|
|
|
if (addr_range.GetBaseAddress().GetSection() ==
|
|
|
|
|
so_addr.GetSection()) {
|
|
|
|
|
// If the requested address is one past the address range of a
|
2018-05-01 00:49:04 +08:00
|
|
|
// function (i.e. a tail call), or the decremented address is the
|
|
|
|
|
// start of a function (i.e. some forms of trampoline), indicate
|
|
|
|
|
// that the symbol has been resolved.
|
2013-09-17 06:00:17 +08:00
|
|
|
if (so_addr.GetOffset() ==
|
|
|
|
|
addr_range.GetBaseAddress().GetOffset() ||
|
|
|
|
|
so_addr.GetOffset() ==
|
|
|
|
|
addr_range.GetBaseAddress().GetOffset() +
|
|
|
|
|
addr_range.GetByteSize()) {
|
|
|
|
|
resolved_flags |= flags;
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2013-09-24 23:34:13 +08:00
|
|
|
sc.symbol =
|
2013-09-17 06:00:17 +08:00
|
|
|
nullptr; // Don't trust the symbol if the sections didn't match.
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
return resolved_flags;
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-10-26 04:45:19 +08:00
|
|
|
uint32_t Module::ResolveSymbolContextForFilePath(
|
|
|
|
|
const char *file_path, uint32_t line, bool check_inlines,
|
|
|
|
|
lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
|
2018-11-02 05:05:36 +08:00
|
|
|
FileSpec file_spec(file_path);
|
2010-06-09 00:52:24 +08:00
|
|
|
return ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
|
|
|
|
|
resolve_scope, sc_list);
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-10-26 04:45:19 +08:00
|
|
|
uint32_t Module::ResolveSymbolContextsForFileSpec(
|
|
|
|
|
const FileSpec &file_spec, uint32_t line, bool check_inlines,
|
|
|
|
|
lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2017-05-15 21:02:37 +08:00
|
|
|
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
|
|
|
|
|
Timer scoped_timer(func_cat,
|
2013-04-30 01:25:54 +08:00
|
|
|
"Module::ResolveSymbolContextForFilePath (%s:%u, "
|
|
|
|
|
"check_inlines = %s, resolve_scope = 0x%8.8x)",
|
|
|
|
|
file_spec.GetPath().c_str(), line,
|
2010-06-09 00:52:24 +08:00
|
|
|
check_inlines ? "yes" : "no", resolve_scope);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
const uint32_t initial_count = sc_list.GetSize();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-08-02 16:16:35 +08:00
|
|
|
if (SymbolFile *symbols = GetSymbolFile())
|
2010-06-09 00:52:24 +08:00
|
|
|
symbols->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope,
|
|
|
|
|
sc_list);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
return sc_list.GetSize() - initial_count;
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-10-18 03:56:40 +08:00
|
|
|
void Module::FindGlobalVariables(ConstString name,
|
2020-02-18 02:25:52 +08:00
|
|
|
const CompilerDeclContext &parent_decl_ctx,
|
2019-10-18 03:56:40 +08:00
|
|
|
size_t max_matches, VariableList &variables) {
|
2019-08-02 16:16:35 +08:00
|
|
|
if (SymbolFile *symbols = GetSymbolFile())
|
2019-10-18 03:56:40 +08:00
|
|
|
symbols->FindGlobalVariables(name, parent_decl_ctx, max_matches, variables);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-10-18 03:56:40 +08:00
|
|
|
void Module::FindGlobalVariables(const RegularExpression ®ex,
|
|
|
|
|
size_t max_matches, VariableList &variables) {
|
2019-08-02 16:16:35 +08:00
|
|
|
SymbolFile *symbols = GetSymbolFile();
|
2010-06-09 00:52:24 +08:00
|
|
|
if (symbols)
|
2019-10-18 03:56:40 +08:00
|
|
|
symbols->FindGlobalVariables(regex, max_matches, variables);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-10-18 03:56:40 +08:00
|
|
|
void Module::FindCompileUnits(const FileSpec &path,
|
|
|
|
|
SymbolContextList &sc_list) {
|
2013-01-26 02:06:21 +08:00
|
|
|
const size_t num_compile_units = GetNumCompileUnits();
|
2011-07-07 09:59:51 +08:00
|
|
|
SymbolContext sc;
|
2012-01-30 04:56:30 +08:00
|
|
|
sc.module_sp = shared_from_this();
|
2016-03-12 04:20:38 +08:00
|
|
|
for (size_t i = 0; i < num_compile_units; ++i) {
|
2011-07-07 09:59:51 +08:00
|
|
|
sc.comp_unit = GetCompileUnitAtIndex(i).get();
|
2012-04-24 06:00:21 +08:00
|
|
|
if (sc.comp_unit) {
|
[lldb] s/FileSpec::Equal/FileSpec::Match
Summary:
The FileSpec class is often used as a sort of a pattern -- one specifies
a bare file name to search, and we check if in matches the full file
name of an existing module (for example).
These comparisons used FileSpec::Equal, which had some support for it
(via the full=false argument), but it was not a good fit for this job.
For one, it did a symmetric comparison, which makes sense for a function
called "equal", but not for typical searches (when searching for
"/foo/bar.so", we don't want to find a module whose name is just
"bar.so"). This resulted in patterns like:
if (FileSpec::Equal(pattern, file, pattern.GetDirectory()))
which would request a "full" match only if the pattern really contained
a directory. This worked, but the intended behavior was very unobvious.
On top of that, a lot of the code wanted to handle the case of an
"empty" pattern, and treat it as matching everything. This resulted in
conditions like:
if (pattern && !FileSpec::Equal(pattern, file, pattern.GetDirectory())
which are nearly impossible to decipher.
This patch introduces a FileSpec::Match function, which does exactly
what most of FileSpec::Equal callers want, an asymmetric match between a
"pattern" FileSpec and a an actual FileSpec. Empty paterns match
everything, filename-only patterns match only the filename component.
I've tried to update all callers of FileSpec::Equal to use a simpler
interface. Those that hardcoded full=true have been changed to use
operator==. Those passing full=pattern.GetDirectory() have been changed
to use FileSpec::Match.
There was also a handful of places which hardcoded full=false. I've
changed these to use FileSpec::Match too. This is a slight change in
semantics, but it does not look like that was ever intended, and it was
more likely a result of a misunderstanding of the "proper" way to use
FileSpec::Equal.
[In an ideal world a "FileSpec" and a "FileSpec pattern" would be two
different types, but given how widespread FileSpec is, it is unlikely
we'll get there in one go. This at least provides a good starting point
by centralizing all matching behavior.]
Reviewers: teemperor, JDevlieghere, jdoerfert
Subscribers: emaste, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D70851
2019-11-29 18:31:00 +08:00
|
|
|
if (FileSpec::Match(path, sc.comp_unit->GetPrimaryFile()))
|
2012-04-24 06:00:21 +08:00
|
|
|
sc_list.Append(sc);
|
2011-07-07 09:59:51 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-07-07 09:59:51 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-03-07 05:22:25 +08:00
|
|
|
Module::LookupInfo::LookupInfo(ConstString name,
|
2018-10-26 04:45:40 +08:00
|
|
|
FunctionNameType name_type_mask,
|
|
|
|
|
LanguageType language)
|
|
|
|
|
: m_name(name), m_lookup_name(), m_language(language),
|
|
|
|
|
m_name_type_mask(eFunctionNameTypeNone),
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
m_match_name_after_lookup(false) {
|
|
|
|
|
const char *name_cstr = name.GetCString();
|
|
|
|
|
llvm::StringRef basename;
|
|
|
|
|
llvm::StringRef context;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
if (name_type_mask & eFunctionNameTypeAuto) {
|
|
|
|
|
if (CPlusPlusLanguage::IsCPPMangledName(name_cstr))
|
|
|
|
|
m_name_type_mask = eFunctionNameTypeFull;
|
|
|
|
|
else if ((language == eLanguageTypeUnknown ||
|
|
|
|
|
Language::LanguageIsObjC(language)) &&
|
|
|
|
|
ObjCLanguage::IsPossibleObjCMethodName(name_cstr))
|
|
|
|
|
m_name_type_mask = eFunctionNameTypeFull;
|
|
|
|
|
else if (Language::LanguageIsC(language)) {
|
|
|
|
|
m_name_type_mask = eFunctionNameTypeFull;
|
|
|
|
|
} else {
|
|
|
|
|
if ((language == eLanguageTypeUnknown ||
|
|
|
|
|
Language::LanguageIsObjC(language)) &&
|
|
|
|
|
ObjCLanguage::IsPossibleObjCSelector(name_cstr))
|
|
|
|
|
m_name_type_mask |= eFunctionNameTypeSelector;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
CPlusPlusLanguage::MethodName cpp_method(name);
|
|
|
|
|
basename = cpp_method.GetBasename();
|
|
|
|
|
if (basename.empty()) {
|
|
|
|
|
if (CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
|
|
|
|
|
basename))
|
|
|
|
|
m_name_type_mask |= (eFunctionNameTypeMethod | eFunctionNameTypeBase);
|
|
|
|
|
else
|
|
|
|
|
m_name_type_mask |= eFunctionNameTypeFull;
|
|
|
|
|
} else {
|
|
|
|
|
m_name_type_mask |= (eFunctionNameTypeMethod | eFunctionNameTypeBase);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
m_name_type_mask = name_type_mask;
|
|
|
|
|
if (name_type_mask & eFunctionNameTypeMethod ||
|
|
|
|
|
name_type_mask & eFunctionNameTypeBase) {
|
|
|
|
|
// If they've asked for a CPP method or function name and it can't be
|
2018-05-01 00:49:04 +08:00
|
|
|
// that, we don't even need to search for CPP methods or names.
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
CPlusPlusLanguage::MethodName cpp_method(name);
|
|
|
|
|
if (cpp_method.IsValid()) {
|
|
|
|
|
basename = cpp_method.GetBasename();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
if (!cpp_method.GetQualifiers().empty()) {
|
|
|
|
|
// There is a "const" or other qualifier following the end of the
|
2018-05-01 00:49:04 +08:00
|
|
|
// function parens, this can't be a eFunctionNameTypeBase
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
m_name_type_mask &= ~(eFunctionNameTypeBase);
|
|
|
|
|
if (m_name_type_mask == eFunctionNameTypeNone)
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
// If the CPP method parser didn't manage to chop this up, try to fill
|
2018-05-01 00:49:04 +08:00
|
|
|
// in the base name if we can. If a::b::c is passed in, we need to just
|
|
|
|
|
// look up "c", and then we'll filter the result later.
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
|
|
|
|
|
basename);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (name_type_mask & eFunctionNameTypeSelector) {
|
|
|
|
|
if (!ObjCLanguage::IsPossibleObjCSelector(name_cstr)) {
|
|
|
|
|
m_name_type_mask &= ~(eFunctionNameTypeSelector);
|
|
|
|
|
if (m_name_type_mask == eFunctionNameTypeNone)
|
2016-09-07 04:57:50 +08:00
|
|
|
return;
|
|
|
|
|
}
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Still try and get a basename in case someone specifies a name type mask
|
2017-02-14 05:34:58 +08:00
|
|
|
// of eFunctionNameTypeFull and a name like "A::func"
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
if (basename.empty()) {
|
2017-02-14 05:34:58 +08:00
|
|
|
if (name_type_mask & eFunctionNameTypeFull &&
|
|
|
|
|
!CPlusPlusLanguage::IsCPPMangledName(name_cstr)) {
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
CPlusPlusLanguage::MethodName cpp_method(name);
|
|
|
|
|
basename = cpp_method.GetBasename();
|
|
|
|
|
if (basename.empty())
|
|
|
|
|
CPlusPlusLanguage::ExtractContextAndIdentifier(name_cstr, context,
|
|
|
|
|
basename);
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
if (!basename.empty()) {
|
2018-05-01 00:49:04 +08:00
|
|
|
// The name supplied was a partial C++ path like "a::count". In this case
|
|
|
|
|
// we want to do a lookup on the basename "count" and then make sure any
|
|
|
|
|
// matching results contain "a::count" so that it would match "b::a::count"
|
|
|
|
|
// and "a::count". This is why we set "match_name_after_lookup" to true
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
m_lookup_name.SetString(basename);
|
|
|
|
|
m_match_name_after_lookup = true;
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
// The name is already correct, just use the exact name as supplied, and we
|
2018-05-01 00:49:04 +08:00
|
|
|
// won't need to check if any matches contain "name"
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
m_lookup_name = name;
|
|
|
|
|
m_match_name_after_lookup = false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
void Module::LookupInfo::Prune(SymbolContextList &sc_list,
|
|
|
|
|
size_t start_idx) const {
|
|
|
|
|
if (m_match_name_after_lookup && m_name) {
|
|
|
|
|
SymbolContext sc;
|
|
|
|
|
size_t i = start_idx;
|
|
|
|
|
while (i < sc_list.GetSize()) {
|
|
|
|
|
if (!sc_list.GetContextAtIndex(i, sc))
|
|
|
|
|
break;
|
|
|
|
|
ConstString full_name(sc.GetFunctionName());
|
|
|
|
|
if (full_name &&
|
|
|
|
|
::strstr(full_name.GetCString(), m_name.GetCString()) == nullptr) {
|
|
|
|
|
sc_list.RemoveContextAtIndex(i);
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
|
|
|
|
++i;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-23 00:19:56 +08:00
|
|
|
// If we have only full name matches we might have tried to set breakpoint on
|
2017-02-14 05:34:58 +08:00
|
|
|
// "func" and specified eFunctionNameTypeFull, but we might have found
|
|
|
|
|
// "a::func()", "a::b::func()", "c::func()", "func()" and "func". Only
|
|
|
|
|
// "func()" and "func" should end up matching.
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
if (m_name_type_mask == eFunctionNameTypeFull) {
|
|
|
|
|
SymbolContext sc;
|
|
|
|
|
size_t i = start_idx;
|
|
|
|
|
while (i < sc_list.GetSize()) {
|
|
|
|
|
if (!sc_list.GetContextAtIndex(i, sc))
|
|
|
|
|
break;
|
2018-05-01 00:49:04 +08:00
|
|
|
// Make sure the mangled and demangled names don't match before we try to
|
|
|
|
|
// pull anything out
|
2017-02-14 05:34:58 +08:00
|
|
|
ConstString mangled_name(sc.GetFunctionName(Mangled::ePreferMangled));
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
ConstString full_name(sc.GetFunctionName());
|
2017-02-14 05:34:58 +08:00
|
|
|
if (mangled_name != m_name && full_name != m_name)
|
|
|
|
|
{
|
|
|
|
|
CPlusPlusLanguage::MethodName cpp_method(full_name);
|
|
|
|
|
if (cpp_method.IsValid()) {
|
|
|
|
|
if (cpp_method.GetContext().empty()) {
|
|
|
|
|
if (cpp_method.GetBasename().compare(m_name.GetStringRef()) != 0) {
|
|
|
|
|
sc_list.RemoveContextAtIndex(i);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
std::string qualified_name;
|
|
|
|
|
llvm::StringRef anon_prefix("(anonymous namespace)");
|
|
|
|
|
if (cpp_method.GetContext() == anon_prefix)
|
|
|
|
|
qualified_name = cpp_method.GetBasename().str();
|
|
|
|
|
else
|
|
|
|
|
qualified_name = cpp_method.GetScopeQualifiedName();
|
2018-12-22 06:46:10 +08:00
|
|
|
if (qualified_name != m_name.GetCString()) {
|
2017-02-14 05:34:58 +08:00
|
|
|
sc_list.RemoveContextAtIndex(i);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
}
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
++i;
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
}
|
|
|
|
|
|
2019-10-18 03:56:40 +08:00
|
|
|
void Module::FindFunctions(ConstString name,
|
2020-02-18 02:25:52 +08:00
|
|
|
const CompilerDeclContext &parent_decl_ctx,
|
2019-10-18 03:56:40 +08:00
|
|
|
FunctionNameType name_type_mask,
|
|
|
|
|
bool include_symbols, bool include_inlines,
|
|
|
|
|
SymbolContextList &sc_list) {
|
2013-04-03 10:00:15 +08:00
|
|
|
const size_t old_size = sc_list.GetSize();
|
2011-01-27 14:44:37 +08:00
|
|
|
|
|
|
|
|
// Find all the functions (not symbols, but debug information functions...
|
2019-08-02 16:16:35 +08:00
|
|
|
SymbolFile *symbols = GetSymbolFile();
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
|
|
|
|
|
if (name_type_mask & eFunctionNameTypeAuto) {
|
|
|
|
|
LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
|
2013-04-03 10:00:15 +08:00
|
|
|
|
|
|
|
|
if (symbols) {
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
symbols->FindFunctions(lookup_info.GetLookupName(), parent_decl_ctx,
|
|
|
|
|
lookup_info.GetNameTypeMask(), include_inlines,
|
2019-10-18 03:56:40 +08:00
|
|
|
sc_list);
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
|
2013-07-02 03:45:50 +08:00
|
|
|
// Now check our symbol table for symbols that are code symbols if
|
|
|
|
|
// requested
|
|
|
|
|
if (include_symbols) {
|
|
|
|
|
Symtab *symtab = symbols->GetSymtab();
|
2013-04-03 10:00:15 +08:00
|
|
|
if (symtab)
|
|
|
|
|
symtab->FindFunctionSymbols(lookup_info.GetLookupName(),
|
|
|
|
|
lookup_info.GetNameTypeMask(), sc_list);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const size_t new_size = sc_list.GetSize();
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2013-01-26 02:06:21 +08:00
|
|
|
if (old_size < new_size)
|
2013-06-12 08:46:38 +08:00
|
|
|
lookup_info.Prune(sc_list, old_size);
|
|
|
|
|
} else {
|
|
|
|
|
if (symbols) {
|
|
|
|
|
symbols->FindFunctions(name, parent_decl_ctx, name_type_mask,
|
2019-10-18 03:56:40 +08:00
|
|
|
include_inlines, sc_list);
|
2013-09-12 10:20:34 +08:00
|
|
|
|
|
|
|
|
// Now check our symbol table for symbols that are code symbols if
|
2012-03-27 07:03:23 +08:00
|
|
|
// requested
|
|
|
|
|
if (include_symbols) {
|
2010-08-03 09:26:16 +08:00
|
|
|
Symtab *symtab = symbols->GetSymtab();
|
|
|
|
|
if (symtab)
|
2016-02-11 05:28:13 +08:00
|
|
|
symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-08-03 09:26:16 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-08-03 09:26:16 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-10-18 03:56:40 +08:00
|
|
|
void Module::FindFunctions(const RegularExpression ®ex, bool include_symbols,
|
|
|
|
|
bool include_inlines,
|
|
|
|
|
SymbolContextList &sc_list) {
|
2012-03-27 07:03:23 +08:00
|
|
|
const size_t start_size = sc_list.GetSize();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-08-02 16:16:35 +08:00
|
|
|
if (SymbolFile *symbols = GetSymbolFile()) {
|
2019-10-18 03:56:40 +08:00
|
|
|
symbols->FindFunctions(regex, include_inlines, sc_list);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-05-01 00:49:04 +08:00
|
|
|
// Now check our symbol table for symbols that are code symbols if
|
|
|
|
|
// requested
|
2016-02-11 05:28:13 +08:00
|
|
|
if (include_symbols) {
|
|
|
|
|
Symtab *symtab = symbols->GetSymtab();
|
2013-04-03 10:00:15 +08:00
|
|
|
if (symtab) {
|
2016-02-11 05:28:13 +08:00
|
|
|
std::vector<uint32_t> symbol_indexes;
|
|
|
|
|
symtab->AppendSymbolIndexesMatchingRegExAndType(
|
|
|
|
|
regex, eSymbolTypeAny, Symtab::eDebugAny, Symtab::eVisibilityAny,
|
2013-02-28 04:13:38 +08:00
|
|
|
symbol_indexes);
|
2016-02-11 05:28:13 +08:00
|
|
|
const size_t num_matches = symbol_indexes.size();
|
2012-12-06 05:24:42 +08:00
|
|
|
if (num_matches) {
|
2012-03-27 07:03:23 +08:00
|
|
|
SymbolContext sc(this);
|
|
|
|
|
const size_t end_functions_added_index = sc_list.GetSize();
|
2013-01-26 02:06:21 +08:00
|
|
|
size_t num_functions_added_to_sc_list =
|
2016-02-11 05:28:13 +08:00
|
|
|
end_functions_added_index - start_size;
|
2013-06-12 08:46:38 +08:00
|
|
|
if (num_functions_added_to_sc_list == 0) {
|
2018-05-01 00:49:04 +08:00
|
|
|
// No functions were added, just symbols, so we can just append
|
|
|
|
|
// them
|
2013-01-26 02:06:21 +08:00
|
|
|
for (size_t i = 0; i < num_matches; ++i) {
|
2012-03-27 07:03:23 +08:00
|
|
|
sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
|
2012-10-23 00:19:56 +08:00
|
|
|
SymbolType sym_type = sc.symbol->GetType();
|
|
|
|
|
if (sc.symbol && (sym_type == eSymbolTypeCode ||
|
|
|
|
|
sym_type == eSymbolTypeResolver))
|
|
|
|
|
sc_list.Append(sc);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-07-30 03:53:35 +08:00
|
|
|
} else {
|
2012-03-27 07:03:23 +08:00
|
|
|
typedef std::map<lldb::addr_t, uint32_t> FileAddrToIndexMap;
|
|
|
|
|
FileAddrToIndexMap file_addr_to_index;
|
|
|
|
|
for (size_t i = start_size; i < end_functions_added_index; ++i) {
|
|
|
|
|
const SymbolContext &sc = sc_list[i];
|
|
|
|
|
if (sc.block)
|
2013-06-12 08:46:38 +08:00
|
|
|
continue;
|
2012-03-27 07:03:23 +08:00
|
|
|
file_addr_to_index[sc.function->GetAddressRange()
|
|
|
|
|
.GetBaseAddress()
|
2014-07-02 05:22:11 +08:00
|
|
|
.GetFileAddress()] = i;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-03-27 07:03:23 +08:00
|
|
|
|
2016-03-12 04:20:38 +08:00
|
|
|
FileAddrToIndexMap::const_iterator end = file_addr_to_index.end();
|
|
|
|
|
// Functions were added so we need to merge symbols into any
|
2013-06-12 08:46:38 +08:00
|
|
|
// existing function symbol contexts
|
2016-03-12 04:20:38 +08:00
|
|
|
for (size_t i = start_size; i < num_matches; ++i) {
|
|
|
|
|
sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
|
|
|
|
|
SymbolType sym_type = sc.symbol->GetType();
|
|
|
|
|
if (sc.symbol && sc.symbol->ValueIsAddress() &&
|
2015-10-08 17:45:41 +08:00
|
|
|
(sym_type == eSymbolTypeCode ||
|
|
|
|
|
sym_type == eSymbolTypeResolver)) {
|
|
|
|
|
FileAddrToIndexMap::const_iterator pos =
|
|
|
|
|
file_addr_to_index.find(
|
|
|
|
|
sc.symbol->GetAddressRef().GetFileAddress());
|
|
|
|
|
if (pos == end)
|
|
|
|
|
sc_list.Append(sc);
|
2016-09-07 04:57:50 +08:00
|
|
|
else
|
2013-06-12 08:46:38 +08:00
|
|
|
sc_list[pos->second].symbol = sc.symbol;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-03-27 07:03:23 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-07-30 03:53:35 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-12 10:20:34 +08:00
|
|
|
void Module::FindAddressesForLine(const lldb::TargetSP target_sp,
|
|
|
|
|
const FileSpec &file, uint32_t line,
|
|
|
|
|
Function *function,
|
|
|
|
|
std::vector<Address> &output_local,
|
|
|
|
|
std::vector<Address> &output_extern) {
|
|
|
|
|
SearchFilterByModule filter(target_sp, m_file);
|
|
|
|
|
AddressResolverFileLine resolver(file, line, true);
|
|
|
|
|
resolver.ResolveAddress(filter);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2016-03-12 04:20:38 +08:00
|
|
|
for (size_t n = 0; n < resolver.GetNumberOfAddresses(); n++) {
|
2013-09-12 10:20:34 +08:00
|
|
|
Address addr = resolver.GetAddressRangeAtIndex(n).GetBaseAddress();
|
|
|
|
|
Function *f = addr.CalculateSymbolContextFunction();
|
|
|
|
|
if (f && f == function)
|
|
|
|
|
output_local.push_back(addr);
|
2011-07-30 03:53:35 +08:00
|
|
|
else
|
2012-03-27 07:03:23 +08:00
|
|
|
output_extern.push_back(addr);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-01 23:40:41 +08:00
|
|
|
void Module::FindTypes_Impl(
|
2020-02-18 02:25:52 +08:00
|
|
|
ConstString name, const CompilerDeclContext &parent_decl_ctx,
|
2019-10-01 00:42:28 +08:00
|
|
|
size_t max_matches,
|
2012-03-27 07:03:23 +08:00
|
|
|
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
|
2015-10-08 17:45:41 +08:00
|
|
|
TypeMap &types) {
|
2017-05-15 21:02:37 +08:00
|
|
|
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
|
|
|
|
|
Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
|
2019-08-02 16:16:35 +08:00
|
|
|
if (SymbolFile *symbols = GetSymbolFile())
|
2019-10-01 23:40:41 +08:00
|
|
|
symbols->FindTypes(name, parent_decl_ctx, max_matches,
|
|
|
|
|
searched_symbol_files, types);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2019-10-01 23:40:41 +08:00
|
|
|
void Module::FindTypesInNamespace(ConstString type_name,
|
2020-02-18 02:25:52 +08:00
|
|
|
const CompilerDeclContext &parent_decl_ctx,
|
2019-10-01 23:40:41 +08:00
|
|
|
size_t max_matches, TypeList &type_list) {
|
2015-10-08 17:45:41 +08:00
|
|
|
TypeMap types_map;
|
2016-03-12 04:20:38 +08:00
|
|
|
llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
|
2019-10-01 23:40:41 +08:00
|
|
|
FindTypes_Impl(type_name, parent_decl_ctx, max_matches, searched_symbol_files,
|
|
|
|
|
types_map);
|
|
|
|
|
if (types_map.GetSize()) {
|
2019-01-15 06:41:21 +08:00
|
|
|
SymbolContext sc;
|
|
|
|
|
sc.module_sp = shared_from_this();
|
2016-03-12 04:20:38 +08:00
|
|
|
sc.SortTypeList(types_map, type_list);
|
2019-01-15 06:41:21 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2016-03-12 04:20:38 +08:00
|
|
|
lldb::TypeSP Module::FindFirstType(const SymbolContext &sc,
|
2019-03-07 05:22:25 +08:00
|
|
|
ConstString name, bool exact_match) {
|
2012-12-06 05:24:42 +08:00
|
|
|
TypeList type_list;
|
2016-02-11 05:28:13 +08:00
|
|
|
llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
|
2019-10-01 23:40:41 +08:00
|
|
|
FindTypes(name, exact_match, 1, searched_symbol_files, type_list);
|
|
|
|
|
if (type_list.GetSize())
|
2015-10-08 17:45:41 +08:00
|
|
|
return type_list.GetTypeAtIndex(0);
|
|
|
|
|
return TypeSP();
|
2012-10-23 00:19:56 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-10-01 23:40:41 +08:00
|
|
|
void Module::FindTypes(
|
2019-03-07 05:22:25 +08:00
|
|
|
ConstString name, bool exact_match, size_t max_matches,
|
2016-03-12 04:20:38 +08:00
|
|
|
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
|
|
|
|
|
TypeList &types) {
|
|
|
|
|
const char *type_name_cstr = name.GetCString();
|
2017-01-10 19:13:59 +08:00
|
|
|
llvm::StringRef type_scope;
|
|
|
|
|
llvm::StringRef type_basename;
|
2012-10-23 00:19:56 +08:00
|
|
|
TypeClass type_class = eTypeClassAny;
|
2016-03-12 04:20:38 +08:00
|
|
|
TypeMap typesmap;
|
2018-05-08 11:08:46 +08:00
|
|
|
|
2016-03-12 04:20:38 +08:00
|
|
|
if (Type::GetTypeScopeAndBasename(type_name_cstr, type_scope, type_basename,
|
2012-10-23 00:19:56 +08:00
|
|
|
type_class)) {
|
2012-03-27 07:03:23 +08:00
|
|
|
// Check if "name" starts with "::" which means the qualified type starts
|
2016-03-12 04:20:38 +08:00
|
|
|
// from the root namespace and implies and exact match. The typenames we
|
2012-03-27 07:03:23 +08:00
|
|
|
// get back from clang do not start with "::" so we need to strip this off
|
2014-07-02 05:22:11 +08:00
|
|
|
// in order to get the qualified names to match
|
2017-01-10 19:13:59 +08:00
|
|
|
exact_match = type_scope.consume_front("::");
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2017-01-10 19:13:59 +08:00
|
|
|
ConstString type_basename_const_str(type_basename);
|
2020-02-18 02:25:52 +08:00
|
|
|
FindTypes_Impl(type_basename_const_str, CompilerDeclContext(), max_matches,
|
2019-10-01 23:40:41 +08:00
|
|
|
searched_symbol_files, typesmap);
|
|
|
|
|
if (typesmap.GetSize())
|
2020-01-29 03:23:46 +08:00
|
|
|
typesmap.RemoveMismatchedTypes(std::string(type_scope),
|
|
|
|
|
std::string(type_basename), type_class,
|
2015-07-25 07:38:01 +08:00
|
|
|
exact_match);
|
2010-06-09 00:52:24 +08:00
|
|
|
} else {
|
|
|
|
|
// The type is not in a namespace/class scope, just search for it by
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
// basename
|
2018-05-01 05:06:30 +08:00
|
|
|
if (type_class != eTypeClassAny && !type_basename.empty()) {
|
2010-06-09 00:52:24 +08:00
|
|
|
// The "type_name_cstr" will have been modified if we have a valid type
|
2018-05-01 00:49:04 +08:00
|
|
|
// class prefix (like "struct", "class", "union", "typedef" etc).
|
2020-02-18 02:25:52 +08:00
|
|
|
FindTypes_Impl(ConstString(type_basename), CompilerDeclContext(),
|
|
|
|
|
UINT_MAX, searched_symbol_files, typesmap);
|
2020-01-29 03:23:46 +08:00
|
|
|
typesmap.RemoveMismatchedTypes(std::string(type_scope),
|
|
|
|
|
std::string(type_basename), type_class,
|
2018-05-01 05:06:30 +08:00
|
|
|
exact_match);
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2020-02-18 02:25:52 +08:00
|
|
|
FindTypes_Impl(name, CompilerDeclContext(), UINT_MAX,
|
|
|
|
|
searched_symbol_files, typesmap);
|
2018-05-01 05:06:30 +08:00
|
|
|
if (exact_match) {
|
|
|
|
|
std::string name_str(name.AsCString(""));
|
2020-01-29 03:23:46 +08:00
|
|
|
typesmap.RemoveMismatchedTypes(std::string(type_scope), name_str,
|
|
|
|
|
type_class, exact_match);
|
2018-05-01 05:06:30 +08:00
|
|
|
}
|
2013-04-30 01:25:54 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2019-10-01 23:40:41 +08:00
|
|
|
if (typesmap.GetSize()) {
|
2019-01-15 06:41:21 +08:00
|
|
|
SymbolContext sc;
|
|
|
|
|
sc.module_sp = shared_from_this();
|
2013-04-30 01:25:54 +08:00
|
|
|
sc.SortTypeList(typesmap, types);
|
2019-01-15 06:41:21 +08:00
|
|
|
}
|
2013-04-30 01:25:54 +08:00
|
|
|
}
|
|
|
|
|
|
2019-11-13 01:25:59 +08:00
|
|
|
void Module::FindTypes(
|
|
|
|
|
llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
|
|
|
|
|
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
|
|
|
|
|
TypeMap &types) {
|
2019-08-23 05:45:58 +08:00
|
|
|
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
|
|
|
|
|
Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
|
|
|
|
|
if (SymbolFile *symbols = GetSymbolFile())
|
2019-11-13 01:25:59 +08:00
|
|
|
symbols->FindTypes(pattern, languages, searched_symbol_files, types);
|
2019-08-23 05:45:58 +08:00
|
|
|
}
|
|
|
|
|
|
2019-08-08 15:34:07 +08:00
|
|
|
SymbolFile *Module::GetSymbolFile(bool can_create, Stream *feedback_strm) {
|
|
|
|
|
if (!m_did_load_symfile.load()) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2019-08-08 15:34:07 +08:00
|
|
|
if (!m_did_load_symfile.load() && can_create) {
|
2011-11-28 09:45:00 +08:00
|
|
|
ObjectFile *obj_file = GetObjectFile();
|
|
|
|
|
if (obj_file != nullptr) {
|
2017-05-15 21:02:37 +08:00
|
|
|
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
|
|
|
|
|
Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
|
2019-02-13 14:25:41 +08:00
|
|
|
m_symfile_up.reset(
|
2011-11-28 09:45:00 +08:00
|
|
|
SymbolVendor::FindPlugin(shared_from_this(), feedback_strm));
|
2019-08-08 15:34:07 +08:00
|
|
|
m_did_load_symfile = true;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-11-28 09:45:00 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2019-08-08 15:34:07 +08:00
|
|
|
return m_symfile_up ? m_symfile_up->GetSymbolFile() : nullptr;
|
2019-08-02 16:16:35 +08:00
|
|
|
}
|
|
|
|
|
|
2019-08-05 17:21:47 +08:00
|
|
|
Symtab *Module::GetSymtab() {
|
|
|
|
|
if (SymbolFile *symbols = GetSymbolFile())
|
|
|
|
|
return symbols->GetSymtab();
|
|
|
|
|
return nullptr;
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
void Module::SetFileSpecAndObjectName(const FileSpec &file,
|
2019-03-07 05:22:25 +08:00
|
|
|
ConstString object_name) {
|
2018-05-01 00:49:04 +08:00
|
|
|
// Container objects whose paths do not specify a file directly can call this
|
|
|
|
|
// function to correct the file and object names.
|
2010-06-09 00:52:24 +08:00
|
|
|
m_file = file;
|
2018-11-01 05:49:27 +08:00
|
|
|
m_mod_time = FileSystem::Instance().GetModificationTime(file);
|
2010-06-09 00:52:24 +08:00
|
|
|
m_object_name = object_name;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2012-02-26 13:51:37 +08:00
|
|
|
const ArchSpec &Module::GetArchitecture() const { return m_arch; }
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
std::string Module::GetSpecificationDescription() const {
|
2015-04-01 05:01:48 +08:00
|
|
|
std::string spec(GetFileSpec().GetPath());
|
2013-04-30 01:25:54 +08:00
|
|
|
if (m_object_name) {
|
|
|
|
|
spec += '(';
|
2010-10-31 11:01:06 +08:00
|
|
|
spec += m_object_name.GetCString();
|
2013-04-30 01:25:54 +08:00
|
|
|
spec += ')';
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-03-16 05:01:31 +08:00
|
|
|
return spec;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2019-12-04 16:20:42 +08:00
|
|
|
void Module::GetDescription(llvm::raw_ostream &s,
|
|
|
|
|
lldb::DescriptionLevel level) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-11-28 09:45:00 +08:00
|
|
|
if (level >= eDescriptionLevelFull) {
|
2011-02-23 08:35:02 +08:00
|
|
|
if (m_arch.IsValid())
|
2019-12-04 16:20:42 +08:00
|
|
|
s << llvm::formatv("({0}) ", m_arch.GetArchitectureName());
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2011-11-28 09:45:00 +08:00
|
|
|
if (level == eDescriptionLevelBrief) {
|
2010-10-31 11:01:06 +08:00
|
|
|
const char *filename = m_file.GetFilename().GetCString();
|
Centralize the way symbol and functions are looked up by making a Module::LookupInfo class that does all of the heavy lifting.
Background: symbols and functions can be looked up by full mangled name and by basename. SymbolFile and ObjectFile are expected to be able to do the lookups based on full mangled name or by basename, so when the user types something that is incomplete, we must be able to look it up efficiently. For example the user types "a::b::c" as a symbol to set a breakpoint on, we will break this down into a 'lookup "c"' and then weed out N matches down to just the ones that match "a::b::c". Previously this was done manaully in many functions by calling Module::PrepareForFunctionNameLookup(...) and then doing the lookup and manually pruning the results down afterward with duplicated code. Now all places use Module::LookupInfo to do the work in one place.
This allowed me to fix the name lookups to look for "func" with eFunctionNameTypeFull as the "name_type_mask", and correctly weed the results:
"func", "func()", "func(int)", "a::func()", "b::func()", and "a::b::func()" down to just "func", "func()", "func(int)". Previously we would have set 6 breakpoints, now we correctly set just 3. This also extends to the expression parser when it looks up names for functions it needs to not get multiple results so we can call the correct function.
<rdar://problem/24599697>
llvm-svn: 275281
2016-07-14 01:12:24 +08:00
|
|
|
if (filename)
|
2019-12-04 16:20:42 +08:00
|
|
|
s << filename;
|
2011-11-28 09:45:00 +08:00
|
|
|
} else {
|
|
|
|
|
char path[PATH_MAX];
|
|
|
|
|
if (m_file.GetPath(path, sizeof(path)))
|
2019-12-04 16:20:42 +08:00
|
|
|
s << path;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2010-10-31 11:01:06 +08:00
|
|
|
const char *object_name = m_object_name.GetCString();
|
|
|
|
|
if (object_name)
|
2019-12-04 16:20:42 +08:00
|
|
|
s << llvm::formatv("({0})", object_name);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2012-01-05 11:57:59 +08:00
|
|
|
void Module::ReportError(const char *format, ...) {
|
|
|
|
|
if (format && format[0]) {
|
|
|
|
|
StreamString strm;
|
|
|
|
|
strm.PutCString("error: ");
|
2019-12-04 16:20:42 +08:00
|
|
|
GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelBrief);
|
2012-01-11 09:59:18 +08:00
|
|
|
strm.PutChar(' ');
|
2012-01-05 11:57:59 +08:00
|
|
|
va_list args;
|
|
|
|
|
va_start(args, format);
|
|
|
|
|
strm.PrintfVarArg(format, args);
|
|
|
|
|
va_end(args);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-01-05 11:57:59 +08:00
|
|
|
const int format_len = strlen(format);
|
|
|
|
|
if (format_len > 0) {
|
|
|
|
|
const char last_char = format[format_len - 1];
|
2019-04-16 15:48:11 +08:00
|
|
|
if (last_char != '\n' && last_char != '\r')
|
2012-01-05 11:57:59 +08:00
|
|
|
strm.EOL();
|
2011-11-28 09:45:00 +08:00
|
|
|
}
|
2016-11-17 05:15:24 +08:00
|
|
|
Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData());
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-10-26 11:11:13 +08:00
|
|
|
}
|
|
|
|
|
|
2011-11-28 09:45:00 +08:00
|
|
|
bool Module::FileHasChanged() const {
|
2016-03-12 04:20:38 +08:00
|
|
|
if (!m_file_has_changed)
|
2016-11-02 00:11:14 +08:00
|
|
|
m_file_has_changed =
|
2018-11-01 05:49:27 +08:00
|
|
|
(FileSystem::Instance().GetModificationTime(m_file) != m_mod_time);
|
2012-07-13 06:51:12 +08:00
|
|
|
return m_file_has_changed;
|
2011-11-28 09:45:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void Module::ReportErrorIfModifyDetected(const char *format, ...) {
|
|
|
|
|
if (!m_first_file_changed_log) {
|
2012-07-13 06:51:12 +08:00
|
|
|
if (FileHasChanged()) {
|
2011-11-28 09:45:00 +08:00
|
|
|
m_first_file_changed_log = true;
|
2012-01-05 11:57:59 +08:00
|
|
|
if (format) {
|
|
|
|
|
StreamString strm;
|
|
|
|
|
strm.PutCString("error: the object file ");
|
2019-12-04 16:20:42 +08:00
|
|
|
GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull);
|
2012-01-11 09:59:18 +08:00
|
|
|
strm.PutCString(" has been modified\n");
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-01-05 11:57:59 +08:00
|
|
|
va_list args;
|
|
|
|
|
va_start(args, format);
|
|
|
|
|
strm.PrintfVarArg(format, args);
|
|
|
|
|
va_end(args);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-01-05 11:57:59 +08:00
|
|
|
const int format_len = strlen(format);
|
|
|
|
|
if (format_len > 0) {
|
|
|
|
|
const char last_char = format[format_len - 1];
|
2019-04-16 15:48:11 +08:00
|
|
|
if (last_char != '\n' && last_char != '\r')
|
2012-01-05 11:57:59 +08:00
|
|
|
strm.EOL();
|
|
|
|
|
}
|
|
|
|
|
strm.PutCString("The debug session should be aborted as the original "
|
2012-07-13 06:51:12 +08:00
|
|
|
"debug information has been overwritten.\n");
|
2016-11-17 05:15:24 +08:00
|
|
|
Host::SystemLog(Host::eSystemLogError, "%s", strm.GetData());
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-01-05 11:57:59 +08:00
|
|
|
}
|
2011-11-28 09:45:00 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2011-11-28 09:45:00 +08:00
|
|
|
void Module::ReportWarning(const char *format, ...) {
|
2016-03-12 04:20:38 +08:00
|
|
|
if (format && format[0]) {
|
2011-11-28 09:45:00 +08:00
|
|
|
StreamString strm;
|
2012-01-05 11:57:59 +08:00
|
|
|
strm.PutCString("warning: ");
|
2019-12-04 16:20:42 +08:00
|
|
|
GetDescription(strm.AsRawOstream(), lldb::eDescriptionLevelFull);
|
2011-11-28 09:45:00 +08:00
|
|
|
strm.PutChar(' ');
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-11-28 09:45:00 +08:00
|
|
|
va_list args;
|
|
|
|
|
va_start(args, format);
|
|
|
|
|
strm.PrintfVarArg(format, args);
|
|
|
|
|
va_end(args);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2011-11-28 09:45:00 +08:00
|
|
|
const int format_len = strlen(format);
|
2012-01-05 11:57:59 +08:00
|
|
|
if (format_len > 0) {
|
|
|
|
|
const char last_char = format[format_len - 1];
|
2019-04-16 15:48:11 +08:00
|
|
|
if (last_char != '\n' && last_char != '\r')
|
2011-11-28 09:45:00 +08:00
|
|
|
strm.EOL();
|
|
|
|
|
}
|
2016-11-17 05:15:24 +08:00
|
|
|
Host::SystemLog(Host::eSystemLogWarning, "%s", strm.GetData());
|
2011-11-28 09:45:00 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2012-04-24 06:55:20 +08:00
|
|
|
void Module::LogMessage(Log *log, const char *format, ...) {
|
|
|
|
|
if (log != nullptr) {
|
|
|
|
|
StreamString log_message;
|
2019-12-04 16:20:42 +08:00
|
|
|
GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull);
|
2012-04-24 06:55:20 +08:00
|
|
|
log_message.PutCString(": ");
|
2012-01-05 11:57:59 +08:00
|
|
|
va_list args;
|
|
|
|
|
va_start(args, format);
|
|
|
|
|
log_message.PrintfVarArg(format, args);
|
|
|
|
|
va_end(args);
|
2016-11-17 05:15:24 +08:00
|
|
|
log->PutCString(log_message.GetData());
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-24 06:55:20 +08:00
|
|
|
void Module::LogMessageVerboseBacktrace(Log *log, const char *format, ...) {
|
2016-03-12 04:20:38 +08:00
|
|
|
if (log != nullptr) {
|
2012-04-24 06:55:20 +08:00
|
|
|
StreamString log_message;
|
2019-12-04 16:20:42 +08:00
|
|
|
GetDescription(log_message.AsRawOstream(), lldb::eDescriptionLevelFull);
|
2012-04-24 06:55:20 +08:00
|
|
|
log_message.PutCString(": ");
|
|
|
|
|
va_list args;
|
|
|
|
|
va_start(args, format);
|
|
|
|
|
log_message.PrintfVarArg(format, args);
|
|
|
|
|
va_end(args);
|
|
|
|
|
if (log->GetVerbose()) {
|
2015-03-07 04:45:43 +08:00
|
|
|
std::string back_trace;
|
|
|
|
|
llvm::raw_string_ostream stream(back_trace);
|
|
|
|
|
llvm::sys::PrintStackTrace(stream);
|
2016-11-03 04:34:10 +08:00
|
|
|
log_message.PutCString(back_trace);
|
2012-04-24 06:55:20 +08:00
|
|
|
}
|
2016-11-17 05:15:24 +08:00
|
|
|
log->PutCString(log_message.GetData());
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-04-24 06:55:20 +08:00
|
|
|
}
|
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
void Module::Dump(Stream *s) {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2010-10-08 08:21:05 +08:00
|
|
|
// s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
|
2010-06-09 00:52:24 +08:00
|
|
|
s->Indent();
|
2013-04-30 01:25:54 +08:00
|
|
|
s->Printf("Module %s%s%s%s\n", m_file.GetPath().c_str(),
|
2010-06-09 00:52:24 +08:00
|
|
|
m_object_name ? "(" : "",
|
|
|
|
|
m_object_name ? m_object_name.GetCString() : "",
|
|
|
|
|
m_object_name ? ")" : "");
|
|
|
|
|
|
|
|
|
|
s->IndentMore();
|
|
|
|
|
|
|
|
|
|
ObjectFile *objfile = GetObjectFile();
|
|
|
|
|
if (objfile)
|
|
|
|
|
objfile->Dump(s);
|
|
|
|
|
|
2019-08-05 17:21:47 +08:00
|
|
|
if (SymbolFile *symbols = GetSymbolFile())
|
|
|
|
|
symbols->Dump(*s);
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
|
s->IndentLess();
|
|
|
|
|
}
|
|
|
|
|
|
2019-03-07 05:22:25 +08:00
|
|
|
ConstString Module::GetObjectName() const { return m_object_name; }
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
|
ObjectFile *Module::GetObjectFile() {
|
|
|
|
|
if (!m_did_load_objfile.load()) {
|
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2016-03-12 04:20:38 +08:00
|
|
|
if (!m_did_load_objfile.load()) {
|
2017-05-15 21:02:37 +08:00
|
|
|
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
|
|
|
|
|
Timer scoped_timer(func_cat, "Module::GetObjectFile () module = %s",
|
2010-06-09 00:52:24 +08:00
|
|
|
GetFileSpec().GetFilename().AsCString(""));
|
2015-07-25 07:38:01 +08:00
|
|
|
DataBufferSP data_sp;
|
|
|
|
|
lldb::offset_t data_offset = 0;
|
2018-11-01 12:45:28 +08:00
|
|
|
const lldb::offset_t file_size =
|
|
|
|
|
FileSystem::Instance().GetByteSize(m_file);
|
2010-06-09 00:52:24 +08:00
|
|
|
if (file_size > m_object_offset) {
|
|
|
|
|
m_did_load_objfile = true;
|
2012-02-25 05:55:59 +08:00
|
|
|
m_objfile_sp = ObjectFile::FindPlugin(
|
2010-06-09 00:52:24 +08:00
|
|
|
shared_from_this(), &m_file, m_object_offset,
|
|
|
|
|
file_size - m_object_offset, data_sp, data_offset);
|
|
|
|
|
if (m_objfile_sp) {
|
2015-07-25 07:38:01 +08:00
|
|
|
// Once we get the object file, update our module with the object
|
2018-05-01 00:49:04 +08:00
|
|
|
// file's architecture since it might differ in vendor/os if some
|
|
|
|
|
// parts were unknown. But since the matching arch might already be
|
|
|
|
|
// more specific than the generic COFF architecture, only merge in
|
|
|
|
|
// those values that overwrite unspecified unknown values.
|
2019-01-03 18:37:19 +08:00
|
|
|
m_arch.MergeFrom(m_objfile_sp->GetArchitecture());
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2010-06-09 00:52:24 +08:00
|
|
|
ReportError("failed to load objfile for %s",
|
|
|
|
|
GetFileSpec().GetPath().c_str());
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
return m_objfile_sp.get();
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-08 08:01:36 +08:00
|
|
|
SectionList *Module::GetSectionList() {
|
2019-02-13 14:25:41 +08:00
|
|
|
// Populate m_sections_up with sections from objfile.
|
|
|
|
|
if (!m_sections_up) {
|
2013-07-10 09:23:25 +08:00
|
|
|
ObjectFile *obj_file = GetObjectFile();
|
2013-01-08 08:01:36 +08:00
|
|
|
if (obj_file != nullptr)
|
2013-07-10 09:23:25 +08:00
|
|
|
obj_file->CreateSections(*GetUnifiedSectionList());
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2019-02-13 14:25:41 +08:00
|
|
|
return m_sections_up.get();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2014-08-22 10:46:46 +08:00
|
|
|
void Module::SectionFileAddressesChanged() {
|
2013-07-10 09:23:25 +08:00
|
|
|
ObjectFile *obj_file = GetObjectFile();
|
2014-08-22 10:46:46 +08:00
|
|
|
if (obj_file)
|
|
|
|
|
obj_file->SectionFileAddressesChanged();
|
2019-08-02 16:16:35 +08:00
|
|
|
if (SymbolFile *symbols = GetSymbolFile())
|
|
|
|
|
symbols->SectionFileAddressesChanged();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2019-03-18 18:45:02 +08:00
|
|
|
UnwindTable &Module::GetUnwindTable() {
|
|
|
|
|
if (!m_unwind_table)
|
|
|
|
|
m_unwind_table.emplace(*this);
|
|
|
|
|
return *m_unwind_table;
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-02 03:45:50 +08:00
|
|
|
SectionList *Module::GetUnifiedSectionList() {
|
2019-02-13 14:25:41 +08:00
|
|
|
if (!m_sections_up)
|
2019-08-15 06:19:23 +08:00
|
|
|
m_sections_up = std::make_unique<SectionList>();
|
2019-02-13 14:25:41 +08:00
|
|
|
return m_sections_up.get();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2019-03-07 05:22:25 +08:00
|
|
|
const Symbol *Module::FindFirstSymbolWithNameAndType(ConstString name,
|
2013-01-08 08:01:36 +08:00
|
|
|
SymbolType symbol_type) {
|
2017-05-15 21:02:37 +08:00
|
|
|
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
|
2016-08-10 07:06:08 +08:00
|
|
|
Timer scoped_timer(
|
2017-05-15 21:02:37 +08:00
|
|
|
func_cat, "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",
|
2013-01-08 08:01:36 +08:00
|
|
|
name.AsCString(), symbol_type);
|
2019-08-05 17:21:47 +08:00
|
|
|
if (Symtab *symtab = GetSymtab())
|
|
|
|
|
return symtab->FindFirstSymbolWithNameAndType(
|
|
|
|
|
name, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny);
|
2016-03-12 04:20:38 +08:00
|
|
|
return nullptr;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
void Module::SymbolIndicesToSymbolContextList(
|
2013-01-08 08:01:36 +08:00
|
|
|
Symtab *symtab, std::vector<uint32_t> &symbol_indexes,
|
|
|
|
|
SymbolContextList &sc_list) {
|
|
|
|
|
// No need to protect this call using m_mutex all other method calls are
|
2010-06-09 00:52:24 +08:00
|
|
|
// already thread safe.
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-01-08 08:01:36 +08:00
|
|
|
size_t num_indices = symbol_indexes.size();
|
|
|
|
|
if (num_indices > 0) {
|
2010-06-09 00:52:24 +08:00
|
|
|
SymbolContext sc;
|
|
|
|
|
CalculateSymbolContext(&sc);
|
2013-01-08 08:01:36 +08:00
|
|
|
for (size_t i = 0; i < num_indices; i++) {
|
|
|
|
|
sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
|
2010-06-09 00:52:24 +08:00
|
|
|
if (sc.symbol)
|
2013-06-12 08:46:38 +08:00
|
|
|
sc_list.Append(sc);
|
2013-01-08 08:01:36 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-01-08 08:01:36 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-10-18 03:56:40 +08:00
|
|
|
void Module::FindFunctionSymbols(ConstString name,
|
2011-10-14 00:49:47 +08:00
|
|
|
uint32_t name_type_mask,
|
|
|
|
|
SymbolContextList &sc_list) {
|
2017-05-15 21:02:37 +08:00
|
|
|
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
|
|
|
|
|
Timer scoped_timer(func_cat,
|
2011-10-14 00:49:47 +08:00
|
|
|
"Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)",
|
2012-03-27 07:03:23 +08:00
|
|
|
name.AsCString(), name_type_mask);
|
2019-08-05 17:21:47 +08:00
|
|
|
if (Symtab *symtab = GetSymtab())
|
2019-10-18 03:56:40 +08:00
|
|
|
symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2019-10-18 03:56:40 +08:00
|
|
|
void Module::FindSymbolsWithNameAndType(ConstString name,
|
2011-10-14 00:49:47 +08:00
|
|
|
SymbolType symbol_type,
|
2010-06-09 00:52:24 +08:00
|
|
|
SymbolContextList &sc_list) {
|
|
|
|
|
// No need to protect this call using m_mutex all other method calls are
|
|
|
|
|
// already thread safe.
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2017-05-15 21:02:37 +08:00
|
|
|
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
|
2016-08-10 07:06:08 +08:00
|
|
|
Timer scoped_timer(
|
2017-05-15 21:02:37 +08:00
|
|
|
func_cat, "Module::FindSymbolsWithNameAndType (name = %s, type = %i)",
|
2010-06-09 00:52:24 +08:00
|
|
|
name.AsCString(), symbol_type);
|
2019-08-05 17:21:47 +08:00
|
|
|
if (Symtab *symtab = GetSymtab()) {
|
|
|
|
|
std::vector<uint32_t> symbol_indexes;
|
|
|
|
|
symtab->FindAllSymbolsWithNameAndType(name, symbol_type, symbol_indexes);
|
|
|
|
|
SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-10-18 03:56:40 +08:00
|
|
|
void Module::FindSymbolsMatchingRegExAndType(const RegularExpression ®ex,
|
|
|
|
|
SymbolType symbol_type,
|
|
|
|
|
SymbolContextList &sc_list) {
|
2010-06-09 00:52:24 +08:00
|
|
|
// No need to protect this call using m_mutex all other method calls are
|
|
|
|
|
// already thread safe.
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2017-05-15 21:02:37 +08:00
|
|
|
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
|
2016-08-10 07:06:08 +08:00
|
|
|
Timer scoped_timer(
|
2017-05-15 21:02:37 +08:00
|
|
|
func_cat,
|
2010-06-09 00:52:24 +08:00
|
|
|
"Module::FindSymbolsMatchingRegExAndType (regex = %s, type = %i)",
|
2016-09-22 00:01:28 +08:00
|
|
|
regex.GetText().str().c_str(), symbol_type);
|
2019-08-05 17:21:47 +08:00
|
|
|
if (Symtab *symtab = GetSymtab()) {
|
|
|
|
|
std::vector<uint32_t> symbol_indexes;
|
|
|
|
|
symtab->FindAllSymbolsMatchingRexExAndType(
|
|
|
|
|
regex, symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny,
|
|
|
|
|
symbol_indexes);
|
|
|
|
|
SymbolIndicesToSymbolContextList(symtab, symbol_indexes, sc_list);
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
2017-04-28 08:51:06 +08:00
|
|
|
void Module::PreloadSymbols() {
|
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2019-08-02 16:16:35 +08:00
|
|
|
SymbolFile *sym_file = GetSymbolFile();
|
|
|
|
|
if (!sym_file)
|
2017-04-28 08:51:06 +08:00
|
|
|
return;
|
2019-08-02 16:16:35 +08:00
|
|
|
|
2017-04-28 08:51:06 +08:00
|
|
|
// Prime the symbol file first, since it adds symbols to the symbol table.
|
2019-08-02 16:16:35 +08:00
|
|
|
sym_file->PreloadSymbols();
|
|
|
|
|
|
2017-04-28 08:51:06 +08:00
|
|
|
// Now we can prime the symbol table.
|
2019-08-02 16:16:35 +08:00
|
|
|
if (Symtab *symtab = sym_file->GetSymtab())
|
2017-04-28 08:51:06 +08:00
|
|
|
symtab->PreloadSymbols();
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-19 02:10:51 +08:00
|
|
|
void Module::SetSymbolFileFileSpec(const FileSpec &file) {
|
2018-11-02 01:09:25 +08:00
|
|
|
if (!FileSystem::Instance().Exists(file))
|
2015-04-01 05:01:48 +08:00
|
|
|
return;
|
2019-02-13 14:25:41 +08:00
|
|
|
if (m_symfile_up) {
|
2015-04-01 05:01:48 +08:00
|
|
|
// Remove any sections in the unified section list that come from the
|
|
|
|
|
// current symbol vendor.
|
2013-07-10 09:23:25 +08:00
|
|
|
SectionList *section_list = GetSectionList();
|
2019-08-02 16:16:35 +08:00
|
|
|
SymbolFile *symbol_file = GetSymbolFile();
|
2013-08-14 00:46:35 +08:00
|
|
|
if (section_list && symbol_file) {
|
2015-04-01 05:01:48 +08:00
|
|
|
ObjectFile *obj_file = symbol_file->GetObjectFile();
|
|
|
|
|
// Make sure we have an object file and that the symbol vendor's objfile
|
2018-05-01 00:49:04 +08:00
|
|
|
// isn't the same as the module's objfile before we remove any sections
|
|
|
|
|
// for it...
|
2015-04-01 05:01:48 +08:00
|
|
|
if (obj_file) {
|
|
|
|
|
// Check to make sure we aren't trying to specify the file we already
|
|
|
|
|
// have
|
|
|
|
|
if (obj_file->GetFileSpec() == file) {
|
|
|
|
|
// We are being told to add the exact same file that we already have
|
|
|
|
|
// we don't have to do anything.
|
|
|
|
|
return;
|
2013-07-02 03:45:50 +08:00
|
|
|
}
|
2013-04-19 02:10:51 +08:00
|
|
|
|
2010-08-10 07:31:02 +08:00
|
|
|
// Cleare the current symtab as we are going to replace it with a new
|
2016-09-07 04:57:50 +08:00
|
|
|
// one
|
2010-08-10 07:31:02 +08:00
|
|
|
obj_file->ClearSymtab();
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-03-18 18:45:02 +08:00
|
|
|
// Clear the unwind table too, as that may also be affected by the
|
|
|
|
|
// symbol file information.
|
|
|
|
|
m_unwind_table.reset();
|
|
|
|
|
|
2010-08-10 07:31:02 +08:00
|
|
|
// The symbol file might be a directory bundle ("/tmp/a.out.dSYM")
|
2018-05-01 00:49:04 +08:00
|
|
|
// instead of a full path to the symbol file within the bundle
|
2016-03-12 04:20:38 +08:00
|
|
|
// ("/tmp/a.out.dSYM/Contents/Resources/DWARF/a.out"). So we need to
|
2012-03-27 07:03:23 +08:00
|
|
|
// check this
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2018-11-08 08:14:50 +08:00
|
|
|
if (FileSystem::Instance().IsDirectory(file)) {
|
2016-03-12 04:20:38 +08:00
|
|
|
std::string new_path(file.GetPath());
|
2010-08-10 07:31:02 +08:00
|
|
|
std::string old_path(obj_file->GetFileSpec().GetPath());
|
2020-04-01 02:56:24 +08:00
|
|
|
if (llvm::StringRef(old_path).startswith(new_path)) {
|
2010-08-10 07:31:02 +08:00
|
|
|
// We specified the same bundle as the symbol file that we already
|
2016-09-07 04:57:50 +08:00
|
|
|
// have
|
2010-08-10 07:31:02 +08:00
|
|
|
return;
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2010-08-10 07:31:02 +08:00
|
|
|
|
2011-08-03 09:03:17 +08:00
|
|
|
if (obj_file != m_objfile_sp.get()) {
|
|
|
|
|
size_t num_sections = section_list->GetNumSections(0);
|
|
|
|
|
for (size_t idx = num_sections; idx > 0; --idx) {
|
|
|
|
|
lldb::SectionSP section_sp(
|
|
|
|
|
section_list->GetSectionAtIndex(idx - 1));
|
|
|
|
|
if (section_sp->GetObjectFile() == obj_file) {
|
|
|
|
|
section_list->DeleteSection(idx - 1);
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-08-03 09:03:17 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2011-08-03 09:03:17 +08:00
|
|
|
}
|
2015-04-01 05:01:48 +08:00
|
|
|
// Keep all old symbol files around in case there are any lingering type
|
2018-05-01 00:49:04 +08:00
|
|
|
// references in any SBValue objects that might have been handed out.
|
2019-02-13 14:25:41 +08:00
|
|
|
m_old_symfiles.push_back(std::move(m_symfile_up));
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2013-04-19 02:10:51 +08:00
|
|
|
m_symfile_spec = file;
|
2019-02-13 14:25:41 +08:00
|
|
|
m_symfile_up.reset();
|
2019-08-08 15:34:07 +08:00
|
|
|
m_did_load_symfile = false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
bool Module::IsExecutable() {
|
2016-03-12 04:20:38 +08:00
|
|
|
if (GetObjectFile() == nullptr)
|
2011-08-03 09:03:17 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
else
|
2013-03-23 08:50:58 +08:00
|
|
|
return GetObjectFile()->IsExecutable();
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2011-08-03 09:03:17 +08:00
|
|
|
bool Module::IsLoadedInTarget(Target *target) {
|
2013-07-10 09:23:25 +08:00
|
|
|
ObjectFile *obj_file = GetObjectFile();
|
2014-08-22 10:46:46 +08:00
|
|
|
if (obj_file) {
|
2013-07-10 09:23:25 +08:00
|
|
|
SectionList *sections = GetSectionList();
|
2016-03-12 04:20:38 +08:00
|
|
|
if (sections != nullptr) {
|
2015-04-01 05:01:48 +08:00
|
|
|
size_t num_sections = sections->GetSize();
|
|
|
|
|
for (size_t sect_idx = 0; sect_idx < num_sections; sect_idx++) {
|
|
|
|
|
SectionSP section_sp = sections->GetSectionAtIndex(sect_idx);
|
2011-08-03 09:03:17 +08:00
|
|
|
if (section_sp->GetLoadBaseAddress(target) != LLDB_INVALID_ADDRESS) {
|
|
|
|
|
return true;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-08-10 07:31:02 +08:00
|
|
|
return false;
|
2011-08-03 09:03:17 +08:00
|
|
|
}
|
2012-11-08 10:22:02 +08:00
|
|
|
|
2017-05-12 12:51:55 +08:00
|
|
|
bool Module::LoadScriptingResourceInTarget(Target *target, Status &error,
|
2013-05-21 08:00:30 +08:00
|
|
|
Stream *feedback_stream) {
|
2012-11-08 10:22:02 +08:00
|
|
|
if (!target) {
|
|
|
|
|
error.SetErrorString("invalid destination Target");
|
2013-01-12 07:44:27 +08:00
|
|
|
return false;
|
|
|
|
|
}
|
2012-11-08 10:22:02 +08:00
|
|
|
|
2013-03-23 08:50:58 +08:00
|
|
|
LoadScriptFromSymFile should_load =
|
|
|
|
|
target->TargetProperties::GetLoadScriptFromSymbolFile();
|
2016-03-12 04:20:38 +08:00
|
|
|
|
2013-03-23 08:50:58 +08:00
|
|
|
if (should_load == eLoadScriptFromSymFileFalse)
|
|
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-03-23 08:50:58 +08:00
|
|
|
Debugger &debugger = target->GetDebugger();
|
|
|
|
|
const ScriptLanguage script_language = debugger.GetScriptLanguage();
|
|
|
|
|
if (script_language != eScriptLanguageNone) {
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2016-03-12 04:20:38 +08:00
|
|
|
PlatformSP platform_sp(target->GetPlatform());
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2016-03-12 04:20:38 +08:00
|
|
|
if (!platform_sp) {
|
2013-01-12 07:44:27 +08:00
|
|
|
error.SetErrorString("invalid Platform");
|
2010-08-10 07:31:02 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
|
|
|
|
|
2013-01-12 07:44:27 +08:00
|
|
|
FileSpecList file_specs = platform_sp->LocateExecutableScriptingResources(
|
2013-07-02 02:49:43 +08:00
|
|
|
target, *this, feedback_stream);
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-07-02 02:49:43 +08:00
|
|
|
const uint32_t num_specs = file_specs.GetSize();
|
2013-01-12 07:44:27 +08:00
|
|
|
if (num_specs) {
|
2019-04-27 06:43:16 +08:00
|
|
|
ScriptInterpreter *script_interpreter = debugger.GetScriptInterpreter();
|
2012-11-08 10:22:02 +08:00
|
|
|
if (script_interpreter) {
|
2016-03-12 04:20:38 +08:00
|
|
|
for (uint32_t i = 0; i < num_specs; ++i) {
|
2013-07-02 02:49:43 +08:00
|
|
|
FileSpec scripting_fspec(file_specs.GetFileSpecAtIndex(i));
|
2018-11-02 01:09:25 +08:00
|
|
|
if (scripting_fspec &&
|
|
|
|
|
FileSystem::Instance().Exists(scripting_fspec)) {
|
2013-07-02 02:49:43 +08:00
|
|
|
if (should_load == eLoadScriptFromSymFileWarn) {
|
2013-01-12 07:44:27 +08:00
|
|
|
if (feedback_stream)
|
|
|
|
|
feedback_stream->Printf(
|
|
|
|
|
"warning: '%s' contains a debug script. To run this script "
|
2013-03-23 08:50:58 +08:00
|
|
|
"in "
|
|
|
|
|
"this debug session:\n\n command script import "
|
2013-07-02 02:49:43 +08:00
|
|
|
"\"%s\"\n\n"
|
2013-03-23 08:50:58 +08:00
|
|
|
"To run all discovered debug scripts in this session:\n\n"
|
|
|
|
|
" settings set target.load-script-from-symbol-file "
|
2016-09-07 04:57:50 +08:00
|
|
|
"true\n",
|
2013-03-23 08:50:58 +08:00
|
|
|
GetFileSpec().GetFileNameStrippingExtension().GetCString(),
|
|
|
|
|
scripting_fspec.GetPath().c_str());
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2013-01-12 07:44:27 +08:00
|
|
|
StreamString scripting_stream;
|
2019-12-06 15:38:23 +08:00
|
|
|
scripting_fspec.Dump(scripting_stream.AsRawOstream());
|
2013-01-12 07:44:27 +08:00
|
|
|
const bool init_lldb_globals = false;
|
2014-07-02 05:22:11 +08:00
|
|
|
bool did_load = script_interpreter->LoadScriptingModule(
|
2019-12-23 13:35:05 +08:00
|
|
|
scripting_stream.GetData(), init_lldb_globals, error);
|
2016-03-12 04:20:38 +08:00
|
|
|
if (!did_load)
|
2010-08-10 07:31:02 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-11-08 10:22:02 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
} else {
|
2013-01-12 07:44:27 +08:00
|
|
|
error.SetErrorString("invalid ScriptInterpreter");
|
2010-08-10 07:31:02 +08:00
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-11-08 10:22:02 +08:00
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
}
|
2012-11-08 10:22:02 +08:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2010-08-10 07:31:02 +08:00
|
|
|
bool Module::SetArchitecture(const ArchSpec &new_arch) {
|
2011-02-23 08:35:02 +08:00
|
|
|
if (!m_arch.IsValid()) {
|
2010-08-10 07:31:02 +08:00
|
|
|
m_arch = new_arch;
|
|
|
|
|
return true;
|
2011-02-23 08:35:02 +08:00
|
|
|
}
|
2015-02-27 06:15:16 +08:00
|
|
|
return m_arch.IsCompatibleMatch(new_arch);
|
2010-08-10 07:31:02 +08:00
|
|
|
}
|
|
|
|
|
|
2014-02-08 06:54:47 +08:00
|
|
|
bool Module::SetLoadAddress(Target &target, lldb::addr_t value,
|
|
|
|
|
bool value_is_offset, bool &changed) {
|
2014-02-07 03:02:19 +08:00
|
|
|
ObjectFile *object_file = GetObjectFile();
|
2016-03-12 04:20:38 +08:00
|
|
|
if (object_file != nullptr) {
|
2014-02-08 06:54:47 +08:00
|
|
|
changed = object_file->SetLoadAddress(target, value, value_is_offset);
|
2014-02-07 04:10:16 +08:00
|
|
|
return true;
|
|
|
|
|
} else {
|
|
|
|
|
changed = false;
|
2012-02-05 10:38:54 +08:00
|
|
|
}
|
2014-02-07 03:02:19 +08:00
|
|
|
return false;
|
2012-02-05 10:38:54 +08:00
|
|
|
}
|
|
|
|
|
|
2012-02-26 13:51:37 +08:00
|
|
|
bool Module::MatchesModuleSpec(const ModuleSpec &module_ref) {
|
|
|
|
|
const UUID &uuid = module_ref.GetUUID();
|
|
|
|
|
|
|
|
|
|
if (uuid.IsValid()) {
|
|
|
|
|
// If the UUID matches, then nothing more needs to match...
|
2016-03-12 04:20:38 +08:00
|
|
|
return (uuid == GetUUID());
|
2012-02-26 13:51:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const FileSpec &file_spec = module_ref.GetFileSpec();
|
[lldb] s/FileSpec::Equal/FileSpec::Match
Summary:
The FileSpec class is often used as a sort of a pattern -- one specifies
a bare file name to search, and we check if in matches the full file
name of an existing module (for example).
These comparisons used FileSpec::Equal, which had some support for it
(via the full=false argument), but it was not a good fit for this job.
For one, it did a symmetric comparison, which makes sense for a function
called "equal", but not for typical searches (when searching for
"/foo/bar.so", we don't want to find a module whose name is just
"bar.so"). This resulted in patterns like:
if (FileSpec::Equal(pattern, file, pattern.GetDirectory()))
which would request a "full" match only if the pattern really contained
a directory. This worked, but the intended behavior was very unobvious.
On top of that, a lot of the code wanted to handle the case of an
"empty" pattern, and treat it as matching everything. This resulted in
conditions like:
if (pattern && !FileSpec::Equal(pattern, file, pattern.GetDirectory())
which are nearly impossible to decipher.
This patch introduces a FileSpec::Match function, which does exactly
what most of FileSpec::Equal callers want, an asymmetric match between a
"pattern" FileSpec and a an actual FileSpec. Empty paterns match
everything, filename-only patterns match only the filename component.
I've tried to update all callers of FileSpec::Equal to use a simpler
interface. Those that hardcoded full=true have been changed to use
operator==. Those passing full=pattern.GetDirectory() have been changed
to use FileSpec::Match.
There was also a handful of places which hardcoded full=false. I've
changed these to use FileSpec::Match too. This is a slight change in
semantics, but it does not look like that was ever intended, and it was
more likely a result of a misunderstanding of the "proper" way to use
FileSpec::Equal.
[In an ideal world a "FileSpec" and a "FileSpec pattern" would be two
different types, but given how widespread FileSpec is, it is unlikely
we'll get there in one go. This at least provides a good starting point
by centralizing all matching behavior.]
Reviewers: teemperor, JDevlieghere, jdoerfert
Subscribers: emaste, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D70851
2019-11-29 18:31:00 +08:00
|
|
|
if (!FileSpec::Match(file_spec, m_file) &&
|
|
|
|
|
!FileSpec::Match(file_spec, m_platform_file))
|
|
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2013-10-04 06:27:29 +08:00
|
|
|
const FileSpec &platform_file_spec = module_ref.GetPlatformFileSpec();
|
[lldb] s/FileSpec::Equal/FileSpec::Match
Summary:
The FileSpec class is often used as a sort of a pattern -- one specifies
a bare file name to search, and we check if in matches the full file
name of an existing module (for example).
These comparisons used FileSpec::Equal, which had some support for it
(via the full=false argument), but it was not a good fit for this job.
For one, it did a symmetric comparison, which makes sense for a function
called "equal", but not for typical searches (when searching for
"/foo/bar.so", we don't want to find a module whose name is just
"bar.so"). This resulted in patterns like:
if (FileSpec::Equal(pattern, file, pattern.GetDirectory()))
which would request a "full" match only if the pattern really contained
a directory. This worked, but the intended behavior was very unobvious.
On top of that, a lot of the code wanted to handle the case of an
"empty" pattern, and treat it as matching everything. This resulted in
conditions like:
if (pattern && !FileSpec::Equal(pattern, file, pattern.GetDirectory())
which are nearly impossible to decipher.
This patch introduces a FileSpec::Match function, which does exactly
what most of FileSpec::Equal callers want, an asymmetric match between a
"pattern" FileSpec and a an actual FileSpec. Empty paterns match
everything, filename-only patterns match only the filename component.
I've tried to update all callers of FileSpec::Equal to use a simpler
interface. Those that hardcoded full=true have been changed to use
operator==. Those passing full=pattern.GetDirectory() have been changed
to use FileSpec::Match.
There was also a handful of places which hardcoded full=false. I've
changed these to use FileSpec::Match too. This is a slight change in
semantics, but it does not look like that was ever intended, and it was
more likely a result of a misunderstanding of the "proper" way to use
FileSpec::Equal.
[In an ideal world a "FileSpec" and a "FileSpec pattern" would be two
different types, but given how widespread FileSpec is, it is unlikely
we'll get there in one go. This at least provides a good starting point
by centralizing all matching behavior.]
Reviewers: teemperor, JDevlieghere, jdoerfert
Subscribers: emaste, lldb-commits
Tags: #lldb
Differential Revision: https://reviews.llvm.org/D70851
2019-11-29 18:31:00 +08:00
|
|
|
if (!FileSpec::Match(platform_file_spec, GetPlatformFileSpec()))
|
|
|
|
|
return false;
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2012-02-26 13:51:37 +08:00
|
|
|
const ArchSpec &arch = module_ref.GetArchitecture();
|
|
|
|
|
if (arch.IsValid()) {
|
2012-12-14 06:07:14 +08:00
|
|
|
if (!m_arch.IsCompatibleMatch(arch))
|
2012-02-26 13:51:37 +08:00
|
|
|
return false;
|
|
|
|
|
}
|
2016-09-07 04:57:50 +08:00
|
|
|
|
2019-03-07 05:22:25 +08:00
|
|
|
ConstString object_name = module_ref.GetObjectName();
|
2012-02-26 13:51:37 +08:00
|
|
|
if (object_name) {
|
|
|
|
|
if (object_name != GetObjectName())
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-16 05:01:31 +08:00
|
|
|
bool Module::FindSourceFile(const FileSpec &orig_spec,
|
|
|
|
|
FileSpec &new_spec) const {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2012-03-16 05:01:31 +08:00
|
|
|
return m_source_mappings.FindFile(orig_spec, new_spec);
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-24 02:42:38 +08:00
|
|
|
bool Module::RemapSourceFile(llvm::StringRef path,
|
|
|
|
|
std::string &new_path) const {
|
2016-05-18 09:59:10 +08:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(m_mutex);
|
2012-03-20 06:22:41 +08:00
|
|
|
return m_source_mappings.RemapPath(path, new_path);
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-20 09:51:36 +08:00
|
|
|
void Module::RegisterXcodeSDK(llvm::StringRef sdk_name, llvm::StringRef sysroot) {
|
|
|
|
|
XcodeSDK sdk(sdk_name.str());
|
|
|
|
|
if (m_xcode_sdk == sdk)
|
|
|
|
|
return;
|
|
|
|
|
m_xcode_sdk.Merge(sdk);
|
|
|
|
|
PlatformSP module_platform =
|
|
|
|
|
Platform::GetPlatformForArchitecture(GetArchitecture(), nullptr);
|
|
|
|
|
ConstString sdk_path(module_platform->GetSDKPath(sdk));
|
|
|
|
|
if (!sdk_path)
|
|
|
|
|
return;
|
|
|
|
|
// If merged SDK changed for a previously registered source path, update it.
|
|
|
|
|
// This could happend with -fdebug-prefix-map, otherwise it's unlikely.
|
|
|
|
|
ConstString sysroot_cs(sysroot);
|
|
|
|
|
if (!m_source_mappings.Replace(sysroot_cs, sdk_path, true))
|
|
|
|
|
// In the general case, however, append it to the list.
|
|
|
|
|
m_source_mappings.Append(sysroot_cs, sdk_path, false);
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-05 01:23:15 +08:00
|
|
|
bool Module::MergeArchitecture(const ArchSpec &arch_spec) {
|
|
|
|
|
if (!arch_spec.IsValid())
|
|
|
|
|
return false;
|
|
|
|
|
LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_MODULES),
|
|
|
|
|
"module has arch %s, merging/replacing with arch %s",
|
|
|
|
|
m_arch.GetTriple().getTriple().c_str(),
|
|
|
|
|
arch_spec.GetTriple().getTriple().c_str());
|
|
|
|
|
if (!m_arch.IsCompatibleMatch(arch_spec)) {
|
|
|
|
|
// The new architecture is different, we just need to replace it.
|
|
|
|
|
return SetArchitecture(arch_spec);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Merge bits from arch_spec into "merged_arch" and set our architecture.
|
|
|
|
|
ArchSpec merged_arch(m_arch);
|
|
|
|
|
merged_arch.MergeFrom(arch_spec);
|
|
|
|
|
// SetArchitecture() is a no-op if m_arch is already valid.
|
|
|
|
|
m_arch = ArchSpec();
|
|
|
|
|
return SetArchitecture(merged_arch);
|
|
|
|
|
}
|
|
|
|
|
|
2018-06-18 23:02:23 +08:00
|
|
|
llvm::VersionTuple Module::GetVersion() {
|
|
|
|
|
if (ObjectFile *obj_file = GetObjectFile())
|
|
|
|
|
return obj_file->GetVersion();
|
|
|
|
|
return llvm::VersionTuple();
|
2012-09-05 02:47:54 +08:00
|
|
|
}
|
2013-04-03 10:00:15 +08:00
|
|
|
|
2015-02-05 10:01:34 +08:00
|
|
|
bool Module::GetIsDynamicLinkEditor() {
|
|
|
|
|
ObjectFile *obj_file = GetObjectFile();
|
|
|
|
|
|
|
|
|
|
if (obj_file)
|
|
|
|
|
return obj_file->GetIsDynamicLinkEditor();
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|