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

2570

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

2571–2572

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.

2591–2631

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.

include/lldb/Core/Module.h

public:
   ///
   /// @return
   ///     /b true if \a path was successfully located and \a new_path
   ///     is filled in with a new source path, \b false otherwise.
   //------------------------------------------------------------------
   bool RemapSourceFile(llvm::StringRef path, std::string &new_path) const;
   bool RemapSourceFile(const char *, std::string &) const = delete;
 
+  //------------------------------------------------------------------
+  /// Loads this module to memory.
+  ///
+  /// Loads the bits needed to create an executable image to the memory.
+  /// It is useful with bare-metal targets where target does not have the
+  /// ability to start a process itself.
+  ///
+  /// @param[in] target
+  ///     Target where to load the module.
+  ///
+  /// @return
+  //------------------------------------------------------------------
+  Error LoadInMemory(Target &target);
+
   //----------------------------------------------------------------------
   /// @class LookupInfo Module.h "lldb/Core/Module.h"
   /// @brief A class that encapsulates name lookup information.
   ///
   /// Users can type a wide variety of partial names when setting
   /// breakpoints by name or when looking for functions by name.
   /// SymbolVendor and SymbolFile objects are only required to implement
   /// name lookup for function basenames and for fully mangled names.

include/lldb/Symbol/ObjectFile.h

public:
   StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const {
     return symbol_name.str();
   }
 
   static lldb::SymbolType GetSymbolTypeFromName(
       llvm::StringRef name,
       lldb::SymbolType symbol_type_hint = lldb::eSymbolTypeUndefined);
 
+  //------------------------------------------------------------------
+  /// Loads this objfile to memory.
+  ///
+  /// Loads the bits needed to create an executable image to the memory.
+  /// It is useful with bare-metal targets where target does not have the
+  /// ability to start a process itself.
+  ///
+  /// @param[in] target
+  ///     Target where to load.
+  ///
+  /// @return
+  //------------------------------------------------------------------
+  virtual Error LoadInMemory(Target &target);
+
 protected:
   //------------------------------------------------------------------
   // Member variables.
   //------------------------------------------------------------------
   FileSpec m_file;
   Type m_type;
   Strata m_strata;
   lldb::addr_t m_file_offset; ///< The offset in bytes into the file, or the

source/Commands/CommandObjectTarget.cpp

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_load_option(LLDB_OPT_SET_1, false, "load", 'l',
+                      "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_load_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 DoExecute(Args &args, CommandReturnObject &result) override {
     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
+    const bool load = m_load_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 "load" option to work without --file or --uuid
+      // option.
+      if (load) {
+        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) {
           module_spec.GetFileSpec() =
               module_list.GetModuleAtIndex(0)->GetFileSpec();
         } else if (num_matches > 1) {
           search_using_module_spec = false;
           result.AppendErrorWithFormat(
               "more than 1 module matched by name '%s'\n", arg_cstr);
           result.SetStatus(eReturnStatusFailed);
         } else {
           search_using_module_spec = false;
           result.AppendErrorWithFormat("no object file for module '%s'\n",
                                        arg_cstr);
           result.SetStatus(eReturnStatusFailed);
         }
       }
if (target == nullptr) {
                 }
 
                 if (changed) {
                   target->ModulesDidLoad(matching_modules);
                   Process *process = m_exe_ctx.GetProcessPtr();
                   if (process)
                     process->Flush();
                 }
+                if (load) {
+                  Error error = module->LoadInMemory(*target);
+                  if (error.Fail()) {
+                    result.AppendError(error.AsCString());
+                    return false;
+                  }
+                }
               } 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_load_option;
   OptionGroupUInt64 m_slide_option;
 };
 
 //----------------------------------------------------------------------
 // List images with associated information
 //----------------------------------------------------------------------
 
 static OptionDefinition g_target_modules_list_options[] = {

source/Core/Module.cpp

 bool Module::GetIsDynamicLinkEditor() {
   ObjectFile *obj_file = GetObjectFile();
 
   if (obj_file)
     return obj_file->GetIsDynamicLinkEditor();
 
   return false;
 }
+
+Error Module::LoadInMemory(Target &target) {
+  return m_objfile_sp->LoadInMemory(target);
+}

source/Symbol/ObjectFile.cpp

 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Symbol/ObjectContainer.h"
 #include "lldb/Symbol/SymbolFile.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/lldb-private.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 ObjectFileSP
 ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file,

 
 ConstString ObjectFile::GetNextSyntheticSymbolName() {
   StreamString ss;
   ConstString file_name = GetModule()->GetFileSpec().GetFilename();
   ss.Printf("___lldb_unnamed_symbol%u$$%s", ++m_synthetic_symbol_idx,
             file_name.GetCString());
   return ConstString(ss.GetString());
 }
+
+Error ObjectFile::LoadInMemory(Target &target) {
+  Error error;
+  ProcessSP process = target.CalculateProcess();
+  if (!process)
+    return Error("No Process");
+
+  SectionList *section_list = GetSectionList();
+  if (!section_list)
+      return Error("No section in object file");
+  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;
+      section_sp->GetSectionData(section_data);
+      lldb::offset_t written = process->WriteMemory(
+          addr, section_data.GetDataStart(), section_data.GetByteSize(), error);
+      if (written != section_data.GetByteSize())
+        return error;
+    }
+  }
+  return error;
+}