Added new OptionGroup classes for UInt64, UUID, File and Boolean values.
Removed the "image" command and moved it to "target modules". Added an alias
for "image" to "target modules".
Added some new target commands to be able to add and load modules to a target:
(lldb) target modules add <path>
(lldb) target modules load [--file <path>] [--slide <offset>] [<sect-name> <sect-load-addr> ...]
So you can load individual sections without running a target:
(lldb) target modules load --file /usr/lib/libSystem.B.dylib __TEXT 0x7fccc80000 __DATA 0x1234000000
Or you can rigidly slide an entire shared library:
(lldb) target modules load --file /usr/lib/libSystem.B.dylib --slid 0x7fccc80000
This should improve bare board debugging when symbol files need to be slid around manually.
git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@130796 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/source/Commands/CommandObjectTarget.cpp b/source/Commands/CommandObjectTarget.cpp
index eea2a75..5913bf1 100644
--- a/source/Commands/CommandObjectTarget.cpp
+++ b/source/Commands/CommandObjectTarget.cpp
@@ -18,12 +18,21 @@
#include "lldb/Interpreter/Args.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/InputReader.h"
+#include "lldb/Core/Section.h"
#include "lldb/Core/State.h"
#include "lldb/Core/Timer.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/Options.h"
#include "lldb/Interpreter/OptionGroupArchitecture.h"
+#include "lldb/Interpreter/OptionGroupFile.h"
#include "lldb/Interpreter/OptionGroupPlatform.h"
+#include "lldb/Interpreter/OptionGroupUInt64.h"
+#include "lldb/Interpreter/OptionGroupUUID.h"
+#include "lldb/Symbol/LineTable.h"
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Symbol/SymbolFile.h"
+#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Thread.h"
@@ -388,15 +397,15 @@
};
-#pragma mark CommandObjectTargetImageSearchPaths
+#pragma mark CommandObjectTargetModulesSearchPathsAdd
-class CommandObjectTargetImageSearchPathsAdd : public CommandObject
+class CommandObjectTargetModulesSearchPathsAdd : public CommandObject
{
public:
- CommandObjectTargetImageSearchPathsAdd (CommandInterpreter &interpreter) :
+ CommandObjectTargetModulesSearchPathsAdd (CommandInterpreter &interpreter) :
CommandObject (interpreter,
- "target image-search-paths add",
+ "target modules search-paths add",
"Add new image search paths substitution pairs to the current target.",
NULL)
{
@@ -422,7 +431,7 @@
m_arguments.push_back (arg);
}
- ~CommandObjectTargetImageSearchPathsAdd ()
+ ~CommandObjectTargetModulesSearchPathsAdd ()
{
}
@@ -474,19 +483,21 @@
}
};
-class CommandObjectTargetImageSearchPathsClear : public CommandObject
+#pragma mark CommandObjectTargetModulesSearchPathsClear
+
+class CommandObjectTargetModulesSearchPathsClear : public CommandObject
{
public:
- CommandObjectTargetImageSearchPathsClear (CommandInterpreter &interpreter) :
+ CommandObjectTargetModulesSearchPathsClear (CommandInterpreter &interpreter) :
CommandObject (interpreter,
- "target image-search-paths clear",
+ "target modules search-paths clear",
"Clear all current image search path substitution pairs from the current target.",
- "target image-search-paths clear")
+ "target modules search-paths clear")
{
}
- ~CommandObjectTargetImageSearchPathsClear ()
+ ~CommandObjectTargetModulesSearchPathsClear ()
{
}
@@ -510,13 +521,15 @@
}
};
-class CommandObjectTargetImageSearchPathsInsert : public CommandObject
+#pragma mark CommandObjectTargetModulesSearchPathsInsert
+
+class CommandObjectTargetModulesSearchPathsInsert : public CommandObject
{
public:
- CommandObjectTargetImageSearchPathsInsert (CommandInterpreter &interpreter) :
+ CommandObjectTargetModulesSearchPathsInsert (CommandInterpreter &interpreter) :
CommandObject (interpreter,
- "target image-search-paths insert",
+ "target modules search-paths insert",
"Insert a new image search path substitution pair into the current target at the specified index.",
NULL)
{
@@ -553,7 +566,7 @@
m_arguments.push_back (arg2);
}
- ~CommandObjectTargetImageSearchPathsInsert ()
+ ~CommandObjectTargetModulesSearchPathsInsert ()
{
}
@@ -625,19 +638,23 @@
}
};
-class CommandObjectTargetImageSearchPathsList : public CommandObject
+
+#pragma mark CommandObjectTargetModulesSearchPathsList
+
+
+class CommandObjectTargetModulesSearchPathsList : public CommandObject
{
public:
- CommandObjectTargetImageSearchPathsList (CommandInterpreter &interpreter) :
+ CommandObjectTargetModulesSearchPathsList (CommandInterpreter &interpreter) :
CommandObject (interpreter,
- "target image-search-paths list",
+ "target modules search-paths list",
"List all current image search path substitution pairs in the current target.",
- "target image-search-paths list")
+ "target modules search-paths list")
{
}
- ~CommandObjectTargetImageSearchPathsList ()
+ ~CommandObjectTargetModulesSearchPathsList ()
{
}
@@ -667,13 +684,15 @@
}
};
-class CommandObjectTargetImageSearchPathsQuery : public CommandObject
+#pragma mark CommandObjectTargetModulesSearchPathsQuery
+
+class CommandObjectTargetModulesSearchPathsQuery : public CommandObject
{
public:
- CommandObjectTargetImageSearchPathsQuery (CommandInterpreter &interpreter) :
+ CommandObjectTargetModulesSearchPathsQuery (CommandInterpreter &interpreter) :
CommandObject (interpreter,
- "target image-search-paths query",
+ "target modules search-paths query",
"Transform a path using the first applicable image search path.",
NULL)
{
@@ -691,7 +710,7 @@
m_arguments.push_back (arg);
}
- ~CommandObjectTargetImageSearchPathsQuery ()
+ ~CommandObjectTargetModulesSearchPathsQuery ()
{
}
@@ -727,84 +746,2078 @@
}
};
-// TODO: implement the target select later when we start doing multiple targets
-//#pragma mark CommandObjectTargetSelect
-//
-////-------------------------------------------------------------------------
-//// CommandObjectTargetSelect
-////-------------------------------------------------------------------------
-//
-//class CommandObjectTargetSelect : public CommandObject
-//{
-//public:
-//
-// CommandObjectTargetSelect () :
-// CommandObject (interpreter,
-// frame select",
-// "Select the current frame by index in the current thread.",
-// "frame select <frame-index>")
-// {
-// }
-//
-// ~CommandObjectTargetSelect ()
-// {
-// }
-//
-// bool
-// Execute (Args& command,
-// Debugger *context,
-// CommandInterpreter &m_interpreter,
-// CommandReturnObject &result)
-// {
-// ExecutionContext exe_ctx (context->GetExecutionContext());
-// if (exe_ctx.thread)
-// {
-// if (command.GetArgumentCount() == 1)
-// {
-// const char *frame_idx_cstr = command.GetArgumentAtIndex(0);
-//
-// const uint32_t num_frames = exe_ctx.thread->GetStackFrameCount();
-// const uint32_t frame_idx = Args::StringToUInt32 (frame_idx_cstr, UINT32_MAX, 0);
-// if (frame_idx < num_frames)
-// {
-// exe_ctx.thread->SetSelectedFrameByIndex (frame_idx);
-// exe_ctx.frame = exe_ctx.thread->GetSelectedFrame ().get();
-//
-// if (exe_ctx.frame)
-// {
-// if (DisplayFrameForExecutionContext (exe_ctx.thread,
-// exe_ctx.frame,
-// m_interpreter,
-// result.GetOutputStream(),
-// true,
-// true,
-// 3,
-// 3))
-// {
-// result.SetStatus (eReturnStatusSuccessFinishResult);
-// return result.Succeeded();
-// }
-// }
-// }
-// if (frame_idx == UINT32_MAX)
-// result.AppendErrorWithFormat ("Invalid frame index: %s.\n", frame_idx_cstr);
-// else
-// result.AppendErrorWithFormat ("Frame index (%u) out of range.\n", frame_idx);
-// }
-// else
-// {
-// result.AppendError ("invalid arguments");
-// result.AppendErrorWithFormat ("Usage: %s\n", m_cmd_syntax.c_str());
-// }
-// }
-// else
-// {
-// result.AppendError ("no current thread");
-// }
-// result.SetStatus (eReturnStatusFailed);
-// return false;
-// }
-//};
+//----------------------------------------------------------------------
+// Static Helper functions
+//----------------------------------------------------------------------
+static void
+DumpModuleArchitecture (Stream &strm, Module *module, bool full_triple, uint32_t width)
+{
+ if (module)
+ {
+ const char *arch_cstr;
+ if (full_triple)
+ arch_cstr = module->GetArchitecture().GetTriple().str().c_str();
+ else
+ arch_cstr = module->GetArchitecture().GetArchitectureName();
+ if (width)
+ strm.Printf("%-*s", width, arch_cstr);
+ else
+ strm.PutCString(arch_cstr);
+ }
+}
+
+static void
+DumpModuleUUID (Stream &strm, Module *module)
+{
+ module->GetUUID().Dump (&strm);
+}
+
+static uint32_t
+DumpCompileUnitLineTable
+(
+ CommandInterpreter &interpreter,
+ Stream &strm,
+ Module *module,
+ const FileSpec &file_spec,
+ bool load_addresses
+ )
+{
+ uint32_t num_matches = 0;
+ if (module)
+ {
+ SymbolContextList sc_list;
+ num_matches = module->ResolveSymbolContextsForFileSpec (file_spec,
+ 0,
+ false,
+ eSymbolContextCompUnit,
+ sc_list);
+
+ for (uint32_t i=0; i<num_matches; ++i)
+ {
+ SymbolContext sc;
+ if (sc_list.GetContextAtIndex(i, sc))
+ {
+ if (i > 0)
+ strm << "\n\n";
+
+ strm << "Line table for " << *static_cast<FileSpec*> (sc.comp_unit) << " in `"
+ << module->GetFileSpec().GetFilename() << "\n";
+ LineTable *line_table = sc.comp_unit->GetLineTable();
+ if (line_table)
+ line_table->GetDescription (&strm,
+ interpreter.GetExecutionContext().target,
+ lldb::eDescriptionLevelBrief);
+ else
+ strm << "No line table";
+ }
+ }
+ }
+ return num_matches;
+}
+
+static void
+DumpFullpath (Stream &strm, const FileSpec *file_spec_ptr, uint32_t width)
+{
+ if (file_spec_ptr)
+ {
+ if (width > 0)
+ {
+ char fullpath[PATH_MAX];
+ if (file_spec_ptr->GetPath(fullpath, sizeof(fullpath)))
+ {
+ strm.Printf("%-*s", width, fullpath);
+ return;
+ }
+ }
+ else
+ {
+ file_spec_ptr->Dump(&strm);
+ return;
+ }
+ }
+ // Keep the width spacing correct if things go wrong...
+ if (width > 0)
+ strm.Printf("%-*s", width, "");
+}
+
+static void
+DumpDirectory (Stream &strm, const FileSpec *file_spec_ptr, uint32_t width)
+{
+ if (file_spec_ptr)
+ {
+ if (width > 0)
+ strm.Printf("%-*s", width, file_spec_ptr->GetDirectory().AsCString(""));
+ else
+ file_spec_ptr->GetDirectory().Dump(&strm);
+ return;
+ }
+ // Keep the width spacing correct if things go wrong...
+ if (width > 0)
+ strm.Printf("%-*s", width, "");
+}
+
+static void
+DumpBasename (Stream &strm, const FileSpec *file_spec_ptr, uint32_t width)
+{
+ if (file_spec_ptr)
+ {
+ if (width > 0)
+ strm.Printf("%-*s", width, file_spec_ptr->GetFilename().AsCString(""));
+ else
+ file_spec_ptr->GetFilename().Dump(&strm);
+ return;
+ }
+ // Keep the width spacing correct if things go wrong...
+ if (width > 0)
+ strm.Printf("%-*s", width, "");
+}
+
+
+static void
+DumpModuleSymtab (CommandInterpreter &interpreter, Stream &strm, Module *module, SortOrder sort_order)
+{
+ if (module)
+ {
+ ObjectFile *objfile = module->GetObjectFile ();
+ if (objfile)
+ {
+ Symtab *symtab = objfile->GetSymtab();
+ if (symtab)
+ symtab->Dump(&strm, interpreter.GetExecutionContext().target, sort_order);
+ }
+ }
+}
+
+static void
+DumpModuleSections (CommandInterpreter &interpreter, Stream &strm, Module *module)
+{
+ if (module)
+ {
+ ObjectFile *objfile = module->GetObjectFile ();
+ if (objfile)
+ {
+ SectionList *section_list = objfile->GetSectionList();
+ if (section_list)
+ {
+ strm.PutCString ("Sections for '");
+ strm << module->GetFileSpec();
+ if (module->GetObjectName())
+ strm << '(' << module->GetObjectName() << ')';
+ strm.Printf ("' (%s):\n", module->GetArchitecture().GetArchitectureName());
+ strm.IndentMore();
+ section_list->Dump(&strm, interpreter.GetExecutionContext().target, true, UINT32_MAX);
+ strm.IndentLess();
+ }
+ }
+ }
+}
+
+static bool
+DumpModuleSymbolVendor (Stream &strm, Module *module)
+{
+ if (module)
+ {
+ SymbolVendor *symbol_vendor = module->GetSymbolVendor(true);
+ if (symbol_vendor)
+ {
+ symbol_vendor->Dump(&strm);
+ return true;
+ }
+ }
+ return false;
+}
+
+static bool
+LookupAddressInModule
+(
+ CommandInterpreter &interpreter,
+ Stream &strm,
+ Module *module,
+ uint32_t resolve_mask,
+ lldb::addr_t raw_addr,
+ lldb::addr_t offset,
+ bool verbose
+ )
+{
+ if (module)
+ {
+ lldb::addr_t addr = raw_addr - offset;
+ Address so_addr;
+ SymbolContext sc;
+ Target *target = interpreter.GetExecutionContext().target;
+ if (target && !target->GetSectionLoadList().IsEmpty())
+ {
+ if (!target->GetSectionLoadList().ResolveLoadAddress (addr, so_addr))
+ return false;
+ else if (so_addr.GetModule() != module)
+ return false;
+ }
+ else
+ {
+ if (!module->ResolveFileAddress (addr, so_addr))
+ return false;
+ }
+
+ // If an offset was given, print out the address we ended up looking up
+ if (offset)
+ strm.Printf("File Address: 0x%llx\n", addr);
+
+ ExecutionContextScope *exe_scope = interpreter.GetExecutionContext().GetBestExecutionContextScope();
+ strm.IndentMore();
+ strm.Indent (" Address: ");
+ so_addr.Dump (&strm, exe_scope, Address::DumpStyleSectionNameOffset);
+ strm.EOL();
+ strm.Indent (" Summary: ");
+ const uint32_t save_indent = strm.GetIndentLevel ();
+ strm.SetIndentLevel (save_indent + 11);
+ so_addr.Dump (&strm, exe_scope, Address::DumpStyleResolvedDescription);
+ strm.SetIndentLevel (save_indent);
+ strm.EOL();
+ // Print out detailed address information when verbose is enabled
+ if (verbose)
+ {
+ if (so_addr.Dump (&strm, exe_scope, Address::DumpStyleDetailedSymbolContext))
+ strm.EOL();
+ }
+ strm.IndentLess();
+ return true;
+ }
+
+ return false;
+}
+
+static uint32_t
+LookupSymbolInModule (CommandInterpreter &interpreter, Stream &strm, Module *module, const char *name, bool name_is_regex)
+{
+ if (module)
+ {
+ SymbolContext sc;
+
+ ObjectFile *objfile = module->GetObjectFile ();
+ if (objfile)
+ {
+ Symtab *symtab = objfile->GetSymtab();
+ if (symtab)
+ {
+ uint32_t i;
+ std::vector<uint32_t> match_indexes;
+ ConstString symbol_name (name);
+ uint32_t num_matches = 0;
+ if (name_is_regex)
+ {
+ RegularExpression name_regexp(name);
+ num_matches = symtab->AppendSymbolIndexesMatchingRegExAndType (name_regexp,
+ eSymbolTypeAny,
+ match_indexes);
+ }
+ else
+ {
+ num_matches = symtab->AppendSymbolIndexesWithName (symbol_name, match_indexes);
+ }
+
+
+ if (num_matches > 0)
+ {
+ strm.Indent ();
+ strm.Printf("%u symbols match %s'%s' in ", num_matches,
+ name_is_regex ? "the regular expression " : "", name);
+ DumpFullpath (strm, &module->GetFileSpec(), 0);
+ strm.PutCString(":\n");
+ strm.IndentMore ();
+ Symtab::DumpSymbolHeader (&strm);
+ for (i=0; i < num_matches; ++i)
+ {
+ Symbol *symbol = symtab->SymbolAtIndex(match_indexes[i]);
+ strm.Indent ();
+ symbol->Dump (&strm, interpreter.GetExecutionContext().target, i);
+ }
+ strm.IndentLess ();
+ return num_matches;
+ }
+ }
+ }
+ }
+ return 0;
+}
+
+
+static void
+DumpSymbolContextList (CommandInterpreter &interpreter, Stream &strm, SymbolContextList &sc_list, bool prepend_addr, bool verbose)
+{
+ strm.IndentMore ();
+ uint32_t i;
+ const uint32_t num_matches = sc_list.GetSize();
+
+ for (i=0; i<num_matches; ++i)
+ {
+ SymbolContext sc;
+ if (sc_list.GetContextAtIndex(i, sc))
+ {
+ strm.Indent();
+ ExecutionContextScope *exe_scope = interpreter.GetExecutionContext().GetBestExecutionContextScope ();
+
+ if (prepend_addr)
+ {
+ if (sc.line_entry.range.GetBaseAddress().IsValid())
+ {
+ sc.line_entry.range.GetBaseAddress().Dump (&strm,
+ exe_scope,
+ Address::DumpStyleLoadAddress,
+ Address::DumpStyleModuleWithFileAddress);
+ strm.PutCString(" in ");
+ }
+ }
+ sc.DumpStopContext(&strm,
+ exe_scope,
+ sc.line_entry.range.GetBaseAddress(),
+ true,
+ true,
+ false);
+ strm.EOL();
+ if (verbose)
+ {
+ if (sc.line_entry.range.GetBaseAddress().IsValid())
+ {
+ if (sc.line_entry.range.GetBaseAddress().Dump (&strm,
+ exe_scope,
+ Address::DumpStyleDetailedSymbolContext))
+ strm.PutCString("\n\n");
+ }
+ else if (sc.function->GetAddressRange().GetBaseAddress().IsValid())
+ {
+ if (sc.function->GetAddressRange().GetBaseAddress().Dump (&strm,
+ exe_scope,
+ Address::DumpStyleDetailedSymbolContext))
+ strm.PutCString("\n\n");
+ }
+ }
+ }
+ }
+ strm.IndentLess ();
+}
+
+static uint32_t
+LookupFunctionInModule (CommandInterpreter &interpreter, Stream &strm, Module *module, const char *name, bool name_is_regex, bool verbose)
+{
+ if (module && name && name[0])
+ {
+ SymbolContextList sc_list;
+ const bool include_symbols = false;
+ const bool append = true;
+ uint32_t num_matches = 0;
+ if (name_is_regex)
+ {
+ RegularExpression function_name_regex (name);
+ num_matches = module->FindFunctions (function_name_regex,
+ include_symbols,
+ append,
+ sc_list);
+ }
+ else
+ {
+ ConstString function_name (name);
+ num_matches = module->FindFunctions (function_name,
+ eFunctionNameTypeBase | eFunctionNameTypeFull | eFunctionNameTypeMethod | eFunctionNameTypeSelector,
+ include_symbols,
+ append,
+ sc_list);
+ }
+
+ if (num_matches)
+ {
+ strm.Indent ();
+ strm.Printf("%u match%s found in ", num_matches, num_matches > 1 ? "es" : "");
+ DumpFullpath (strm, &module->GetFileSpec(), 0);
+ strm.PutCString(":\n");
+ DumpSymbolContextList (interpreter, strm, sc_list, true, verbose);
+ }
+ return num_matches;
+ }
+ return 0;
+}
+
+static uint32_t
+LookupTypeInModule
+(
+ CommandInterpreter &interpreter,
+ Stream &strm,
+ Module *module,
+ const char *name_cstr,
+ bool name_is_regex
+ )
+{
+ if (module && name_cstr && name_cstr[0])
+ {
+ SymbolContextList sc_list;
+
+ SymbolVendor *symbol_vendor = module->GetSymbolVendor();
+ if (symbol_vendor)
+ {
+ TypeList type_list;
+ uint32_t num_matches = 0;
+ SymbolContext sc;
+ // if (name_is_regex)
+ // {
+ // RegularExpression name_regex (name_cstr);
+ // num_matches = symbol_vendor->FindFunctions(sc, name_regex, true, UINT32_MAX, type_list);
+ // }
+ // else
+ // {
+ ConstString name(name_cstr);
+ num_matches = symbol_vendor->FindTypes(sc, name, true, UINT32_MAX, type_list);
+ // }
+
+ if (num_matches)
+ {
+ strm.Indent ();
+ strm.Printf("%u match%s found in ", num_matches, num_matches > 1 ? "es" : "");
+ DumpFullpath (strm, &module->GetFileSpec(), 0);
+ strm.PutCString(":\n");
+ const uint32_t num_types = type_list.GetSize();
+ for (uint32_t i=0; i<num_types; ++i)
+ {
+ TypeSP type_sp (type_list.GetTypeAtIndex(i));
+ if (type_sp)
+ {
+ // Resolve the clang type so that any forward references
+ // to types that haven't yet been parsed will get parsed.
+ type_sp->GetClangFullType ();
+ type_sp->GetDescription (&strm, eDescriptionLevelFull, true);
+ }
+ strm.EOL();
+ }
+ }
+ return num_matches;
+ }
+ }
+ return 0;
+}
+
+static uint32_t
+LookupFileAndLineInModule (CommandInterpreter &interpreter,
+ Stream &strm,
+ Module *module,
+ const FileSpec &file_spec,
+ uint32_t line,
+ bool check_inlines,
+ bool verbose)
+{
+ if (module && file_spec)
+ {
+ SymbolContextList sc_list;
+ const uint32_t num_matches = module->ResolveSymbolContextsForFileSpec(file_spec, line, check_inlines,
+ eSymbolContextEverything, sc_list);
+ if (num_matches > 0)
+ {
+ strm.Indent ();
+ strm.Printf("%u match%s found in ", num_matches, num_matches > 1 ? "es" : "");
+ strm << file_spec;
+ if (line > 0)
+ strm.Printf (":%u", line);
+ strm << " in ";
+ DumpFullpath (strm, &module->GetFileSpec(), 0);
+ strm.PutCString(":\n");
+ DumpSymbolContextList (interpreter, strm, sc_list, true, verbose);
+ return num_matches;
+ }
+ }
+ return 0;
+
+}
+
+#pragma mark CommandObjectTargetModulesModuleAutoComplete
+
+//----------------------------------------------------------------------
+// A base command object class that can auto complete with module file
+// paths
+//----------------------------------------------------------------------
+
+class CommandObjectTargetModulesModuleAutoComplete : public CommandObject
+{
+public:
+
+ CommandObjectTargetModulesModuleAutoComplete (CommandInterpreter &interpreter,
+ const char *name,
+ const char *help,
+ const char *syntax) :
+ CommandObject (interpreter, name, help, syntax)
+ {
+ CommandArgumentEntry arg;
+ CommandArgumentData file_arg;
+
+ // Define the first (and only) variant of this arg.
+ file_arg.arg_type = eArgTypeFilename;
+ file_arg.arg_repetition = eArgRepeatStar;
+
+ // There is only one variant this argument could be; put it into the argument entry.
+ arg.push_back (file_arg);
+
+ // Push the data for the first argument into the m_arguments vector.
+ m_arguments.push_back (arg);
+ }
+
+ virtual
+ ~CommandObjectTargetModulesModuleAutoComplete ()
+ {
+ }
+
+ virtual int
+ HandleArgumentCompletion (Args &input,
+ int &cursor_index,
+ int &cursor_char_position,
+ OptionElementVector &opt_element_vector,
+ int match_start_point,
+ int max_return_elements,
+ bool &word_complete,
+ StringList &matches)
+ {
+ // Arguments are the standard module completer.
+ std::string completion_str (input.GetArgumentAtIndex(cursor_index));
+ completion_str.erase (cursor_char_position);
+
+ CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
+ CommandCompletions::eModuleCompletion,
+ completion_str.c_str(),
+ match_start_point,
+ max_return_elements,
+ NULL,
+ word_complete,
+ matches);
+ return matches.GetSize();
+ }
+};
+
+#pragma mark CommandObjectTargetModulesSourceFileAutoComplete
+
+//----------------------------------------------------------------------
+// A base command object class that can auto complete with module source
+// file paths
+//----------------------------------------------------------------------
+
+class CommandObjectTargetModulesSourceFileAutoComplete : public CommandObject
+{
+public:
+
+ CommandObjectTargetModulesSourceFileAutoComplete (CommandInterpreter &interpreter,
+ const char *name,
+ const char *help,
+ const char *syntax) :
+ CommandObject (interpreter, name, help, syntax)
+ {
+ CommandArgumentEntry arg;
+ CommandArgumentData source_file_arg;
+
+ // Define the first (and only) variant of this arg.
+ source_file_arg.arg_type = eArgTypeSourceFile;
+ source_file_arg.arg_repetition = eArgRepeatPlus;
+
+ // There is only one variant this argument could be; put it into the argument entry.
+ arg.push_back (source_file_arg);
+
+ // Push the data for the first argument into the m_arguments vector.
+ m_arguments.push_back (arg);
+ }
+
+ virtual
+ ~CommandObjectTargetModulesSourceFileAutoComplete ()
+ {
+ }
+
+ virtual int
+ HandleArgumentCompletion (Args &input,
+ int &cursor_index,
+ int &cursor_char_position,
+ OptionElementVector &opt_element_vector,
+ int match_start_point,
+ int max_return_elements,
+ bool &word_complete,
+ StringList &matches)
+ {
+ // Arguments are the standard source file completer.
+ std::string completion_str (input.GetArgumentAtIndex(cursor_index));
+ completion_str.erase (cursor_char_position);
+
+ CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
+ CommandCompletions::eSourceFileCompletion,
+ completion_str.c_str(),
+ match_start_point,
+ max_return_elements,
+ NULL,
+ word_complete,
+ matches);
+ return matches.GetSize();
+ }
+};
+
+
+#pragma mark CommandObjectTargetModulesDumpSymtab
+
+
+class CommandObjectTargetModulesDumpSymtab : public CommandObjectTargetModulesModuleAutoComplete
+{
+public:
+ CommandObjectTargetModulesDumpSymtab (CommandInterpreter &interpreter) :
+ CommandObjectTargetModulesModuleAutoComplete (interpreter,
+ "target modules dump symtab",
+ "Dump the symbol table from one or more target modules.",
+ NULL),
+ m_options (interpreter)
+ {
+ }
+
+ virtual
+ ~CommandObjectTargetModulesDumpSymtab ()
+ {
+ }
+
+ virtual bool
+ Execute (Args& command,
+ CommandReturnObject &result)
+ {
+ Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+ if (target == NULL)
+ {
+ result.AppendError ("invalid target, create a debug target using the 'target create' command");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ else
+ {
+ uint32_t num_dumped = 0;
+
+ uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
+ result.GetOutputStream().SetAddressByteSize(addr_byte_size);
+ result.GetErrorStream().SetAddressByteSize(addr_byte_size);
+
+ if (command.GetArgumentCount() == 0)
+ {
+ // Dump all sections for all modules images
+ const uint32_t num_modules = target->GetImages().GetSize();
+ if (num_modules > 0)
+ {
+ result.GetOutputStream().Printf("Dumping symbol table for %u modules.\n", num_modules);
+ for (uint32_t image_idx = 0; image_idx<num_modules; ++image_idx)
+ {
+ if (num_dumped > 0)
+ {
+ result.GetOutputStream().EOL();
+ result.GetOutputStream().EOL();
+ }
+ num_dumped++;
+ DumpModuleSymtab (m_interpreter, result.GetOutputStream(), target->GetImages().GetModulePointerAtIndex(image_idx), m_options.m_sort_order);
+ }
+ }
+ else
+ {
+ result.AppendError ("the target has no associated executable images");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ }
+ else
+ {
+ // Dump specified images (by basename or fullpath)
+ const char *arg_cstr;
+ for (int arg_idx = 0; (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != NULL; ++arg_idx)
+ {
+ FileSpec image_file(arg_cstr, false);
+ ModuleList matching_modules;
+ size_t num_matching_modules = target->GetImages().FindModules(&image_file, NULL, NULL, NULL, matching_modules);
+
+ // Not found in our module list for our target, check the main
+ // shared module list in case it is a extra file used somewhere
+ // else
+ if (num_matching_modules == 0)
+ num_matching_modules = ModuleList::FindSharedModules (image_file,
+ target->GetArchitecture(),
+ NULL,
+ NULL,
+ matching_modules);
+
+ if (num_matching_modules > 0)
+ {
+ for (size_t i=0; i<num_matching_modules; ++i)
+ {
+ Module *image_module = matching_modules.GetModulePointerAtIndex(i);
+ if (image_module)
+ {
+ if (num_dumped > 0)
+ {
+ result.GetOutputStream().EOL();
+ result.GetOutputStream().EOL();
+ }
+ num_dumped++;
+ DumpModuleSymtab (m_interpreter, result.GetOutputStream(), image_module, m_options.m_sort_order);
+ }
+ }
+ }
+ else
+ result.AppendWarningWithFormat("Unable to find an image that matches '%s'.\n", arg_cstr);
+ }
+ }
+
+ if (num_dumped > 0)
+ result.SetStatus (eReturnStatusSuccessFinishResult);
+ else
+ {
+ result.AppendError ("no matching executable images found");
+ result.SetStatus (eReturnStatusFailed);
+ }
+ }
+ return result.Succeeded();
+ }
+
+ virtual Options *
+ GetOptions ()
+ {
+ return &m_options;
+ }
+
+ class CommandOptions : public Options
+ {
+ public:
+
+ CommandOptions (CommandInterpreter &interpreter) :
+ Options(interpreter),
+ m_sort_order (eSortOrderNone)
+ {
+ }
+
+ virtual
+ ~CommandOptions ()
+ {
+ }
+
+ virtual Error
+ SetOptionValue (uint32_t option_idx, const char *option_arg)
+ {
+ Error error;
+ char short_option = (char) m_getopt_table[option_idx].val;
+
+ switch (short_option)
+ {
+ case 's':
+ {
+ bool found_one = false;
+ m_sort_order = (SortOrder) Args::StringToOptionEnum (option_arg,
+ g_option_table[option_idx].enum_values,
+ eSortOrderNone,
+ &found_one);
+ if (!found_one)
+ error.SetErrorStringWithFormat("Invalid enumeration value '%s' for option '%c'.\n",
+ option_arg,
+ short_option);
+ }
+ break;
+
+ default:
+ error.SetErrorStringWithFormat("Invalid short option character '%c'.\n", short_option);
+ break;
+
+ }
+ return error;
+ }
+
+ void
+ OptionParsingStarting ()
+ {
+ m_sort_order = eSortOrderNone;
+ }
+
+ const OptionDefinition*
+ GetDefinitions ()
+ {
+ return g_option_table;
+ }
+
+ // Options table: Required for subclasses of Options.
+ static OptionDefinition g_option_table[];
+
+ SortOrder m_sort_order;
+ };
+
+protected:
+
+ CommandOptions m_options;
+};
+
+static OptionEnumValueElement
+g_sort_option_enumeration[4] =
+{
+ { eSortOrderNone, "none", "No sorting, use the original symbol table order."},
+ { eSortOrderByAddress, "address", "Sort output by symbol address."},
+ { eSortOrderByName, "name", "Sort output by symbol name."},
+ { 0, NULL, NULL }
+};
+
+
+OptionDefinition
+CommandObjectTargetModulesDumpSymtab::CommandOptions::g_option_table[] =
+{
+ { LLDB_OPT_SET_1, false, "sort", 's', required_argument, g_sort_option_enumeration, 0, eArgTypeSortOrder, "Supply a sort order when dumping the symbol table."},
+ { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
+};
+
+#pragma mark CommandObjectTargetModulesDumpSections
+
+//----------------------------------------------------------------------
+// Image section dumping command
+//----------------------------------------------------------------------
+
+class CommandObjectTargetModulesDumpSections : public CommandObjectTargetModulesModuleAutoComplete
+{
+public:
+ CommandObjectTargetModulesDumpSections (CommandInterpreter &interpreter) :
+ CommandObjectTargetModulesModuleAutoComplete (interpreter,
+ "target modules dump sections",
+ "Dump the sections from one or more target modules.",
+ //"target modules dump sections [<file1> ...]")
+ NULL)
+ {
+ }
+
+ virtual
+ ~CommandObjectTargetModulesDumpSections ()
+ {
+ }
+
+ virtual bool
+ Execute (Args& command,
+ CommandReturnObject &result)
+ {
+ Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+ if (target == NULL)
+ {
+ result.AppendError ("invalid target, create a debug target using the 'target create' command");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ else
+ {
+ uint32_t num_dumped = 0;
+
+ uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
+ result.GetOutputStream().SetAddressByteSize(addr_byte_size);
+ result.GetErrorStream().SetAddressByteSize(addr_byte_size);
+
+ if (command.GetArgumentCount() == 0)
+ {
+ // Dump all sections for all modules images
+ const uint32_t num_modules = target->GetImages().GetSize();
+ if (num_modules > 0)
+ {
+ result.GetOutputStream().Printf("Dumping sections for %u modules.\n", num_modules);
+ for (uint32_t image_idx = 0; image_idx<num_modules; ++image_idx)
+ {
+ num_dumped++;
+ DumpModuleSections (m_interpreter, result.GetOutputStream(), target->GetImages().GetModulePointerAtIndex(image_idx));
+ }
+ }
+ else
+ {
+ result.AppendError ("the target has no associated executable images");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ }
+ else
+ {
+ // Dump specified images (by basename or fullpath)
+ const char *arg_cstr;
+ for (int arg_idx = 0; (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != NULL; ++arg_idx)
+ {
+ FileSpec image_file(arg_cstr, false);
+ ModuleList matching_modules;
+ size_t num_matching_modules = target->GetImages().FindModules(&image_file, NULL, NULL, NULL, matching_modules);
+
+ // Not found in our module list for our target, check the main
+ // shared module list in case it is a extra file used somewhere
+ // else
+ if (num_matching_modules == 0)
+ num_matching_modules = ModuleList::FindSharedModules (image_file,
+ target->GetArchitecture(),
+ NULL,
+ NULL,
+ matching_modules);
+
+ if (num_matching_modules > 0)
+ {
+ for (size_t i=0; i<num_matching_modules; ++i)
+ {
+ Module * image_module = matching_modules.GetModulePointerAtIndex(i);
+ if (image_module)
+ {
+ num_dumped++;
+ DumpModuleSections (m_interpreter, result.GetOutputStream(), image_module);
+ }
+ }
+ }
+ else
+ result.AppendWarningWithFormat("Unable to find an image that matches '%s'.\n", arg_cstr);
+ }
+ }
+
+ if (num_dumped > 0)
+ result.SetStatus (eReturnStatusSuccessFinishResult);
+ else
+ {
+ result.AppendError ("no matching executable images found");
+ result.SetStatus (eReturnStatusFailed);
+ }
+ }
+ return result.Succeeded();
+ }
+};
+
+
+#pragma mark CommandObjectTargetModulesDumpSymfile
+
+//----------------------------------------------------------------------
+// Image debug symbol dumping command
+//----------------------------------------------------------------------
+
+class CommandObjectTargetModulesDumpSymfile : public CommandObjectTargetModulesModuleAutoComplete
+{
+public:
+ CommandObjectTargetModulesDumpSymfile (CommandInterpreter &interpreter) :
+ CommandObjectTargetModulesModuleAutoComplete (interpreter,
+ "target modules dump symfile",
+ "Dump the debug symbol file for one or more target modules.",
+ //"target modules dump symfile [<file1> ...]")
+ NULL)
+ {
+ }
+
+ virtual
+ ~CommandObjectTargetModulesDumpSymfile ()
+ {
+ }
+
+ virtual bool
+ Execute (Args& command,
+ CommandReturnObject &result)
+ {
+ Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+ if (target == NULL)
+ {
+ result.AppendError ("invalid target, create a debug target using the 'target create' command");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ else
+ {
+ uint32_t num_dumped = 0;
+
+ uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
+ result.GetOutputStream().SetAddressByteSize(addr_byte_size);
+ result.GetErrorStream().SetAddressByteSize(addr_byte_size);
+
+ if (command.GetArgumentCount() == 0)
+ {
+ // Dump all sections for all modules images
+ const uint32_t num_modules = target->GetImages().GetSize();
+ if (num_modules > 0)
+ {
+ result.GetOutputStream().Printf("Dumping debug symbols for %u modules.\n", num_modules);
+ for (uint32_t image_idx = 0; image_idx<num_modules; ++image_idx)
+ {
+ if (DumpModuleSymbolVendor (result.GetOutputStream(), target->GetImages().GetModulePointerAtIndex(image_idx)))
+ num_dumped++;
+ }
+ }
+ else
+ {
+ result.AppendError ("the target has no associated executable images");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ }
+ else
+ {
+ // Dump specified images (by basename or fullpath)
+ const char *arg_cstr;
+ for (int arg_idx = 0; (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != NULL; ++arg_idx)
+ {
+ FileSpec image_file(arg_cstr, false);
+ ModuleList matching_modules;
+ size_t num_matching_modules = target->GetImages().FindModules(&image_file, NULL, NULL, NULL, matching_modules);
+
+ // Not found in our module list for our target, check the main
+ // shared module list in case it is a extra file used somewhere
+ // else
+ if (num_matching_modules == 0)
+ num_matching_modules = ModuleList::FindSharedModules (image_file,
+ target->GetArchitecture(),
+ NULL,
+ NULL,
+ matching_modules);
+
+ if (num_matching_modules > 0)
+ {
+ for (size_t i=0; i<num_matching_modules; ++i)
+ {
+ Module * image_module = matching_modules.GetModulePointerAtIndex(i);
+ if (image_module)
+ {
+ if (DumpModuleSymbolVendor (result.GetOutputStream(), image_module))
+ num_dumped++;
+ }
+ }
+ }
+ else
+ result.AppendWarningWithFormat("Unable to find an image that matches '%s'.\n", arg_cstr);
+ }
+ }
+
+ if (num_dumped > 0)
+ result.SetStatus (eReturnStatusSuccessFinishResult);
+ else
+ {
+ result.AppendError ("no matching executable images found");
+ result.SetStatus (eReturnStatusFailed);
+ }
+ }
+ return result.Succeeded();
+ }
+};
+
+
+#pragma mark CommandObjectTargetModulesDumpLineTable
+
+//----------------------------------------------------------------------
+// Image debug line table dumping command
+//----------------------------------------------------------------------
+
+class CommandObjectTargetModulesDumpLineTable : public CommandObjectTargetModulesSourceFileAutoComplete
+{
+public:
+ CommandObjectTargetModulesDumpLineTable (CommandInterpreter &interpreter) :
+ CommandObjectTargetModulesSourceFileAutoComplete (interpreter,
+ "target modules dump line-table",
+ "Dump the debug symbol file for one or more target modules.",
+ NULL)
+ {
+ }
+
+ virtual
+ ~CommandObjectTargetModulesDumpLineTable ()
+ {
+ }
+
+ virtual bool
+ Execute (Args& command,
+ CommandReturnObject &result)
+ {
+ Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+ if (target == NULL)
+ {
+ result.AppendError ("invalid target, create a debug target using the 'target create' command");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ else
+ {
+ ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
+ uint32_t total_num_dumped = 0;
+
+ uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
+ result.GetOutputStream().SetAddressByteSize(addr_byte_size);
+ result.GetErrorStream().SetAddressByteSize(addr_byte_size);
+
+ if (command.GetArgumentCount() == 0)
+ {
+ result.AppendErrorWithFormat ("\nSyntax: %s\n", m_cmd_syntax.c_str());
+ result.SetStatus (eReturnStatusFailed);
+ }
+ else
+ {
+ // Dump specified images (by basename or fullpath)
+ const char *arg_cstr;
+ for (int arg_idx = 0; (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != NULL; ++arg_idx)
+ {
+ FileSpec file_spec(arg_cstr, false);
+ const uint32_t num_modules = target->GetImages().GetSize();
+ if (num_modules > 0)
+ {
+ uint32_t num_dumped = 0;
+ for (uint32_t i = 0; i<num_modules; ++i)
+ {
+ if (DumpCompileUnitLineTable (m_interpreter,
+ result.GetOutputStream(),
+ target->GetImages().GetModulePointerAtIndex(i),
+ file_spec,
+ exe_ctx.process != NULL && exe_ctx.process->IsAlive()))
+ num_dumped++;
+ }
+ if (num_dumped == 0)
+ result.AppendWarningWithFormat ("No source filenames matched '%s'.\n", arg_cstr);
+ else
+ total_num_dumped += num_dumped;
+ }
+ }
+ }
+
+ if (total_num_dumped > 0)
+ result.SetStatus (eReturnStatusSuccessFinishResult);
+ else
+ {
+ result.AppendError ("no source filenames matched any command arguments");
+ result.SetStatus (eReturnStatusFailed);
+ }
+ }
+ return result.Succeeded();
+ }
+};
+
+
+#pragma mark CommandObjectTargetModulesDump
+
+//----------------------------------------------------------------------
+// Dump multi-word command for target modules
+//----------------------------------------------------------------------
+
+class CommandObjectTargetModulesDump : public CommandObjectMultiword
+{
+public:
+
+ //------------------------------------------------------------------
+ // Constructors and Destructors
+ //------------------------------------------------------------------
+ CommandObjectTargetModulesDump(CommandInterpreter &interpreter) :
+ CommandObjectMultiword (interpreter,
+ "target modules dump",
+ "A set of commands for dumping information about one or more target modules.",
+ "target modules dump [symtab|sections|symfile|line-table] [<file1> <file2> ...]")
+ {
+ LoadSubCommand ("symtab", CommandObjectSP (new CommandObjectTargetModulesDumpSymtab (interpreter)));
+ LoadSubCommand ("sections", CommandObjectSP (new CommandObjectTargetModulesDumpSections (interpreter)));
+ LoadSubCommand ("symfile", CommandObjectSP (new CommandObjectTargetModulesDumpSymfile (interpreter)));
+ LoadSubCommand ("line-table", CommandObjectSP (new CommandObjectTargetModulesDumpLineTable (interpreter)));
+ }
+
+ virtual
+ ~CommandObjectTargetModulesDump()
+ {
+ }
+};
+
+class CommandObjectTargetModulesAdd : public CommandObject
+{
+public:
+ CommandObjectTargetModulesAdd (CommandInterpreter &interpreter) :
+ CommandObject (interpreter,
+ "target modules add",
+ "Add a new module to the current target's modules.",
+ "target modules add [<module>]")
+ {
+ }
+
+ virtual
+ ~CommandObjectTargetModulesAdd ()
+ {
+ }
+
+ virtual bool
+ Execute (Args& args,
+ CommandReturnObject &result)
+ {
+ Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+ if (target == NULL)
+ {
+ result.AppendError ("invalid target, create a debug target using the 'target create' command");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ else
+ {
+ const size_t argc = args.GetArgumentCount();
+ if (argc == 0)
+ {
+ result.AppendError ("one or more executable image paths must be specified");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ else
+ {
+ for (size_t i=0; i<argc; ++i)
+ {
+ const char *path = args.GetArgumentAtIndex(i);
+ if (path)
+ {
+ FileSpec file_spec(path, true);
+ ArchSpec arch;
+ if (file_spec.Exists())
+ {
+ ModuleSP module_sp (target->GetSharedModule(file_spec, arch));
+ if (!module_sp)
+ {
+ result.AppendError ("one or more executable image paths must be specified");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ }
+ else
+ {
+ char resolved_path[PATH_MAX];
+ result.SetStatus (eReturnStatusFailed);
+ if (file_spec.GetPath (resolved_path, sizeof(resolved_path)))
+ {
+ if (strcmp (resolved_path, path) != 0)
+ {
+ result.AppendErrorWithFormat ("invalid module path '%s' with resolved path '%s'\n", path, resolved_path);
+ break;
+ }
+ }
+ result.AppendErrorWithFormat ("invalid module path '%s'\n", path);
+ break;
+ }
+ }
+ }
+ }
+ }
+ return result.Succeeded();
+ }
+
+ int
+ HandleArgumentCompletion (Args &input,
+ int &cursor_index,
+ int &cursor_char_position,
+ OptionElementVector &opt_element_vector,
+ int match_start_point,
+ int max_return_elements,
+ bool &word_complete,
+ StringList &matches)
+ {
+ std::string completion_str (input.GetArgumentAtIndex(cursor_index));
+ completion_str.erase (cursor_char_position);
+
+ CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
+ CommandCompletions::eDiskFileCompletion,
+ completion_str.c_str(),
+ match_start_point,
+ max_return_elements,
+ NULL,
+ word_complete,
+ matches);
+ return matches.GetSize();
+ }
+
+};
+
+class CommandObjectTargetModulesLoad : public CommandObjectTargetModulesModuleAutoComplete
+{
+public:
+ CommandObjectTargetModulesLoad (CommandInterpreter &interpreter) :
+ CommandObjectTargetModulesModuleAutoComplete (interpreter,
+ "target modules load",
+ "Set the load addresses for one or more sections in a target module.",
+ "target modules load [--file <module> --uuid <uuid>] <sect-name> <address> [<sect-name> <address> ....]"),
+ m_option_group (interpreter),
+ m_file_option (LLDB_OPT_SET_1, false, "file", 'f', 0, eArgTypePath, "Fullpath or basename for module to load."),
+ m_slide_option(LLDB_OPT_SET_1, false, "slide", 's', 0, eArgTypeOffset, "Set the load address for all sections to be the virtual address in the file plus the offset.", 0)
+ {
+ m_option_group.Append (&m_uuid_option_group, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
+ m_option_group.Append (&m_file_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
+ m_option_group.Append (&m_slide_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
+ m_option_group.Finalize();
+ }
+
+ virtual
+ ~CommandObjectTargetModulesLoad ()
+ {
+ }
+
+ virtual bool
+ Execute (Args& args,
+ CommandReturnObject &result)
+ {
+ Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+ if (target == NULL)
+ {
+ result.AppendError ("invalid target, create a debug target using the 'target create' command");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ else
+ {
+ const size_t argc = args.GetArgumentCount();
+ const FileSpec *file_ptr = NULL;
+ const UUID *uuid_ptr = NULL;
+ if (m_file_option.GetOptionValue().OptionWasSet())
+ file_ptr = &m_file_option.GetOptionValue().GetCurrentValue();
+
+ if (m_uuid_option_group.GetOptionValue().OptionWasSet())
+ uuid_ptr = &m_uuid_option_group.GetOptionValue().GetCurrentValue();
+
+ if (file_ptr || uuid_ptr)
+ {
+
+ ModuleList matching_modules;
+ const size_t num_matches = target->GetImages().FindModules (file_ptr, // File spec to match (can be NULL to match by UUID only)
+ NULL, // Architecture
+ uuid_ptr, // UUID to match (can be NULL to not match on UUID)
+ NULL, // Object name
+ matching_modules);
+
+ char path[PATH_MAX];
+ if (num_matches == 1)
+ {
+ Module *module = matching_modules.GetModulePointerAtIndex(0);
+ if (module)
+ {
+ ObjectFile *objfile = module->GetObjectFile();
+ if (objfile)
+ {
+ SectionList *section_list = objfile->GetSectionList();
+ if (section_list)
+ {
+ if (argc == 0)
+ {
+ if (m_slide_option.GetOptionValue().OptionWasSet())
+ {
+ Module *module = matching_modules.GetModulePointerAtIndex(0);
+ if (module)
+ {
+ ObjectFile *objfile = module->GetObjectFile();
+ if (objfile)
+ {
+ SectionList *section_list = objfile->GetSectionList();
+ if (section_list)
+ {
+ const size_t num_sections = section_list->GetSize();
+ const addr_t slide = m_slide_option.GetOptionValue().GetCurrentValue();
+ for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx)
+ {
+ SectionSP section_sp (section_list->GetSectionAtIndex(sect_idx));
+ if (section_sp)
+ target->GetSectionLoadList().SetSectionLoadAddress (section_sp.get(), section_sp->GetFileAddress() + slide);
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ result.AppendError ("one or more section name + load address pair must be specified");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ }
+ else
+ {
+ if (m_slide_option.GetOptionValue().OptionWasSet())
+ {
+ result.AppendError ("The \"--slide <offset>\" option can't be used in conjunction with setting section load addresses.\n");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+
+ for (size_t i=0; i<argc; i += 2)
+ {
+ const char *sect_name = args.GetArgumentAtIndex(i);
+ const char *load_addr_cstr = args.GetArgumentAtIndex(i+1);
+ if (sect_name && load_addr_cstr)
+ {
+ ConstString const_sect_name(sect_name);
+ bool success = false;
+ addr_t load_addr = Args::StringToUInt64(load_addr_cstr, LLDB_INVALID_ADDRESS, 0, &success);
+ if (success)
+ {
+ SectionSP section_sp (section_list->FindSectionByName(const_sect_name));
+ if (section_sp)
+ {
+ target->GetSectionLoadList().SetSectionLoadAddress (section_sp.get(), load_addr);
+ result.AppendMessageWithFormat("section '%s' loaded at 0x%llx\n", sect_name, load_addr);
+ }
+ else
+ {
+ result.AppendErrorWithFormat ("no section found that matches the section name '%s'\n", sect_name);
+ result.SetStatus (eReturnStatusFailed);
+ break;
+ }
+ }
+ else
+ {
+ result.AppendErrorWithFormat ("invalid load address string '%s'\n", load_addr_cstr);
+ result.SetStatus (eReturnStatusFailed);
+ break;
+ }
+ }
+ else
+ {
+ if (sect_name)
+ result.AppendError ("section names must be followed by a load address.\n");
+ else
+ result.AppendError ("one or more section name + load address pair must be specified.\n");
+ result.SetStatus (eReturnStatusFailed);
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ module->GetFileSpec().GetPath (path, sizeof(path));
+ result.AppendErrorWithFormat ("no sections in object file '%s'\n", path);
+ result.SetStatus (eReturnStatusFailed);
+ }
+ }
+ else
+ {
+ module->GetFileSpec().GetPath (path, sizeof(path));
+ result.AppendErrorWithFormat ("no object file for module '%s'\n", path);
+ result.SetStatus (eReturnStatusFailed);
+ }
+ }
+ else
+ {
+ module->GetFileSpec().GetPath (path, sizeof(path));
+ result.AppendErrorWithFormat ("invalid module '%s'.\n", path);
+ result.SetStatus (eReturnStatusFailed);
+ }
+ }
+ else
+ {
+ char uuid_cstr[64];
+ if (file_ptr)
+ file_ptr->GetPath (path, sizeof(path));
+ else
+ path[0] = '\0';
+
+ if (uuid_ptr)
+ uuid_ptr->GetAsCString(uuid_cstr, sizeof(uuid_cstr));
+ else
+ uuid_cstr[0] = '\0';
+ if (num_matches > 1)
+ {
+ result.AppendErrorWithFormat ("multiple modules match%s%s%s%s:\n",
+ path[0] ? " file=" : "",
+ path,
+ uuid_cstr[0] ? " uuid=" : "",
+ uuid_cstr);
+ for (size_t i=0; i<num_matches; ++i)
+ {
+ if (matching_modules.GetModulePointerAtIndex(i)->GetFileSpec().GetPath (path, sizeof(path)))
+ result.AppendMessageWithFormat("%s\n", path);
+ }
+ }
+ else
+ {
+ result.AppendErrorWithFormat ("no modules were found that match%s%s%s%s.\n",
+ path[0] ? " file=" : "",
+ path,
+ uuid_cstr[0] ? " uuid=" : "",
+ uuid_cstr);
+ }
+ result.SetStatus (eReturnStatusFailed);
+ }
+ }
+ else
+ {
+ result.AppendError ("either the \"--file <module>\" or the \"--uuid <uuid>\" option must be specified.\n");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ }
+ return result.Succeeded();
+ }
+
+ virtual Options *
+ GetOptions ()
+ {
+ return &m_option_group;
+ }
+
+protected:
+ OptionGroupOptions m_option_group;
+ OptionGroupUUID m_uuid_option_group;
+ OptionGroupFile m_file_option;
+ OptionGroupUInt64 m_slide_option;
+};
+
+//----------------------------------------------------------------------
+// List images with associated information
+//----------------------------------------------------------------------
+class CommandObjectTargetModulesList : public CommandObject
+{
+public:
+
+ class CommandOptions : public Options
+ {
+ public:
+
+ CommandOptions (CommandInterpreter &interpreter) :
+ Options(interpreter),
+ m_format_array()
+ {
+ }
+
+ virtual
+ ~CommandOptions ()
+ {
+ }
+
+ virtual Error
+ SetOptionValue (uint32_t option_idx, const char *option_arg)
+ {
+ char short_option = (char) m_getopt_table[option_idx].val;
+ uint32_t width = 0;
+ if (option_arg)
+ width = strtoul (option_arg, NULL, 0);
+ m_format_array.push_back(std::make_pair(short_option, width));
+ Error error;
+ return error;
+ }
+
+ void
+ OptionParsingStarting ()
+ {
+ m_format_array.clear();
+ }
+
+ const OptionDefinition*
+ GetDefinitions ()
+ {
+ return g_option_table;
+ }
+
+ // Options table: Required for subclasses of Options.
+
+ static OptionDefinition g_option_table[];
+
+ // Instance variables to hold the values for command options.
+ typedef std::vector< std::pair<char, uint32_t> > FormatWidthCollection;
+ FormatWidthCollection m_format_array;
+ };
+
+ CommandObjectTargetModulesList (CommandInterpreter &interpreter) :
+ CommandObject (interpreter,
+ "target modules list",
+ "List current executable and dependent shared library images.",
+ "target modules list [<cmd-options>]"),
+ m_options (interpreter)
+ {
+ }
+
+ virtual
+ ~CommandObjectTargetModulesList ()
+ {
+ }
+
+ virtual
+ Options *
+ GetOptions ()
+ {
+ return &m_options;
+ }
+
+ virtual bool
+ Execute (Args& command,
+ CommandReturnObject &result)
+ {
+ Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+ if (target == NULL)
+ {
+ result.AppendError ("invalid target, create a debug target using the 'target create' command");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ else
+ {
+ uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
+ result.GetOutputStream().SetAddressByteSize(addr_byte_size);
+ result.GetErrorStream().SetAddressByteSize(addr_byte_size);
+ // Dump all sections for all modules images
+ const uint32_t num_modules = target->GetImages().GetSize();
+ if (num_modules > 0)
+ {
+ Stream &strm = result.GetOutputStream();
+
+ for (uint32_t image_idx = 0; image_idx<num_modules; ++image_idx)
+ {
+ Module *module = target->GetImages().GetModulePointerAtIndex(image_idx);
+ strm.Printf("[%3u] ", image_idx);
+
+ bool dump_object_name = false;
+ if (m_options.m_format_array.empty())
+ {
+ DumpFullpath(strm, &module->GetFileSpec(), 0);
+ dump_object_name = true;
+ }
+ else
+ {
+ const size_t num_entries = m_options.m_format_array.size();
+ for (size_t i=0; i<num_entries; ++i)
+ {
+ if (i > 0)
+ strm.PutChar(' ');
+ char format_char = m_options.m_format_array[i].first;
+ uint32_t width = m_options.m_format_array[i].second;
+ switch (format_char)
+ {
+ case 'a':
+ DumpModuleArchitecture (strm, module, false, width);
+ break;
+
+ case 't':
+ DumpModuleArchitecture (strm, module, true, width);
+ break;
+
+ case 'f':
+ DumpFullpath (strm, &module->GetFileSpec(), width);
+ dump_object_name = true;
+ break;
+
+ case 'd':
+ DumpDirectory (strm, &module->GetFileSpec(), width);
+ break;
+
+ case 'b':
+ DumpBasename (strm, &module->GetFileSpec(), width);
+ dump_object_name = true;
+ break;
+
+ case 's':
+ case 'S':
+ {
+ SymbolVendor *symbol_vendor = module->GetSymbolVendor();
+ if (symbol_vendor)
+ {
+ SymbolFile *symbol_file = symbol_vendor->GetSymbolFile();
+ if (symbol_file)
+ {
+ if (format_char == 'S')
+ DumpBasename(strm, &symbol_file->GetObjectFile()->GetFileSpec(), width);
+ else
+ DumpFullpath (strm, &symbol_file->GetObjectFile()->GetFileSpec(), width);
+ dump_object_name = true;
+ break;
+ }
+ }
+ strm.Printf("%.*s", width, "<NONE>");
+ }
+ break;
+
+ case 'u':
+ DumpModuleUUID(strm, module);
+ break;
+
+ default:
+ break;
+ }
+
+ }
+ }
+ if (dump_object_name)
+ {
+ const char *object_name = module->GetObjectName().GetCString();
+ if (object_name)
+ strm.Printf ("(%s)", object_name);
+ }
+ strm.EOL();
+ }
+ result.SetStatus (eReturnStatusSuccessFinishResult);
+ }
+ else
+ {
+ result.AppendError ("the target has no associated executable images");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ }
+ return result.Succeeded();
+ }
+protected:
+
+ CommandOptions m_options;
+};
+
+OptionDefinition
+CommandObjectTargetModulesList::CommandOptions::g_option_table[] =
+{
+ { LLDB_OPT_SET_1, false, "arch", 'a', optional_argument, NULL, 0, eArgTypeWidth, "Display the architecture when listing images."},
+ { LLDB_OPT_SET_1, false, "triple", 't', optional_argument, NULL, 0, eArgTypeWidth, "Display the triple when listing images."},
+ { LLDB_OPT_SET_1, false, "uuid", 'u', no_argument, NULL, 0, eArgTypeNone, "Display the UUID when listing images."},
+ { LLDB_OPT_SET_1, false, "fullpath", 'f', optional_argument, NULL, 0, eArgTypeWidth, "Display the fullpath to the image object file."},
+ { LLDB_OPT_SET_1, false, "directory", 'd', optional_argument, NULL, 0, eArgTypeWidth, "Display the directory with optional width for the image object file."},
+ { LLDB_OPT_SET_1, false, "basename", 'b', optional_argument, NULL, 0, eArgTypeWidth, "Display the basename with optional width for the image object file."},
+ { LLDB_OPT_SET_1, false, "symfile", 's', optional_argument, NULL, 0, eArgTypeWidth, "Display the fullpath to the image symbol file with optional width."},
+ { LLDB_OPT_SET_1, false, "symfile-basename", 'S', optional_argument, NULL, 0, eArgTypeWidth, "Display the basename to the image symbol file with optional width."},
+ { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
+};
+
+
+
+//----------------------------------------------------------------------
+// Lookup information in images
+//----------------------------------------------------------------------
+class CommandObjectTargetModulesLookup : public CommandObject
+{
+public:
+
+ enum
+ {
+ eLookupTypeInvalid = -1,
+ eLookupTypeAddress = 0,
+ eLookupTypeSymbol,
+ eLookupTypeFileLine, // Line is optional
+ eLookupTypeFunction,
+ eLookupTypeType,
+ kNumLookupTypes
+ };
+
+ class CommandOptions : public Options
+ {
+ public:
+
+ CommandOptions (CommandInterpreter &interpreter) :
+ Options(interpreter)
+ {
+ OptionParsingStarting();
+ }
+
+ virtual
+ ~CommandOptions ()
+ {
+ }
+
+ virtual Error
+ SetOptionValue (uint32_t option_idx, const char *option_arg)
+ {
+ Error error;
+
+ char short_option = (char) m_getopt_table[option_idx].val;
+
+ switch (short_option)
+ {
+ case 'a':
+ m_type = eLookupTypeAddress;
+ m_addr = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS);
+ if (m_addr == LLDB_INVALID_ADDRESS)
+ error.SetErrorStringWithFormat ("Invalid address string '%s'.\n", option_arg);
+ break;
+
+ case 'o':
+ m_offset = Args::StringToUInt64(option_arg, LLDB_INVALID_ADDRESS);
+ if (m_offset == LLDB_INVALID_ADDRESS)
+ error.SetErrorStringWithFormat ("Invalid offset string '%s'.\n", option_arg);
+ break;
+
+ case 's':
+ m_str = option_arg;
+ m_type = eLookupTypeSymbol;
+ break;
+
+ case 'f':
+ m_file.SetFile (option_arg, false);
+ m_type = eLookupTypeFileLine;
+ break;
+
+ case 'i':
+ m_check_inlines = false;
+ break;
+
+ case 'l':
+ m_line_number = Args::StringToUInt32(option_arg, UINT32_MAX);
+ if (m_line_number == UINT32_MAX)
+ error.SetErrorStringWithFormat ("Invalid line number string '%s'.\n", option_arg);
+ else if (m_line_number == 0)
+ error.SetErrorString ("Zero is an invalid line number.");
+ m_type = eLookupTypeFileLine;
+ break;
+
+ case 'n':
+ m_str = option_arg;
+ m_type = eLookupTypeFunction;
+ break;
+
+ case 't':
+ m_str = option_arg;
+ m_type = eLookupTypeType;
+ break;
+
+ case 'v':
+ m_verbose = 1;
+ break;
+
+ case 'r':
+ m_use_regex = true;
+ break;
+ }
+
+ return error;
+ }
+
+ void
+ OptionParsingStarting ()
+ {
+ m_type = eLookupTypeInvalid;
+ m_str.clear();
+ m_file.Clear();
+ m_addr = LLDB_INVALID_ADDRESS;
+ m_offset = 0;
+ m_line_number = 0;
+ m_use_regex = false;
+ m_check_inlines = true;
+ m_verbose = false;
+ }
+
+ const OptionDefinition*
+ GetDefinitions ()
+ {
+ return g_option_table;
+ }
+
+ // Options table: Required for subclasses of Options.
+
+ static OptionDefinition g_option_table[];
+ int m_type; // Should be a eLookupTypeXXX enum after parsing options
+ std::string m_str; // Holds name lookup
+ FileSpec m_file; // Files for file lookups
+ lldb::addr_t m_addr; // Holds the address to lookup
+ lldb::addr_t m_offset; // Subtract this offset from m_addr before doing lookups.
+ uint32_t m_line_number; // Line number for file+line lookups
+ bool m_use_regex; // Name lookups in m_str are regular expressions.
+ bool m_check_inlines;// Check for inline entries when looking up by file/line.
+ bool m_verbose; // Enable verbose lookup info
+
+ };
+
+ CommandObjectTargetModulesLookup (CommandInterpreter &interpreter) :
+ CommandObject (interpreter,
+ "target modules lookup",
+ "Look up information within executable and dependent shared library images.",
+ NULL),
+ m_options (interpreter)
+ {
+ CommandArgumentEntry arg;
+ CommandArgumentData file_arg;
+
+ // Define the first (and only) variant of this arg.
+ file_arg.arg_type = eArgTypeFilename;
+ file_arg.arg_repetition = eArgRepeatStar;
+
+ // There is only one variant this argument could be; put it into the argument entry.
+ arg.push_back (file_arg);
+
+ // Push the data for the first argument into the m_arguments vector.
+ m_arguments.push_back (arg);
+ }
+
+ virtual
+ ~CommandObjectTargetModulesLookup ()
+ {
+ }
+
+ virtual Options *
+ GetOptions ()
+ {
+ return &m_options;
+ }
+
+
+ bool
+ LookupInModule (CommandInterpreter &interpreter, Module *module, CommandReturnObject &result, bool &syntax_error)
+ {
+ switch (m_options.m_type)
+ {
+ case eLookupTypeAddress:
+ if (m_options.m_addr != LLDB_INVALID_ADDRESS)
+ {
+ if (LookupAddressInModule (m_interpreter,
+ result.GetOutputStream(),
+ module,
+ eSymbolContextEverything,
+ m_options.m_addr,
+ m_options.m_offset,
+ m_options.m_verbose))
+ {
+ result.SetStatus(eReturnStatusSuccessFinishResult);
+ return true;
+ }
+ }
+ break;
+
+ case eLookupTypeSymbol:
+ if (!m_options.m_str.empty())
+ {
+ if (LookupSymbolInModule (m_interpreter, result.GetOutputStream(), module, m_options.m_str.c_str(), m_options.m_use_regex))
+ {
+ result.SetStatus(eReturnStatusSuccessFinishResult);
+ return true;
+ }
+ }
+ break;
+
+ case eLookupTypeFileLine:
+ if (m_options.m_file)
+ {
+
+ if (LookupFileAndLineInModule (m_interpreter,
+ result.GetOutputStream(),
+ module,
+ m_options.m_file,
+ m_options.m_line_number,
+ m_options.m_check_inlines,
+ m_options.m_verbose))
+ {
+ result.SetStatus(eReturnStatusSuccessFinishResult);
+ return true;
+ }
+ }
+ break;
+
+ case eLookupTypeFunction:
+ if (!m_options.m_str.empty())
+ {
+ if (LookupFunctionInModule (m_interpreter,
+ result.GetOutputStream(),
+ module,
+ m_options.m_str.c_str(),
+ m_options.m_use_regex,
+ m_options.m_verbose))
+ {
+ result.SetStatus(eReturnStatusSuccessFinishResult);
+ return true;
+ }
+ }
+ break;
+
+ case eLookupTypeType:
+ if (!m_options.m_str.empty())
+ {
+ if (LookupTypeInModule (m_interpreter,
+ result.GetOutputStream(),
+ module,
+ m_options.m_str.c_str(),
+ m_options.m_use_regex))
+ {
+ result.SetStatus(eReturnStatusSuccessFinishResult);
+ return true;
+ }
+ }
+ break;
+
+ default:
+ m_options.GenerateOptionUsage (result.GetErrorStream(), this);
+ syntax_error = true;
+ break;
+ }
+
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+
+ virtual bool
+ Execute (Args& command,
+ CommandReturnObject &result)
+ {
+ Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+ if (target == NULL)
+ {
+ result.AppendError ("invalid target, create a debug target using the 'target create' command");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ else
+ {
+ bool syntax_error = false;
+ uint32_t i;
+ uint32_t num_successful_lookups = 0;
+ uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
+ result.GetOutputStream().SetAddressByteSize(addr_byte_size);
+ result.GetErrorStream().SetAddressByteSize(addr_byte_size);
+ // Dump all sections for all modules images
+
+ if (command.GetArgumentCount() == 0)
+ {
+ // Dump all sections for all modules images
+ const uint32_t num_modules = target->GetImages().GetSize();
+ if (num_modules > 0)
+ {
+ for (i = 0; i<num_modules && syntax_error == false; ++i)
+ {
+ if (LookupInModule (m_interpreter, target->GetImages().GetModulePointerAtIndex(i), result, syntax_error))
+ {
+ result.GetOutputStream().EOL();
+ num_successful_lookups++;
+ }
+ }
+ }
+ else
+ {
+ result.AppendError ("the target has no associated executable images");
+ result.SetStatus (eReturnStatusFailed);
+ return false;
+ }
+ }
+ else
+ {
+ // Dump specified images (by basename or fullpath)
+ const char *arg_cstr;
+ for (i = 0; (arg_cstr = command.GetArgumentAtIndex(i)) != NULL && syntax_error == false; ++i)
+ {
+ FileSpec image_file(arg_cstr, false);
+ ModuleList matching_modules;
+ size_t num_matching_modules = target->GetImages().FindModules(&image_file, NULL, NULL, NULL, matching_modules);
+
+ // Not found in our module list for our target, check the main
+ // shared module list in case it is a extra file used somewhere
+ // else
+ if (num_matching_modules == 0)
+ num_matching_modules = ModuleList::FindSharedModules (image_file,
+ target->GetArchitecture(),
+ NULL,
+ NULL,
+ matching_modules);
+
+ if (num_matching_modules > 0)
+ {
+ for (size_t j=0; j<num_matching_modules; ++j)
+ {
+ Module * image_module = matching_modules.GetModulePointerAtIndex(j);
+ if (image_module)
+ {
+ if (LookupInModule (m_interpreter, image_module, result, syntax_error))
+ {
+ result.GetOutputStream().EOL();
+ num_successful_lookups++;
+ }
+ }
+ }
+ }
+ else
+ result.AppendWarningWithFormat("Unable to find an image that matches '%s'.\n", arg_cstr);
+ }
+ }
+
+ if (num_successful_lookups > 0)
+ result.SetStatus (eReturnStatusSuccessFinishResult);
+ else
+ result.SetStatus (eReturnStatusFailed);
+ }
+ return result.Succeeded();
+ }
+protected:
+
+ CommandOptions m_options;
+};
+
+OptionDefinition
+CommandObjectTargetModulesLookup::CommandOptions::g_option_table[] =
+{
+ { LLDB_OPT_SET_1, true, "address", 'a', required_argument, NULL, 0, eArgTypeAddress, "Lookup an address in one or more target modules."},
+ { LLDB_OPT_SET_1, false, "offset", 'o', required_argument, NULL, 0, eArgTypeOffset, "When looking up an address subtract <offset> from any addresses before doing the lookup."},
+ { LLDB_OPT_SET_2, true, "symbol", 's', required_argument, NULL, 0, eArgTypeSymbol, "Lookup a symbol by name in the symbol tables in one or more target modules."},
+ { LLDB_OPT_SET_2, false, "regex", 'r', no_argument, NULL, 0, eArgTypeNone, "The <name> argument for name lookups are regular expressions."},
+ { LLDB_OPT_SET_3, true, "file", 'f', required_argument, NULL, 0, eArgTypeFilename, "Lookup a file by fullpath or basename in one or more target modules."},
+ { LLDB_OPT_SET_3, false, "line", 'l', required_argument, NULL, 0, eArgTypeLineNum, "Lookup a line number in a file (must be used in conjunction with --file)."},
+ { LLDB_OPT_SET_3, false, "no-inlines", 'i', no_argument, NULL, 0, eArgTypeNone, "Check inline line entries (must be used in conjunction with --file)."},
+ { LLDB_OPT_SET_4, true, "function", 'n', required_argument, NULL, 0, eArgTypeFunctionName, "Lookup a function by name in the debug symbols in one or more target modules."},
+ { LLDB_OPT_SET_5, true, "type", 't', required_argument, NULL, 0, eArgTypeName, "Lookup a type by name in the debug symbols in one or more target modules."},
+ { LLDB_OPT_SET_ALL, false, "verbose", 'v', no_argument, NULL, 0, eArgTypeNone, "Enable verbose lookup information."},
+ { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
+};
#pragma mark CommandObjectMultiwordImageSearchPaths
@@ -813,28 +2826,70 @@
// CommandObjectMultiwordImageSearchPaths
//-------------------------------------------------------------------------
-class CommandObjectMultiwordImageSearchPaths : public CommandObjectMultiword
+class CommandObjectTargetModulesImageSearchPaths : public CommandObjectMultiword
{
public:
-
- CommandObjectMultiwordImageSearchPaths (CommandInterpreter &interpreter) :
- CommandObjectMultiword (interpreter,
- "target image-search-paths",
- "A set of commands for operating on debugger target image search paths.",
- "target image-search-paths <subcommand> [<subcommand-options>]")
+
+ CommandObjectTargetModulesImageSearchPaths (CommandInterpreter &interpreter) :
+ CommandObjectMultiword (interpreter,
+ "target modules search-paths",
+ "A set of commands for operating on debugger target image search paths.",
+ "target modules search-paths <subcommand> [<subcommand-options>]")
{
- LoadSubCommand ("add", CommandObjectSP (new CommandObjectTargetImageSearchPathsAdd (interpreter)));
- LoadSubCommand ("clear", CommandObjectSP (new CommandObjectTargetImageSearchPathsClear (interpreter)));
- LoadSubCommand ("insert", CommandObjectSP (new CommandObjectTargetImageSearchPathsInsert (interpreter)));
- LoadSubCommand ("list", CommandObjectSP (new CommandObjectTargetImageSearchPathsList (interpreter)));
- LoadSubCommand ("query", CommandObjectSP (new CommandObjectTargetImageSearchPathsQuery (interpreter)));
+ LoadSubCommand ("add", CommandObjectSP (new CommandObjectTargetModulesSearchPathsAdd (interpreter)));
+ LoadSubCommand ("clear", CommandObjectSP (new CommandObjectTargetModulesSearchPathsClear (interpreter)));
+ LoadSubCommand ("insert", CommandObjectSP (new CommandObjectTargetModulesSearchPathsInsert (interpreter)));
+ LoadSubCommand ("list", CommandObjectSP (new CommandObjectTargetModulesSearchPathsList (interpreter)));
+ LoadSubCommand ("query", CommandObjectSP (new CommandObjectTargetModulesSearchPathsQuery (interpreter)));
}
-
- ~CommandObjectMultiwordImageSearchPaths()
+
+ ~CommandObjectTargetModulesImageSearchPaths()
{
}
};
+
+
+#pragma mark CommandObjectTargetModules
+
+//-------------------------------------------------------------------------
+// CommandObjectTargetModules
+//-------------------------------------------------------------------------
+
+class CommandObjectTargetModules : public CommandObjectMultiword
+{
+public:
+ //------------------------------------------------------------------
+ // Constructors and Destructors
+ //------------------------------------------------------------------
+ CommandObjectTargetModules(CommandInterpreter &interpreter) :
+ CommandObjectMultiword (interpreter,
+ "target modules",
+ "A set of commands for accessing information for one or more target modules.",
+ "target modules <sub-command> ...")
+ {
+ LoadSubCommand ("add", CommandObjectSP (new CommandObjectTargetModulesAdd (interpreter)));
+ LoadSubCommand ("load", CommandObjectSP (new CommandObjectTargetModulesLoad (interpreter)));
+ //LoadSubCommand ("unload", CommandObjectSP (new CommandObjectTargetModulesUnload (interpreter)));
+ LoadSubCommand ("dump", CommandObjectSP (new CommandObjectTargetModulesDump (interpreter)));
+ LoadSubCommand ("list", CommandObjectSP (new CommandObjectTargetModulesList (interpreter)));
+ LoadSubCommand ("lookup", CommandObjectSP (new CommandObjectTargetModulesLookup (interpreter)));
+ LoadSubCommand ("search-paths", CommandObjectSP (new CommandObjectTargetModulesImageSearchPaths (interpreter)));
+
+ }
+ virtual
+ ~CommandObjectTargetModules()
+ {
+ }
+
+private:
+ //------------------------------------------------------------------
+ // For CommandObjectTargetModules only
+ //------------------------------------------------------------------
+ DISALLOW_COPY_AND_ASSIGN (CommandObjectTargetModules);
+};
+
+
#pragma mark CommandObjectTargetStopHookAdd
//-------------------------------------------------------------------------
@@ -1491,7 +3546,7 @@
LoadSubCommand ("list", CommandObjectSP (new CommandObjectTargetList (interpreter)));
LoadSubCommand ("select", CommandObjectSP (new CommandObjectTargetSelect (interpreter)));
LoadSubCommand ("stop-hook", CommandObjectSP (new CommandObjectMultiwordTargetStopHooks (interpreter)));
- LoadSubCommand ("image-search-paths", CommandObjectSP (new CommandObjectMultiwordImageSearchPaths (interpreter)));
+ LoadSubCommand ("modules", CommandObjectSP (new CommandObjectTargetModules (interpreter)));
}
CommandObjectMultiwordTarget::~CommandObjectMultiwordTarget ()