Provide a substitute to load command of gdb

[abidh]

Summary

For bare-metal targets, lldb was missing a command like 'load' in gdb which can be used to create executable image on the target. This was discussed in
http://lists.llvm.org/pipermail/lldb-dev/2016-December/011752.html

This diff adds an option to "target module load" command to provide that functionality. Instead of delegating the responsibility of writing bits to memory to Module or Objfile as was discussed in the thread above, it seemed simple to do it right in the command. Otherwise it looks straight forward. I have added a little code so that this option can be used with specifying the file so that it is easy to alias this long command to something simple. I was not sure what should be the name of that option. So I am open to suggestion.

Tested with qemu and STM32L476 board and works ok. Although it needs a few more changes else where in lldb to make them work. Those changes will come in separate commits.

[clayborg]

We need to agree on options names and move the object file loading code into ObjectFile.cpp. See inlined comments.

source/Commands/CommandObjectTarget.cpp

2571

How about "--load" witg -l as a short option? "--write-to-mem" seems a bit long.

2572–2573

I am guessing we will have other clients that will want to load more than one image to memory so I am not sure bundling setting the PC should always happen. This might be better as another option: "--set-pc-to-entry" or -p? Then you could load the main image and any other images needed. I know EFI does something similar to this.

2592–2632

We should have a Module and ObjectFile method to do this. Move this code there in a function like:

lldb_private::Error lldb_private::Module::LoadInMemory(Target &target);

This will call through to the ObjectFile method:

lldb_private::Error lldb_private::ObjectFile::LoadInMemory(Target &target);

We should have each object file subclass override this method as well. When loading and ELF file you load only the program headers into memory as directed by the contents of the file. With mach-o you would load the entire file into memory with the exception of some of the __LINKEDIT section, but again this depends on the contents of the file. So each object file subclass should do this as they see fit. We could have a default implementation do this in ObjectFile.cpp that does what you did above: load the section contents only depending on the section load lists for that module/object file. Then we would let ObjectFileMachO override this method if we ever need to.

[abidh]

Changed the name of the option. Added LoadInMemory function to Module and ObjectFile class and moved the functionality of writing to memory there. Removed part which set the pc.

[clayborg]

Very nice!

[abidh]

Committed in 292499. Removed this bit "set PC to its entry address." before committing as it is not being done now.

source/Commands/CommandObjectTarget.cpp

 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
 
 // C Includes
 // C++ Includes
 #include <cerrno>
CommandObjectTargetModulesLoad(CommandInterpreter &interpreter)
             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(),
         m_file_option(LLDB_OPT_SET_1, false, "file", 'f', 0, eArgTypeName,
                       "Fullpath or basename for module to load.", ""),
+        m_write_option(LLDB_OPT_SET_1, false, "write-to-mem", 'w',
+                      "Write file contents to the memory and set PC to its"
+                      "entry address.",
+                      false, true),
         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_write_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();
   }
 
   ~CommandObjectTargetModulesLoad() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
+  bool WriteToMemory(CommandReturnObject &result, Module *module) {
+    ObjectFile *objfile = module->GetObjectFile();
+    Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+    Process *process = m_exe_ctx.GetProcessPtr();
+    if (objfile && target && process) {
+      SectionList *section_list = module->GetSectionList();
+      size_t section_count = section_list->GetNumSections(0);
+      for (size_t i = 0; i < section_count; ++i) {
+        SectionSP section_sp = section_list->GetSectionAtIndex(i);
+        addr_t addr =
+            target->GetSectionLoadList().GetSectionLoadAddress(section_sp);
+        if (addr != LLDB_INVALID_ADDRESS) {
+          DataExtractor section_data;
+          // We can skip sections like bss
+          if (section_sp->GetFileSize() == 0)
+            continue;
+          Error error;
+          section_sp->GetSectionData(section_data);
+          lldb::offset_t written =
+              process->WriteMemory(addr, section_data.GetDataStart(),
+                                   section_data.GetByteSize(), error);
+          if (written != section_data.GetByteSize()) {
+            result.AppendError(error.AsCString());
+            result.SetStatus(eReturnStatusFailed);
+            return false;
+          }
+          result.AppendMessageWithFormat(
+              "Loading section %s Size 0x%" PRIx64 "Addr 0x%" PRIx64 "\n",
+              section_sp->GetName().AsCString(), section_data.GetByteSize(),
+              addr);
+        }
+      }
+      ThreadList &thread_list = process->GetThreadList();
+      ThreadSP curr_thread(thread_list.GetSelectedThread());
+      RegisterContextSP reg_context(curr_thread->GetRegisterContext());
+      reg_context->SetPC(objfile->GetEntryPointAddress());
+      return result.Succeeded();
+    }
+    return false;
+  }
+
   bool DoExecute(Args &args, CommandReturnObject &result) override {
     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+    const bool write = m_write_option.GetOptionValue().GetCurrentValue();
     if (target == nullptr) {
       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();
       ModuleSpec module_spec;
       bool search_using_module_spec = false;
+
+      // Allow "--write-to-mem" option to work without --file or --uuid
+      // option.
+      if (write) {
+        if (!m_file_option.GetOptionValue().OptionWasSet() &&
+            !m_uuid_option_group.GetOptionValue().OptionWasSet()) {
+          ModuleList &module_list = target->GetImages();
+          if (module_list.GetSize() == 1) {
+            search_using_module_spec = true;
+            module_spec.GetFileSpec() =
+                module_list.GetModuleAtIndex(0)->GetFileSpec();
+          }
+        }
+      }
+
       if (m_file_option.GetOptionValue().OptionWasSet()) {
         search_using_module_spec = true;
         const char *arg_cstr = m_file_option.GetOptionValue().GetCurrentValue();
         const bool use_global_module_list = true;
         ModuleList module_list;
         const size_t num_matches = FindModulesByName(
             target, arg_cstr, module_list, use_global_module_list);
         if (num_matches == 1) {
if (target == nullptr) {
                 }
 
                 if (changed) {
                   target->ModulesDidLoad(matching_modules);
                   Process *process = m_exe_ctx.GetProcessPtr();
                   if (process)
                     process->Flush();
                 }
+                if (write)
+                  return WriteToMemory(result, module);
               } 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));
if (target == nullptr) {
       }
     }
     return result.Succeeded();
   }
 
   OptionGroupOptions m_option_group;
   OptionGroupUUID m_uuid_option_group;
   OptionGroupString m_file_option;
+  OptionGroupBoolean m_write_option;
   OptionGroupUInt64 m_slide_option;
 };
 
 //----------------------------------------------------------------------
 // List images with associated information
 //----------------------------------------------------------------------
 
 static OptionDefinition g_target_modules_list_options[] = {