```C++
virtual Error
- ConfigureStructuredData(const ConstString &type_name,
+ ConfigureStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp)
```
```C++
virtual Error
- ConfigureStructuredData(const ConstString &type_name,
+ ConfigureStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp)
```
class Breakpoint : public std::enable_shared_from_this<Breakpoint>,
public Stoppoint {
public:
- static const ConstString &GetEventIdentifier();
+ static ConstString GetEventIdentifier();
//------------------------------------------------------------------
/// An enum specifying the match style for breakpoint settings. At present
~BreakpointEventData() override;
- static const ConstString &GetFlavorString();
+ static ConstString GetFlavorString();
- const ConstString &GetFlavor() const override;
+ ConstString GetFlavor() const override;
lldb::BreakpointEventType GetBreakpointEventType() const;
/// the
/// description.
//------------------------------------------------------------------
- bool GetMatchingFileLine(const ConstString &filename, uint32_t line_number,
+ bool GetMatchingFileLine(ConstString filename, uint32_t line_number,
BreakpointLocationCollection &loc_coll);
void GetFilterDescription(Stream *s);
}
};
- BreakpointName(const ConstString &name, const char *help = nullptr) :
+ BreakpointName(ConstString name, const char *help = nullptr) :
m_name(name), m_options(false)
{
SetHelp(help);
}
- BreakpointName(const ConstString &name,
+ BreakpointName(ConstString name,
BreakpointOptions &options,
const Permissions &permissions = Permissions(),
const char *help = nullptr) :
m_permissions(rhs.m_permissions), m_help(rhs.m_help)
{}
- BreakpointName(const ConstString &name, const Breakpoint &bkpt,
+ BreakpointName(ConstString name, const Breakpoint &bkpt,
const char *help);
- const ConstString &GetName() const { return m_name; }
+ ConstString GetName() const { return m_name; }
BreakpointOptions &GetOptions() { return m_options; }
const BreakpointOptions &GetOptions() const { return m_options; }
lldb::LanguageType m_language;
bool m_skip_prologue;
- void AddNameLookup(const ConstString &name,
+ void AddNameLookup(ConstString name,
lldb::FunctionNameType name_type_mask);
};
~WatchpointEventData() override;
- static const ConstString &GetFlavorString();
+ static ConstString GetFlavorString();
- const ConstString &GetFlavor() const override;
+ ConstString GetFlavor() const override;
lldb::WatchpointEventType GetWatchpointEventType() const;
static lldb::DebuggerSP FindDebuggerWithID(lldb::user_id_t id);
static lldb::DebuggerSP
- FindDebuggerWithInstanceName(const ConstString &instance_name);
+ FindDebuggerWithInstanceName(ConstString instance_name);
static size_t GetNumDebuggers();
bool GetNotifyVoid() const;
- const ConstString &GetInstanceName() { return m_instance_name; }
+ ConstString GetInstanceName() { return m_instance_name; }
bool LoadPlugin(const FileSpec &spec, Status &error);
static bool
Disassemble(Debugger &debugger, const ArchSpec &arch, const char *plugin_name,
const char *flavor, const ExecutionContext &exe_ctx,
- const ConstString &name, Module *module,
+ ConstString name, Module *module,
uint32_t num_instructions, bool mixed_source_and_assembly,
uint32_t num_mixed_context_lines, uint32_t options, Stream &strm);
/// If \b true then \a name is a mangled name, if \b false then
/// \a name is demangled.
//----------------------------------------------------------------------
- Mangled(const ConstString &name, bool is_mangled);
+ Mangled(ConstString name, bool is_mangled);
Mangled(llvm::StringRef name, bool is_mangled);
//----------------------------------------------------------------------
/// @param[in] name
/// The already const name to copy into this object.
//----------------------------------------------------------------------
- explicit Mangled(const ConstString &name);
+ explicit Mangled(ConstString name);
explicit Mangled(llvm::StringRef name);
/// @return
/// A const reference to the demangled name string object.
//----------------------------------------------------------------------
- const ConstString &GetDemangledName(lldb::LanguageType language) const;
+ ConstString GetDemangledName(lldb::LanguageType language) const;
//----------------------------------------------------------------------
/// Display demangled name get accessor.
//----------------------------------------------------------------------
ConstString GetDisplayDemangledName(lldb::LanguageType language) const;
- void SetDemangledName(const ConstString &name) { m_demangled = name; }
+ void SetDemangledName(ConstString name) { m_demangled = name; }
- void SetMangledName(const ConstString &name) { m_mangled = name; }
+ void SetMangledName(ConstString name) { m_mangled = name; }
//----------------------------------------------------------------------
/// Mangled name get accessor.
/// @return
/// A const reference to the mangled name string object.
//----------------------------------------------------------------------
- const ConstString &GetMangledName() const { return m_mangled; }
+ ConstString GetMangledName() const { return m_mangled; }
//----------------------------------------------------------------------
/// Best name get accessor.
/// @return
/// \b True if \a name matches either name, \b false otherwise.
//----------------------------------------------------------------------
- bool NameMatches(const ConstString &name, lldb::LanguageType language) const {
+ bool NameMatches(ConstString name, lldb::LanguageType language) const {
if (m_mangled == name)
return true;
return GetDemangledName(language) == name;
/// If \b true then \a name is a mangled name, if \b false then
/// \a name is demangled.
//----------------------------------------------------------------------
- void SetValue(const ConstString &name, bool is_mangled);
+ void SetValue(ConstString name, bool is_mangled);
//----------------------------------------------------------------------
/// Set the string value in this object.
/// @param[in] name
/// The already const version of the name for this object.
//----------------------------------------------------------------------
- void SetValue(const ConstString &name);
+ void SetValue(ConstString name);
//----------------------------------------------------------------------
/// Try to guess the language from the mangling.
/// nullptr otherwise.
//------------------------------------------------------------------
const Symbol *FindFirstSymbolWithNameAndType(
- const ConstString &name,
+ ConstString name,
lldb::SymbolType symbol_type = lldb::eSymbolTypeAny);
- size_t FindSymbolsWithNameAndType(const ConstString &name,
+ size_t FindSymbolsWithNameAndType(ConstString name,
lldb::SymbolType symbol_type,
SymbolContextList &sc_list);
/// @return
/// The number of symbol contexts that were added to \a sc_list
//------------------------------------------------------------------
- size_t FindFunctionSymbols(const ConstString &name, uint32_t name_type_mask,
+ size_t FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
SymbolContextList &sc_list);
//------------------------------------------------------------------
/// @return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
- size_t FindFunctions(const ConstString &name,
+ size_t FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, bool symbols_ok,
bool inlines_ok, bool append,
/// @return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
- size_t FindGlobalVariables(const ConstString &name,
+ size_t FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, VariableList &variable_list);
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
size_t
- FindTypes(const ConstString &type_name, bool exact_match, size_t max_matches,
+ FindTypes(ConstString type_name, bool exact_match, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeList &types);
lldb::TypeSP FindFirstType(const SymbolContext &sc,
- const ConstString &type_name, bool exact_match);
+ ConstString type_name, bool exact_match);
//------------------------------------------------------------------
/// Find types by name that are in a namespace. This function is used by the
/// @return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
- size_t FindTypesInNamespace(const ConstString &type_name,
+ size_t FindTypesInNamespace(ConstString type_name,
const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, TypeList &type_list);
lldb::CompUnitSP GetCompileUnitAtIndex(size_t idx);
- const ConstString &GetObjectName() const;
+ ConstString GetObjectName() const;
uint64_t GetObjectOffset() const { return m_object_offset; }
lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list);
void SetFileSpecAndObjectName(const FileSpec &file,
- const ConstString &object_name);
+ ConstString object_name);
bool GetIsDynamicLinkEditor();
m_name_type_mask(lldb::eFunctionNameTypeNone),
m_match_name_after_lookup(false) {}
- LookupInfo(const ConstString &name, lldb::FunctionNameType name_type_mask,
+ LookupInfo(ConstString name, lldb::FunctionNameType name_type_mask,
lldb::LanguageType language);
- const ConstString &GetName() const { return m_name; }
+ ConstString GetName() const { return m_name; }
- void SetName(const ConstString &name) { m_name = name; }
+ void SetName(ConstString name) { m_name = name; }
- const ConstString &GetLookupName() const { return m_lookup_name; }
+ ConstString GetLookupName() const { return m_lookup_name; }
- void SetLookupName(const ConstString &name) { m_lookup_name = name; }
+ void SetLookupName(ConstString name) { m_lookup_name = name; }
lldb::FunctionNameType GetNameTypeMask() const { return m_name_type_mask; }
Module(); // Only used internally by CreateJITModule ()
size_t FindTypes_Impl(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types);
//------------------------------------------------------------------
/// @see Module::FindFunctions ()
//------------------------------------------------------------------
- size_t FindFunctions(const ConstString &name,
+ size_t FindFunctions(ConstString name,
lldb::FunctionNameType name_type_mask,
bool include_symbols, bool include_inlines, bool append,
SymbolContextList &sc_list) const;
//------------------------------------------------------------------
/// @see Module::FindFunctionSymbols ()
//------------------------------------------------------------------
- size_t FindFunctionSymbols(const ConstString &name,
+ size_t FindFunctionSymbols(ConstString name,
lldb::FunctionNameType name_type_mask,
SymbolContextList &sc_list);
/// @return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
- size_t FindGlobalVariables(const ConstString &name, size_t max_matches,
+ size_t FindGlobalVariables(ConstString name, size_t max_matches,
VariableList &variable_list) const;
//------------------------------------------------------------------
lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const;
- size_t FindSymbolsWithNameAndType(const ConstString &name,
+ size_t FindSymbolsWithNameAndType(ConstString name,
lldb::SymbolType symbol_type,
SymbolContextList &sc_list,
bool append = false) const;
/// @return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
- size_t FindTypes(Module *search_first, const ConstString &name,
+ size_t FindTypes(Module *search_first, ConstString name,
bool name_is_fully_qualified, size_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files,
TypeList &types) const;
ConstString &GetObjectName() { return m_object_name; }
- const ConstString &GetObjectName() const { return m_object_name; }
+ ConstString GetObjectName() const { return m_object_name; }
uint64_t GetObjectOffset() const { return m_object_offset; }
//------------------------------------------------------------------
// ABI
//------------------------------------------------------------------
- static bool RegisterPlugin(const ConstString &name, const char *description,
+ static bool RegisterPlugin(ConstString name, const char *description,
ABICreateInstance create_callback);
static bool UnregisterPlugin(ABICreateInstance create_callback);
static ABICreateInstance GetABICreateCallbackAtIndex(uint32_t idx);
static ABICreateInstance
- GetABICreateCallbackForPluginName(const ConstString &name);
+ GetABICreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// Architecture
using ArchitectureCreateInstance =
std::unique_ptr<Architecture> (*)(const ArchSpec &);
- static void RegisterPlugin(const ConstString &name,
+ static void RegisterPlugin(ConstString name,
llvm::StringRef description,
ArchitectureCreateInstance create_callback);
//------------------------------------------------------------------
// Disassembler
//------------------------------------------------------------------
- static bool RegisterPlugin(const ConstString &name, const char *description,
+ static bool RegisterPlugin(ConstString name, const char *description,
DisassemblerCreateInstance create_callback);
static bool UnregisterPlugin(DisassemblerCreateInstance create_callback);
GetDisassemblerCreateCallbackAtIndex(uint32_t idx);
static DisassemblerCreateInstance
- GetDisassemblerCreateCallbackForPluginName(const ConstString &name);
+ GetDisassemblerCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// DynamicLoader
//------------------------------------------------------------------
static bool
- RegisterPlugin(const ConstString &name, const char *description,
+ RegisterPlugin(ConstString name, const char *description,
DynamicLoaderCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr);
GetDynamicLoaderCreateCallbackAtIndex(uint32_t idx);
static DynamicLoaderCreateInstance
- GetDynamicLoaderCreateCallbackForPluginName(const ConstString &name);
+ GetDynamicLoaderCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// JITLoader
//------------------------------------------------------------------
static bool
- RegisterPlugin(const ConstString &name, const char *description,
+ RegisterPlugin(ConstString name, const char *description,
JITLoaderCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr);
GetJITLoaderCreateCallbackAtIndex(uint32_t idx);
static JITLoaderCreateInstance
- GetJITLoaderCreateCallbackForPluginName(const ConstString &name);
+ GetJITLoaderCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// EmulateInstruction
//------------------------------------------------------------------
- static bool RegisterPlugin(const ConstString &name, const char *description,
+ static bool RegisterPlugin(ConstString name, const char *description,
EmulateInstructionCreateInstance create_callback);
static bool
GetEmulateInstructionCreateCallbackAtIndex(uint32_t idx);
static EmulateInstructionCreateInstance
- GetEmulateInstructionCreateCallbackForPluginName(const ConstString &name);
+ GetEmulateInstructionCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// OperatingSystem
//------------------------------------------------------------------
- static bool RegisterPlugin(const ConstString &name, const char *description,
+ static bool RegisterPlugin(ConstString name, const char *description,
OperatingSystemCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback);
GetOperatingSystemCreateCallbackAtIndex(uint32_t idx);
static OperatingSystemCreateInstance
- GetOperatingSystemCreateCallbackForPluginName(const ConstString &name);
+ GetOperatingSystemCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// Language
//------------------------------------------------------------------
- static bool RegisterPlugin(const ConstString &name, const char *description,
+ static bool RegisterPlugin(ConstString name, const char *description,
LanguageCreateInstance create_callback);
static bool UnregisterPlugin(LanguageCreateInstance create_callback);
static LanguageCreateInstance GetLanguageCreateCallbackAtIndex(uint32_t idx);
static LanguageCreateInstance
- GetLanguageCreateCallbackForPluginName(const ConstString &name);
+ GetLanguageCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// LanguageRuntime
//------------------------------------------------------------------
static bool
- RegisterPlugin(const ConstString &name, const char *description,
+ RegisterPlugin(ConstString name, const char *description,
LanguageRuntimeCreateInstance create_callback,
LanguageRuntimeGetCommandObject command_callback = nullptr);
GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx);
static LanguageRuntimeCreateInstance
- GetLanguageRuntimeCreateCallbackForPluginName(const ConstString &name);
+ GetLanguageRuntimeCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// SystemRuntime
//------------------------------------------------------------------
- static bool RegisterPlugin(const ConstString &name, const char *description,
+ static bool RegisterPlugin(ConstString name, const char *description,
SystemRuntimeCreateInstance create_callback);
static bool UnregisterPlugin(SystemRuntimeCreateInstance create_callback);
GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx);
static SystemRuntimeCreateInstance
- GetSystemRuntimeCreateCallbackForPluginName(const ConstString &name);
+ GetSystemRuntimeCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// ObjectFile
//------------------------------------------------------------------
static bool
- RegisterPlugin(const ConstString &name, const char *description,
+ RegisterPlugin(ConstString name, const char *description,
ObjectFileCreateInstance create_callback,
ObjectFileCreateMemoryInstance create_memory_callback,
ObjectFileGetModuleSpecifications get_module_specifications,
GetObjectFileGetModuleSpecificationsCallbackAtIndex(uint32_t idx);
static ObjectFileCreateInstance
- GetObjectFileCreateCallbackForPluginName(const ConstString &name);
+ GetObjectFileCreateCallbackForPluginName(ConstString name);
static ObjectFileCreateMemoryInstance
- GetObjectFileCreateMemoryCallbackForPluginName(const ConstString &name);
+ GetObjectFileCreateMemoryCallbackForPluginName(ConstString name);
static Status SaveCore(const lldb::ProcessSP &process_sp,
const FileSpec &outfile);
// ObjectContainer
//------------------------------------------------------------------
static bool
- RegisterPlugin(const ConstString &name, const char *description,
+ RegisterPlugin(ConstString name, const char *description,
ObjectContainerCreateInstance create_callback,
ObjectFileGetModuleSpecifications get_module_specifications);
GetObjectContainerCreateCallbackAtIndex(uint32_t idx);
static ObjectContainerCreateInstance
- GetObjectContainerCreateCallbackForPluginName(const ConstString &name);
+ GetObjectContainerCreateCallbackForPluginName(ConstString name);
static ObjectFileGetModuleSpecifications
GetObjectContainerGetModuleSpecificationsCallbackAtIndex(uint32_t idx);
// Platform
//------------------------------------------------------------------
static bool
- RegisterPlugin(const ConstString &name, const char *description,
+ RegisterPlugin(ConstString name, const char *description,
PlatformCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr);
static PlatformCreateInstance GetPlatformCreateCallbackAtIndex(uint32_t idx);
static PlatformCreateInstance
- GetPlatformCreateCallbackForPluginName(const ConstString &name);
+ GetPlatformCreateCallbackForPluginName(ConstString name);
static const char *GetPlatformPluginNameAtIndex(uint32_t idx);
// Process
//------------------------------------------------------------------
static bool
- RegisterPlugin(const ConstString &name, const char *description,
+ RegisterPlugin(ConstString name, const char *description,
ProcessCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr);
static ProcessCreateInstance GetProcessCreateCallbackAtIndex(uint32_t idx);
static ProcessCreateInstance
- GetProcessCreateCallbackForPluginName(const ConstString &name);
+ GetProcessCreateCallbackForPluginName(ConstString name);
static const char *GetProcessPluginNameAtIndex(uint32_t idx);
//------------------------------------------------------------------
// ScriptInterpreter
//------------------------------------------------------------------
- static bool RegisterPlugin(const ConstString &name, const char *description,
+ static bool RegisterPlugin(ConstString name, const char *description,
lldb::ScriptLanguage script_lang,
ScriptInterpreterCreateInstance create_callback);
/// Returns true upon success; otherwise, false.
//------------------------------------------------------------------
static bool
- RegisterPlugin(const ConstString &name, const char *description,
+ RegisterPlugin(ConstString name, const char *description,
StructuredDataPluginCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr,
StructuredDataFilterLaunchInfo filter_callback = nullptr);
GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx);
static StructuredDataPluginCreateInstance
- GetStructuredDataPluginCreateCallbackForPluginName(const ConstString &name);
+ GetStructuredDataPluginCreateCallbackForPluginName(ConstString name);
static StructuredDataFilterLaunchInfo
GetStructuredDataFilterCallbackAtIndex(uint32_t idx,
// SymbolFile
//------------------------------------------------------------------
static bool
- RegisterPlugin(const ConstString &name, const char *description,
+ RegisterPlugin(ConstString name, const char *description,
SymbolFileCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr);
GetSymbolFileCreateCallbackAtIndex(uint32_t idx);
static SymbolFileCreateInstance
- GetSymbolFileCreateCallbackForPluginName(const ConstString &name);
+ GetSymbolFileCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// SymbolVendor
//------------------------------------------------------------------
- static bool RegisterPlugin(const ConstString &name, const char *description,
+ static bool RegisterPlugin(ConstString name, const char *description,
SymbolVendorCreateInstance create_callback);
static bool UnregisterPlugin(SymbolVendorCreateInstance create_callback);
GetSymbolVendorCreateCallbackAtIndex(uint32_t idx);
static SymbolVendorCreateInstance
- GetSymbolVendorCreateCallbackForPluginName(const ConstString &name);
+ GetSymbolVendorCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// UnwindAssembly
//------------------------------------------------------------------
- static bool RegisterPlugin(const ConstString &name, const char *description,
+ static bool RegisterPlugin(ConstString name, const char *description,
UnwindAssemblyCreateInstance create_callback);
static bool UnregisterPlugin(UnwindAssemblyCreateInstance create_callback);
GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx);
static UnwindAssemblyCreateInstance
- GetUnwindAssemblyCreateCallbackForPluginName(const ConstString &name);
+ GetUnwindAssemblyCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// MemoryHistory
//------------------------------------------------------------------
- static bool RegisterPlugin(const ConstString &name, const char *description,
+ static bool RegisterPlugin(ConstString name, const char *description,
MemoryHistoryCreateInstance create_callback);
static bool UnregisterPlugin(MemoryHistoryCreateInstance create_callback);
GetMemoryHistoryCreateCallbackAtIndex(uint32_t idx);
static MemoryHistoryCreateInstance
- GetMemoryHistoryCreateCallbackForPluginName(const ConstString &name);
+ GetMemoryHistoryCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// InstrumentationRuntime
//------------------------------------------------------------------
static bool
- RegisterPlugin(const ConstString &name, const char *description,
+ RegisterPlugin(ConstString name, const char *description,
InstrumentationRuntimeCreateInstance create_callback,
InstrumentationRuntimeGetType get_type_callback);
GetInstrumentationRuntimeCreateCallbackAtIndex(uint32_t idx);
static InstrumentationRuntimeCreateInstance
- GetInstrumentationRuntimeCreateCallbackForPluginName(const ConstString &name);
+ GetInstrumentationRuntimeCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------
// TypeSystem
//------------------------------------------------------------------
static bool RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
TypeSystemCreateInstance create_callback,
TypeSystemEnumerateSupportedLanguages enumerate_languages_callback);
GetTypeSystemCreateCallbackAtIndex(uint32_t idx);
static TypeSystemCreateInstance
- GetTypeSystemCreateCallbackForPluginName(const ConstString &name);
+ GetTypeSystemCreateCallbackForPluginName(ConstString name);
static TypeSystemEnumerateSupportedLanguages
GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx);
static TypeSystemEnumerateSupportedLanguages
GetTypeSystemEnumerateSupportedLanguagesCallbackForPluginName(
- const ConstString &name);
+ ConstString name);
//------------------------------------------------------------------
// REPL
//------------------------------------------------------------------
static bool
- RegisterPlugin(const ConstString &name, const char *description,
+ RegisterPlugin(ConstString name, const char *description,
REPLCreateInstance create_callback,
REPLEnumerateSupportedLanguages enumerate_languages_callback);
static REPLCreateInstance GetREPLCreateCallbackAtIndex(uint32_t idx);
static REPLCreateInstance
- GetREPLCreateCallbackForPluginName(const ConstString &name);
+ GetREPLCreateCallbackForPluginName(ConstString name);
static REPLEnumerateSupportedLanguages
GetREPLEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx);
static REPLEnumerateSupportedLanguages
GetREPLSystemEnumerateSupportedLanguagesCallbackForPluginName(
- const ConstString &name);
+ ConstString name);
//------------------------------------------------------------------
// Some plug-ins might register a DebuggerInitializeCallback callback when
static lldb::OptionValuePropertiesSP
GetSettingForDynamicLoaderPlugin(Debugger &debugger,
- const ConstString &setting_name);
+ ConstString setting_name);
static bool CreateSettingForDynamicLoaderPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property);
+ ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP
GetSettingForPlatformPlugin(Debugger &debugger,
- const ConstString &setting_name);
+ ConstString setting_name);
static bool CreateSettingForPlatformPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property);
+ ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP
GetSettingForProcessPlugin(Debugger &debugger,
- const ConstString &setting_name);
+ ConstString setting_name);
static bool CreateSettingForProcessPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property);
+ ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP
GetSettingForSymbolFilePlugin(Debugger &debugger,
- const ConstString &setting_name);
+ ConstString setting_name);
static bool CreateSettingForSymbolFilePlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property);
+ ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP
GetSettingForJITLoaderPlugin(Debugger &debugger,
- const ConstString &setting_name);
+ ConstString setting_name);
static bool CreateSettingForJITLoaderPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property);
+ ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP
GetSettingForOperatingSystemPlugin(Debugger &debugger,
- const ConstString &setting_name);
+ ConstString setting_name);
static bool CreateSettingForOperatingSystemPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property);
+ ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP
GetSettingForStructuredDataPlugin(Debugger &debugger,
- const ConstString &setting_name);
+ ConstString setting_name);
static bool CreateSettingForStructuredDataPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property);
+ ConstString description, bool is_global_property);
};
} // namespace lldb_private
/// Use the ItaniumPartialDemangler to obtain rich mangling information from
/// the given mangled name.
- bool FromItaniumName(const ConstString &mangled);
+ bool FromItaniumName(ConstString mangled);
/// Use the legacy language parser implementation to obtain rich mangling
/// information from the given demangled name.
- bool FromCxxMethodName(const ConstString &demangled);
+ bool FromCxxMethodName(ConstString demangled);
/// If this symbol describes a constructor or destructor.
bool IsCtorOrDtor() const;
void Dump(Stream *s, Target *target, bool show_header, uint32_t depth) const;
- lldb::SectionSP FindSectionByName(const ConstString §ion_dstr) const;
+ lldb::SectionSP FindSectionByName(ConstString section_dstr) const;
lldb::SectionSP FindSectionByID(lldb::user_id_t sect_id) const;
public:
// Create a root section (one that has no parent)
Section(const lldb::ModuleSP &module_sp, ObjectFile *obj_file,
- lldb::user_id_t sect_id, const ConstString &name,
+ lldb::user_id_t sect_id, ConstString name,
lldb::SectionType sect_type, lldb::addr_t file_vm_addr,
lldb::addr_t vm_size, lldb::offset_t file_offset,
lldb::offset_t file_size, uint32_t log2align, uint32_t flags,
// sections, non-NULL for
// child sections
const lldb::ModuleSP &module_sp, ObjectFile *obj_file,
- lldb::user_id_t sect_id, const ConstString &name,
+ lldb::user_id_t sect_id, ConstString name,
lldb::SectionType sect_type, lldb::addr_t file_vm_addr,
lldb::addr_t vm_size, lldb::offset_t file_offset,
lldb::offset_t file_size, uint32_t log2align, uint32_t flags,
bool IsDescendant(const Section *section);
- const ConstString &GetName() const { return m_name; }
+ ConstString GetName() const { return m_name; }
bool Slide(lldb::addr_t slide_amount, bool slide_children);
std::vector<const Property *> &matching_properties) const;
lldb::OptionValuePropertiesSP GetSubProperty(const ExecutionContext *exe_ctx,
- const ConstString &name);
+ ConstString name);
// We sometimes need to introduce a setting to enable experimental features,
// but then we don't want the setting for these to cause errors when the
//------------------------------------------------------------------
const Status &GetError();
- const ConstString &GetName() const;
+ ConstString GetName() const;
virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create);
GetChildAtNamePath(llvm::ArrayRef<std::pair<ConstString, bool>> names,
ConstString *name_of_error = nullptr);
- virtual lldb::ValueObjectSP GetChildMemberWithName(const ConstString &name,
+ virtual lldb::ValueObjectSP GetChildMemberWithName(ConstString name,
bool can_create);
- virtual size_t GetIndexOfChildWithName(const ConstString &name);
+ virtual size_t GetIndexOfChildWithName(ConstString name);
size_t GetNumChildren(uint32_t max = UINT32_MAX);
// Change the name of the current ValueObject. Should *not* be used from a
// synthetic child provider as it would change the name of the non synthetic
// child as well.
- void SetName(const ConstString &name);
+ void SetName(ConstString name);
virtual lldb::addr_t GetAddressOf(bool scalar_is_load_address = true,
AddressType *address_type = nullptr);
lldb::addr_t GetPointerValue(AddressType *address_type = nullptr);
- lldb::ValueObjectSP GetSyntheticChild(const ConstString &key) const;
+ lldb::ValueObjectSP GetSyntheticChild(ConstString key) const;
lldb::ValueObjectSP GetSyntheticArrayMember(size_t index, bool can_create);
GetQualifiedRepresentationIfAvailable(lldb::DynamicValueType dynValue,
bool synthValue);
- virtual lldb::ValueObjectSP CreateConstantValue(const ConstString &name);
+ virtual lldb::ValueObjectSP CreateConstantValue(ConstString name);
virtual lldb::ValueObjectSP Dereference(Status &error);
// ValueObject as its parent. It should be used when we want to change the
// name of a ValueObject without modifying the actual ValueObject itself
// (e.g. sythetic child provider).
- virtual lldb::ValueObjectSP Clone(const ConstString &new_name);
+ virtual lldb::ValueObjectSP Clone(ConstString new_name);
virtual lldb::ValueObjectSP AddressOf(Status &error);
void ClearUserVisibleData(
uint32_t items = ValueObject::eClearUserVisibleDataItemsAllStrings);
- void AddSyntheticChild(const ConstString &key, ValueObject *valobj);
+ void AddSyntheticChild(ConstString key, ValueObject *valobj);
DataExtractor &GetDataExtractor();
~ValueObjectCast() override;
static lldb::ValueObjectSP Create(ValueObject &parent,
- const ConstString &name,
+ ConstString name,
const CompilerType &cast_type);
uint64_t GetByteSize() override;
}
protected:
- ValueObjectCast(ValueObject &parent, const ConstString &name,
+ ValueObjectCast(ValueObject &parent, ConstString name,
const CompilerType &cast_type);
bool UpdateValue() override;
friend class ValueObjectConstResultImpl;
ValueObjectChild(ValueObject &parent, const CompilerType &compiler_type,
- const ConstString &name, uint64_t byte_size,
+ ConstString name, uint64_t byte_size,
int32_t byte_offset, uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset, bool is_base_class,
bool is_deref_of_parent,
static lldb::ValueObjectSP
Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
- const ConstString &name, const DataExtractor &data,
+ ConstString name, const DataExtractor &data,
lldb::addr_t address = LLDB_INVALID_ADDRESS);
static lldb::ValueObjectSP
Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
- const ConstString &name, const lldb::DataBufferSP &result_data_sp,
+ ConstString name, const lldb::DataBufferSP &result_data_sp,
lldb::ByteOrder byte_order, uint32_t addr_size,
lldb::addr_t address = LLDB_INVALID_ADDRESS);
static lldb::ValueObjectSP
Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
- const ConstString &name, lldb::addr_t address,
+ ConstString name, lldb::addr_t address,
AddressType address_type, uint32_t addr_byte_size);
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
- Value &value, const ConstString &name,
+ Value &value, ConstString name,
Module *module = nullptr);
// When an expression fails to evaluate, we return an error
ValueObjectConstResult(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type,
- const ConstString &name, const DataExtractor &data,
+ ConstString name, const DataExtractor &data,
lldb::addr_t address);
ValueObjectConstResult(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type,
- const ConstString &name,
+ ConstString name,
const lldb::DataBufferSP &result_data_sp,
lldb::ByteOrder byte_order, uint32_t addr_size,
lldb::addr_t address);
ValueObjectConstResult(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type,
- const ConstString &name, lldb::addr_t address,
+ ConstString name, lldb::addr_t address,
AddressType address_type, uint32_t addr_byte_size);
ValueObjectConstResult(ExecutionContextScope *exe_scope, const Value &value,
- const ConstString &name, Module *module = nullptr);
+ ConstString name, Module *module = nullptr);
ValueObjectConstResult(ExecutionContextScope *exe_scope, const Status &error);
class ValueObjectConstResultCast : public ValueObjectCast {
public:
- ValueObjectConstResultCast(ValueObject &parent, const ConstString &name,
+ ValueObjectConstResultCast(ValueObject &parent, ConstString name,
const CompilerType &cast_type,
lldb::addr_t live_address = LLDB_INVALID_ADDRESS);
public:
ValueObjectConstResultChild(ValueObject &parent,
const CompilerType &compiler_type,
- const ConstString &name, uint32_t byte_size,
+ ConstString name, uint32_t byte_size,
int32_t byte_offset, uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset, bool is_base_class,
bool is_deref_of_parent,
ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member,
int32_t synthetic_index) override;
- lldb::ValueObjectSP GetChildMemberWithName(const ConstString &name,
+ lldb::ValueObjectSP GetChildMemberWithName(ConstString name,
bool can_create) override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
protected:
bool UpdateValue() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create) override;
- lldb::ValueObjectSP GetChildMemberWithName(const ConstString &name,
+ lldb::ValueObjectSP GetChildMemberWithName(ConstString name,
bool can_create) override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
lldb::ValueObjectSP
GetDynamicValue(lldb::DynamicValueType valueType) override;
class NamedSummaryFormats {
public:
- static bool GetSummaryFormat(const ConstString &type,
+ static bool GetSummaryFormat(ConstString type,
lldb::TypeSummaryImplSP &entry);
- static void Add(const ConstString &type,
+ static void Add(ConstString type,
const lldb::TypeSummaryImplSP &entry);
- static bool Delete(const ConstString &type);
+ static bool Delete(ConstString type);
static void Clear();
class Categories {
public:
- static bool GetCategory(const ConstString &category,
+ static bool GetCategory(ConstString category,
lldb::TypeCategoryImplSP &entry,
bool allow_create = true);
static bool GetCategory(lldb::LanguageType language,
lldb::TypeCategoryImplSP &entry);
- static void Add(const ConstString &category);
+ static void Add(ConstString category);
- static bool Delete(const ConstString &category);
+ static bool Delete(ConstString category);
static void Clear();
- static void Clear(const ConstString &category);
+ static void Clear(ConstString category);
- static void Enable(const ConstString &category,
+ static void Enable(ConstString category,
TypeCategoryMap::Position = TypeCategoryMap::Default);
static void Enable(lldb::LanguageType lang_type);
- static void Disable(const ConstString &category);
+ static void Disable(ConstString category);
static void Disable(lldb::LanguageType lang_type);
uint64_t m_cache_hits;
uint64_t m_cache_misses;
- Entry &GetEntry(const ConstString &type);
+ Entry &GetEntry(ConstString type);
public:
FormatCache();
- bool GetFormat(const ConstString &type, lldb::TypeFormatImplSP &format_sp);
+ bool GetFormat(ConstString type, lldb::TypeFormatImplSP &format_sp);
- bool GetSummary(const ConstString &type, lldb::TypeSummaryImplSP &summary_sp);
+ bool GetSummary(ConstString type, lldb::TypeSummaryImplSP &summary_sp);
- bool GetSynthetic(const ConstString &type,
+ bool GetSynthetic(ConstString type,
lldb::SyntheticChildrenSP &synthetic_sp);
- bool GetValidator(const ConstString &type,
+ bool GetValidator(ConstString type,
lldb::TypeValidatorImplSP &summary_sp);
- void SetFormat(const ConstString &type, lldb::TypeFormatImplSP &format_sp);
+ void SetFormat(ConstString type, lldb::TypeFormatImplSP &format_sp);
- void SetSummary(const ConstString &type, lldb::TypeSummaryImplSP &summary_sp);
+ void SetSummary(ConstString type, lldb::TypeSummaryImplSP &summary_sp);
- void SetSynthetic(const ConstString &type,
+ void SetSynthetic(ConstString type,
lldb::SyntheticChildrenSP &synthetic_sp);
- void SetValidator(const ConstString &type,
+ void SetValidator(ConstString type,
lldb::TypeValidatorImplSP &synthetic_sp);
void Clear();
}
void
- EnableCategory(const ConstString &category_name,
+ EnableCategory(ConstString category_name,
TypeCategoryMap::Position pos = TypeCategoryMap::Default) {
EnableCategory(category_name, pos,
std::initializer_list<lldb::LanguageType>());
}
- void EnableCategory(const ConstString &category_name,
+ void EnableCategory(ConstString category_name,
TypeCategoryMap::Position pos, lldb::LanguageType lang) {
std::initializer_list<lldb::LanguageType> langs = {lang};
EnableCategory(category_name, pos, langs);
}
- void EnableCategory(const ConstString &category_name,
+ void EnableCategory(ConstString category_name,
TypeCategoryMap::Position pos = TypeCategoryMap::Default,
std::initializer_list<lldb::LanguageType> langs = {}) {
TypeCategoryMap::ValueSP category_sp;
}
}
- void DisableCategory(const ConstString &category_name) {
+ void DisableCategory(ConstString category_name) {
m_categories_map.Disable(category_name);
}
void DisableAllCategories();
- bool DeleteCategory(const ConstString &category_name) {
+ bool DeleteCategory(ConstString category_name) {
return m_categories_map.Delete(category_name);
}
return GetCategory(ConstString(category_name));
}
- lldb::TypeCategoryImplSP GetCategory(const ConstString &category_name,
+ lldb::TypeCategoryImplSP GetCategory(ConstString category_name,
bool can_create = true);
lldb::TypeFormatImplSP
// method looks for the case where the user is adding a
// "class","struct","enum" or "union" Foo and strips the unnecessary
// qualifier
- static ConstString GetValidTypeName(const ConstString &type);
+ static ConstString GetValidTypeName(ConstString type);
// when DataExtractor dumps a vectorOfT, it uses a predefined format for each
// item this method returns it, or eFormatInvalid if vector_format is not a
// match any type because of the way we strip qualifiers from typenames this
// method looks for the case where the user is adding a "class","struct","enum"
// or "union" Foo and strips the unnecessary qualifier
-static inline ConstString GetValidTypeName_Impl(const ConstString &type) {
+static inline ConstString GetValidTypeName_Impl(ConstString type) {
if (type.IsEmpty())
return type;
m_format_map.Add(type, entry);
}
- void Add_Impl(const ConstString &type, const MapValueType &entry,
+ void Add_Impl(ConstString type, const MapValueType &entry,
ConstString *dummy) {
m_format_map.Add(GetValidTypeName_Impl(type), entry);
}
virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx) = 0;
- virtual size_t GetIndexOfChildWithName(const ConstString &name) = 0;
+ virtual size_t GetIndexOfChildWithName(ConstString name) = 0;
// this function is assumed to always succeed and it if fails, the front-end
// should know to deal with it in the correct way (most probably, by refusing
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { return nullptr; }
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
return UINT32_MAX;
}
bool MightHaveChildren() override { return filter->GetCount() > 0; }
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer;
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
lldb::ValueObjectSP GetSyntheticValue() override;
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
ExecutionContextRef m_exe_ctx_ref;
size_t GetByteSize() { return m_frozen_sp->GetByteSize(); }
- const ConstString &GetName() { return m_frozen_sp->GetName(); }
+ ConstString GetName() { return m_frozen_sp->GetName(); }
lldb::ValueObjectSP GetValueObject() { return m_frozen_sp; }
m_frozen_sp->GetValue().SetCompilerType(compiler_type);
}
- void SetName(const ConstString &name) { m_frozen_sp->SetName(name); }
+ void SetName(ConstString name) { m_frozen_sp->SetName(name); }
// this function is used to copy the address-of m_live_sp into m_frozen_sp
// this is necessary because the results of certain cast and pointer-
/// The variable requested, or nullptr if that variable is not in the
/// list.
//----------------------------------------------------------------------
- lldb::ExpressionVariableSP GetVariable(const ConstString &name) {
+ lldb::ExpressionVariableSP GetVariable(ConstString name) {
lldb::ExpressionVariableSP var_sp;
for (size_t index = 0, size = GetSize(); index < size; ++index) {
var_sp = GetVariableAtIndex(index);
virtual lldb::ExpressionVariableSP
CreatePersistentVariable(ExecutionContextScope *exe_scope,
- const ConstString &name, const CompilerType &type,
+ ConstString name, const CompilerType &type,
lldb::ByteOrder byte_order,
uint32_t addr_byte_size) = 0;
virtual void
RemovePersistentVariable(lldb::ExpressionVariableSP variable) = 0;
- virtual lldb::addr_t LookupSymbol(const ConstString &name);
+ virtual lldb::addr_t LookupSymbol(ConstString name);
void RegisterExecutionUnit(lldb::IRExecutionUnitSP &execution_unit_sp);
lldb::ModuleSP GetJITModule();
- lldb::addr_t FindSymbol(const ConstString &name);
+ lldb::addr_t FindSymbol(ConstString name);
void GetStaticInitializers(std::vector<lldb::addr_t> &static_initializers);
struct SearchSpec;
void CollectCandidateCNames(std::vector<SearchSpec> &C_specs,
- const ConstString &name);
+ ConstString name);
void CollectCandidateCPlusPlusNames(std::vector<SearchSpec> &CPP_specs,
const std::vector<SearchSpec> &C_specs,
lldb::addr_t FindInUserDefinedSymbols(const std::vector<SearchSpec> &specs,
const lldb_private::SymbolContext &sc);
- void ReportSymbolLookupError(const ConstString &name);
+ void ReportSymbolLookupError(ConstString name);
class MemoryManager : public llvm::SectionMemoryManager {
public:
m_platform_name.clear();
}
- const ConstString &GetSDKRootDirectory() const { return m_sdk_sysroot; }
+ ConstString GetSDKRootDirectory() const { return m_sdk_sysroot; }
- void SetSDKRootDirectory(const ConstString &sdk_root_directory) {
+ void SetSDKRootDirectory(ConstString sdk_root_directory) {
m_sdk_sysroot = sdk_root_directory;
}
- const ConstString &GetSDKBuild() const { return m_sdk_build; }
+ ConstString GetSDKBuild() const { return m_sdk_build; }
- void SetSDKBuild(const ConstString &sdk_build) { m_sdk_build = sdk_build; }
+ void SetSDKBuild(ConstString sdk_build) { m_sdk_build = sdk_build; }
bool PlatformMatches(const lldb::PlatformSP &platform_sp) const;
size_t GetNumValues() const { return m_values.size(); }
- lldb::OptionValueSP GetValueForKey(const ConstString &key) const;
+ lldb::OptionValueSP GetValueForKey(ConstString key) const;
lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx,
llvm::StringRef name, bool will_modify,
Status SetSubValue(const ExecutionContext *exe_ctx, VarSetOperationType op,
llvm::StringRef name, llvm::StringRef value) override;
- bool SetValueForKey(const ConstString &key,
+ bool SetValueForKey(ConstString key,
const lldb::OptionValueSP &value_sp,
bool can_replace = true);
- bool DeleteValueForKey(const ConstString &key);
+ bool DeleteValueForKey(ConstString key);
size_t GetArgs(Args &args) const;
OptionValueProperties()
: OptionValue(), m_name(), m_properties(), m_name_to_index() {}
- OptionValueProperties(const ConstString &name);
+ OptionValueProperties(ConstString name);
OptionValueProperties(const OptionValueProperties &global_properties);
// collection, "name" can't be a path to a property path that refers to a
// property within a property
//---------------------------------------------------------------------
- virtual uint32_t GetPropertyIndex(const ConstString &name) const;
+ virtual uint32_t GetPropertyIndex(ConstString name) const;
//---------------------------------------------------------------------
// Get a property by exact name exists in this property collection, name can
//---------------------------------------------------------------------
virtual const Property *GetProperty(const ExecutionContext *exe_ctx,
bool will_modify,
- const ConstString &name) const;
+ ConstString name) const;
virtual const Property *GetPropertyAtIndex(const ExecutionContext *exe_ctx,
bool will_modify,
uint32_t idx) const;
virtual lldb::OptionValueSP GetValueForKey(const ExecutionContext *exe_ctx,
- const ConstString &key,
+ ConstString key,
bool value_will_be_modified) const;
lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx,
OptionValueFileSpecList *GetPropertyAtIndexAsOptionValueFileSpecList(
const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const;
- void AppendProperty(const ConstString &name, const ConstString &desc,
+ void AppendProperty(ConstString name, ConstString desc,
bool is_global, const lldb::OptionValueSP &value_sp);
lldb::OptionValuePropertiesSP GetSubProperty(const ExecutionContext *exe_ctx,
- const ConstString &name);
+ ConstString name);
void SetValueChangedCallback(uint32_t property_idx,
OptionValueChangedCallback callback,
public:
Property(const PropertyDefinition &definition);
- Property(const ConstString &name, const ConstString &desc, bool is_global,
+ Property(ConstString name, ConstString desc, bool is_global,
const lldb::OptionValueSP &value_sp);
llvm::StringRef GetName() const { return m_name.GetStringRef(); }
lldb::BasicType type);
static CompilerType GetBasicType(clang::ASTContext *ast,
- const ConstString &name);
+ ConstString name);
- static lldb::BasicType GetBasicTypeEnumeration(const ConstString &name);
+ static lldb::BasicType GetBasicTypeEnumeration(ConstString name);
CompilerType GetBuiltinTypeForDWARFEncodingAndBitSize(const char *type_name,
uint32_t dw_ate,
template <typename RecordDeclType>
CompilerType
- GetTypeForIdentifier(const ConstString &type_name,
+ GetTypeForIdentifier(ConstString type_name,
clang::DeclContext *decl_context = nullptr) {
CompilerType compiler_type;
}
CompilerType CreateStructForIdentifier(
- const ConstString &type_name,
+ ConstString type_name,
const std::initializer_list<std::pair<const char *, CompilerType>>
&type_fields,
bool packed = false);
CompilerType GetOrCreateStructForIdentifier(
- const ConstString &type_name,
+ ConstString type_name,
const std::initializer_list<std::pair<const char *, CompilerType>>
&type_fields,
bool packed = false);
bool omit_empty_base_classes,
const ExecutionContext *exe_ctx) override;
- CompilerType GetBuiltinTypeByName(const ConstString &name) override;
+ CompilerType GetBuiltinTypeByName(ConstString name) override;
lldb::BasicType
GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override;
static lldb::BasicType
GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type,
- const ConstString &name);
+ ConstString name);
void ForEachEnumerator(
lldb::opaque_compiler_type_t type,
std::function<bool(const CompilerType &integer_type,
- const ConstString &name,
+ ConstString name,
const llvm::APSInt &value)> const &callback) override;
uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;
virtual ~MapCompleter();
virtual void CompleteNamespaceMap(NamespaceMapSP &namespace_map,
- const ConstString &name,
+ ConstString name,
NamespaceMapSP &parent_map) const = 0;
};
lldb::BasicType GetBasicTypeEnumeration() const;
- static lldb::BasicType GetBasicTypeEnumeration(const ConstString &name);
+ static lldb::BasicType GetBasicTypeEnumeration(ConstString name);
//----------------------------------------------------------------------
// If this type is an enumeration, iterate through all of its enumerators
//----------------------------------------------------------------------
void ForEachEnumerator(
std::function<bool(const CompilerType &integer_type,
- const ConstString &name,
+ ConstString name,
const llvm::APSInt &value)> const &callback) const;
uint32_t GetNumFields() const;
/// The number of Decls added to decls; will not exceed
/// max_matches.
//------------------------------------------------------------------
- virtual uint32_t FindDecls(const ConstString &name, bool append,
+ virtual uint32_t FindDecls(ConstString name, bool append,
uint32_t max_matches,
std::vector<clang::NamedDecl *> &decls) = 0;
/// Optional declaration information that describes where the
/// function was declared. This can be NULL.
//------------------------------------------------------------------
- FunctionInfo(const ConstString &name, const Declaration *decl_ptr);
+ FunctionInfo(ConstString name, const Declaration *decl_ptr);
//------------------------------------------------------------------
/// Destructor.
/// Optional calling location declaration information that
/// describes from where this inlined function was called.
//------------------------------------------------------------------
- InlineFunctionInfo(const ConstString &name, const Mangled &mangled,
+ InlineFunctionInfo(ConstString name, const Mangled &mangled,
const Declaration *decl_ptr,
const Declaration *call_decl_ptr);
void Clear();
- bool Compare(const ConstString &name, lldb::SymbolType type) const;
+ bool Compare(ConstString name, lldb::SymbolType type) const;
void Dump(Stream *s, Target *target, uint32_t index) const;
FileSpec GetReExportedSymbolSharedLibrary() const;
- void SetReExportedSymbolName(const ConstString &name);
+ void SetReExportedSymbolName(ConstString name);
bool SetReExportedSymbolSharedLibrary(const FileSpec &fspec);
/// @return
/// The symbol that was found, or \b nullptr if none was found.
//------------------------------------------------------------------
- const Symbol *FindBestGlobalDataSymbol(const ConstString &name, Status &error);
+ const Symbol *FindBestGlobalDataSymbol(ConstString name, Status &error);
void GetDescription(Stream *s, lldb::DescriptionLevel level,
Target *target) const;
virtual void DumpClangAST(Stream &s) {}
virtual uint32_t
- FindGlobalVariables(const ConstString &name,
+ FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables);
virtual uint32_t FindGlobalVariables(const RegularExpression ®ex,
uint32_t max_matches,
VariableList &variables);
- virtual uint32_t FindFunctions(const ConstString &name,
+ virtual uint32_t FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask,
bool include_inlines, bool append,
bool include_inlines, bool append,
SymbolContextList &sc_list);
virtual uint32_t
- FindTypes(const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types);
GetTypeSystemForLanguage(lldb::LanguageType language);
virtual CompilerDeclContext
- FindNamespace(const ConstString &name,
+ FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) {
return CompilerDeclContext();
}
lldb::SymbolContextItem resolve_scope,
SymbolContextList &sc_list);
- virtual size_t FindGlobalVariables(const ConstString &name,
+ virtual size_t FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
size_t max_matches,
VariableList &variables);
size_t max_matches,
VariableList &variables);
- virtual size_t FindFunctions(const ConstString &name,
+ virtual size_t FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask,
bool include_inlines, bool append,
SymbolContextList &sc_list);
virtual size_t
- FindTypes(const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types);
bool append, TypeMap &types);
virtual CompilerDeclContext
- FindNamespace(const ConstString &name,
+ FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx);
virtual size_t GetNumCompileUnits();
std::vector<uint32_t> &matches,
uint32_t start_idx = 0,
uint32_t end_index = UINT32_MAX) const;
- uint32_t AppendSymbolIndexesWithName(const ConstString &symbol_name,
+ uint32_t AppendSymbolIndexesWithName(ConstString symbol_name,
std::vector<uint32_t> &matches);
- uint32_t AppendSymbolIndexesWithName(const ConstString &symbol_name,
+ uint32_t AppendSymbolIndexesWithName(ConstString symbol_name,
Debug symbol_debug_type,
Visibility symbol_visibility,
std::vector<uint32_t> &matches);
- uint32_t AppendSymbolIndexesWithNameAndType(const ConstString &symbol_name,
+ uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
lldb::SymbolType symbol_type,
std::vector<uint32_t> &matches);
- uint32_t AppendSymbolIndexesWithNameAndType(const ConstString &symbol_name,
+ uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
lldb::SymbolType symbol_type,
Debug symbol_debug_type,
Visibility symbol_visibility,
const RegularExpression ®ex, lldb::SymbolType symbol_type,
Debug symbol_debug_type, Visibility symbol_visibility,
std::vector<uint32_t> &indexes);
- size_t FindAllSymbolsWithNameAndType(const ConstString &name,
+ size_t FindAllSymbolsWithNameAndType(ConstString name,
lldb::SymbolType symbol_type,
std::vector<uint32_t> &symbol_indexes);
- size_t FindAllSymbolsWithNameAndType(const ConstString &name,
+ size_t FindAllSymbolsWithNameAndType(ConstString name,
lldb::SymbolType symbol_type,
Debug symbol_debug_type,
Visibility symbol_visibility,
const RegularExpression ®ex, lldb::SymbolType symbol_type,
Debug symbol_debug_type, Visibility symbol_visibility,
std::vector<uint32_t> &symbol_indexes);
- Symbol *FindFirstSymbolWithNameAndType(const ConstString &name,
+ Symbol *FindFirstSymbolWithNameAndType(ConstString name,
lldb::SymbolType symbol_type,
Debug symbol_debug_type,
Visibility symbol_visibility);
Symbol *FindSymbolContainingFileAddress(lldb::addr_t file_addr);
void ForEachSymbolContainingFileAddress(
lldb::addr_t file_addr, std::function<bool(Symbol *)> const &callback);
- size_t FindFunctionSymbols(const ConstString &name, uint32_t name_type_mask,
+ size_t FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
SymbolContextList &sc_list);
void CalculateSymbolSizes();
// detailed lookups in SymbolVendor and SymbolFile functions.
//----------------------------------------------------------------------
struct CompilerContext {
- CompilerContext(CompilerContextKind t, const ConstString &n)
+ CompilerContext(CompilerContextKind t, ConstString n)
: type(t), name(n) {}
bool operator==(const CompilerContext &rhs) const {
eResolveStateFull = 3
} ResolveState;
- Type(lldb::user_id_t uid, SymbolFile *symbol_file, const ConstString &name,
+ Type(lldb::user_id_t uid, SymbolFile *symbol_file, ConstString name,
llvm::Optional<uint64_t> byte_size, SymbolContextScope *context,
lldb::user_id_t encoding_uid, EncodingDataType encoding_uid_type,
const Declaration &decl, const CompilerType &compiler_qual_type,
TypeList *GetTypeList();
- const ConstString &GetName();
+ ConstString GetName();
llvm::Optional<uint64_t> GetByteSize();
lldb::TypeSP GetTypedefType();
- const ConstString &GetName() const { return m_name; }
+ ConstString GetName() const { return m_name; }
ConstString GetQualifiedName();
{}
TypeMemberImpl(const lldb::TypeImplSP &type_impl_sp, uint64_t bit_offset,
- const ConstString &name, uint32_t bitfield_bit_size = 0,
+ ConstString name, uint32_t bitfield_bit_size = 0,
bool is_bitfield = false)
: m_type_impl_sp(type_impl_sp), m_bit_offset(bit_offset), m_name(name),
m_bitfield_bit_size(bitfield_bit_size), m_is_bitfield(is_bitfield) {}
const lldb::TypeImplSP &GetTypeImpl() { return m_type_impl_sp; }
- const ConstString &GetName() const { return m_name; }
+ ConstString GetName() const { return m_name; }
uint64_t GetBitOffset() const { return m_bit_offset; }
CompilerType GetCompilerType() const { return m_type_pair.GetCompilerType(); }
- void SetName(const ConstString &type_name);
+ void SetName(ConstString type_name);
void SetName(const char *type_name_cstr);
: m_integer_type_sp(), m_name("<invalid>"), m_value(), m_valid(false) {}
TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp,
- const ConstString &name, const llvm::APSInt &value);
+ ConstString name, const llvm::APSInt &value);
TypeEnumMemberImpl(const TypeEnumMemberImpl &rhs)
: m_integer_type_sp(rhs.m_integer_type_sp), m_name(rhs.m_name),
bool IsValid() { return m_valid; }
- const ConstString &GetName() const { return m_name; }
+ ConstString GetName() const { return m_name; }
const lldb::TypeImplSP &GetIntegerType() const { return m_integer_type_sp; }
// lldb::TypeSP
// FindType(lldb::user_id_t uid);
- TypeList FindTypes(const ConstString &name);
+ TypeList FindTypes(ConstString name);
void Insert(const lldb::TypeSP &type);
void Dump(Stream *s, bool show_context);
- TypeMap FindTypes(const ConstString &name);
+ TypeMap FindTypes(ConstString name);
void Insert(const lldb::TypeSP &type);
bool omit_empty_base_classes,
const ExecutionContext *exe_ctx) = 0;
- virtual CompilerType GetBuiltinTypeByName(const ConstString &name);
+ virtual CompilerType GetBuiltinTypeByName(ConstString name);
virtual lldb::BasicType
GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) = 0;
virtual void ForEachEnumerator(
lldb::opaque_compiler_type_t type,
std::function<bool(const CompilerType &integer_type,
- const ConstString &name,
+ ConstString name,
const llvm::APSInt &value)> const &callback) {}
virtual uint32_t GetNumFields(lldb::opaque_compiler_type_t type) = 0;
// namespace)::i", this function will allow a generic match function that can
// be called by commands and expression parsers to make sure we match
// anything we come across.
- bool NameMatches(const ConstString &name) const;
+ bool NameMatches(ConstString name) const;
bool NameMatches(const RegularExpression ®ex) const;
lldb::VariableSP RemoveVariableAtIndex(size_t idx);
- lldb::VariableSP FindVariable(const ConstString &name,
+ lldb::VariableSP FindVariable(ConstString name,
bool include_static_members = true);
- lldb::VariableSP FindVariable(const ConstString &name,
+ lldb::VariableSP FindVariable(ConstString name,
lldb::ValueType value_type,
bool include_static_members = true);
virtual const RegisterInfo *GetRegisterInfoArray(uint32_t &count) = 0;
- bool GetRegisterInfoByName(const ConstString &name, RegisterInfo &info);
+ bool GetRegisterInfoByName(ConstString name, RegisterInfo &info);
bool GetRegisterInfoByKind(lldb::RegisterKind reg_kind, uint32_t reg_num,
RegisterInfo &info);
OptionalBool GetMapped() const { return m_mapped; }
- const ConstString &GetName() const { return m_name; }
+ ConstString GetName() const { return m_name; }
void SetReadable(OptionalBool val) { m_read = val; }
ClassDescriptorSP GetNonKVOClassDescriptor(ValueObject &in_value);
virtual ClassDescriptorSP
- GetClassDescriptorFromClassName(const ConstString &class_name);
+ GetClassDescriptorFromClassName(ConstString class_name);
virtual ClassDescriptorSP GetClassDescriptorFromISA(ObjCISA isa);
}
}
- virtual ObjCISA GetISA(const ConstString &name);
+ virtual ObjCISA GetISA(ConstString name);
virtual ConstString GetActualTypeName(ObjCISA isa);
// Given the name of an Objective-C runtime symbol (e.g., ivar offset
// symbol), try to determine from the runtime what the value of that symbol
// would be. Useful when the underlying binary is stripped.
- virtual lldb::addr_t LookupRuntimeSymbol(const ConstString &name) {
+ virtual lldb::addr_t LookupRuntimeSymbol(ConstString name) {
return LLDB_INVALID_ADDRESS;
}
CompleteClassMap m_complete_class_cache;
struct ConstStringSetHelpers {
- size_t operator()(const ConstString &arg) const // for hashing
+ size_t operator()(ConstString arg) const // for hashing
{
return (size_t)arg.GetCString();
}
- bool operator()(const ConstString &arg1,
- const ConstString &arg2) const // for equality
+ bool operator()(ConstString arg1,
+ ConstString arg2) const // for equality
{
return arg1.operator==(arg2);
}
CompleteClassSet;
CompleteClassSet m_negative_complete_class_cache;
- ISAToDescriptorIterator GetDescriptorIterator(const ConstString &name);
+ ISAToDescriptorIterator GetDescriptorIterator(ConstString name);
friend class ::CommandObjectObjC_ClassTable_Dump;
const PathMappingList &operator=(const PathMappingList &rhs);
- void Append(const ConstString &path, const ConstString &replacement,
+ void Append(ConstString path, ConstString replacement,
bool notify);
void Append(const PathMappingList &rhs, bool notify);
bool GetPathsAtIndex(uint32_t idx, ConstString &path,
ConstString &new_path) const;
- void Insert(const ConstString &path, const ConstString &replacement,
+ void Insert(ConstString path, ConstString replacement,
uint32_t insert_idx, bool notify);
bool Remove(size_t index, bool notify);
- bool Remove(const ConstString &path, bool notify);
+ bool Remove(ConstString path, bool notify);
- bool Replace(const ConstString &path, const ConstString &replacement,
+ bool Replace(ConstString path, ConstString replacement,
bool notify);
- bool Replace(const ConstString &path, const ConstString &replacement,
+ bool Replace(ConstString path, ConstString replacement,
uint32_t index, bool notify);
- bool RemapPath(const ConstString &path, ConstString &new_path) const;
+ bool RemapPath(ConstString path, ConstString &new_path) const;
//------------------------------------------------------------------
/// Remaps a source file given \a path into \a new_path.
//------------------------------------------------------------------
bool FindFile(const FileSpec &orig_spec, FileSpec &new_spec) const;
- uint32_t FindIndexForPath(const ConstString &path) const;
+ uint32_t FindIndexForPath(ConstString path) const;
uint32_t GetModificationID() const { return m_mod_id; }
typedef collection::iterator iterator;
typedef collection::const_iterator const_iterator;
- iterator FindIteratorForPath(const ConstString &path);
+ iterator FindIteratorForPath(ConstString path);
- const_iterator FindIteratorForPath(const ConstString &path) const;
+ const_iterator FindIteratorForPath(ConstString path) const;
collection m_pairs;
ChangedCallback m_callback;
static void SetHostPlatform(const lldb::PlatformSP &platform_sp);
// Find an existing platform plug-in by name
- static lldb::PlatformSP Find(const ConstString &name);
+ static lldb::PlatformSP Find(ConstString name);
- static lldb::PlatformSP Create(const ConstString &name, Status &error);
+ static lldb::PlatformSP Create(ConstString name, Status &error);
static lldb::PlatformSP Create(const ArchSpec &arch,
ArchSpec *platform_arch_ptr, Status &error);
/// should be used. If nullptr, pick the best plug-in.
//------------------------------------------------------------------
// static lldb::PlatformSP
- // FindPlugin (Process *process, const ConstString &plugin_name);
+ // FindPlugin (Process *process, ConstString plugin_name);
//------------------------------------------------------------------
/// Set the target's executable based off of the existing architecture
// Used for column widths
size_t GetMaxGroupIDNameLength() const { return m_max_gid_name_len; }
- const ConstString &GetSDKRootDirectory() const { return m_sdk_sysroot; }
+ ConstString GetSDKRootDirectory() const { return m_sdk_sysroot; }
- void SetSDKRootDirectory(const ConstString &dir) { m_sdk_sysroot = dir; }
+ void SetSDKRootDirectory(ConstString dir) { m_sdk_sysroot = dir; }
- const ConstString &GetSDKBuild() const { return m_sdk_build; }
+ ConstString GetSDKBuild() const { return m_sdk_build; }
- void SetSDKBuild(const ConstString &sdk_build) { m_sdk_build = sdk_build; }
+ void SetSDKBuild(ConstString sdk_build) { m_sdk_build = sdk_build; }
// Override this to return true if your platform supports Clang modules. You
// may also need to override AddClangModuleCompilationOptions to pass the
~ProcessEventData() override;
- static const ConstString &GetFlavorString();
+ static ConstString GetFlavorString();
- const ConstString &GetFlavor() const override;
+ ConstString GetFlavor() const override;
lldb::ProcessSP GetProcessSP() const { return m_process_wp.lock(); }
/// Returns the result of attempting to configure the feature.
//------------------------------------------------------------------
virtual Status
- ConfigureStructuredData(const ConstString &type_name,
+ ConfigureStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp);
//------------------------------------------------------------------
/// otherwise, returns an empty shared pointer.
//------------------------------------------------------------------
lldb::StructuredDataPluginSP
- GetStructuredDataPlugin(const ConstString &type_name) const;
+ GetStructuredDataPlugin(ConstString type_name) const;
//------------------------------------------------------------------
/// Starts tracing with the configuration provided in options. To enable
///
/// virtual void
/// HandleArrivalOfStructuredData(Process &process,
- /// const ConstString &type_name,
+ /// ConstString type_name,
/// const StructuredData::ObjectSP
/// &object_sp)
///
class StackFrameRecognizerManager {
public:
static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
- const ConstString &module,
- const ConstString &symbol,
+ ConstString module,
+ ConstString symbol,
bool first_instruction_only = true);
static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
/// @return
/// true if the plugin supports the feature; otherwise, false.
// -------------------------------------------------------------------------
- virtual bool SupportsStructuredDataType(const ConstString &type_name) = 0;
+ virtual bool SupportsStructuredDataType(ConstString type_name) = 0;
// -------------------------------------------------------------------------
/// Handle the arrival of asynchronous structured data from the process.
/// structured data type name.
// -------------------------------------------------------------------------
virtual void
- HandleArrivalOfStructuredData(Process &process, const ConstString &type_name,
+ HandleArrivalOfStructuredData(Process &process, ConstString type_name,
const StructuredData::ObjectSP &object_sp) = 0;
// -------------------------------------------------------------------------
/// The name of the feature tag for the asynchronous structured data.
/// This is needed for plugins that support more than one feature.
// -------------------------------------------------------------------------
- virtual bool GetEnabled(const ConstString &type_name) const;
+ virtual bool GetEnabled(ConstString type_name) const;
// -------------------------------------------------------------------------
/// Allow the plugin to do work related to modules that loaded in the
~TargetEventData() override;
- static const ConstString &GetFlavorString();
+ static ConstString GetFlavorString();
- const ConstString &GetFlavor() const override {
+ ConstString GetFlavor() const override {
return TargetEventData::GetFlavorString();
}
Status &error);
void RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp,
- const ConstString &name);
+ ConstString name);
- BreakpointName *FindBreakpointName(const ConstString &name, bool can_create,
+ BreakpointName *FindBreakpointName(ConstString name, bool can_create,
Status &error);
- void DeleteBreakpointName(const ConstString &name);
+ void DeleteBreakpointName(ConstString name);
void ConfigureBreakpointName(BreakpointName &bp_name,
const BreakpointOptions &options,
std::string *fixed_expression = nullptr,
ValueObject *ctx_obj = nullptr);
- lldb::ExpressionVariableSP GetPersistentVariable(const ConstString &name);
+ lldb::ExpressionVariableSP GetPersistentVariable(ConstString name);
/// Return the next available number for numbered persistent variables.
unsigned GetNextPersistentVariableIndex() {
return m_next_persistent_variable_index++;
}
- lldb::addr_t GetPersistentSymbol(const ConstString &name);
+ lldb::addr_t GetPersistentSymbol(ConstString name);
//------------------------------------------------------------------
// Target Stop Hooks
~ThreadEventData() override;
- static const ConstString &GetFlavorString();
+ static ConstString GetFlavorString();
- const ConstString &GetFlavor() const override {
+ ConstString GetFlavor() const override {
return ThreadEventData::GetFlavorString();
}
/// @return A ConstString ref containing the distribution id,
/// potentially empty.
//------------------------------------------------------------------
- const ConstString &GetDistributionId() const;
+ ConstString GetDistributionId() const;
//------------------------------------------------------------------
/// Set the distribution id of the architecture.
//----------------------------------------------------------------------
class BroadcastEventSpec {
public:
- BroadcastEventSpec(const ConstString &broadcaster_class, uint32_t event_bits)
+ BroadcastEventSpec(ConstString broadcaster_class, uint32_t event_bits)
: m_broadcaster_class(broadcaster_class), m_event_bits(event_bits) {}
BroadcastEventSpec(const BroadcastEventSpec &rhs);
~BroadcastEventSpec() = default;
- const ConstString &GetBroadcasterClass() const { return m_broadcaster_class; }
+ ConstString GetBroadcasterClass() const { return m_broadcaster_class; }
uint32_t GetEventBits() const { return m_event_bits; }
class BroadcasterClassMatches {
public:
- BroadcasterClassMatches(const ConstString &broadcaster_class)
+ BroadcasterClassMatches(ConstString broadcaster_class)
: m_broadcaster_class(broadcaster_class) {}
~BroadcasterClassMatches() = default;
/// @return
/// The NULL terminated C string name of this Broadcaster.
//------------------------------------------------------------------
- const ConstString &GetBroadcasterName() { return m_broadcaster_name; }
+ ConstString GetBroadcasterName() { return m_broadcaster_name; }
//------------------------------------------------------------------
/// Get the event name(s) for one or more event bits.
/// @return
/// A const reference to this object.
//------------------------------------------------------------------
- const ConstString &operator=(const ConstString &rhs) {
+ ConstString operator=(ConstString rhs) {
m_string = rhs.m_string;
return *this;
}
/// @li \b true if this object is equal to \a rhs.
/// @li \b false if this object is not equal to \a rhs.
//------------------------------------------------------------------
- bool operator==(const ConstString &rhs) const {
+ bool operator==(ConstString rhs) const {
// We can do a pointer compare to compare these strings since they must
// come from the same pool in order to be equal.
return m_string == rhs.m_string;
/// @li \b true if this object is not equal to \a rhs.
/// @li \b false if this object is equal to \a rhs.
//------------------------------------------------------------------
- bool operator!=(const ConstString &rhs) const {
+ bool operator!=(ConstString rhs) const {
return m_string != rhs.m_string;
}
- bool operator<(const ConstString &rhs) const;
+ bool operator<(ConstString rhs) const;
//------------------------------------------------------------------
/// Get the string value as a C string.
/// @li \b true if this object is equal to \a rhs.
/// @li \b false if this object is not equal to \a rhs.
//------------------------------------------------------------------
- static bool Equals(const ConstString &lhs, const ConstString &rhs,
+ static bool Equals(ConstString lhs, ConstString rhs,
const bool case_sensitive = true);
//------------------------------------------------------------------
/// @li 0 if lhs == rhs
/// @li 1 if lhs > rhs
//------------------------------------------------------------------
- static int Compare(const ConstString &lhs, const ConstString &rhs,
+ static int Compare(ConstString lhs, ConstString rhs,
const bool case_sensitive = true);
//------------------------------------------------------------------
/// soon to be uniqued version of \a demangled.
//------------------------------------------------------------------
void SetStringWithMangledCounterpart(llvm::StringRef demangled,
- const ConstString &mangled);
+ ConstString mangled);
//------------------------------------------------------------------
/// Retrieve the mangled or demangled counterpart for a mangled or demangled
//------------------------------------------------------------------
/// Stream the string value \a str to the stream \a s
//------------------------------------------------------------------
-Stream &operator<<(Stream &s, const ConstString &str);
+Stream &operator<<(Stream &s, ConstString str);
} // namespace lldb_private
virtual ~EventData();
- virtual const ConstString &GetFlavor() const = 0;
+ virtual ConstString GetFlavor() const = 0;
virtual void Dump(Stream *s) const;
//------------------------------------------------------------------
// Member functions
//------------------------------------------------------------------
- const ConstString &GetFlavor() const override;
+ ConstString GetFlavor() const override;
void Dump(Stream *s) const override;
static size_t GetByteSizeFromEvent(const Event *event_ptr);
- static const ConstString &GetFlavorString();
+ static ConstString GetFlavorString();
private:
std::string m_bytes;
~EventDataReceipt() override {}
- static const ConstString &GetFlavorString() {
+ static ConstString GetFlavorString() {
static ConstString g_flavor("Process::ProcessEventData");
return g_flavor;
}
- const ConstString &GetFlavor() const override { return GetFlavorString(); }
+ ConstString GetFlavor() const override { return GetFlavorString(); }
bool WaitForEventReceived(const Timeout<std::micro> &timeout = llvm::None) {
return m_predicate.WaitForValueEqualTo(true, timeout);
//------------------------------------------------------------------
// Member functions
//------------------------------------------------------------------
- const ConstString &GetFlavor() const override;
+ ConstString GetFlavor() const override;
void Dump(Stream *s) const override;
static lldb::StructuredDataPluginSP
GetPluginFromEvent(const Event *event_ptr);
- static const ConstString &GetFlavorString();
+ static ConstString GetFlavorString();
private:
lldb::ProcessSP m_process_sp;
/// @return
/// A const reference to the directory string object.
//------------------------------------------------------------------
- const ConstString &GetDirectory() const;
+ ConstString GetDirectory() const;
//------------------------------------------------------------------
/// Filename string get accessor.
/// @return
/// A const reference to the filename string object.
//------------------------------------------------------------------
- const ConstString &GetFilename() const;
+ ConstString GetFilename() const;
//------------------------------------------------------------------
/// Returns true if the filespec represents an implementation source file
llvm::ArrayRef<const char *> categories,
llvm::raw_ostream &error_stream);
- static bool ListChannelCategories(llvm::StringRef channel, llvm::raw_ostream &stream);
+ static bool ListChannelCategories(llvm::StringRef channel,
+ llvm::raw_ostream &stream);
static void DisableAllLogChannels();
if (this_type.IsValid()) {
this_type.ForEachEnumerator([&sb_enum_member_list](
const CompilerType &integer_type,
- const ConstString &name,
+ ConstString name,
const llvm::APSInt &value) -> bool {
SBTypeEnumMember enum_member(
lldb::TypeEnumMemberImplSP(new TypeEnumMemberImpl(
using namespace lldb_private;
using namespace llvm;
-const ConstString &Breakpoint::GetEventIdentifier() {
+ConstString Breakpoint::GetEventIdentifier() {
static ConstString g_identifier("event-identifier.breakpoint.changed");
return g_identifier;
}
m_resolver_sp->GetDescription(s);
}
-bool Breakpoint::GetMatchingFileLine(const ConstString &filename,
+bool Breakpoint::GetMatchingFileLine(ConstString filename,
uint32_t line_number,
BreakpointLocationCollection &loc_coll) {
// TODO: To be correct, this method needs to fill the breakpoint location
Breakpoint::BreakpointEventData::~BreakpointEventData() = default;
-const ConstString &Breakpoint::BreakpointEventData::GetFlavorString() {
+ConstString Breakpoint::BreakpointEventData::GetFlavorString() {
static ConstString g_flavor("Breakpoint::BreakpointEventData");
return g_flavor;
}
-const ConstString &Breakpoint::BreakpointEventData::GetFlavor() const {
+ConstString Breakpoint::BreakpointEventData::GetFlavor() const {
return BreakpointEventData::GetFlavorString();
}
(0x5u)
};
-BreakpointName::BreakpointName(const ConstString &name, const Breakpoint &bkpt,
+BreakpointName::BreakpointName(ConstString name, const Breakpoint &bkpt,
const char *help) :
m_name(name), m_options(bkpt.GetOptions())
{
return WrapOptionsDict(options_dict_sp);
}
-void BreakpointResolverName::AddNameLookup(const ConstString &name,
+void BreakpointResolverName::AddNameLookup(ConstString name,
FunctionNameType name_type_mask) {
ObjCLanguage::MethodName objc_method(name.GetCString(), false);
if (objc_method.IsValid(false)) {
Watchpoint::WatchpointEventData::~WatchpointEventData() = default;
-const ConstString &Watchpoint::WatchpointEventData::GetFlavorString() {
+ConstString Watchpoint::WatchpointEventData::GetFlavorString() {
static ConstString g_flavor("Watchpoint::WatchpointEventData");
return g_flavor;
}
-const ConstString &Watchpoint::WatchpointEventData::GetFlavor() const {
+ConstString Watchpoint::WatchpointEventData::GetFlavor() const {
return WatchpointEventData::GetFlavorString();
}
continue;
// Print a new header if the module changed.
- const ConstString &module_file_name =
+ ConstString module_file_name =
module->GetFileSpec().GetFilename();
assert(module_file_name);
if (module_file_name != last_module_file_name) {
// Dump all matching lines at or above start_line for the file in the
// CU.
- const ConstString &file_spec_name = file_spec.GetFilename();
- const ConstString &module_file_name =
+ ConstString file_spec_name = file_spec.GetFilename();
+ ConstString module_file_name =
module->GetFileSpec().GetFilename();
bool cu_header_printed = false;
uint32_t line = start_line;
ConstString function;
LineEntry line_entry;
- SourceInfo(const ConstString &name, const LineEntry &line_entry)
+ SourceInfo(ConstString name, const LineEntry &line_entry)
: function(name), line_entry(line_entry) {}
SourceInfo() : function(), line_entry() {}
// these somewhere, there should probably be a module-filter-list that can be
// passed to the various ModuleList::Find* calls, which would either be a
// vector of string names or a ModuleSpecList.
- size_t FindMatchingFunctions(Target *target, const ConstString &name,
+ size_t FindMatchingFunctions(Target *target, ConstString name,
SymbolContextList &sc_list) {
// Displaying the source for a symbol:
bool include_inlines = true;
return num_matches;
}
- size_t FindMatchingFunctionSymbols(Target *target, const ConstString &name,
+ size_t FindMatchingFunctionSymbols(Target *target, ConstString name,
SymbolContextList &sc_list) {
size_t num_matches = 0;
const size_t num_modules = m_options.modules.size();
std::string m_category;
ScriptAddOptions(const TypeSummaryImpl::Flags &flags, bool regx,
- const ConstString &name, std::string catg)
+ ConstString name, std::string catg)
: m_flags(flags), m_regex(regx), m_name(name), m_category(catg) {}
typedef std::shared_ptr<ScriptAddOptions> SharedPointer;
}
DebuggerSP
-Debugger::FindDebuggerWithInstanceName(const ConstString &instance_name) {
+Debugger::FindDebuggerWithInstanceName(ConstString instance_name) {
DebuggerSP debugger_sp;
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
bool Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch,
const char *plugin_name, const char *flavor,
const ExecutionContext &exe_ctx,
- const ConstString &name, Module *module,
+ ConstString name, Module *module,
uint32_t num_instructions,
bool mixed_source_and_assembly,
uint32_t num_mixed_context_lines,
return cstring_mangling_scheme(s) != Mangled::eManglingSchemeNone;
}
-static const ConstString &
+static ConstString
get_demangled_name_without_arguments(ConstString mangled,
ConstString demangled) {
// This pair is <mangled name, demangled name without function arguments>
// Constructor with an optional string and a boolean indicating if it is the
// mangled version.
//----------------------------------------------------------------------
-Mangled::Mangled(const ConstString &s, bool mangled)
+Mangled::Mangled(ConstString s, bool mangled)
: m_mangled(), m_demangled() {
if (s)
SetValue(s, mangled);
SetValue(ConstString(name), is_mangled);
}
-Mangled::Mangled(const ConstString &s) : m_mangled(), m_demangled() {
+Mangled::Mangled(ConstString s) : m_mangled(), m_demangled() {
if (s)
SetValue(s);
}
// Set the string value in this objects. If "mangled" is true, then the mangled
// named is set with the new value in "s", else the demangled name is set.
//----------------------------------------------------------------------
-void Mangled::SetValue(const ConstString &s, bool mangled) {
+void Mangled::SetValue(ConstString s, bool mangled) {
if (s) {
if (mangled) {
m_demangled.Clear();
}
}
-void Mangled::SetValue(const ConstString &name) {
+void Mangled::SetValue(ConstString name) {
if (name) {
if (cstring_is_mangled(name.GetCString())) {
m_demangled.Clear();
// name. The result is cached and will be kept until a new string value is
// supplied to this object, or until the end of the object's lifetime.
//----------------------------------------------------------------------
-const ConstString &
+ConstString
Mangled::GetDemangledName(lldb::LanguageType language) const {
// Check to make sure we have a valid mangled name and that we haven't
// already decoded our mangled name.
if (obj.GetMangledName())
s << "mangled = '" << obj.GetMangledName() << "'";
- const ConstString &demangled =
+ ConstString demangled =
obj.GetDemangledName(lldb::eLanguageTypeUnknown);
if (demangled)
s << ", demangled = '" << demangled << '\'';
return sc_list.GetSize() - initial_count;
}
-size_t Module::FindGlobalVariables(const ConstString &name,
+size_t Module::FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
size_t max_matches,
VariableList &variables) {
return sc_list.GetSize() - start_size;
}
-Module::LookupInfo::LookupInfo(const ConstString &name,
+Module::LookupInfo::LookupInfo(ConstString name,
FunctionNameType name_type_mask,
LanguageType language)
: m_name(name), m_lookup_name(), m_language(language),
}
}
-size_t Module::FindFunctions(const ConstString &name,
+size_t Module::FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask,
bool include_symbols, bool include_inlines,
}
size_t Module::FindTypes_Impl(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types) {
return 0;
}
-size_t Module::FindTypesInNamespace(const ConstString &type_name,
+size_t Module::FindTypesInNamespace(ConstString type_name,
const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, TypeList &type_list) {
const bool append = true;
}
lldb::TypeSP Module::FindFirstType(const SymbolContext &sc,
- const ConstString &name, bool exact_match) {
+ ConstString name, bool exact_match) {
TypeList type_list;
llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
const size_t num_matches =
}
size_t Module::FindTypes(
- const ConstString &name, bool exact_match, size_t max_matches,
+ ConstString name, bool exact_match, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeList &types) {
size_t num_matches = 0;
}
void Module::SetFileSpecAndObjectName(const FileSpec &file,
- const ConstString &object_name) {
+ ConstString object_name) {
// Container objects whose paths do not specify a file directly can call this
// function to correct the file and object names.
m_file = file;
return nullptr;
}
-const ConstString &Module::GetObjectName() const { return m_object_name; }
+ConstString Module::GetObjectName() const { return m_object_name; }
ObjectFile *Module::GetObjectFile() {
if (!m_did_load_objfile.load()) {
return m_sections_up.get();
}
-const Symbol *Module::FindFirstSymbolWithNameAndType(const ConstString &name,
+const Symbol *Module::FindFirstSymbolWithNameAndType(ConstString name,
SymbolType symbol_type) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(
}
}
-size_t Module::FindFunctionSymbols(const ConstString &name,
+size_t Module::FindFunctionSymbols(ConstString name,
uint32_t name_type_mask,
SymbolContextList &sc_list) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
return 0;
}
-size_t Module::FindSymbolsWithNameAndType(const ConstString &name,
+size_t Module::FindSymbolsWithNameAndType(ConstString name,
SymbolType symbol_type,
SymbolContextList &sc_list) {
// No need to protect this call using m_mutex all other method calls are
return false;
}
- const ConstString &object_name = module_ref.GetObjectName();
+ ConstString object_name = module_ref.GetObjectName();
if (object_name) {
if (object_name != GetObjectName())
return false;
return module_sp;
}
-size_t ModuleList::FindFunctions(const ConstString &name,
+size_t ModuleList::FindFunctions(ConstString name,
FunctionNameType name_type_mask,
bool include_symbols, bool include_inlines,
bool append,
return sc_list.GetSize() - old_size;
}
-size_t ModuleList::FindFunctionSymbols(const ConstString &name,
+size_t ModuleList::FindFunctionSymbols(ConstString name,
lldb::FunctionNameType name_type_mask,
SymbolContextList &sc_list) {
const size_t old_size = sc_list.GetSize();
return sc_list.GetSize();
}
-size_t ModuleList::FindGlobalVariables(const ConstString &name,
+size_t ModuleList::FindGlobalVariables(ConstString name,
size_t max_matches,
VariableList &variable_list) const {
size_t initial_size = variable_list.GetSize();
return variable_list.GetSize() - initial_size;
}
-size_t ModuleList::FindSymbolsWithNameAndType(const ConstString &name,
+size_t ModuleList::FindSymbolsWithNameAndType(ConstString name,
SymbolType symbol_type,
SymbolContextList &sc_list,
bool append) const {
}
size_t
-ModuleList::FindTypes(Module *search_first, const ConstString &name,
+ModuleList::FindTypes(Module *search_first, ConstString name,
bool name_is_fully_qualified, size_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files,
TypeList &types) const {
return g_instances;
}
-bool PluginManager::RegisterPlugin(const ConstString &name,
+bool PluginManager::RegisterPlugin(ConstString name,
const char *description,
ABICreateInstance create_callback) {
if (create_callback) {
}
ABICreateInstance
-PluginManager::GetABICreateCallbackForPluginName(const ConstString &name) {
+PluginManager::GetABICreateCallbackForPluginName(ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
ABIInstances &instances = GetABIInstances();
return g_instances;
}
-void PluginManager::RegisterPlugin(const ConstString &name,
+void PluginManager::RegisterPlugin(ConstString name,
llvm::StringRef description,
ArchitectureCreateInstance create_callback) {
std::lock_guard<std::mutex> guard(GetArchitectureMutex());
return g_instances;
}
-bool PluginManager::RegisterPlugin(const ConstString &name,
+bool PluginManager::RegisterPlugin(ConstString name,
const char *description,
DisassemblerCreateInstance create_callback) {
if (create_callback) {
DisassemblerCreateInstance
PluginManager::GetDisassemblerCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
DisassemblerInstances &instances = GetDisassemblerInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
DynamicLoaderCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) {
DynamicLoaderCreateInstance
PluginManager::GetDynamicLoaderCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
DynamicLoaderInstances &instances = GetDynamicLoaderInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
JITLoaderCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) {
}
JITLoaderCreateInstance PluginManager::GetJITLoaderCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
JITLoaderInstances &instances = GetJITLoaderInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
EmulateInstructionCreateInstance create_callback) {
if (create_callback) {
EmulateInstructionInstance instance;
EmulateInstructionCreateInstance
PluginManager::GetEmulateInstructionCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
EmulateInstructionInstances &instances = GetEmulateInstructionInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
OperatingSystemCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) {
OperatingSystemCreateInstance
PluginManager::GetOperatingSystemCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
OperatingSystemInstances &instances = GetOperatingSystemInstances();
return g_instances;
}
-bool PluginManager::RegisterPlugin(const ConstString &name,
+bool PluginManager::RegisterPlugin(ConstString name,
const char *description,
LanguageCreateInstance create_callback) {
if (create_callback) {
}
LanguageCreateInstance
-PluginManager::GetLanguageCreateCallbackForPluginName(const ConstString &name) {
+PluginManager::GetLanguageCreateCallbackForPluginName(ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
LanguageInstances &instances = GetLanguageInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
LanguageRuntimeCreateInstance create_callback,
LanguageRuntimeGetCommandObject command_callback) {
if (create_callback) {
LanguageRuntimeCreateInstance
PluginManager::GetLanguageRuntimeCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
SystemRuntimeCreateInstance create_callback) {
if (create_callback) {
SystemRuntimeInstance instance;
SystemRuntimeCreateInstance
PluginManager::GetSystemRuntimeCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
SystemRuntimeInstances &instances = GetSystemRuntimeInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
ObjectFileCreateInstance create_callback,
ObjectFileCreateMemoryInstance create_memory_callback,
ObjectFileGetModuleSpecifications get_module_specifications,
ObjectFileCreateInstance
PluginManager::GetObjectFileCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
ObjectFileInstances &instances = GetObjectFileInstances();
ObjectFileCreateMemoryInstance
PluginManager::GetObjectFileCreateMemoryCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
ObjectFileInstances &instances = GetObjectFileInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
ObjectContainerCreateInstance create_callback,
ObjectFileGetModuleSpecifications get_module_specifications) {
if (create_callback) {
ObjectContainerCreateInstance
PluginManager::GetObjectContainerCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
ObjectContainerInstances &instances = GetObjectContainerInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
PlatformCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) {
}
PlatformCreateInstance
-PluginManager::GetPlatformCreateCallbackForPluginName(const ConstString &name) {
+PluginManager::GetPlatformCreateCallbackForPluginName(ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
PlatformInstances &instances = GetPlatformInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
ProcessCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) {
}
ProcessCreateInstance
-PluginManager::GetProcessCreateCallbackForPluginName(const ConstString &name) {
+PluginManager::GetProcessCreateCallbackForPluginName(ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
ProcessInstances &instances = GetProcessInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
lldb::ScriptLanguage script_language,
ScriptInterpreterCreateInstance create_callback) {
if (!create_callback)
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
StructuredDataPluginCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback,
StructuredDataFilterLaunchInfo filter_callback) {
StructuredDataPluginCreateInstance
PluginManager::GetStructuredDataPluginCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
StructuredDataPluginInstances &instances =
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
SymbolFileCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) {
SymbolFileCreateInstance
PluginManager::GetSymbolFileCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
SymbolFileInstances &instances = GetSymbolFileInstances();
return g_instances;
}
-bool PluginManager::RegisterPlugin(const ConstString &name,
+bool PluginManager::RegisterPlugin(ConstString name,
const char *description,
SymbolVendorCreateInstance create_callback) {
if (create_callback) {
SymbolVendorCreateInstance
PluginManager::GetSymbolVendorCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
SymbolVendorInstances &instances = GetSymbolVendorInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
UnwindAssemblyCreateInstance create_callback) {
if (create_callback) {
UnwindAssemblyInstance instance;
UnwindAssemblyCreateInstance
PluginManager::GetUnwindAssemblyCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
MemoryHistoryCreateInstance create_callback) {
if (create_callback) {
MemoryHistoryInstance instance;
MemoryHistoryCreateInstance
PluginManager::GetMemoryHistoryCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
MemoryHistoryInstances &instances = GetMemoryHistoryInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
InstrumentationRuntimeCreateInstance create_callback,
InstrumentationRuntimeGetType get_type_callback) {
if (create_callback) {
InstrumentationRuntimeCreateInstance
PluginManager::GetInstrumentationRuntimeCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(
GetInstrumentationRuntimeMutex());
return g_instances;
}
-bool PluginManager::RegisterPlugin(const ConstString &name,
+bool PluginManager::RegisterPlugin(ConstString name,
const char *description,
TypeSystemCreateInstance create_callback,
TypeSystemEnumerateSupportedLanguages
TypeSystemCreateInstance
PluginManager::GetTypeSystemCreateCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
TypeSystemInstances &instances = GetTypeSystemInstances();
TypeSystemEnumerateSupportedLanguages
PluginManager::GetTypeSystemEnumerateSupportedLanguagesCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
TypeSystemInstances &instances = GetTypeSystemInstances();
}
bool PluginManager::RegisterPlugin(
- const ConstString &name, const char *description,
+ ConstString name, const char *description,
REPLCreateInstance create_callback,
REPLEnumerateSupportedLanguages enumerate_languages_callback) {
if (create_callback) {
}
REPLCreateInstance
-PluginManager::GetREPLCreateCallbackForPluginName(const ConstString &name) {
+PluginManager::GetREPLCreateCallbackForPluginName(ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
REPLInstances &instances = GetREPLInstances();
REPLEnumerateSupportedLanguages
PluginManager::GetREPLSystemEnumerateSupportedLanguagesCallbackForPluginName(
- const ConstString &name) {
+ ConstString name) {
if (name) {
std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
REPLInstances &instances = GetREPLInstances();
// This will put a plugin's settings under e.g.
// "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME".
static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPlugins(
- Debugger &debugger, const ConstString &plugin_type_name,
- const ConstString &plugin_type_desc, bool can_create) {
+ Debugger &debugger, ConstString plugin_type_name,
+ ConstString plugin_type_desc, bool can_create) {
lldb::OptionValuePropertiesSP parent_properties_sp(
debugger.GetValueProperties());
if (parent_properties_sp) {
// "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME" and Platform
// generic settings would be under "platform.SETTINGNAME".
static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPluginsOldStyle(
- Debugger &debugger, const ConstString &plugin_type_name,
- const ConstString &plugin_type_desc, bool can_create) {
+ Debugger &debugger, ConstString plugin_type_name,
+ ConstString plugin_type_desc, bool can_create) {
static ConstString g_property_name("plugin");
lldb::OptionValuePropertiesSP parent_properties_sp(
debugger.GetValueProperties());
namespace {
typedef lldb::OptionValuePropertiesSP
-GetDebuggerPropertyForPluginsPtr(Debugger &, const ConstString &,
- const ConstString &, bool can_create);
+GetDebuggerPropertyForPluginsPtr(Debugger &, ConstString ,
+ ConstString , bool can_create);
lldb::OptionValuePropertiesSP
-GetSettingForPlugin(Debugger &debugger, const ConstString &setting_name,
- const ConstString &plugin_type_name,
+GetSettingForPlugin(Debugger &debugger, ConstString setting_name,
+ ConstString plugin_type_name,
GetDebuggerPropertyForPluginsPtr get_debugger_property =
GetDebuggerPropertyForPlugins) {
lldb::OptionValuePropertiesSP properties_sp;
}
bool CreateSettingForPlugin(
- Debugger &debugger, const ConstString &plugin_type_name,
- const ConstString &plugin_type_desc,
+ Debugger &debugger, ConstString plugin_type_name,
+ ConstString plugin_type_desc,
const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property,
+ ConstString description, bool is_global_property,
GetDebuggerPropertyForPluginsPtr get_debugger_property =
GetDebuggerPropertyForPlugins) {
if (properties_sp) {
} // anonymous namespace
lldb::OptionValuePropertiesSP PluginManager::GetSettingForDynamicLoaderPlugin(
- Debugger &debugger, const ConstString &setting_name) {
+ Debugger &debugger, ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name,
ConstString(kDynamicLoaderPluginName));
}
bool PluginManager::CreateSettingForDynamicLoaderPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property) {
+ ConstString description, bool is_global_property) {
return CreateSettingForPlugin(
debugger, ConstString(kDynamicLoaderPluginName),
ConstString("Settings for dynamic loader plug-ins"), properties_sp,
lldb::OptionValuePropertiesSP
PluginManager::GetSettingForPlatformPlugin(Debugger &debugger,
- const ConstString &setting_name) {
+ ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name,
ConstString(kPlatformPluginName),
GetDebuggerPropertyForPluginsOldStyle);
bool PluginManager::CreateSettingForPlatformPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property) {
+ ConstString description, bool is_global_property) {
return CreateSettingForPlugin(debugger, ConstString(kPlatformPluginName),
ConstString("Settings for platform plug-ins"),
properties_sp, description, is_global_property,
lldb::OptionValuePropertiesSP
PluginManager::GetSettingForProcessPlugin(Debugger &debugger,
- const ConstString &setting_name) {
+ ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name,
ConstString(kProcessPluginName));
}
bool PluginManager::CreateSettingForProcessPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property) {
+ ConstString description, bool is_global_property) {
return CreateSettingForPlugin(debugger, ConstString(kProcessPluginName),
ConstString("Settings for process plug-ins"),
properties_sp, description, is_global_property);
lldb::OptionValuePropertiesSP
PluginManager::GetSettingForSymbolFilePlugin(Debugger &debugger,
- const ConstString &setting_name) {
+ ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name,
ConstString(kSymbolFilePluginName));
}
bool PluginManager::CreateSettingForSymbolFilePlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property) {
+ ConstString description, bool is_global_property) {
return CreateSettingForPlugin(
debugger, ConstString(kSymbolFilePluginName),
ConstString("Settings for symbol file plug-ins"), properties_sp,
lldb::OptionValuePropertiesSP
PluginManager::GetSettingForJITLoaderPlugin(Debugger &debugger,
- const ConstString &setting_name) {
+ ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name,
ConstString(kJITLoaderPluginName));
}
bool PluginManager::CreateSettingForJITLoaderPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property) {
+ ConstString description, bool is_global_property) {
return CreateSettingForPlugin(debugger, ConstString(kJITLoaderPluginName),
ConstString("Settings for JIT loader plug-ins"),
properties_sp, description, is_global_property);
static const char *kOperatingSystemPluginName("os");
lldb::OptionValuePropertiesSP PluginManager::GetSettingForOperatingSystemPlugin(
- Debugger &debugger, const ConstString &setting_name) {
+ Debugger &debugger, ConstString setting_name) {
lldb::OptionValuePropertiesSP properties_sp;
lldb::OptionValuePropertiesSP plugin_type_properties_sp(
GetDebuggerPropertyForPlugins(
bool PluginManager::CreateSettingForOperatingSystemPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property) {
+ ConstString description, bool is_global_property) {
if (properties_sp) {
lldb::OptionValuePropertiesSP plugin_type_properties_sp(
GetDebuggerPropertyForPlugins(
}
lldb::OptionValuePropertiesSP PluginManager::GetSettingForStructuredDataPlugin(
- Debugger &debugger, const ConstString &setting_name) {
+ Debugger &debugger, ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name,
ConstString(kStructuredDataPluginName));
}
bool PluginManager::CreateSettingForStructuredDataPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
- const ConstString &description, bool is_global_property) {
+ ConstString description, bool is_global_property) {
return CreateSettingForPlugin(
debugger, ConstString(kStructuredDataPluginName),
ConstString("Settings for structured data plug-ins"), properties_sp,
m_provider = new_provider;
}
-bool RichManglingContext::FromItaniumName(const ConstString &mangled) {
+bool RichManglingContext::FromItaniumName(ConstString mangled) {
bool err = m_ipd.partialDemangle(mangled.GetCString());
if (!err) {
ResetProvider(ItaniumPartialDemangler);
return !err; // true == success
}
-bool RichManglingContext::FromCxxMethodName(const ConstString &demangled) {
+bool RichManglingContext::FromCxxMethodName(ConstString demangled) {
ResetProvider(PluginCxxLanguage);
m_cxx_method_parser = new CPlusPlusLanguage::MethodName(demangled);
return true;
}
Section::Section(const ModuleSP &module_sp, ObjectFile *obj_file,
- user_id_t sect_id, const ConstString &name,
+ user_id_t sect_id, ConstString name,
SectionType sect_type, addr_t file_addr, addr_t byte_size,
lldb::offset_t file_offset, lldb::offset_t file_size,
uint32_t log2align, uint32_t flags,
Section::Section(const lldb::SectionSP &parent_section_sp,
const ModuleSP &module_sp, ObjectFile *obj_file,
- user_id_t sect_id, const ConstString &name,
+ user_id_t sect_id, ConstString name,
SectionType sect_type, addr_t file_addr, addr_t byte_size,
lldb::offset_t file_offset, lldb::offset_t file_size,
uint32_t log2align, uint32_t flags,
}
SectionSP
-SectionList::FindSectionByName(const ConstString §ion_dstr) const {
+SectionList::FindSectionByName(ConstString section_dstr) const {
SectionSP sect_sp;
// Check if we have a valid section string
if (section_dstr && !m_sections.empty()) {
lldb::OptionValuePropertiesSP
Properties::GetSubProperty(const ExecutionContext *exe_ctx,
- const ConstString &name) {
+ ConstString name) {
OptionValuePropertiesSP properties_sp(GetValueProperties());
if (properties_sp)
return properties_sp->GetSubProperty(exe_ctx, name);
return m_error;
}
-const ConstString &ValueObject::GetName() const { return m_name; }
+ConstString ValueObject::GetName() const { return m_name; }
const char *ValueObject::GetLocationAsCString() {
return GetLocationAsCStringImpl(m_value, m_data);
return root;
}
-size_t ValueObject::GetIndexOfChildWithName(const ConstString &name) {
+size_t ValueObject::GetIndexOfChildWithName(ConstString name) {
bool omit_empty_base_classes = true;
return GetCompilerType().GetIndexOfChildWithName(name.GetCString(),
omit_empty_base_classes);
}
-ValueObjectSP ValueObject::GetChildMemberWithName(const ConstString &name,
+ValueObjectSP ValueObject::GetChildMemberWithName(ConstString name,
bool can_create) {
// when getting a child by name, it could be buried inside some base classes
// (which really aren't part of the expression path), so we need a vector of
m_children.SetChildrenCount(num_children);
}
-void ValueObject::SetName(const ConstString &name) { m_name = name; }
+void ValueObject::SetName(ConstString name) { m_name = name; }
ValueObject *ValueObject::CreateChildAtIndex(size_t idx,
bool synthetic_array_member,
return GetCompilerType().GetMinimumLanguage();
}
-void ValueObject::AddSyntheticChild(const ConstString &key,
+void ValueObject::AddSyntheticChild(ConstString key,
ValueObject *valobj) {
m_synthetic_children[key] = valobj;
}
-ValueObjectSP ValueObject::GetSyntheticChild(const ConstString &key) const {
+ValueObjectSP ValueObject::GetSyntheticChild(ConstString key) const {
ValueObjectSP synthetic_child_sp;
std::map<ConstString, ValueObject *>::const_iterator pos =
m_synthetic_children.find(key);
printer.PrintValueObject();
}
-ValueObjectSP ValueObject::CreateConstantValue(const ConstString &name) {
+ValueObjectSP ValueObject::CreateConstantValue(ConstString name) {
ValueObjectSP valobj_sp;
if (UpdateValueIfNeeded(false) && m_error.Success()) {
return ValueObjectCast::Create(*this, GetName(), compiler_type);
}
-lldb::ValueObjectSP ValueObject::Clone(const ConstString &new_name) {
+lldb::ValueObjectSP ValueObject::Clone(ConstString new_name) {
return ValueObjectCast::Create(*this, new_name, GetCompilerType());
}
using namespace lldb_private;
lldb::ValueObjectSP ValueObjectCast::Create(ValueObject &parent,
- const ConstString &name,
+ ConstString name,
const CompilerType &cast_type) {
ValueObjectCast *cast_valobj_ptr =
new ValueObjectCast(parent, name, cast_type);
return cast_valobj_ptr->GetSP();
}
-ValueObjectCast::ValueObjectCast(ValueObject &parent, const ConstString &name,
+ValueObjectCast::ValueObjectCast(ValueObject &parent, ConstString name,
const CompilerType &cast_type)
: ValueObject(parent), m_cast_type(cast_type) {
SetName(name);
ValueObjectChild::ValueObjectChild(
ValueObject &parent, const CompilerType &compiler_type,
- const ConstString &name, uint64_t byte_size, int32_t byte_offset,
+ ConstString name, uint64_t byte_size, int32_t byte_offset,
uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
bool is_base_class, bool is_deref_of_parent,
AddressType child_ptr_or_ref_addr_type, uint64_t language_flags)
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type,
- const ConstString &name,
+ ConstString name,
const DataExtractor &data,
lldb::addr_t address) {
return (new ValueObjectConstResult(exe_scope, compiler_type, name, data,
ValueObjectConstResult::ValueObjectConstResult(
ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
- const ConstString &name, const DataExtractor &data, lldb::addr_t address)
+ ConstString name, const DataExtractor &data, lldb::addr_t address)
: ValueObject(exe_scope), m_type_name(), m_byte_size(0),
m_impl(this, address) {
m_data = data;
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type,
- const ConstString &name,
+ ConstString name,
const lldb::DataBufferSP &data_sp,
lldb::ByteOrder data_byte_order,
uint32_t data_addr_size,
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
Value &value,
- const ConstString &name,
+ ConstString name,
Module *module) {
return (new ValueObjectConstResult(exe_scope, value, name, module))->GetSP();
}
ValueObjectConstResult::ValueObjectConstResult(
ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
- const ConstString &name, const lldb::DataBufferSP &data_sp,
+ ConstString name, const lldb::DataBufferSP &data_sp,
lldb::ByteOrder data_byte_order, uint32_t data_addr_size,
lldb::addr_t address)
: ValueObject(exe_scope), m_type_name(), m_byte_size(0),
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type,
- const ConstString &name,
+ ConstString name,
lldb::addr_t address,
AddressType address_type,
uint32_t addr_byte_size) {
ValueObjectConstResult::ValueObjectConstResult(
ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
- const ConstString &name, lldb::addr_t address, AddressType address_type,
+ ConstString name, lldb::addr_t address, AddressType address_type,
uint32_t addr_byte_size)
: ValueObject(exe_scope), m_type_name(), m_byte_size(0),
m_impl(this, address) {
ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
const Value &value,
- const ConstString &name,
+ ConstString name,
Module *module)
: ValueObject(exe_scope), m_type_name(), m_byte_size(0), m_impl(this) {
m_value = value;
using namespace lldb_private;
ValueObjectConstResultCast::ValueObjectConstResultCast(
- ValueObject &parent, const ConstString &name, const CompilerType &cast_type,
+ ValueObject &parent, ConstString name, const CompilerType &cast_type,
lldb::addr_t live_address)
: ValueObjectCast(parent, name, cast_type), m_impl(this, live_address) {
m_name = name;
ValueObjectConstResultChild::ValueObjectConstResultChild(
ValueObject &parent, const CompilerType &compiler_type,
- const ConstString &name, uint32_t byte_size, int32_t byte_offset,
+ ConstString name, uint32_t byte_size, int32_t byte_offset,
uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
bool is_base_class, bool is_deref_of_parent, lldb::addr_t live_address,
uint64_t language_flags)
}
lldb::ValueObjectSP
-ValueObjectRegisterSet::GetChildMemberWithName(const ConstString &name,
+ValueObjectRegisterSet::GetChildMemberWithName(ConstString name,
bool can_create) {
ValueObject *valobj = NULL;
if (m_reg_ctx_sp && m_reg_set) {
}
size_t
-ValueObjectRegisterSet::GetIndexOfChildWithName(const ConstString &name) {
+ValueObjectRegisterSet::GetIndexOfChildWithName(ConstString name) {
if (m_reg_ctx_sp && m_reg_set) {
const RegisterInfo *reg_info =
m_reg_ctx_sp->GetRegisterInfoByName(name.AsCString());
return m_backend.GetChildAtIndex(idx, true);
}
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
return m_backend.GetIndexOfChildWithName(name);
}
}
lldb::ValueObjectSP
-ValueObjectSynthetic::GetChildMemberWithName(const ConstString &name,
+ValueObjectSynthetic::GetChildMemberWithName(ConstString name,
bool can_create) {
UpdateValueIfNeeded();
return GetChildAtIndex(index, can_create);
}
-size_t ValueObjectSynthetic::GetIndexOfChildWithName(const ConstString &name) {
+size_t ValueObjectSynthetic::GetIndexOfChildWithName(ConstString name) {
UpdateValueIfNeeded();
uint32_t found_index = UINT32_MAX;
matching_category, matching_type);
}
-bool DataVisualization::Categories::GetCategory(const ConstString &category,
+bool DataVisualization::Categories::GetCategory(ConstString category,
lldb::TypeCategoryImplSP &entry,
bool allow_create) {
entry = GetFormatManager().GetCategory(category, allow_create);
return (entry.get() != nullptr);
}
-void DataVisualization::Categories::Add(const ConstString &category) {
+void DataVisualization::Categories::Add(ConstString category) {
GetFormatManager().GetCategory(category);
}
-bool DataVisualization::Categories::Delete(const ConstString &category) {
+bool DataVisualization::Categories::Delete(ConstString category) {
GetFormatManager().DisableCategory(category);
return GetFormatManager().DeleteCategory(category);
}
GetFormatManager().ClearCategories();
}
-void DataVisualization::Categories::Clear(const ConstString &category) {
+void DataVisualization::Categories::Clear(ConstString category) {
GetFormatManager().GetCategory(category)->Clear(
eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary);
}
-void DataVisualization::Categories::Enable(const ConstString &category,
+void DataVisualization::Categories::Enable(ConstString category,
TypeCategoryMap::Position pos) {
if (GetFormatManager().GetCategory(category)->IsEnabled())
GetFormatManager().DisableCategory(category);
lang_category->Enable();
}
-void DataVisualization::Categories::Disable(const ConstString &category) {
+void DataVisualization::Categories::Disable(ConstString category) {
if (GetFormatManager().GetCategory(category)->IsEnabled())
GetFormatManager().DisableCategory(category);
}
}
bool DataVisualization::NamedSummaryFormats::GetSummaryFormat(
- const ConstString &type, lldb::TypeSummaryImplSP &entry) {
+ ConstString type, lldb::TypeSummaryImplSP &entry) {
return GetFormatManager().GetNamedSummaryContainer().Get(type, entry);
}
void DataVisualization::NamedSummaryFormats::Add(
- const ConstString &type, const lldb::TypeSummaryImplSP &entry) {
+ ConstString type, const lldb::TypeSummaryImplSP &entry) {
GetFormatManager().GetNamedSummaryContainer().Add(
FormatManager::GetValidTypeName(type), entry);
}
-bool DataVisualization::NamedSummaryFormats::Delete(const ConstString &type) {
+bool DataVisualization::NamedSummaryFormats::Delete(ConstString type) {
return GetFormatManager().GetNamedSummaryContainer().Delete(type);
}
{
}
-FormatCache::Entry &FormatCache::GetEntry(const ConstString &type) {
+FormatCache::Entry &FormatCache::GetEntry(ConstString type) {
auto i = m_map.find(type), e = m_map.end();
if (i != e)
return i->second;
return m_map[type];
}
-bool FormatCache::GetFormat(const ConstString &type,
+bool FormatCache::GetFormat(ConstString type,
lldb::TypeFormatImplSP &format_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type);
return false;
}
-bool FormatCache::GetSummary(const ConstString &type,
+bool FormatCache::GetSummary(ConstString type,
lldb::TypeSummaryImplSP &summary_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type);
return false;
}
-bool FormatCache::GetSynthetic(const ConstString &type,
+bool FormatCache::GetSynthetic(ConstString type,
lldb::SyntheticChildrenSP &synthetic_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type);
return false;
}
-bool FormatCache::GetValidator(const ConstString &type,
+bool FormatCache::GetValidator(ConstString type,
lldb::TypeValidatorImplSP &validator_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type);
return false;
}
-void FormatCache::SetFormat(const ConstString &type,
+void FormatCache::SetFormat(ConstString type,
lldb::TypeFormatImplSP &format_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetFormat(format_sp);
}
-void FormatCache::SetSummary(const ConstString &type,
+void FormatCache::SetSummary(ConstString type,
lldb::TypeSummaryImplSP &summary_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetSummary(summary_sp);
}
-void FormatCache::SetSynthetic(const ConstString &type,
+void FormatCache::SetSynthetic(ConstString type,
lldb::SyntheticChildrenSP &synthetic_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetSynthetic(synthetic_sp);
}
-void FormatCache::SetValidator(const ConstString &type,
+void FormatCache::SetValidator(ConstString type,
lldb::TypeValidatorImplSP &validator_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetValidator(validator_sp);
}
lldb::TypeCategoryImplSP
-FormatManager::GetCategory(const ConstString &category_name, bool can_create) {
+FormatManager::GetCategory(ConstString category_name, bool can_create) {
if (!category_name)
return GetCategory(m_default_category_name);
lldb::TypeCategoryImplSP category;
return true;
}
-ConstString FormatManager::GetValidTypeName(const ConstString &type) {
+ConstString FormatManager::GetValidTypeName(ConstString type) {
return ::GetValidTypeName_Impl(type);
}
}
size_t
-TypeFilterImpl::FrontEnd::GetIndexOfChildWithName(const ConstString &name) {
+TypeFilterImpl::FrontEnd::GetIndexOfChildWithName(ConstString name) {
const char *name_cstr = name.GetCString();
if (name_cstr) {
for (size_t i = 0; i < filter->GetCount(); i++) {
}
size_t ScriptedSyntheticChildren::FrontEnd::GetIndexOfChildWithName(
- const ConstString &name) {
+ ConstString name) {
if (!m_wrapper_sp || m_interpreter == NULL)
return UINT32_MAX;
return m_interpreter->GetIndexOfChildWithName(m_wrapper_sp,
bool MightHaveChildren() override { return true; }
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren())
PersistentExpressionState::~PersistentExpressionState() {}
-lldb::addr_t PersistentExpressionState::LookupSymbol(const ConstString &name) {
+lldb::addr_t PersistentExpressionState::LookupSymbol(ConstString name) {
SymbolMap::iterator si = m_symbol_map.find(name.GetCString());
if (si != m_symbol_map.end())
}
}
-void IRExecutionUnit::ReportSymbolLookupError(const ConstString &name) {
+void IRExecutionUnit::ReportSymbolLookupError(ConstString name) {
m_failed_lookups.push_back(name);
}
bool emitNewLine = false;
- for (const ConstString &failed_lookup : m_failed_lookups) {
+ for (ConstString failed_lookup : m_failed_lookups) {
if (emitNewLine)
ss.PutCString("\n");
emitNewLine = true;
}
static ConstString
-FindBestAlternateMangledName(const ConstString &demangled,
+FindBestAlternateMangledName(ConstString demangled,
const lldb::LanguageType &lang_type,
const SymbolContext &sym_ctx) {
CPlusPlusLanguage::MethodName cpp_name(demangled);
void IRExecutionUnit::CollectCandidateCNames(
std::vector<IRExecutionUnit::SearchSpec> &C_specs,
- const ConstString &name) {
+ ConstString name) {
if (m_strip_underscore && name.AsCString()[0] == '_')
C_specs.insert(C_specs.begin(), ConstString(&name.AsCString()[1]));
C_specs.push_back(SearchSpec(name));
std::vector<IRExecutionUnit::SearchSpec> &CPP_specs,
const std::vector<SearchSpec> &C_specs, const SymbolContext &sc) {
for (const SearchSpec &C_spec : C_specs) {
- const ConstString &name = C_spec.name;
+ ConstString name = C_spec.name;
if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
Mangled mangled(name, true);
// but the DWARF doesn't always encode "extern C" correctly.
for (const SearchSpec &C_spec : C_specs) {
- const ConstString &name = C_spec.name;
+ ConstString name = C_spec.name;
if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
Mangled mangled_name(name);
}
lldb::addr_t
-IRExecutionUnit::FindSymbol(const lldb_private::ConstString &name) {
+IRExecutionUnit::FindSymbol(lldb_private::ConstString name) {
std::vector<SearchSpec> candidate_C_names;
std::vector<SearchSpec> candidate_CPlusPlus_names;
bool FileSystem::ResolveExecutableLocation(FileSpec &file_spec) {
// If the directory is set there's nothing to do.
- const ConstString &directory = file_spec.GetDirectory();
+ ConstString directory = file_spec.GetDirectory();
if (directory)
return false;
// We cannot look for a file if there's no file name.
- const ConstString &filename = file_spec.GetFilename();
+ ConstString filename = file_spec.GetFilename();
if (!filename)
return false;
}
lldb::OptionValueSP
-OptionValueDictionary::GetValueForKey(const ConstString &key) const {
+OptionValueDictionary::GetValueForKey(ConstString key) const {
lldb::OptionValueSP value_sp;
collection::const_iterator pos = m_values.find(key);
if (pos != m_values.end())
return value_sp;
}
-bool OptionValueDictionary::SetValueForKey(const ConstString &key,
+bool OptionValueDictionary::SetValueForKey(ConstString key,
const lldb::OptionValueSP &value_sp,
bool can_replace) {
// Make sure the value_sp object is allowed to contain values of the type
return false;
}
-bool OptionValueDictionary::DeleteValueForKey(const ConstString &key) {
+bool OptionValueDictionary::DeleteValueForKey(ConstString key) {
collection::iterator pos = m_values.find(key);
if (pos != m_values.end()) {
m_values.erase(pos);
using namespace lldb;
using namespace lldb_private;
-OptionValueProperties::OptionValueProperties(const ConstString &name)
+OptionValueProperties::OptionValueProperties(ConstString name)
: OptionValue(), m_name(name), m_properties(), m_name_to_index() {}
OptionValueProperties::OptionValueProperties(
property->SetValueChangedCallback(callback, baton);
}
-void OptionValueProperties::AppendProperty(const ConstString &name,
- const ConstString &desc,
+void OptionValueProperties::AppendProperty(ConstString name,
+ ConstString desc,
bool is_global,
const OptionValueSP &value_sp) {
Property property(name, desc, is_global, value_sp);
//
lldb::OptionValueSP
OptionValueProperties::GetValueForKey(const ExecutionContext *exe_ctx,
- const ConstString &key,
+ ConstString key,
bool will_modify) const {
lldb::OptionValueSP value_sp;
size_t idx = m_name_to_index.Find(key, SIZE_MAX);
}
uint32_t
-OptionValueProperties::GetPropertyIndex(const ConstString &name) const {
+OptionValueProperties::GetPropertyIndex(ConstString name) const {
return m_name_to_index.Find(name, SIZE_MAX);
}
const Property *
OptionValueProperties::GetProperty(const ExecutionContext *exe_ctx,
bool will_modify,
- const ConstString &name) const {
+ ConstString name) const {
return GetPropertyAtIndex(
exe_ctx, will_modify,
m_name_to_index.Find(name, SIZE_MAX));
lldb::OptionValuePropertiesSP
OptionValueProperties::GetSubProperty(const ExecutionContext *exe_ctx,
- const ConstString &name) {
+ ConstString name) {
lldb::OptionValueSP option_value_sp(GetValueForKey(exe_ctx, name, false));
if (option_value_sp) {
OptionValueProperties *ov_properties = option_value_sp->GetAsProperties();
}
}
-Property::Property(const ConstString &name, const ConstString &desc,
+Property::Property(ConstString name, ConstString desc,
bool is_global, const lldb::OptionValueSP &value_sp)
: m_name(name), m_description(desc), m_value_sp(value_sp),
m_is_global(is_global) {}
for (size_t i = 0; i < symtab->GetNumSymbols(); i++) {
const Symbol *sym = symtab->SymbolAtIndex(i);
assert(sym != nullptr);
- const ConstString &symName = sym->GetName();
+ ConstString symName = sym->GetName();
if (ConstString::Compare(findName, symName) == 0) {
Address addr = sym->GetAddress();
}
const DynamicLoaderDarwin::Segment *
-DynamicLoaderDarwin::ImageInfo::FindSegment(const ConstString &name) const {
+DynamicLoaderDarwin::ImageInfo::FindSegment(ConstString name) const {
const size_t num_segments = segments.size();
for (size_t i = 0; i < num_segments; ++i) {
if (segments[i].name == name)
std::vector<Address> addresses;
if (current_symbol->IsTrampoline()) {
- const ConstString &trampoline_name = current_symbol->GetMangled().GetName(
+ ConstString trampoline_name = current_symbol->GetMangled().GetName(
current_symbol->GetLanguage(), Mangled::ePreferMangled);
if (trampoline_name) {
size_t DynamicLoaderDarwin::FindEquivalentSymbols(
lldb_private::Symbol *original_symbol, lldb_private::ModuleList &images,
lldb_private::SymbolContextList &equivalent_symbols) {
- const ConstString &trampoline_name = original_symbol->GetMangled().GetName(
+ ConstString trampoline_name = original_symbol->GetMangled().GetName(
original_symbol->GetLanguage(), Mangled::ePreferMangled);
if (!trampoline_name)
return 0;
header.cputype, header.cpusubtype);
}
- const Segment *FindSegment(const lldb_private::ConstString &name) const;
+ const Segment *FindSegment(lldb_private::ConstString name) const;
void PutToLog(lldb_private::Log *log) const;
}
void ClangASTSource::CompleteNamespaceMap(
- ClangASTImporter::NamespaceMapSP &namespace_map, const ConstString &name,
+ ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name,
ClangASTImporter::NamespaceMapSP &parent_map) const {
static unsigned int invocation_id = 0;
unsigned int current_id = invocation_id++;
/// one.
//------------------------------------------------------------------
void CompleteNamespaceMap(
- ClangASTImporter::NamespaceMapSP &namespace_map, const ConstString &name,
+ ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name,
ClangASTImporter::NamespaceMapSP &parent_map) const override;
//
}
bool ClangExpressionDeclMap::AddPersistentVariable(const NamedDecl *decl,
- const ConstString &name,
+ ConstString name,
TypeFromParser parser_type,
bool is_result,
bool is_lvalue) {
}
bool ClangExpressionDeclMap::AddValueToStruct(const NamedDecl *decl,
- const ConstString &name,
+ ConstString name,
llvm::Value *value, size_t size,
lldb::offset_t alignment) {
assert(m_struct_vars.get());
addr_t ClangExpressionDeclMap::GetSymbolAddress(Target &target,
Process *process,
- const ConstString &name,
+ ConstString name,
lldb::SymbolType symbol_type,
lldb_private::Module *module) {
SymbolContextList sc_list;
return symbol_load_addr;
}
-addr_t ClangExpressionDeclMap::GetSymbolAddress(const ConstString &name,
+addr_t ClangExpressionDeclMap::GetSymbolAddress(ConstString name,
lldb::SymbolType symbol_type) {
assert(m_parser_vars.get());
}
lldb::VariableSP ClangExpressionDeclMap::FindGlobalVariable(
- Target &target, ModuleSP &module, const ConstString &name,
+ Target &target, ModuleSP &module, ConstString name,
CompilerDeclContext *namespace_decl, TypeFromUser *type) {
VariableList vars;
/// True on success; false otherwise.
//------------------------------------------------------------------
bool AddPersistentVariable(const clang::NamedDecl *decl,
- const ConstString &name, TypeFromParser type,
+ ConstString name, TypeFromParser type,
bool is_result, bool is_lvalue);
//------------------------------------------------------------------
/// @return
/// True on success; false otherwise.
//------------------------------------------------------------------
- bool AddValueToStruct(const clang::NamedDecl *decl, const ConstString &name,
+ bool AddValueToStruct(const clang::NamedDecl *decl, ConstString name,
llvm::Value *value, size_t size,
lldb::offset_t alignment);
/// Valid load address for the symbol
//------------------------------------------------------------------
lldb::addr_t GetSymbolAddress(Target &target, Process *process,
- const ConstString &name,
+ ConstString name,
lldb::SymbolType symbol_type,
Module *module = NULL);
- lldb::addr_t GetSymbolAddress(const ConstString &name,
+ lldb::addr_t GetSymbolAddress(ConstString name,
lldb::SymbolType symbol_type);
//------------------------------------------------------------------
/// The LLDB Variable found, or NULL if none was found.
//------------------------------------------------------------------
lldb::VariableSP FindGlobalVariable(Target &target, lldb::ModuleSP &module,
- const ConstString &name,
+ ConstString name,
CompilerDeclContext *namespace_decl,
TypeFromUser *type = NULL);
}
ClangExpressionVariable::ClangExpressionVariable(
- ExecutionContextScope *exe_scope, Value &value, const ConstString &name,
+ ExecutionContextScope *exe_scope, Value &value, ConstString name,
uint16_t flags)
: ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(),
m_jit_vars() {
}
ClangExpressionVariable::ClangExpressionVariable(
- ExecutionContextScope *exe_scope, const ConstString &name,
+ ExecutionContextScope *exe_scope, ConstString name,
const TypeFromUser &user_type, lldb::ByteOrder byte_order,
uint32_t addr_byte_size)
: ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(),
lldb::ByteOrder byte_order, uint32_t addr_byte_size);
ClangExpressionVariable(ExecutionContextScope *exe_scope, Value &value,
- const ConstString &name, uint16_t flags = EVNone);
+ ConstString name, uint16_t flags = EVNone);
ClangExpressionVariable(const lldb::ValueObjectSP &valobj_sp);
ClangExpressionVariable(ExecutionContextScope *exe_scope,
- const ConstString &name,
+ ConstString name,
const TypeFromUser &user_type,
lldb::ByteOrder byte_order, uint32_t addr_byte_size);
bool AddModulesForCompileUnit(CompileUnit &cu, ModuleVector &exported_modules,
Stream &error_stream) override;
- uint32_t FindDecls(const ConstString &name, bool append, uint32_t max_matches,
+ uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
std::vector<clang::NamedDecl *> &decls) override;
void ForEachMacro(const ModuleVector &modules,
// ClangImporter::lookupValue
uint32_t
-ClangModulesDeclVendorImpl::FindDecls(const ConstString &name, bool append,
+ClangModulesDeclVendorImpl::FindDecls(ConstString name, bool append,
uint32_t max_matches,
std::vector<clang::NamedDecl *> &decls) {
if (!m_enabled) {
}
ExpressionVariableSP ClangPersistentVariables::CreatePersistentVariable(
- ExecutionContextScope *exe_scope, const ConstString &name,
+ ExecutionContextScope *exe_scope, ConstString name,
const CompilerType &compiler_type, lldb::ByteOrder byte_order,
uint32_t addr_byte_size) {
return AddNewlyConstructedVariable(new ClangExpressionVariable(
m_next_persistent_variable_id--;
}
-void ClangPersistentVariables::RegisterPersistentDecl(const ConstString &name,
+void ClangPersistentVariables::RegisterPersistentDecl(ConstString name,
clang::NamedDecl *decl) {
m_persistent_decls.insert(
std::pair<const char *, clang::NamedDecl *>(name.GetCString(), decl));
}
clang::NamedDecl *
-ClangPersistentVariables::GetPersistentDecl(const ConstString &name) {
+ClangPersistentVariables::GetPersistentDecl(ConstString name) {
PersistentDeclMap::const_iterator i =
m_persistent_decls.find(name.GetCString());
CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) override;
lldb::ExpressionVariableSP CreatePersistentVariable(
- ExecutionContextScope *exe_scope, const ConstString &name,
+ ExecutionContextScope *exe_scope, ConstString name,
const CompilerType &compiler_type, lldb::ByteOrder byte_order,
uint32_t addr_byte_size) override;
return "$";
}
- void RegisterPersistentDecl(const ConstString &name, clang::NamedDecl *decl);
+ void RegisterPersistentDecl(ConstString name, clang::NamedDecl *decl);
- clang::NamedDecl *GetPersistentDecl(const ConstString &name);
+ clang::NamedDecl *GetPersistentDecl(ConstString name);
void AddHandLoadedClangModule(ClangModulesDeclVendor::ModuleID module) {
m_hand_loaded_clang_modules.push_back(module);
/// The Clang type of the result variable.
//------------------------------------------------------------------
void MaybeSetConstantResult(llvm::Constant *initializer,
- const lldb_private::ConstString &name,
+ lldb_private::ConstString name,
lldb_private::TypeFromParser type);
//------------------------------------------------------------------
}
addr_t JITLoaderGDB::GetSymbolAddress(ModuleList &module_list,
- const ConstString &name,
+ ConstString name,
SymbolType symbol_type) const {
SymbolContextList target_symbols;
Target &target = m_process->GetTarget();
private:
lldb::addr_t GetSymbolAddress(lldb_private::ModuleList &module_list,
- const lldb_private::ConstString &name,
+ lldb_private::ConstString name,
lldb::SymbolType symbol_type) const;
void SetJITBreakpoint(lldb_private::ModuleList &module_list);
// maybe return false if the block pointer is, say, null
bool MightHaveChildren() override { return true; }
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
if (!m_block_struct_type.IsValid())
return UINT32_MAX;
: m_full(), m_basename(), m_context(), m_arguments(), m_qualifiers(),
m_parsed(false), m_parse_error(false) {}
- MethodName(const ConstString &s)
+ MethodName(ConstString s)
: m_full(s), m_basename(), m_context(), m_arguments(), m_qualifiers(),
m_parsed(false), m_parse_error(false) {}
return (bool)m_full;
}
- const ConstString &GetFullName() const { return m_full; }
+ ConstString GetFullName() const { return m_full; }
std::string GetScopeQualifiedName();
}
size_t lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::
- GetIndexOfChildWithName(const ConstString &name) {
+ GetIndexOfChildWithName(ConstString name) {
if (name == ConstString("first"))
return 0;
if (name == ConstString("second"))
}
size_t lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::
- GetIndexOfChildWithName(const ConstString &name) {
+ GetIndexOfChildWithName(ConstString name) {
if (name == ConstString("__ptr_"))
return 0;
if (name == ConstString("count"))
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
~LibCxxMapIteratorSyntheticFrontEnd() override;
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
~LibcxxSharedPtrSyntheticFrontEnd() override;
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
lldb::ValueObjectSP GetSyntheticValue() override;
}
size_t lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::
- GetIndexOfChildWithName(const ConstString &name) {
+ GetIndexOfChildWithName(ConstString name) {
return m_real_child ? m_real_child->GetIndexOfChildWithName(name)
: UINT32_MAX;
}
public:
BitsetFrontEnd(ValueObject &valobj);
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
return formatters::ExtractIndexFromString(name.GetCString());
}
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
ValueObject *m_start;
}
size_t lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
- GetIndexOfChildWithName(const ConstString &name) {
+ GetIndexOfChildWithName(ConstString name) {
if (!m_start)
return UINT32_MAX;
return ExtractIndexFromString(name.GetCString());
class AbstractListFrontEnd : public SyntheticChildrenFrontEnd {
public:
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
return ExtractIndexFromString(name.GetCString());
}
bool MightHaveChildren() override { return true; }
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
bool GetDataType();
}
size_t lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
- GetIndexOfChildWithName(const ConstString &name) {
+ GetIndexOfChildWithName(ConstString name) {
return ExtractIndexFromString(name.GetCString());
}
Update();
}
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
return formatters::ExtractIndexFromString(name.GetCString());
}
Update();
}
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
return m_container_sp ? m_container_sp->GetIndexOfChildWithName(name)
: UINT32_MAX;
}
Update();
}
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
return formatters::ExtractIndexFromString(name.GetCString());
}
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
CompilerType m_element_type;
}
size_t lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::
- GetIndexOfChildWithName(const ConstString &name) {
+ GetIndexOfChildWithName(ConstString name) {
return ExtractIndexFromString(name.GetCString());
}
Update();
}
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
return formatters::ExtractIndexFromString(name.GetCString());
}
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
ValueObject *m_start;
bool MightHaveChildren() override { return true; }
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
CompilerType m_bool_type;
}
size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
- GetIndexOfChildWithName(const ConstString &name) {
+ GetIndexOfChildWithName(ConstString name) {
if (!m_start || !m_finish)
return UINT32_MAX;
return ExtractIndexFromString(name.GetCString());
}
size_t lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
- GetIndexOfChildWithName(const ConstString &name) {
+ GetIndexOfChildWithName(ConstString name) {
if (!m_count || !m_base_data_address)
return UINT32_MAX;
const char *item_name = name.GetCString();
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
ExecutionContextRef m_exe_ctx_ref;
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
};
} // end of anonymous namespace
bool LibstdcppMapIteratorSyntheticFrontEnd::MightHaveChildren() { return true; }
size_t LibstdcppMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName(
- const ConstString &name) {
+ ConstString name) {
if (name == ConstString("first"))
return 0;
if (name == ConstString("second"))
bool VectorIteratorSyntheticFrontEnd::MightHaveChildren() { return true; }
size_t VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName(
- const ConstString &name) {
+ ConstString name) {
if (name == ConstString("item"))
return 0;
return UINT32_MAX;
bool LibStdcppSharedPtrSyntheticFrontEnd::MightHaveChildren() { return true; }
size_t LibStdcppSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName(
- const ConstString &name) {
+ ConstString name) {
if (name == ConstString("_M_ptr"))
return 0;
return UINT32_MAX;
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
std::vector<ValueObjectSP> m_members;
}
size_t LibStdcppTupleSyntheticFrontEnd::GetIndexOfChildWithName(
- const ConstString &name) {
+ ConstString name) {
return ExtractIndexFromString(name.GetCString());
}
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
bool GetSummary(Stream &stream, const TypeSummaryOptions &options);
}
size_t LibStdcppUniquePtrSyntheticFrontEnd::GetIndexOfChildWithName(
- const ConstString &name) {
+ ConstString name) {
if (name == ConstString("ptr") || name == ConstString("pointer"))
return 0;
if (name == ConstString("del") || name == ConstString("deleter"))
bool MightHaveChildren() override { return false; }
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
return UINT32_MAX;
}
};
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
protected:
virtual lldb::addr_t GetDataAddress() = 0;
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
ExecutionContextRef m_exe_ctx_ref;
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
};
class NSArray1SyntheticFrontEnd : public SyntheticChildrenFrontEnd {
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
};
} // namespace formatters
} // namespace lldb_private
size_t
lldb_private::formatters::NSArrayMSyntheticFrontEndBase::GetIndexOfChildWithName(
- const ConstString &name) {
+ ConstString name) {
const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren())
template <typename D32, typename D64, bool Inline>
size_t
lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
- GetIndexOfChildWithName(const ConstString &name) {
+ GetIndexOfChildWithName(ConstString name) {
const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren())
size_t
lldb_private::formatters::NSArray0SyntheticFrontEnd::GetIndexOfChildWithName(
- const ConstString &name) {
+ ConstString name) {
return UINT32_MAX;
}
size_t
lldb_private::formatters::NSArray1SyntheticFrontEnd::GetIndexOfChildWithName(
- const ConstString &name) {
+ ConstString name) {
static const ConstString g_zero("[0]");
if (name == g_zero)
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
struct DataDescriptor_32 {
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
ValueObjectSP m_pair;
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
struct DictionaryItemDescriptor {
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
struct DataDescriptor_32 {
}
size_t lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
- GetIndexOfChildWithName(const ConstString &name) {
+ GetIndexOfChildWithName(ConstString name) {
const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren())
: SyntheticChildrenFrontEnd(*valobj_sp.get()), m_pair(nullptr) {}
size_t lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
- GetIndexOfChildWithName(const ConstString &name) {
+ GetIndexOfChildWithName(ConstString name) {
static const ConstString g_zero("[0]");
return name == g_zero ? 0 : UINT32_MAX;
}
template <typename D32, typename D64>
size_t
-lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>:: GetIndexOfChildWithName(const ConstString &name) {
+lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>:: GetIndexOfChildWithName(ConstString name) {
const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren())
size_t
lldb_private::formatters::Foundation1100::
- NSDictionaryMSyntheticFrontEnd::GetIndexOfChildWithName(const ConstString &name) {
+ NSDictionaryMSyntheticFrontEnd::GetIndexOfChildWithName(ConstString name) {
const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren())
bool MightHaveChildren() override { return true; }
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
static ConstString g___userInfo("_userInfo");
if (name == g___userInfo)
return 0;
bool MightHaveChildren() override { return true; }
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
// NSException has 4 members:
// NSString *name;
// NSString *reason;
bool MightHaveChildren() override { return m_impl.m_mode != Mode::Invalid; }
- size_t GetIndexOfChildWithName(const ConstString &name) override {
+ size_t GetIndexOfChildWithName(ConstString name) override {
const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren())
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
struct DataDescriptor_32 {
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
private:
bool MightHaveChildren() override;
- size_t GetIndexOfChildWithName(const ConstString &name) override;
+ size_t GetIndexOfChildWithName(ConstString name) override;
};
} // namespace formatters
} // namespace lldb_private
size_t
lldb_private::formatters::NSSetISyntheticFrontEnd::GetIndexOfChildWithName(
- const ConstString &name) {
+ ConstString name) {
const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren())
size_t
lldb_private::formatters::
GenericNSSetMSyntheticFrontEnd<D32, D64>::GetIndexOfChildWithName(
- const ConstString &name) {
+ ConstString name) {
const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return SetName(llvm::StringRef(name), strict);
}
-const ConstString &ObjCLanguage::MethodName::GetClassName() {
+ConstString ObjCLanguage::MethodName::GetClassName() {
if (!m_class) {
if (IsValid(false)) {
const char *full = m_full.GetCString();
return m_class;
}
-const ConstString &ObjCLanguage::MethodName::GetClassNameWithCategory() {
+ConstString ObjCLanguage::MethodName::GetClassNameWithCategory() {
if (!m_class_category) {
if (IsValid(false)) {
const char *full = m_full.GetCString();
return m_class_category;
}
-const ConstString &ObjCLanguage::MethodName::GetSelector() {
+ConstString ObjCLanguage::MethodName::GetSelector() {
if (!m_selector) {
if (IsValid(false)) {
const char *full = m_full.GetCString();
return m_selector;
}
-const ConstString &ObjCLanguage::MethodName::GetCategory() {
+ConstString ObjCLanguage::MethodName::GetCategory() {
if (!m_category_is_valid && !m_category) {
if (IsValid(false)) {
m_category_is_valid = true;
StreamString strm;
const bool is_class_method = m_type == eTypeClassMethod;
const bool is_instance_method = m_type == eTypeInstanceMethod;
- const ConstString &category = GetCategory();
+ ConstString category = GetCategory();
if (is_class_method || is_instance_method) {
names.push_back(m_full);
if (category) {
names.emplace_back(strm.GetString());
}
} else {
- const ConstString &class_name = GetClassName();
- const ConstString &selector = GetSelector();
+ ConstString class_name = GetClassName();
+ ConstString selector = GetSelector();
strm.Printf("+[%s %s]", class_name.GetCString(), selector.GetCString());
names.emplace_back(strm.GetString());
strm.Clear();
Type GetType() const { return m_type; }
- const ConstString &GetFullName() const { return m_full; }
+ ConstString GetFullName() const { return m_full; }
ConstString GetFullNameWithoutCategory(bool empty_if_no_category);
bool SetName(const char *name, bool strict);
bool SetName(llvm::StringRef name, bool strict);
- const ConstString &GetClassName();
+ ConstString GetClassName();
- const ConstString &GetClassNameWithCategory();
+ ConstString GetClassNameWithCategory();
- const ConstString &GetCategory();
+ ConstString GetCategory();
- const ConstString &GetSelector();
+ ConstString GetSelector();
// Get all possible names for a method. Examples:
// If name is "+[NSString(my_additions) myStringWithCString:]"
if (!descriptor)
return NULL;
- const ConstString &name(descriptor->GetClassName());
+ ConstString name(descriptor->GetClassName());
clang::IdentifierInfo &identifier_info =
ast_ctx->Idents.get(name.GetStringRef());
}
uint32_t
-AppleObjCDeclVendor::FindDecls(const ConstString &name, bool append,
+AppleObjCDeclVendor::FindDecls(ConstString name, bool append,
uint32_t max_matches,
std::vector<clang::NamedDecl *> &decls) {
static unsigned int invocation_id = 0;
public:
AppleObjCDeclVendor(ObjCLanguageRuntime &runtime);
- uint32_t FindDecls(const ConstString &name, bool append, uint32_t max_matches,
+ uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
std::vector<clang::NamedDecl *> &decls) override;
clang::ExternalASTMerger::ImporterSource GetImporterSource() override;
return m_decl_vendor_up.get();
}
-lldb::addr_t AppleObjCRuntimeV2::LookupRuntimeSymbol(const ConstString &name) {
+lldb::addr_t AppleObjCRuntimeV2::LookupRuntimeSymbol(ConstString name) {
lldb::addr_t ret = LLDB_INVALID_ADDRESS;
const char *name_cstr = name.AsCString();
DeclVendor *GetDeclVendor() override;
- lldb::addr_t LookupRuntimeSymbol(const ConstString &name) override;
+ lldb::addr_t LookupRuntimeSymbol(ConstString name) override;
EncodingToTypeSP GetEncodingToType() override;
array_size; // Number of items in array, only needed for structs
ConstString type_name; // Name of type, only needed for structs
- static const ConstString &
+ static ConstString
GetFallbackStructName(); // Print this as the type name of a struct Element
// If we can't resolve the actual struct name
}
};
-const ConstString &RenderScriptRuntime::Element::GetFallbackStructName() {
+ConstString RenderScriptRuntime::Element::GetFallbackStructName() {
static const ConstString FallbackStructName("struct");
return FallbackStructName;
}
size_diff);
for (uint32_t i = 0; i < size_diff; ++i) {
- const ConstString &name = elem.children[num_children + i].type_name;
+ ConstString name = elem.children[num_children + i].type_name;
if (strcmp(name.AsCString(), "#rs_padding") < 0)
found = false;
}
// Given the name of a kernel this function creates a breakpoint using our own
// breakpoint resolver, and returns the Breakpoint shared pointer.
BreakpointSP
-RenderScriptRuntime::CreateKernelBreakpoint(const ConstString &name) {
+RenderScriptRuntime::CreateKernelBreakpoint(ConstString name) {
Log *log(
GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
}
BreakpointSP
-RenderScriptRuntime::CreateReductionBreakpoint(const ConstString &name,
+RenderScriptRuntime::CreateReductionBreakpoint(ConstString name,
int kernel_types) {
Log *log(
GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
}
BreakpointSP
-RenderScriptRuntime::CreateScriptGroupBreakpoint(const ConstString &name,
+RenderScriptRuntime::CreateScriptGroupBreakpoint(ConstString name,
bool stop_on_all) {
Log *log(
GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
bool RenderScriptRuntime::PlaceBreakpointOnScriptGroup(TargetSP target,
Stream &strm,
- const ConstString &name,
+ ConstString name,
bool multi) {
InitSearchFilter(target);
BreakpointSP bp = CreateScriptGroupBreakpoint(name, multi);
class RSScriptGroupBreakpointResolver : public BreakpointResolver {
public:
- RSScriptGroupBreakpointResolver(Breakpoint *bp, const ConstString &name,
+ RSScriptGroupBreakpointResolver(Breakpoint *bp, ConstString name,
const RSScriptGroupList &groups,
bool stop_on_all)
: BreakpointResolver(bp, BreakpointResolver::NameResolver),
protected:
const RSScriptGroupDescriptorSP
- FindScriptGroup(const ConstString &name) const {
+ FindScriptGroup(ConstString name) const {
for (auto sg : m_script_groups) {
if (ConstString::Compare(sg->m_name, name) == 0)
return sg;
int kernel_types = ~(0));
bool PlaceBreakpointOnScriptGroup(lldb::TargetSP target, Stream &strm,
- const ConstString &name, bool stop_on_all);
+ ConstString name, bool stop_on_all);
void SetBreakAllKernels(bool do_break, lldb::TargetSP target);
return m_scriptGroups;
};
- bool IsKnownKernel(const ConstString &name) {
+ bool IsKnownKernel(ConstString name) {
for (const auto &module : m_rsmodules)
for (const auto &kernel : module->m_kernels)
if (kernel.m_name == name)
bool EvalRSExpression(const char *expression, StackFrame *frame_ptr,
uint64_t *result);
- lldb::BreakpointSP CreateScriptGroupBreakpoint(const ConstString &name,
+ lldb::BreakpointSP CreateScriptGroupBreakpoint(ConstString name,
bool multi);
- lldb::BreakpointSP CreateKernelBreakpoint(const ConstString &name);
+ lldb::BreakpointSP CreateKernelBreakpoint(ConstString name);
- lldb::BreakpointSP CreateReductionBreakpoint(const ConstString &name,
+ lldb::BreakpointSP CreateReductionBreakpoint(ConstString name,
int kernel_types);
void BreakOnModuleKernels(
ObjectContainerBSDArchive::Object *
ObjectContainerBSDArchive::Archive::FindObject(
- const ConstString &object_name,
+ ConstString object_name,
const llvm::sys::TimePoint<> &object_mod_time) {
const ObjectNameToIndexMap::Entry *match =
m_object_name_to_index_map.FindFirstValueForName(object_name);
size_t ParseObjects();
- Object *FindObject(const lldb_private::ConstString &object_name,
+ Object *FindObject(lldb_private::ConstString object_name,
const llvm::sys::TimePoint<> &object_mod_time);
lldb::offset_t GetFileOffset() const { return m_file_offset; }
if (symbol_type == eSymbolTypeInvalid && symbol.getType() != STT_SECTION) {
if (symbol_section_sp) {
- const ConstString §_name = symbol_section_sp->GetName();
+ ConstString sect_name = symbol_section_sp->GetName();
if (sect_name == text_section_name || sect_name == init_section_name ||
sect_name == fini_section_name || sect_name == ctors_section_name ||
sect_name == dtors_section_name) {
if (symbol_section_sp && module_section_list &&
module_section_list != section_list) {
- const ConstString §_name = symbol_section_sp->GetName();
+ ConstString sect_name = symbol_section_sp->GetName();
auto section_it = section_name_to_section.find(sect_name.GetCString());
if (section_it == section_name_to_section.end())
section_it =
return specs.GetSize() - initial_count;
}
-const ConstString &ObjectFileMachO::GetSegmentNameTEXT() {
+ConstString ObjectFileMachO::GetSegmentNameTEXT() {
static ConstString g_segment_name_TEXT("__TEXT");
return g_segment_name_TEXT;
}
-const ConstString &ObjectFileMachO::GetSegmentNameDATA() {
+ConstString ObjectFileMachO::GetSegmentNameDATA() {
static ConstString g_segment_name_DATA("__DATA");
return g_segment_name_DATA;
}
-const ConstString &ObjectFileMachO::GetSegmentNameDATA_DIRTY() {
+ConstString ObjectFileMachO::GetSegmentNameDATA_DIRTY() {
static ConstString g_segment_name("__DATA_DIRTY");
return g_segment_name;
}
-const ConstString &ObjectFileMachO::GetSegmentNameDATA_CONST() {
+ConstString ObjectFileMachO::GetSegmentNameDATA_CONST() {
static ConstString g_segment_name("__DATA_CONST");
return g_segment_name;
}
-const ConstString &ObjectFileMachO::GetSegmentNameOBJC() {
+ConstString ObjectFileMachO::GetSegmentNameOBJC() {
static ConstString g_segment_name_OBJC("__OBJC");
return g_segment_name_OBJC;
}
-const ConstString &ObjectFileMachO::GetSegmentNameLINKEDIT() {
+ConstString ObjectFileMachO::GetSegmentNameLINKEDIT() {
static ConstString g_section_name_LINKEDIT("__LINKEDIT");
return g_section_name_LINKEDIT;
}
-const ConstString &ObjectFileMachO::GetSegmentNameDWARF() {
+ConstString ObjectFileMachO::GetSegmentNameDWARF() {
static ConstString g_section_name("__DWARF");
return g_section_name;
}
-const ConstString &ObjectFileMachO::GetSectionNameEHFrame() {
+ConstString ObjectFileMachO::GetSectionNameEHFrame() {
static ConstString g_section_name_eh_frame("__eh_frame");
return g_section_name_eh_frame;
}
}
}
- const ConstString &g_segment_name_TEXT = GetSegmentNameTEXT();
- const ConstString &g_segment_name_DATA = GetSegmentNameDATA();
- const ConstString &g_segment_name_DATA_DIRTY = GetSegmentNameDATA_DIRTY();
- const ConstString &g_segment_name_DATA_CONST = GetSegmentNameDATA_CONST();
- const ConstString &g_segment_name_OBJC = GetSegmentNameOBJC();
- const ConstString &g_section_name_eh_frame = GetSectionNameEHFrame();
+ ConstString g_segment_name_TEXT = GetSegmentNameTEXT();
+ ConstString g_segment_name_DATA = GetSegmentNameDATA();
+ ConstString g_segment_name_DATA_DIRTY = GetSegmentNameDATA_DIRTY();
+ ConstString g_segment_name_DATA_CONST = GetSegmentNameDATA_CONST();
+ ConstString g_segment_name_OBJC = GetSegmentNameOBJC();
+ ConstString g_section_name_eh_frame = GetSectionNameEHFrame();
SectionSP text_section_sp(
section_list->FindSectionByName(g_segment_name_TEXT));
SectionSP data_section_sp(
bool SectionIsLoadable(const lldb_private::Section *section);
llvm::MachO::mach_header m_header;
- static const lldb_private::ConstString &GetSegmentNameTEXT();
- static const lldb_private::ConstString &GetSegmentNameDATA();
- static const lldb_private::ConstString &GetSegmentNameDATA_DIRTY();
- static const lldb_private::ConstString &GetSegmentNameDATA_CONST();
- static const lldb_private::ConstString &GetSegmentNameOBJC();
- static const lldb_private::ConstString &GetSegmentNameLINKEDIT();
- static const lldb_private::ConstString &GetSegmentNameDWARF();
- static const lldb_private::ConstString &GetSectionNameEHFrame();
+ static lldb_private::ConstString GetSegmentNameTEXT();
+ static lldb_private::ConstString GetSegmentNameDATA();
+ static lldb_private::ConstString GetSegmentNameDATA_DIRTY();
+ static lldb_private::ConstString GetSegmentNameDATA_CONST();
+ static lldb_private::ConstString GetSegmentNameOBJC();
+ static lldb_private::ConstString GetSegmentNameLINKEDIT();
+ static lldb_private::ConstString GetSegmentNameDWARF();
+ static lldb_private::ConstString GetSectionNameEHFrame();
llvm::MachO::dysymtab_command m_dysymtab;
std::vector<llvm::MachO::segment_command_64> m_mach_segments;
}
const lldb_private::RegisterInfo *DynamicRegisterInfo::GetRegisterInfo(
- const lldb_private::ConstString ®_name) const {
+ lldb_private::ConstString reg_name) const {
for (auto ®_info : m_regs) {
// We can use pointer comparison since we used a ConstString to set the
// "name" member in AddRegister()
typedef std::map<uint32_t, dwarf_opcode> dynamic_reg_size_map;
const lldb_private::RegisterInfo *
- GetRegisterInfo(const lldb_private::ConstString ®_name) const;
+ GetRegisterInfo(lldb_private::ConstString reg_name) const;
void MoveFrom(DynamicRegisterInfo &&info);
}
Status GDBRemoteCommunicationClient::ConfigureRemoteStructuredData(
- const ConstString &type_name, const StructuredData::ObjectSP &config_sp) {
+ ConstString type_name, const StructuredData::ObjectSP &config_sp) {
Status error;
if (type_name.GetLength() == 0) {
/// @see \b Process::ConfigureStructuredData(...) for details.
//------------------------------------------------------------------
Status
- ConfigureRemoteStructuredData(const ConstString &type_name,
+ ConfigureRemoteStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp);
lldb::user_id_t SendStartTracePacket(const TraceOptions &options,
}
Status ProcessGDBRemote::ConfigureStructuredData(
- const ConstString &type_name, const StructuredData::ObjectSP &config_sp) {
+ ConstString type_name, const StructuredData::ObjectSP &config_sp) {
return m_gdb_comm.ConfigureRemoteStructuredData(type_name, config_sp);
}
lldb::addr_t image_count) override;
Status
- ConfigureStructuredData(const ConstString &type_name,
+ ConfigureStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp) override;
StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos() override;
// used to format message text
};
-static const ConstString &GetDarwinLogTypeName() {
+static ConstString GetDarwinLogTypeName() {
static const ConstString s_key_name("DarwinLog");
return s_key_name;
}
-static const ConstString &GetLogEventType() {
+static ConstString GetLogEventType() {
static const ConstString s_event_type("log");
return s_event_type;
}
std::function<FilterRuleSP(bool accept, size_t attribute_index,
const std::string &op_arg, Status &error)>;
- static void RegisterOperation(const ConstString &operation,
+ static void RegisterOperation(ConstString operation,
const OperationCreationFunc &creation_func) {
GetCreationFuncMap().insert(std::make_pair(operation, creation_func));
}
static FilterRuleSP CreateRule(bool match_accepts, size_t attribute,
- const ConstString &operation,
+ ConstString operation,
const std::string &op_arg, Status &error) {
// Find the creation func for this type of filter rule.
auto map = GetCreationFuncMap();
virtual void Dump(Stream &stream) const = 0;
- const ConstString &GetOperationType() const { return m_operation; }
+ ConstString GetOperationType() const { return m_operation; }
protected:
- FilterRule(bool accept, size_t attribute_index, const ConstString &operation)
+ FilterRule(bool accept, size_t attribute_index, ConstString operation)
: m_accept(accept), m_attribute_index(attribute_index),
m_operation(operation) {}
return FilterRuleSP(new RegexFilterRule(accept, attribute_index, op_arg));
}
- static const ConstString &StaticGetOperation() {
+ static ConstString StaticGetOperation() {
static ConstString s_operation("regex");
return s_operation;
}
new ExactMatchFilterRule(accept, attribute_index, op_arg));
}
- static const ConstString &StaticGetOperation() {
+ static ConstString StaticGetOperation() {
static ConstString s_operation("match");
return s_operation;
}
process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
stream.Printf("Availability: %s\n",
plugin_sp ? "available" : "unavailable");
- auto &plugin_name = StructuredDataDarwinLog::GetStaticPluginName();
+ ConstString plugin_name = StructuredDataDarwinLog::GetStaticPluginName();
const bool enabled =
plugin_sp ? plugin_sp->GetEnabled(plugin_name) : false;
stream.Printf("Enabled: %s\n", enabled ? "true" : "false");
PluginManager::UnregisterPlugin(&CreateInstance);
}
-const ConstString &StructuredDataDarwinLog::GetStaticPluginName() {
+ConstString StructuredDataDarwinLog::GetStaticPluginName() {
static ConstString s_plugin_name("darwin-log");
return s_plugin_name;
}
// -----------------------------------------------------------------------------
bool StructuredDataDarwinLog::SupportsStructuredDataType(
- const ConstString &type_name) {
+ ConstString type_name) {
return type_name == GetDarwinLogTypeName();
}
void StructuredDataDarwinLog::HandleArrivalOfStructuredData(
- Process &process, const ConstString &type_name,
+ Process &process, ConstString type_name,
const StructuredData::ObjectSP &object_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
if (log) {
return error;
}
-bool StructuredDataDarwinLog::GetEnabled(const ConstString &type_name) const {
+bool StructuredDataDarwinLog::GetEnabled(ConstString type_name) const {
if (type_name == GetStaticPluginName())
return m_is_enabled;
else
static void Terminate();
- static const ConstString &GetStaticPluginName();
+ static ConstString GetStaticPluginName();
// -------------------------------------------------------------------------
/// Return whether the DarwinLog functionality is enabled.
// StructuredDataPlugin API
// -------------------------------------------------------------------------
- bool SupportsStructuredDataType(const ConstString &type_name) override;
+ bool SupportsStructuredDataType(ConstString type_name) override;
void HandleArrivalOfStructuredData(
- Process &process, const ConstString &type_name,
+ Process &process, ConstString type_name,
const StructuredData::ObjectSP &object_sp) override;
Status GetDescription(const StructuredData::ObjectSP &object_sp,
lldb_private::Stream &stream) override;
- bool GetEnabled(const ConstString &type_name) const override;
+ bool GetEnabled(ConstString type_name) const override;
void ModulesDidLoad(Process &process, ModuleList &module_list) override;
}
uint32_t SymbolFileBreakpad::FindFunctions(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, bool include_inlines, bool append,
SymbolContextList &sc_list) {
// TODO
}
uint32_t SymbolFileBreakpad::FindTypes(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
if (!append)
size_t ParseBlocksRecursive(Function &func) override { return 0; }
- uint32_t FindGlobalVariables(const ConstString &name,
+ uint32_t FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
VariableList &variables) override {
return 0;
}
- uint32_t FindFunctions(const ConstString &name,
+ uint32_t FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask,
bool include_inlines, bool append,
uint32_t FindFunctions(const RegularExpression ®ex, bool include_inlines,
bool append, SymbolContextList &sc_list) override;
- uint32_t FindTypes(const ConstString &name,
+ uint32_t FindTypes(ConstString name,
const CompilerDeclContext *parent_decl_ctx, bool append,
uint32_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files,
}
CompilerDeclContext
- FindNamespace(const ConstString &name,
+ FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) override {
return CompilerDeclContext();
}
m_map.SizeToFit();
}
-void NameToDIE::Insert(const ConstString &name, const DIERef &die_ref) {
+void NameToDIE::Insert(ConstString name, const DIERef &die_ref) {
m_map.Append(name, die_ref);
}
-size_t NameToDIE::Find(const ConstString &name, DIEArray &info_array) const {
+size_t NameToDIE::Find(ConstString name, DIEArray &info_array) const {
return m_map.GetValues(name, info_array);
}
void Dump(lldb_private::Stream *s);
- void Insert(const lldb_private::ConstString &name, const DIERef &die_ref);
+ void Insert(lldb_private::ConstString name, const DIERef &die_ref);
void Append(const NameToDIE &other);
void Finalize();
- size_t Find(const lldb_private::ConstString &name,
+ size_t Find(lldb_private::ConstString name,
DIEArray &info_array) const;
size_t Find(const lldb_private::RegularExpression ®ex,
SymbolFileDWARF::~SymbolFileDWARF() {}
-static const ConstString &GetDWARFMachOSegmentName() {
+static ConstString GetDWARFMachOSegmentName() {
static ConstString g_dwarf_section_name("__DWARF");
return g_dwarf_section_name;
}
}
uint32_t SymbolFileDWARF::FindGlobalVariables(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables) {
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
}
uint32_t SymbolFileDWARF::FindFunctions(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, bool include_inlines, bool append,
SymbolContextList &sc_list) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
}
uint32_t SymbolFileDWARF::FindTypes(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types) {
}
CompilerDeclContext
-SymbolFileDWARF::FindNamespace(const ConstString &name,
+SymbolFileDWARF::FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) {
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
}
Symbol *
-SymbolFileDWARF::GetObjCClassSymbol(const ConstString &objc_class_name) {
+SymbolFileDWARF::GetObjCClassSymbol(ConstString objc_class_name) {
Symbol *objc_class_symbol = NULL;
if (m_obj_file) {
Symtab *symtab = m_obj_file->GetSymtab();
// This function can be used when a DIE is found that is a forward declaration
// DIE and we want to try and find a type that has the complete definition.
TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
- const DWARFDIE &die, const ConstString &type_name,
+ const DWARFDIE &die, ConstString type_name,
bool must_be_implementation) {
TypeSP type_sp;
lldb_private::SymbolContextList &sc_list) override;
uint32_t
- FindGlobalVariables(const lldb_private::ConstString &name,
+ FindGlobalVariables(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
lldb_private::VariableList &variables) override;
lldb_private::VariableList &variables) override;
uint32_t
- FindFunctions(const lldb_private::ConstString &name,
+ FindFunctions(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, bool include_inlines,
bool append, lldb_private::SymbolContextList &sc_list) override;
std::vector<lldb_private::ConstString> &mangled_names) override;
uint32_t
- FindTypes(const lldb_private::ConstString &name,
+ FindTypes(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
GetTypeSystemForLanguage(lldb::LanguageType language) override;
lldb_private::CompilerDeclContext FindNamespace(
- const lldb_private::ConstString &name,
+ lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
void PreloadSymbols() override;
FindDefinitionTypeForDWARFDeclContext(const DWARFDeclContext &die_decl_ctx);
virtual lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
- const DWARFDIE &die, const lldb_private::ConstString &type_name,
+ const DWARFDIE &die, lldb_private::ConstString type_name,
bool must_be_implementation);
lldb_private::Symbol *
- GetObjCClassSymbol(const lldb_private::ConstString &objc_class_name);
+ GetObjCClassSymbol(lldb_private::ConstString objc_class_name);
lldb::TypeSP GetTypeForDIE(const DWARFDIE &die,
bool resolve_function_context = false);
bool DIEDeclContextsMatch(const DWARFDIE &die1, const DWARFDIE &die2);
bool ClassContainsSelector(const DWARFDIE &class_die,
- const lldb_private::ConstString &selector);
+ lldb_private::ConstString selector);
bool FixupAddress(lldb_private::Address &addr);
return file_range_map;
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP));
- if (log) {
- ConstString object_name(oso_module->GetObjectName());
+ if (log)
log->Printf(
"%p: SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap ('%s')",
static_cast<void *>(this),
oso_module->GetSpecificationDescription().c_str());
- }
std::vector<SymbolFileDWARFDebugMap::CompileUnitInfo *> cu_infos;
if (exe_symfile->GetCompUnitInfosForModule(oso_module, cu_infos)) {
}
uint32_t SymbolFileDWARFDebugMap::PrivateFindGlobalVariables(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
const std::vector<uint32_t>
&indexes, // Indexes into the symbol table that match "name"
uint32_t max_matches, VariableList &variables) {
}
uint32_t SymbolFileDWARFDebugMap::FindGlobalVariables(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables) {
// Remember how many variables are in the list before we search.
}
uint32_t SymbolFileDWARFDebugMap::FindFunctions(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, bool include_inlines, bool append,
SymbolContextList &sc_list) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
}
TypeSP SymbolFileDWARFDebugMap::FindCompleteObjCDefinitionTypeForDIE(
- const DWARFDIE &die, const ConstString &type_name,
+ const DWARFDIE &die, ConstString type_name,
bool must_be_implementation) {
// If we have a debug map, we will have an Objective-C symbol whose name is
// the type name and whose type is eSymbolTypeObjCClass. If we can find that
}
uint32_t SymbolFileDWARFDebugMap::FindTypes(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types) {
//}
CompilerDeclContext SymbolFileDWARFDebugMap::FindNamespace(
- const lldb_private::ConstString &name,
+ lldb_private::ConstString name,
const CompilerDeclContext *parent_decl_ctx) {
CompilerDeclContext matching_namespace;
lldb::SymbolContextItem resolve_scope,
lldb_private::SymbolContextList &sc_list) override;
uint32_t
- FindGlobalVariables(const lldb_private::ConstString &name,
+ FindGlobalVariables(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
lldb_private::VariableList &variables) override;
uint32_t max_matches,
lldb_private::VariableList &variables) override;
uint32_t
- FindFunctions(const lldb_private::ConstString &name,
+ FindFunctions(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, bool include_inlines,
bool append, lldb_private::SymbolContextList &sc_list) override;
bool include_inlines, bool append,
lldb_private::SymbolContextList &sc_list) override;
uint32_t
- FindTypes(const lldb_private::ConstString &name,
+ FindTypes(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
lldb_private::TypeMap &types) override;
lldb_private::CompilerDeclContext FindNamespace(
- const lldb_private::ConstString &name,
+ lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
lldb::TypeClass type_mask,
const CompileUnitInfo *comp_unit_info);
uint32_t PrivateFindGlobalVariables(
- const lldb_private::ConstString &name,
+ lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
const std::vector<uint32_t> &name_symbol_indexes, uint32_t max_matches,
lldb_private::VariableList &variables);
bool Supports_DW_AT_APPLE_objc_complete_type(SymbolFileDWARF *skip_dwarf_oso);
lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
- const DWARFDIE &die, const lldb_private::ConstString &type_name,
+ const DWARFDIE &die, lldb_private::ConstString type_name,
bool must_be_implementation);
UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() {
}
lldb::TypeSP SymbolFileDWARFDwo::FindCompleteObjCDefinitionTypeForDIE(
- const DWARFDIE &die, const lldb_private::ConstString &type_name,
+ const DWARFDIE &die, lldb_private::ConstString type_name,
bool must_be_implementation) {
return GetBaseSymbolFile()->FindCompleteObjCDefinitionTypeForDIE(
die, type_name, must_be_implementation);
const DWARFDeclContext &die_decl_ctx) override;
lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
- const DWARFDIE &die, const lldb_private::ConstString &type_name,
+ const DWARFDIE &die, lldb_private::ConstString type_name,
bool must_be_implementation) override;
SymbolFileDWARF *GetBaseSymbolFile();
~UniqueDWARFASTTypeMap() {}
- void Insert(const lldb_private::ConstString &name,
+ void Insert(lldb_private::ConstString name,
const UniqueDWARFASTType &entry) {
m_collection[name.GetCString()].Append(entry);
}
- bool Find(const lldb_private::ConstString &name, const DWARFDIE &die,
+ bool Find(lldb_private::ConstString name, const DWARFDIE &die,
const lldb_private::Declaration &decl, const int32_t byte_size,
UniqueDWARFASTType &entry) const {
const char *unique_name_cstr = name.GetCString();
void SymbolFileNativePDB::DumpClangAST(Stream &s) { m_ast->Dump(s); }
uint32_t SymbolFileNativePDB::FindGlobalVariables(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables) {
using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
}
uint32_t SymbolFileNativePDB::FindFunctions(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, bool include_inlines, bool append,
SymbolContextList &sc_list) {
// For now we only support lookup by method name.
}
uint32_t SymbolFileNativePDB::FindTypes(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
if (!append)
}
CompilerDeclContext
-SymbolFileNativePDB::FindNamespace(const ConstString &name,
+SymbolFileNativePDB::FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) {
return {};
}
size_t ParseBlocksRecursive(Function &func) override;
- uint32_t FindGlobalVariables(const ConstString &name,
+ uint32_t FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
VariableList &variables) override;
size_t GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
TypeList &type_list) override;
- uint32_t FindFunctions(const ConstString &name,
+ uint32_t FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask,
bool include_inlines, bool append,
uint32_t FindFunctions(const RegularExpression ®ex, bool include_inlines,
bool append, SymbolContextList &sc_list) override;
- uint32_t FindTypes(const ConstString &name,
+ uint32_t FindTypes(ConstString name,
const CompilerDeclContext *parent_decl_ctx, bool append,
uint32_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files,
TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override;
CompilerDeclContext
- FindNamespace(const ConstString &name,
+ FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) override;
ConstString GetPluginName() override;
}
uint32_t SymbolFilePDB::FindGlobalVariables(
- const lldb_private::ConstString &name,
+ lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, lldb_private::VariableList &variables) {
if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
}
uint32_t SymbolFilePDB::FindFunctions(
- const lldb_private::ConstString &name,
+ lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, bool include_inlines, bool append,
lldb_private::SymbolContextList &sc_list) {
}
uint32_t SymbolFilePDB::FindTypes(
- const lldb_private::ConstString &name,
+ lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append,
uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace(
- const lldb_private::ConstString &name,
+ lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx) {
auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
auto clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
lldb_private::SymbolContextList &sc_list) override;
uint32_t
- FindGlobalVariables(const lldb_private::ConstString &name,
+ FindGlobalVariables(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches,
lldb_private::VariableList &variables) override;
lldb_private::VariableList &variables) override;
uint32_t
- FindFunctions(const lldb_private::ConstString &name,
+ FindFunctions(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, bool include_inlines,
bool append, lldb_private::SymbolContextList &sc_list) override;
void AddSymbols(lldb_private::Symtab &symtab) override;
uint32_t
- FindTypes(const lldb_private::ConstString &name,
+ FindTypes(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
GetTypeSystemForLanguage(lldb::LanguageType language) override;
lldb_private::CompilerDeclContext FindNamespace(
- const lldb_private::ConstString &name,
+ lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
lldb_private::ConstString GetPluginName() override;
}
lldb::BasicType
-ClangASTContext::GetBasicTypeEnumeration(const ConstString &name) {
+ClangASTContext::GetBasicTypeEnumeration(ConstString name) {
if (name) {
typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
static TypeNameToBasicTypeMap g_type_map;
}
CompilerType ClangASTContext::GetBasicType(ASTContext *ast,
- const ConstString &name) {
+ ConstString name) {
if (ast) {
lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration(name);
return ClangASTContext::GetBasicType(ast, basic_type);
}
CompilerType ClangASTContext::CreateStructForIdentifier(
- const ConstString &type_name,
+ ConstString type_name,
const std::initializer_list<std::pair<const char *, CompilerType>>
&type_fields,
bool packed) {
}
CompilerType ClangASTContext::GetOrCreateStructForIdentifier(
- const ConstString &type_name,
+ ConstString type_name,
const std::initializer_list<std::pair<const char *, CompilerType>>
&type_fields,
bool packed) {
return num_children;
}
-CompilerType ClangASTContext::GetBuiltinTypeByName(const ConstString &name) {
+CompilerType ClangASTContext::GetBuiltinTypeByName(ConstString name) {
return GetBasicType(GetBasicTypeEnumeration(name));
}
void ClangASTContext::ForEachEnumerator(
lldb::opaque_compiler_type_t type,
std::function<bool(const CompilerType &integer_type,
- const ConstString &name,
+ ConstString name,
const llvm::APSInt &value)> const &callback) {
const clang::EnumType *enum_type =
llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type));
void CompilerType::ForEachEnumerator(
std::function<bool(const CompilerType &integer_type,
- const ConstString &name,
+ ConstString name,
const llvm::APSInt &value)> const &callback) const {
if (IsValid())
return m_type_system->ForEachEnumerator(m_type, callback);
FunctionInfo::FunctionInfo(const char *name, const Declaration *decl_ptr)
: m_name(name), m_declaration(decl_ptr) {}
-FunctionInfo::FunctionInfo(const ConstString &name, const Declaration *decl_ptr)
+FunctionInfo::FunctionInfo(ConstString name, const Declaration *decl_ptr)
: m_name(name), m_declaration(decl_ptr) {}
FunctionInfo::~FunctionInfo() {}
: FunctionInfo(name, decl_ptr), m_mangled(ConstString(mangled), true),
m_call_decl(call_decl_ptr) {}
-InlineFunctionInfo::InlineFunctionInfo(const ConstString &name,
+InlineFunctionInfo::InlineFunctionInfo(ConstString name,
const Mangled &mangled,
const Declaration *decl_ptr,
const Declaration *call_decl_ptr)
FileSystem::Instance().ResolveSymbolicLink(module_file_spec,
module_file_spec);
- const ConstString &file_dir = module_file_spec.GetDirectory();
+ ConstString file_dir = module_file_spec.GetDirectory();
{
FileSpec file_spec(file_dir.AsCString("."));
FileSystem::Instance().Resolve(file_spec);
return FileSpec();
}
-void Symbol::SetReExportedSymbolName(const ConstString &name) {
+void Symbol::SetReExportedSymbolName(ConstString name) {
SetType(eSymbolTypeReExported);
// For eSymbolTypeReExported, the "const char *" from a ConstString is used
// as the offset in the address range base address.
return 0;
}
-bool Symbol::Compare(const ConstString &name, SymbolType type) const {
+bool Symbol::Compare(ConstString name, SymbolType type) const {
if (type == eSymbolTypeAny || m_type == type)
return m_mangled.GetMangledName() == name ||
m_mangled.GetDemangledName(GetLanguage()) == name;
}
const Symbol *
-SymbolContext::FindBestGlobalDataSymbol(const ConstString &name, Status &error) {
+SymbolContext::FindBestGlobalDataSymbol(ConstString name, Status &error) {
error.Clear();
if (!target_sp) {
}
uint32_t
-SymbolFile::FindGlobalVariables(const ConstString &name,
+SymbolFile::FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables) {
return 0;
return 0;
}
-uint32_t SymbolFile::FindFunctions(const ConstString &name,
+uint32_t SymbolFile::FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask,
bool include_inlines, bool append,
}
uint32_t SymbolFile::FindTypes(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types) {
}
size_t
-SymbolVendor::FindGlobalVariables(const ConstString &name,
+SymbolVendor::FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, VariableList &variables) {
ModuleSP module_sp(GetModule());
return 0;
}
-size_t SymbolVendor::FindFunctions(const ConstString &name,
+size_t SymbolVendor::FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask,
bool include_inlines, bool append,
}
size_t SymbolVendor::FindTypes(
- const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
+ ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types) {
}
CompilerDeclContext
-SymbolVendor::FindNamespace(const ConstString &name,
+SymbolVendor::FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) {
CompilerDeclContext namespace_decl_ctx;
ModuleSP module_sp(GetModule());
}
}
-uint32_t Symtab::AppendSymbolIndexesWithName(const ConstString &symbol_name,
+uint32_t Symtab::AppendSymbolIndexesWithName(ConstString symbol_name,
std::vector<uint32_t> &indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
return 0;
}
-uint32_t Symtab::AppendSymbolIndexesWithName(const ConstString &symbol_name,
+uint32_t Symtab::AppendSymbolIndexesWithName(ConstString symbol_name,
Debug symbol_debug_type,
Visibility symbol_visibility,
std::vector<uint32_t> &indexes) {
}
uint32_t
-Symtab::AppendSymbolIndexesWithNameAndType(const ConstString &symbol_name,
+Symtab::AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
SymbolType symbol_type,
std::vector<uint32_t> &indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
}
uint32_t Symtab::AppendSymbolIndexesWithNameAndType(
- const ConstString &symbol_name, SymbolType symbol_type,
+ ConstString symbol_name, SymbolType symbol_type,
Debug symbol_debug_type, Visibility symbol_visibility,
std::vector<uint32_t> &indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
}
size_t
-Symtab::FindAllSymbolsWithNameAndType(const ConstString &name,
+Symtab::FindAllSymbolsWithNameAndType(ConstString name,
SymbolType symbol_type,
std::vector<uint32_t> &symbol_indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
}
size_t Symtab::FindAllSymbolsWithNameAndType(
- const ConstString &name, SymbolType symbol_type, Debug symbol_debug_type,
+ ConstString name, SymbolType symbol_type, Debug symbol_debug_type,
Visibility symbol_visibility, std::vector<uint32_t> &symbol_indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex);
return symbol_indexes.size();
}
-Symbol *Symtab::FindFirstSymbolWithNameAndType(const ConstString &name,
+Symbol *Symtab::FindFirstSymbolWithNameAndType(ConstString name,
SymbolType symbol_type,
Debug symbol_debug_type,
Visibility symbol_visibility) {
}
}
-size_t Symtab::FindFunctionSymbols(const ConstString &name,
+size_t Symtab::FindFunctionSymbols(ConstString name,
uint32_t name_type_mask,
SymbolContextList &sc_list) {
size_t count = 0;
}
Type::Type(lldb::user_id_t uid, SymbolFile *symbol_file,
- const ConstString &name, llvm::Optional<uint64_t> byte_size,
+ ConstString name, llvm::Optional<uint64_t> byte_size,
SymbolContextScope *context, user_id_t encoding_uid,
EncodingDataType encoding_uid_type, const Declaration &decl,
const CompilerType &compiler_type,
// Call the name accessor to make sure we resolve the type name
if (show_name) {
- const ConstString &type_name = GetName();
+ ConstString type_name = GetName();
if (type_name) {
*s << ", name = \"" << type_name << '"';
ConstString qualified_type_name(GetQualifiedName());
s->EOL();
}
-const ConstString &Type::GetName() {
+ConstString Type::GetName() {
if (!m_name)
m_name = GetForwardCompilerType().GetConstTypeName();
return m_name;
return ConstString("<invalid>");
}
-void TypeAndOrName::SetName(const ConstString &type_name) {
+void TypeAndOrName::SetName(ConstString type_name) {
m_type_name = type_name;
}
}
TypeEnumMemberImpl::TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp,
- const ConstString &name,
+ ConstString name,
const llvm::APSInt &value)
: m_integer_type_sp(integer_type_sp), m_name(name), m_value(value),
m_valid((bool)name && (bool)integer_type_sp)
// Find a type by name.
//----------------------------------------------------------------------
// TypeList
-// TypeList::FindTypes (const ConstString &name)
+// TypeList::FindTypes (ConstString name)
//{
// // Do we ever need to make a lookup by name map? Here we are doing
// // a linear search which isn't going to be fast.
// Find a type by name.
//----------------------------------------------------------------------
// TypeMap
-// TypeMap::FindTypes (const ConstString &name)
+// TypeMap::FindTypes (ConstString name)
//{
// // Do we ever need to make a lookup by name map? Here we are doing
// // a linear search which isn't going to be fast.
return CompilerType();
}
-CompilerType TypeSystem::GetBuiltinTypeByName(const ConstString &name) {
+CompilerType TypeSystem::GetBuiltinTypeByName(ConstString name) {
return CompilerType();
}
ConstString Variable::GetUnqualifiedName() const { return m_name; }
-bool Variable::NameMatches(const ConstString &name) const {
+bool Variable::NameMatches(ConstString name) const {
if (m_name == name)
return true;
SymbolContext variable_sc;
return UINT32_MAX;
}
-VariableSP VariableList::FindVariable(const ConstString &name,
+VariableSP VariableList::FindVariable(ConstString name,
bool include_static_members) {
VariableSP var_sp;
iterator pos, end = m_variables.end();
return var_sp;
}
-VariableSP VariableList::FindVariable(const ConstString &name,
+VariableSP VariableList::FindVariable(ConstString name,
lldb::ValueType value_type,
bool include_static_members) {
VariableSP var_sp;
ABI::~ABI() = default;
-bool ABI::GetRegisterInfoByName(const ConstString &name, RegisterInfo &info) {
+bool ABI::GetRegisterInfoByName(ConstString name, RegisterInfo &info) {
uint32_t count = 0;
const RegisterInfo *register_info_array = GetRegisterInfoArray(count);
if (register_info_array) {
}
ObjCLanguageRuntime::ObjCISA
-ObjCLanguageRuntime::GetISA(const ConstString &name) {
+ObjCLanguageRuntime::GetISA(ConstString name) {
ISAToDescriptorIterator pos = GetDescriptorIterator(name);
if (pos != m_isa_to_descriptor.end())
return pos->first;
}
ObjCLanguageRuntime::ISAToDescriptorIterator
-ObjCLanguageRuntime::GetDescriptorIterator(const ConstString &name) {
+ObjCLanguageRuntime::GetDescriptorIterator(ConstString name) {
ISAToDescriptorIterator end = m_isa_to_descriptor.end();
if (name) {
ObjCLanguageRuntime::ClassDescriptorSP
ObjCLanguageRuntime::GetClassDescriptorFromClassName(
- const ConstString &class_name) {
+ ConstString class_name) {
ISAToDescriptorIterator pos = GetDescriptorIterator(class_name);
if (pos != m_isa_to_descriptor.end())
return pos->second;
// with the raw path pair, which doesn't work anymore because the paths have
// been normalized when the debug info was loaded. So we need to store
// nomalized path pairs to ensure things match up.
- ConstString NormalizePath(const ConstString &path) {
+ ConstString NormalizePath(ConstString path) {
// If we use "path" to construct a FileSpec, it will normalize the path for
// us. We then grab the string and turn it back into a ConstString.
return ConstString(FileSpec(path.GetStringRef()).GetPath());
PathMappingList::~PathMappingList() = default;
-void PathMappingList::Append(const ConstString &path,
- const ConstString &replacement, bool notify) {
+void PathMappingList::Append(ConstString path,
+ ConstString replacement, bool notify) {
++m_mod_id;
m_pairs.emplace_back(pair(NormalizePath(path), NormalizePath(replacement)));
if (notify && m_callback)
}
}
-void PathMappingList::Insert(const ConstString &path,
- const ConstString &replacement, uint32_t index,
+void PathMappingList::Insert(ConstString path,
+ ConstString replacement, uint32_t index,
bool notify) {
++m_mod_id;
iterator insert_iter;
m_callback(*this, m_callback_baton);
}
-bool PathMappingList::Replace(const ConstString &path,
- const ConstString &replacement, uint32_t index,
+bool PathMappingList::Replace(ConstString path,
+ ConstString replacement, uint32_t index,
bool notify) {
if (index >= m_pairs.size())
return false;
m_callback(*this, m_callback_baton);
}
-bool PathMappingList::RemapPath(const ConstString &path,
+bool PathMappingList::RemapPath(ConstString path,
ConstString &new_path) const {
std::string remapped;
if (RemapPath(path.GetStringRef(), remapped)) {
return false;
}
-bool PathMappingList::Replace(const ConstString &path,
- const ConstString &new_path, bool notify) {
+bool PathMappingList::Replace(ConstString path,
+ ConstString new_path, bool notify) {
uint32_t idx = FindIndexForPath(path);
if (idx < m_pairs.size()) {
++m_mod_id;
return false;
}
-bool PathMappingList::Remove(const ConstString &path, bool notify) {
+bool PathMappingList::Remove(ConstString path, bool notify) {
iterator pos = FindIteratorForPath(path);
if (pos != m_pairs.end()) {
++m_mod_id;
}
PathMappingList::const_iterator
-PathMappingList::FindIteratorForPath(const ConstString &path) const {
+PathMappingList::FindIteratorForPath(ConstString path) const {
const_iterator pos;
const_iterator begin = m_pairs.begin();
const_iterator end = m_pairs.end();
}
PathMappingList::iterator
-PathMappingList::FindIteratorForPath(const ConstString &path) {
+PathMappingList::FindIteratorForPath(ConstString path) {
iterator pos;
iterator begin = m_pairs.begin();
iterator end = m_pairs.end();
return false;
}
-uint32_t PathMappingList::FindIndexForPath(const ConstString &orig_path) const {
+uint32_t PathMappingList::FindIndexForPath(ConstString orig_path) const {
const ConstString path = NormalizePath(orig_path);
const_iterator pos;
const_iterator begin = m_pairs.begin();
}
// PlatformSP
-// Platform::FindPlugin (Process *process, const ConstString &plugin_name)
+// Platform::FindPlugin (Process *process, ConstString plugin_name)
//{
// PlatformCreateInstance create_callback = nullptr;
// if (plugin_name)
module_spec);
}
-PlatformSP Platform::Find(const ConstString &name) {
+PlatformSP Platform::Find(ConstString name) {
if (name) {
static ConstString g_host_platform_name("host");
if (name == g_host_platform_name)
return PlatformSP();
}
-PlatformSP Platform::Create(const ConstString &name, Status &error) {
+PlatformSP Platform::Create(ConstString name, Status &error) {
PlatformCreateInstance create_callback = nullptr;
lldb::PlatformSP platform_sp;
if (name) {
class ProcessOptionValueProperties : public OptionValueProperties {
public:
- ProcessOptionValueProperties(const ConstString &name)
+ ProcessOptionValueProperties(ConstString name)
: OptionValueProperties(name) {}
// This constructor is used when creating ProcessOptionValueProperties when
Process::ProcessEventData::~ProcessEventData() = default;
-const ConstString &Process::ProcessEventData::GetFlavorString() {
+ConstString Process::ProcessEventData::GetFlavorString() {
static ConstString g_flavor("Process::ProcessEventData");
return g_flavor;
}
-const ConstString &Process::ProcessEventData::GetFlavor() const {
+ConstString Process::ProcessEventData::GetFlavor() const {
return ProcessEventData::GetFlavorString();
}
}
StructuredDataPluginSP
-Process::GetStructuredDataPlugin(const ConstString &type_name) const {
+Process::GetStructuredDataPlugin(ConstString type_name) const {
auto find_it = m_structured_data_plugin_map.find(type_name);
if (find_it != m_structured_data_plugin_map.end())
return find_it->second;
}
Status
-Process::ConfigureStructuredData(const ConstString &type_name,
+Process::ConfigureStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp) {
// If you get this, the Process-derived class needs to implement a method to
// enable an already-reported asynchronous structured data feature. See
class StackFrameRecognizerManagerImpl {
public:
void AddRecognizer(StackFrameRecognizerSP recognizer,
- const ConstString &module, const ConstString &symbol,
+ ConstString module, ConstString symbol,
bool first_instruction_only) {
m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer, false, module, RegularExpressionSP(),
symbol, RegularExpressionSP(),
}
void StackFrameRecognizerManager::AddRecognizer(
- StackFrameRecognizerSP recognizer, const ConstString &module,
- const ConstString &symbol, bool first_instruction_only) {
+ StackFrameRecognizerSP recognizer, ConstString module,
+ ConstString symbol, bool first_instruction_only) {
GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol,
first_instruction_only);
}
StructuredDataPlugin::~StructuredDataPlugin() {}
-bool StructuredDataPlugin::GetEnabled(const ConstString &type_name) const {
+bool StructuredDataPlugin::GetEnabled(ConstString type_name) const {
// By default, plugins are always enabled. Plugin authors should override
// this if there is an enabled/disabled state for their plugin.
return true;
m_breakpoint_names.insert(std::make_pair(bp_name->GetName(), bp_name));
}
-BreakpointName *Target::FindBreakpointName(const ConstString &name,
+BreakpointName *Target::FindBreakpointName(ConstString name,
bool can_create,
Status &error)
{
}
void
-Target::DeleteBreakpointName(const ConstString &name)
+Target::DeleteBreakpointName(ConstString name)
{
BreakpointNameList::iterator iter = m_breakpoint_names.find(name);
}
void Target::RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp,
- const ConstString &name)
+ ConstString name)
{
bp_sp->RemoveName(name.AsCString());
}
}
lldb::ExpressionVariableSP
-Target::GetPersistentVariable(const ConstString &name) {
+Target::GetPersistentVariable(ConstString name) {
lldb::ExpressionVariableSP variable_sp;
m_scratch_type_system_map.ForEach(
[name, &variable_sp](TypeSystem *type_system) -> bool {
return variable_sp;
}
-lldb::addr_t Target::GetPersistentSymbol(const ConstString &name) {
+lldb::addr_t Target::GetPersistentSymbol(ConstString name) {
lldb::addr_t address = LLDB_INVALID_ADDRESS;
m_scratch_type_system_map.ForEach(
class TargetOptionValueProperties : public OptionValueProperties {
public:
- TargetOptionValueProperties(const ConstString &name)
+ TargetOptionValueProperties(ConstString name)
: OptionValueProperties(name), m_target(nullptr), m_got_host_env(false) {}
// This constructor is used when creating TargetOptionValueProperties when it
Target::TargetEventData::~TargetEventData() = default;
-const ConstString &Target::TargetEventData::GetFlavorString() {
+ConstString Target::TargetEventData::GetFlavorString() {
static ConstString g_flavor("Target::TargetEventData");
return g_flavor;
}
class ThreadOptionValueProperties : public OptionValueProperties {
public:
- ThreadOptionValueProperties(const ConstString &name)
+ ThreadOptionValueProperties(ConstString name)
: OptionValueProperties(name) {}
// This constructor is used when creating ThreadOptionValueProperties when it
// Thread Event Data
//------------------------------------------------------------------
-const ConstString &Thread::ThreadEventData::GetFlavorString() {
+ConstString Thread::ThreadEventData::GetFlavorString() {
static ConstString g_flavor("Thread::ThreadEventData");
return g_flavor;
}
return llvm::Triple::UnknownArch;
}
-const ConstString &ArchSpec::GetDistributionId() const {
+ConstString ArchSpec::GetDistributionId() const {
return m_distribution_id;
}
ConstString::ConstString(const llvm::StringRef &s)
: m_string(StringPool().GetConstCStringWithLength(s.data(), s.size())) {}
-bool ConstString::operator<(const ConstString &rhs) const {
+bool ConstString::operator<(ConstString rhs) const {
if (m_string == rhs.m_string)
return false;
return lhs_string_ref.data() == nullptr;
}
-Stream &lldb_private::operator<<(Stream &s, const ConstString &str) {
+Stream &lldb_private::operator<<(Stream &s, ConstString str) {
const char *cstr = str.GetCString();
if (cstr != nullptr)
s << cstr;
return Pool::GetConstCStringLength(m_string);
}
-bool ConstString::Equals(const ConstString &lhs, const ConstString &rhs,
+bool ConstString::Equals(ConstString lhs, ConstString rhs,
const bool case_sensitive) {
if (lhs.m_string == rhs.m_string)
return true;
return lhs_string_ref.equals_lower(rhs_string_ref);
}
-int ConstString::Compare(const ConstString &lhs, const ConstString &rhs,
+int ConstString::Compare(ConstString lhs, ConstString rhs,
const bool case_sensitive) {
// If the iterators are the same, this is the same string
const char *lhs_cstr = lhs.m_string;
}
void ConstString::SetStringWithMangledCounterpart(llvm::StringRef demangled,
- const ConstString &mangled) {
+ ConstString mangled) {
m_string = StringPool().GetConstCStringAndSetMangledCounterPart(
demangled, mangled.m_string);
}
EventDataBytes::~EventDataBytes() = default;
-const ConstString &EventDataBytes::GetFlavorString() {
+ConstString EventDataBytes::GetFlavorString() {
static ConstString g_flavor("EventDataBytes");
return g_flavor;
}
-const ConstString &EventDataBytes::GetFlavor() const {
+ConstString EventDataBytes::GetFlavor() const {
return EventDataBytes::GetFlavorString();
}
// EventDataStructuredData member functions
//------------------------------------------------------------------
-const ConstString &EventDataStructuredData::GetFlavor() const {
+ConstString EventDataStructuredData::GetFlavor() const {
return EventDataStructuredData::GetFlavorString();
}
return StructuredDataPluginSP();
}
-const ConstString &EventDataStructuredData::GetFlavorString() {
+ConstString EventDataStructuredData::GetFlavorString() {
static ConstString s_flavor("EventDataStructuredData");
return s_flavor;
}
//------------------------------------------------------------------
// Directory string const get accessor.
//------------------------------------------------------------------
-const ConstString &FileSpec::GetDirectory() const { return m_directory; }
+ConstString FileSpec::GetDirectory() const { return m_directory; }
//------------------------------------------------------------------
// Filename string get accessor.
//------------------------------------------------------------------
// Filename string const get accessor.
//------------------------------------------------------------------
-const ConstString &FileSpec::GetFilename() const { return m_filename; }
+ConstString FileSpec::GetFilename() const { return m_filename; }
//------------------------------------------------------------------
// Extract the directory and path into a fixed buffer. This is needed as the
if (m_broadcaster_names) {
bool found_source = false;
- const ConstString &event_broadcaster_name =
+ ConstString event_broadcaster_name =
event_sp->GetBroadcaster()->GetBroadcasterName();
for (uint32_t i = 0; i < m_num_broadcaster_names; ++i) {
if (m_broadcaster_names[i] == event_broadcaster_name) {
bool IsMangled = true;
Mangled TheMangled(MangledName, IsMangled);
- const ConstString &TheDemangled =
+ ConstString TheDemangled =
TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
ConstString ExpectedResult("void a::b::c<int, int, int>(unsigned long)");
bool IsMangled = true;
Mangled TheMangled(MangledName, IsMangled);
- const ConstString &TheDemangled =
+ ConstString TheDemangled =
TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
EXPECT_STREQ("", TheDemangled.GetCString());
</li>
<li>
virtual size_t
- GetIndexOfChildWithName (const ConstString &name) = 0;
+ GetIndexOfChildWithName (ConstString name) = 0;
</li>
<li>
virtual bool
projects / platform / upstream / llvm.git / commitdiff