Provide option to set pc of the file loaded in memory.

[abidh]

Summary

This commit adds an option to set PC to the entry point of the file loaded using "target module load" command. In D28804, Greg asked me to separate this part under a different option.

[clayborg]

Just set an error when "set_pc" is true and you get no entry point back from thee object file and this is good to go.

source/Symbol/ObjectFile.cpp

687–688

Set an error if there is no valid entry point address. This would happen if someone tries to run load on a shared library.

[abidh]

Added a check for case when entry address is not valid.

[clayborg]

Looks good.

include/lldb/Core/Module.h

public:
   /// 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);
+  Error LoadInMemory(Target &target, bool set_pc);
 
   //----------------------------------------------------------------------
   /// @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

include/lldb/Symbol/ObjectFile.h

public:
   /// 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);
+  virtual Error LoadInMemory(Target &target, bool set_pc);
 
 protected:
   //------------------------------------------------------------------
   // Member variables.
   //------------------------------------------------------------------
   FileSpec m_file;
   Type m_type;
   Strata m_strata;

source/Commands/CommandObjectTarget.cpp

CommandObjectTargetModulesLoad(CommandInterpreter &interpreter)
                                                 "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.",
-                      false, true),
+                      "Write file contents to the memory.", false, true),
+        m_pc_option(LLDB_OPT_SET_1, false, "--set-pc-to-entry", 'p',
+                    "Set PC to the entry point."
+                    " Only applicable with '--load' option.",
         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_pc_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();
+    const bool set_pc = m_pc_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;
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);
+                  Error error = module->LoadInMemory(*target, set_pc);
                   if (error.Fail()) {
                     result.AppendError(error.AsCString());
                     return false;
                   }
                 }
               } else {
                 module->GetFileSpec().GetPath(path, sizeof(path));
                 result.AppendErrorWithFormat(
bool DoExecute(Args &args, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 
   OptionGroupOptions m_option_group;
   OptionGroupUUID m_uuid_option_group;
   OptionGroupString m_file_option;
   OptionGroupBoolean m_load_option;
+  OptionGroupBoolean m_pc_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);
+Error Module::LoadInMemory(Target &target, bool set_pc) {
+  return m_objfile_sp->LoadInMemory(target, set_pc);
 }

source/Symbol/ObjectFile.cpp

 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 ObjectFile::LoadInMemory(Target &target, bool set_pc) {
   Error error;
   ProcessSP process = target.CalculateProcess();
   if (!process)
     return Error("No Process");
+  if (set_pc && !GetEntryPointAddress().IsValid())
+    return Error("No entry address in object file");
 
   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;
     }
   }
+  if (set_pc) {
+    ThreadList &thread_list = process->GetThreadList();
+    ThreadSP curr_thread(thread_list.GetSelectedThread());
+    RegisterContextSP reg_context(curr_thread->GetRegisterContext());
+    Address file_entry = GetEntryPointAddress();
+    reg_context->SetPC(file_entry.GetLoadAddress(&target));
+  }
   return error;
 }