[NFC] Turn "load dependent files" boolean into an enum

[JDevlieghere]

Summary

This is an NFC commit to refactor the "load dependent files" parameter from a boolean to an enum value. We want to be able to specify a default, in which case we decide whether or not to load the dependent files based on whether the target is an executable or not (i.e. a dylib).

A second diff will build on top of this to allow the user to specify a value to target -d so we can choose between the default behavior or force (not) loading the dependent files.

[stella.stamenova]

This broke the windows build:

##[error]llvm\tools\lldb\source\plugins\process\windows\common\processwindows.cpp(840,0): Error C2664: 'void lldb_private::Target::SetExecutableModule(lldb::ModuleSP &,lldb_private::LoadDependentFiles)': cannot convert argument 2 from 'bool' to 'lldb_private::LoadDependentFiles'

[stella.stamenova]

lldb/trunk/source/Target/Target.cpp

1449 ↗

(On Diff #166243)

I think it's a good idea to either initialize this to false or to add a default case in the switch statement. That way if the enum ever changes, the behavior will be strictly defined.

1455 ↗

(On Diff #166243)

Typo - I think you wanted this to be load_dependents

[brooks]

Also broke the FreeBSD build:

/usr/local/poudriere/ports/brooks/devel/llvm-devel/work/llvm-b418c2351b1fdf6faf6
a2d010d804e895ef49932/tools/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.c
pp:338:50: error: cannot initialize a parameter of type 'lldb_private::LoadDepen
dentFiles' with an rvalue of type 'bool'
  GetTarget().SetExecutableModule(exe_module_sp, true);                        
                                                 ^~~~
/usr/local/poudriere/ports/brooks/devel/llvm-devel/work/llvm-b418c2351b1fdf6faf6
a2d010d804e895ef49932/tools/lldb/include/lldb/Target/Target.h:860:26: note: pass
ing argument to parameter 'load_dependent_files' here
      LoadDependentFiles load_dependent_files = eLoadDependentsDefault);
                         ^
/usr/local/poudriere/ports/brooks/devel/llvm-devel/work/llvm-b418c2351b1fdf6faf6
a2d010d804e895ef49932/tools/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.c
pp:522:50: error: cannot initialize a parameter of type 'lldb_private::LoadDepen
dentFiles' with an rvalue of type 'bool'
      target->SetExecutableModule(exe_module_sp, true);
                                                 ^~~~
/usr/local/poudriere/ports/brooks/devel/llvm-devel/work/llvm-b418c2351b1fdf6faf6
a2d010d804e895ef49932/tools/lldb/include/lldb/Target/Target.h:860:26: note: pass
ing argument to parameter 'load_dependent_files' here
      LoadDependentFiles load_dependent_files = eLoadDependentsDefault);
                         ^
2 errors generated.
ninja: build stopped: subcommand failed.

include/lldb/Target/Target.h

 } LoadScriptFromSymFile;
 
 typedef enum LoadCWDlldbinitFile {
   eLoadCWDlldbinitTrue,
   eLoadCWDlldbinitFalse,
   eLoadCWDlldbinitWarn
 } LoadCWDlldbinitFile;
 
+typedef enum LoadDependentFiles {
+  eLoadDependentsDefault,
+  eLoadDependentsYes,
+  eLoadDependentsNo,
+} LoadDependentFiles;
+
 //----------------------------------------------------------------------
 // TargetProperties
 //----------------------------------------------------------------------
 class TargetExperimentalProperties : public Properties {
 public:
   TargetExperimentalProperties();
 };
 
BreakpointName *FindBreakpointName(const ConstString &name, bool can_create,
                                      Status &error);
                                      
   void DeleteBreakpointName(const ConstString &name);
   
   void ConfigureBreakpointName(BreakpointName &bp_name,
                                const BreakpointOptions &options,
                                const BreakpointName::Permissions &permissions);
  void ApplyNameToBreakpoints(BreakpointName &bp_name);
-   
-  
   // This takes ownership of the name obj passed in.
   void AddBreakpointName(BreakpointName *bp_name);
   
   void GetBreakpointNames(std::vector<std::string> &names);
                                
   //This call removes ALL breakpoints regardless of permission.
   void RemoveAllBreakpoints(bool internal_also = false);
   
void ApplyNameToBreakpoints(BreakpointName &bp_name);
   /// needed to make the address point to an opcode. For ARM this can
   /// clear bit zero (if it already isn't) if \a load_addr is a
   /// thumb function and load_addr is in code.
   /// If \a addr_class is set to AddressClass::eInvalid, then the address
   /// adjustment will always happen. If it is set to an address class
   /// that doesn't have code in it, LLDB_INVALID_ADDRESS will be
   /// returned.
   //------------------------------------------------------------------
-  lldb::addr_t GetOpcodeLoadAddress(
-      lldb::addr_t load_addr,
+  lldb::addr_t
+  GetOpcodeLoadAddress(lldb::addr_t load_addr,
                        AddressClass addr_class = AddressClass::eInvalid) const;
 
   // Get load_addr as breakable load address for this target. Take a addr and
   // check if for any reason there is a better address than this to put a
   // breakpoint on. If there is then return that address. For MIPS, if
   // instruction at addr is a delay slot instruction then this method will find
   // the address of its previous instruction and return that address.
   lldb::addr_t GetBreakableLoadAddress(lldb::addr_t addr);
 
void ApplyNameToBreakpoints(BreakpointName &bp_name);
   /// executable and any modules on which it depends. Calling
   /// Process::GetImages() will return the newly found images that
   /// were obtained from all of the object files.
   ///
   /// @param[in] module_sp
   ///     A shared pointer reference to the module that will become
   ///     the main executable for this process.
   ///
-  /// @param[in] get_dependent_files
+  /// @param[in] load_dependent_files
   ///     If \b true then ask the object files to track down any
   ///     known dependent files.
   ///
   /// @see ObjectFile::GetDependentModules (FileSpecList&)
   /// @see Process::GetImages()
   //------------------------------------------------------------------
-  void SetExecutableModule(lldb::ModuleSP &module_sp, bool get_dependent_files);
+  void SetExecutableModule(
+      lldb::ModuleSP &module_sp,
+      LoadDependentFiles load_dependent_files = eLoadDependentsDefault);
 
   bool LoadScriptingResources(std::list<Status> &errors,
                               Stream *feedback_stream = nullptr,
                               bool continue_on_error = true) {
     return m_images.LoadScriptingResourcesInTarget(
         this, errors, feedback_stream, continue_on_error);
   }
 

include/lldb/Target/TargetList.h

public:
   /// @param[out] target_sp
   ///     A shared pointer to a target that will be filled in if
   ///     this call is successful.
   ///
   /// @return
   ///     An error object that indicates success or failure
   //------------------------------------------------------------------
   Status CreateTarget(Debugger &debugger, llvm::StringRef user_exe_path,
-                      llvm::StringRef triple_str, bool get_dependent_modules,
+                      llvm::StringRef triple_str,
+                      LoadDependentFiles get_dependent_modules,
                       const OptionGroupPlatform *platform_options,
                       lldb::TargetSP &target_sp);
 
   //------------------------------------------------------------------
   /// Create a new Target.
   ///
   /// Same as the function above, but used when you already know the
   /// platform you will be using
   //------------------------------------------------------------------
   Status CreateTarget(Debugger &debugger, llvm::StringRef user_exe_path,
-                      const ArchSpec &arch, bool get_dependent_modules,
+                      const ArchSpec &arch,
+                      LoadDependentFiles get_dependent_modules,
                       lldb::PlatformSP &platform_sp, lldb::TargetSP &target_sp);
 
   //------------------------------------------------------------------
   /// Delete a Target object from the list.
   ///
   /// When clients are done with the Target objects, this function
   /// should be called to release the memory associated with a target
   /// object.
private:
   lldb::TargetSP GetDummyTarget(lldb_private::Debugger &debugger);
 
   Status CreateDummyTarget(Debugger &debugger,
                            llvm::StringRef specified_arch_name,
                            lldb::TargetSP &target_sp);
 
   Status CreateTargetInternal(Debugger &debugger, llvm::StringRef user_exe_path,
                               llvm::StringRef triple_str,
-                              bool get_dependent_files,
+                              LoadDependentFiles load_dependent_files,
                               const OptionGroupPlatform *platform_options,
                               lldb::TargetSP &target_sp, bool is_dummy_target);
 
   Status CreateTargetInternal(Debugger &debugger, llvm::StringRef user_exe_path,
-                              const ArchSpec &arch, bool get_dependent_modules,
+                              const ArchSpec &arch,
+                              LoadDependentFiles get_dependent_modules,
                               lldb::PlatformSP &platform_sp,
                               lldb::TargetSP &target_sp, bool is_dummy_target);
 
   DISALLOW_COPY_AND_ASSIGN(TargetList);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_TargetList_h_

source/API/SBDebugger.cpp

lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {
     sb_error.Clear();
     OptionGroupPlatform platform_options(false);
     platform_options.SetPlatformName(platform_name);
 
     sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget(
-        *m_opaque_sp, filename, target_triple, add_dependent_modules,
+        *m_opaque_sp, filename, target_triple,
+        add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo,
         &platform_options, target_sp);
 
     if (sb_error.Success())
       sb_target.SetSP(target_sp);
   } else {
     sb_error.SetErrorString("invalid debugger");
   }
 

 SBTarget
 SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
                                                 const char *target_triple) {
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {
     const bool add_dependent_modules = true;
     Status error(m_opaque_sp->GetTargetList().CreateTarget(
-        *m_opaque_sp, filename, target_triple, add_dependent_modules, nullptr,
+        *m_opaque_sp, filename, target_triple,
+        add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
         target_sp));
     sb_target.SetSP(target_sp);
   }
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)
     log->Printf("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple "
                 "(filename=\"%s\", triple=%s) => SBTarget(%p)",
SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
 
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {
     Status error;
     const bool add_dependent_modules = true;
 
     error = m_opaque_sp->GetTargetList().CreateTarget(
-        *m_opaque_sp, filename, arch_cstr, add_dependent_modules, nullptr,
+        *m_opaque_sp, filename, arch_cstr,
+        add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
         target_sp);
 
     if (error.Success()) {
       m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
       sb_target.SetSP(target_sp);
     }
   }
 
   if (log)
     log->Printf("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", "
                 "arch=%s) => SBTarget(%p)",
                 static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr,
                 static_cast<void *>(target_sp.get()));
 
   return sb_target;
 }
 
 SBTarget SBDebugger::CreateTarget(const char *filename) {
   SBTarget sb_target;
   TargetSP target_sp;
   if (m_opaque_sp) {
     Status error;
     const bool add_dependent_modules = true;
     error = m_opaque_sp->GetTargetList().CreateTarget(
-        *m_opaque_sp, filename, "", add_dependent_modules, nullptr, target_sp);
+        *m_opaque_sp, filename, "",
+        add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
+        target_sp);
 
     if (error.Success()) {
       m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
       sb_target.SetSP(target_sp);
     }
   }
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (log)

source/Commands/CommandObjectProcess.cpp

if (!StopProcessIfNecessary(process, state, result))
       return false;
 
     if (target == nullptr) {
       // If there isn't a current target create one.
       TargetSP new_target_sp;
       Status error;
 
       error = m_interpreter.GetDebugger().GetTargetList().CreateTarget(
-          m_interpreter.GetDebugger(), "", "", false,
+          m_interpreter.GetDebugger(), "", "", eLoadDependentsNo,
           nullptr, // No platform options
           new_target_sp);
       target = new_target_sp.get();
       if (target == nullptr || error.Fail()) {
         result.AppendError(error.AsCString("Error creating target"));
         return false;
       }
       m_interpreter.GetDebugger().GetTargetList().SetSelectedTarget(target);

source/Commands/CommandObjectTarget.cpp

if (argc == 1 || core_file || remote_file) {
 
       Debugger &debugger = m_interpreter.GetDebugger();
 
       TargetSP target_sp;
       llvm::StringRef arch_cstr = m_arch_option.GetArchitectureName();
       const bool get_dependent_files =
           m_add_dependents.GetOptionValue().GetCurrentValue();
       Status error(debugger.GetTargetList().CreateTarget(
-          debugger, file_path, arch_cstr, get_dependent_files, nullptr,
+          debugger, file_path, arch_cstr,
+          get_dependent_files ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
           target_sp));
 
       if (target_sp) {
         // Only get the platform after we create the target because we might
         // have switched platforms depending on what the arguments were to
         // CreateTarget() we can't rely on the selected platform.
 
         PlatformSP platform_sp = target_sp->GetPlatform();

source/Core/DynamicLoader.cpp

if (executable->GetFileSpec().Exists()) {
         executable.reset();
       }
 
       if (!executable) {
         executable = target.GetSharedModule(module_spec);
         if (executable.get() != target.GetExecutableModulePointer()) {
           // Don't load dependent images since we are in dyld where we will
           // know and find out about all images that are loaded
-          const bool get_dependent_images = false;
-          target.SetExecutableModule(executable, get_dependent_images);
+          target.SetExecutableModule(executable, eLoadDependentsNo);
         }
       }
     }
   }
   return executable;
 }
 
 void DynamicLoader::UpdateLoadedSections(ModuleSP module, addr_t link_map_addr,

source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

if (m_module_sp) {
         if (m_module_sp->GetUUID() != m_memory_module_sp->GetUUID()) {
           uuid_match_ok = false;
         }
       }
       if (uuid_match_ok) {
         target.GetImages().AppendIfNeeded(m_module_sp);
         if (IsKernel() &&
             target.GetExecutableModulePointer() != m_module_sp.get()) {
-          target.SetExecutableModule(m_module_sp, false);
+          target.SetExecutableModule(m_module_sp, eLoadDependentsNo);
         }
       }
     }
   }
 
   if (!m_module_sp && !IsKernel() && m_uuid.IsValid() && !m_name.empty()) {
     Stream *s = target.GetDebugger().GetOutputFile().get();
     if (s) {

source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

ModuleSP DynamicLoaderHexagonDYLD::GetTargetExecutable() {
   if (executable.get())
     return executable;
 
   // TODO: What case is this code used?
   executable = target.GetSharedModule(module_spec);
   if (executable.get() != target.GetExecutableModulePointer()) {
     // Don't load dependent images since we are in dyld where we will know and
     // find out about all images that are loaded
-    const bool get_dependent_images = false;
-    target.SetExecutableModule(executable, get_dependent_images);
+    target.SetExecutableModule(executable, eLoadDependentsNo);
   }
 
   return executable;
 }
 
 // AD: Needs to be updated?
 Status DynamicLoaderHexagonDYLD::CanLoadImage() { return Status(); }
 

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

ModuleSP exe_module_sp(
         FindTargetModuleForImageInfo(image_infos[exe_idx], can_create, NULL));
     if (exe_module_sp) {
       if (log)
         log->Printf("Found executable module: %s",
                     exe_module_sp->GetFileSpec().GetPath().c_str());
       target.GetImages().AppendIfNeeded(exe_module_sp);
       UpdateImageLoadAddress(exe_module_sp.get(), image_infos[exe_idx]);
       if (exe_module_sp.get() != target.GetExecutableModulePointer()) {
-        const bool get_dependent_images = false;
-        target.SetExecutableModule(exe_module_sp, get_dependent_images);
+        target.SetExecutableModule(exe_module_sp, eLoadDependentsNo);
       }
     }
   }
 
   if (dyld_idx != UINT32_MAX) {
     const bool can_create = true;
     ModuleSP dyld_sp =
         FindTargetModuleForImageInfo(image_infos[dyld_idx], can_create, NULL);

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

if (exe_module_sp) {
         // executable module, it will clear the targets module list, and if we
         // have an in memory dyld module, it will get removed from the list so
         // we will need to add it back after setting the executable module, so
         // we first try and see if we already have a weak pointer to the dyld
         // module, make it into a shared pointer, then add the executable, then
         // re-add it back to make sure it is always in the list.
         ModuleSP dyld_module_sp(GetDYLDModule());
 
-        const bool get_dependent_images = false;
         m_process->GetTarget().SetExecutableModule(exe_module_sp,
-                                                   get_dependent_images);
+                                                   eLoadDependentsNo);
 
         if (dyld_module_sp) {
           if (target.GetImages().AppendIfNeeded(dyld_module_sp)) {
             std::lock_guard<std::recursive_mutex> baseclass_guard(GetMutex());
 
             // Also add it to the section list.
             UpdateImageLoadAddress(dyld_module_sp.get(), m_dyld);
           }

source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

if (error.Fail()) {
 
     if (log)
       log->Printf("DynamicLoaderPOSIXDYLD::%s - failed to resolve executable "
                   "with module spec \"%s\": %s",
                   __FUNCTION__, stream.GetData(), error.AsCString());
     return;
   }
 
-  target.SetExecutableModule(module_sp, false);
+  target.SetExecutableModule(module_sp, eLoadDependentsNo);
 }
 
 bool DynamicLoaderPOSIXDYLD::AlwaysRelyOnEHUnwindInfo(
     lldb_private::SymbolContext &sym_ctx) {
   ModuleSP module_sp;
   if (sym_ctx.symbol)
     module_sp = sym_ctx.symbol->GetAddressRef().GetModule();
   if (!module_sp && sym_ctx.function)
     module_sp =
         sym_ctx.function->GetAddressRange().GetBaseAddress().GetModule();
   if (!module_sp)
     return false;
 
   return module_sp->GetFileSpec().GetPath() == "[vdso]";
 }

source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp

lldb::ProcessSP PlatformFreeBSD::Attach(ProcessAttachInfo &attach_info,
                                         Debugger &debugger, Target *target,
                                         Status &error) {
   lldb::ProcessSP process_sp;
   if (IsHost()) {
     if (target == NULL) {
       TargetSP new_target_sp;
       ArchSpec emptyArchSpec;
 
-      error = debugger.GetTargetList().CreateTarget(debugger, "", emptyArchSpec,
-                                                    false, m_remote_platform_sp,
-                                                    new_target_sp);
+      error = debugger.GetTargetList().CreateTarget(
+          debugger, "", emptyArchSpec, eLoadDependentsNo, m_remote_platform_sp,
       target = new_target_sp.get();
     } else
       error.Clear();
 
     if (target && error.Success()) {
       debugger.GetTargetList().SetSelectedTarget(target);
       // The freebsd always currently uses the GDB remote debugger plug-in so
       // even when debugging locally we are debugging remotely! Just like the

source/Plugins/Platform/Linux/PlatformLinux.cpp

PlatformLinux::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
   // group, since then we can handle ^C interrupts ourselves w/o having to
   // worry about the target getting them as well.
   launch_info.SetLaunchInSeparateProcessGroup(true);
 
   // Ensure we have a target.
   if (target == nullptr) {
     LLDB_LOG(log, "creating new target");
     TargetSP new_target_sp;
-    error = debugger.GetTargetList().CreateTarget(debugger, "", "", false,
-                                                  nullptr, new_target_sp);
+    error = debugger.GetTargetList().CreateTarget(
+        debugger, "", "", eLoadDependentsNo, nullptr, new_target_sp);
     if (error.Fail()) {
       LLDB_LOG(log, "failed to create new target: {0}", error);
       return process_sp;
     }
 
     target = new_target_sp.get();
     if (!target) {
       error.SetErrorString("CreateTarget() returned nullptr");

source/Plugins/Platform/NetBSD/PlatformNetBSD.cpp

PlatformNetBSD::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
   // group, since then we can handle ^C interrupts ourselves w/o having to
   // worry about the target getting them as well.
   launch_info.SetLaunchInSeparateProcessGroup(true);
 
   // Ensure we have a target.
   if (target == nullptr) {
     LLDB_LOG(log, "creating new target");
     TargetSP new_target_sp;
-    error = debugger.GetTargetList().CreateTarget(debugger, "", "", false,
-                                                  nullptr, new_target_sp);
+    error = debugger.GetTargetList().CreateTarget(
+        debugger, "", "", eLoadDependentsNo, nullptr, new_target_sp);
     if (error.Fail()) {
       LLDB_LOG(log, "failed to create new target: {0}", error);
       return process_sp;
     }
 
     target = new_target_sp.get();
     if (!target) {
       error.SetErrorString("CreateTarget() returned nullptr");

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

lldb::ProcessSP PlatformPOSIX::Attach(ProcessAttachInfo &attach_info,
                                       Status &error) {
   lldb::ProcessSP process_sp;
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
 
   if (IsHost()) {
     if (target == NULL) {
       TargetSP new_target_sp;
 
-      error = debugger.GetTargetList().CreateTarget(debugger, "", "", false,
-                                                    NULL, new_target_sp);
+      error = debugger.GetTargetList().CreateTarget(
+          debugger, "", "", eLoadDependentsNo, NULL, new_target_sp);
       target = new_target_sp.get();
       if (log)
         log->Printf("PlatformPOSIX::%s created new target", __FUNCTION__);
     } else {
       error.Clear();
       if (log)
         log->Printf("PlatformPOSIX::%s target already existed, setting target",
                     __FUNCTION__);

source/Plugins/Platform/Windows/PlatformWindows.cpp

if (!IsHost()) {
     return process_sp;
   }
 
   if (target == nullptr) {
     TargetSP new_target_sp;
     FileSpec emptyFileSpec;
     ArchSpec emptyArchSpec;
 
-    error = debugger.GetTargetList().CreateTarget(debugger, "", "", false,
-                                                  nullptr, new_target_sp);
+    error = debugger.GetTargetList().CreateTarget(
+        debugger, "", "", eLoadDependentsNo, nullptr, new_target_sp);
     target = new_target_sp.get();
   }
 
   if (!target || error.Fail())
     return process_sp;
 
   debugger.GetTargetList().SetSelectedTarget(target);
 

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

if (IsConnected()) {
       std::string connect_url;
       if (!LaunchGDBServer(debugserver_pid, connect_url)) {
         error.SetErrorStringWithFormat("unable to launch a GDB server on '%s'",
                                        GetHostname());
       } else {
         if (target == NULL) {
           TargetSP new_target_sp;
 
-          error = debugger.GetTargetList().CreateTarget(debugger, "", "", false,
-                                                        NULL, new_target_sp);
+          error = debugger.GetTargetList().CreateTarget(
+              debugger, "", "", eLoadDependentsNo, NULL, new_target_sp);
           target = new_target_sp.get();
         } else
           error.Clear();
 
         if (target && error.Success()) {
           debugger.GetTargetList().SetSelectedTarget(target);
 
           // The darwin always currently uses the GDB remote debugger plug-in
if (IsConnected()) {
       std::string connect_url;
       if (!LaunchGDBServer(debugserver_pid, connect_url)) {
         error.SetErrorStringWithFormat("unable to launch a GDB server on '%s'",
                                        GetHostname());
       } else {
         if (target == NULL) {
           TargetSP new_target_sp;
 
-          error = debugger.GetTargetList().CreateTarget(debugger, "", "", false,
-                                                        NULL, new_target_sp);
+          error = debugger.GetTargetList().CreateTarget(
+              debugger, "", "", eLoadDependentsNo, NULL, new_target_sp);
           target = new_target_sp.get();
         } else
           error.Clear();
 
         if (target && error.Success()) {
           debugger.GetTargetList().SetSelectedTarget(target);
 
           // The darwin always currently uses the GDB remote debugger plug-in

source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

if (reply_port != 0) {
                 ModuleSP module_sp(new Module(module_spec));
                 if (module_sp.get() && module_sp->GetObjectFile()) {
                   // Get the current target executable
                   ModuleSP exe_module_sp(target.GetExecutableModule());
 
                   // Make sure you don't already have the right module loaded
                   // and they will be uniqued
                   if (exe_module_sp.get() != module_sp.get())
-                    target.SetExecutableModule(module_sp, false);
+                    target.SetExecutableModule(module_sp, eLoadDependentsNo);
                 }
               }
             }
           } else if (m_comm.RemoteIsDarwinKernel()) {
             m_dyld_plugin_name =
                 DynamicLoaderDarwinKernel::GetPluginNameStatic();
             if (kernel_load_addr != LLDB_INVALID_ADDRESS) {
               m_kernel_load_addr = kernel_load_addr;

source/Plugins/Process/elf-core/ProcessElfCore.cpp

if (!m_nt_file_entries.empty()) {
       ModuleSpec exe_module_spec;
       exe_module_spec.GetArchitecture() = arch;
       exe_module_spec.GetFileSpec().SetFile(
           m_nt_file_entries[0].path.GetCString(), false,
           FileSpec::Style::native);
       if (exe_module_spec.GetFileSpec()) {
         exe_module_sp = GetTarget().GetSharedModule(exe_module_spec);
         if (exe_module_sp)
-          GetTarget().SetExecutableModule(exe_module_sp, false);
+          GetTarget().SetExecutableModule(exe_module_sp, eLoadDependentsNo);
       }
     }
   }
   return error;
 }
 
 lldb_private::DynamicLoader *ProcessElfCore::GetDynamicLoader() {
   if (m_dyld_ap.get() == NULL)

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

new_modules.ForEach([&target](const lldb::ModuleSP module_sp) -> bool {
       lldb_private::ObjectFile *obj = module_sp->GetObjectFile();
       if (!obj)
         return true;
 
       if (obj->GetType() != ObjectFile::Type::eTypeExecutable)
         return true;
 
       lldb::ModuleSP module_copy_sp = module_sp;
-      target.SetExecutableModule(module_copy_sp, false);
+      target.SetExecutableModule(module_copy_sp, eLoadDependentsNo);
       return false;
     });
 
     loaded_modules.AppendIfNeeded(new_modules);
     m_process->GetTarget().ModulesDidLoad(new_modules);
   }
 
   return new_modules.GetSize();

source/Target/Platform.cpp

lldb::ProcessSP Platform::ConnectProcess(llvm::StringRef connect_url,
                                          llvm::StringRef plugin_name,
                                          lldb_private::Debugger &debugger,
                                          lldb_private::Target *target,
                                          lldb_private::Status &error) {
   error.Clear();
 
   if (!target) {
     TargetSP new_target_sp;
-    error = debugger.GetTargetList().CreateTarget(debugger, "", "", false,
-                                                  nullptr, new_target_sp);
+    error = debugger.GetTargetList().CreateTarget(
+        debugger, "", "", eLoadDependentsNo, nullptr, new_target_sp);
     target = new_target_sp.get();
   }
 
   if (!target || error.Fail())
     return nullptr;
 
   debugger.GetTargetList().SetSelectedTarget(target);
 

source/Target/Process.cpp

for (size_t i = 0; i < num_modules; i++) {
     ModuleSP module_sp(target_modules.GetModuleAtIndexUnlocked(i));
     if (module_sp && module_sp->IsExecutable()) {
       if (GetTarget().GetExecutableModulePointer() != module_sp.get())
         new_executable_module_sp = module_sp;
       break;
     }
   }
   if (new_executable_module_sp) {
-    GetTarget().SetExecutableModule(new_executable_module_sp, false);
+    GetTarget().SetExecutableModule(new_executable_module_sp,
+                                    eLoadDependentsNo);
     if (log) {
       ModuleSP exe_module_sp = GetTarget().GetExecutableModule();
       log->Printf(
           "Process::%s after looping through modules, target executable is %s",
           __FUNCTION__,
           exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str()
                         : "<none>");
     }

source/Target/Target.cpp

 
 void Target::DidExec() {
   // When a process exec's we need to know about it so we can do some cleanup.
   m_breakpoint_list.RemoveInvalidLocations(m_arch.GetSpec());
   m_internal_breakpoint_list.RemoveInvalidLocations(m_arch.GetSpec());
 }
 
 void Target::SetExecutableModule(ModuleSP &executable_sp,
-                                 bool get_dependent_files) {
+                                 LoadDependentFiles load_dependent_files) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_TARGET));
   ClearModules(false);
 
   if (executable_sp) {
     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
     Timer scoped_timer(func_cat,
                        "Target::SetExecutableModule (executable = '%s')",
                        executable_sp->GetFileSpec().GetPath().c_str());
 
     m_images.Append(executable_sp); // The first image is our executable file
 
     // If we haven't set an architecture yet, reset our architecture based on
     // what we found in the executable module.
     if (!m_arch.GetSpec().IsValid()) {
       m_arch = executable_sp->GetArchitecture();
       LLDB_LOG(log,
                "setting architecture to {0} ({1}) based on executable file",
                m_arch.GetSpec().GetArchitectureName(),
                m_arch.GetSpec().GetTriple().getTriple());
     }
 
     FileSpecList dependent_files;
     ObjectFile *executable_objfile = executable_sp->GetObjectFile();
+    bool load_dependens;
+    switch (load_dependent_files) {
+    case eLoadDependentsDefault:
+      load_dependens = executable_sp->IsExecutable();
+      break;
+    case eLoadDependentsYes:
+      load_dependens = true;
+      break;
+    case eLoadDependentsNo:
+      load_dependens = false;
+      break;
+    }
 
-    if (executable_objfile && get_dependent_files) {
+    if (executable_objfile && load_dependens) {
       executable_objfile->GetDependentModules(dependent_files);
       for (uint32_t i = 0; i < dependent_files.GetSize(); i++) {
         FileSpec dependent_file_spec(
             dependent_files.GetFileSpecPointerAtIndex(i));
         FileSpec platform_dependent_file_spec;
         if (m_platform_sp)
           m_platform_sp->GetFileWithUUID(dependent_file_spec, nullptr,
                                          platform_dependent_file_spec);
if (log)
                   arch_spec.GetArchitectureName(),
                   arch_spec.GetTriple().getTriple().c_str());
     ModuleSpec module_spec(executable_sp->GetFileSpec(), other);
     Status error = ModuleList::GetSharedModule(module_spec, executable_sp,
                                                &GetExecutableSearchPaths(),
                                                nullptr, nullptr);
 
     if (!error.Fail() && executable_sp) {
-      SetExecutableModule(executable_sp, true);
+      SetExecutableModule(executable_sp, eLoadDependentsYes);
       return true;
     }
   }
   return false;
 }
 
 bool Target::MergeArchitecture(const ArchSpec &arch_spec) {
   if (arch_spec.IsValid()) {
PathMappingList &Target::GetImageSearchPathList() {
   return m_image_search_paths;
 }
 
 void Target::ImageSearchPathsChanged(const PathMappingList &path_list,
                                      void *baton) {
   Target *target = (Target *)baton;
   ModuleSP exe_module_sp(target->GetExecutableModule());
   if (exe_module_sp)
-    target->SetExecutableModule(exe_module_sp, true);
+    target->SetExecutableModule(exe_module_sp, eLoadDependentsYes);
 }
 
 TypeSystem *Target::GetScratchTypeSystemForLanguage(Status *error,
                                                     lldb::LanguageType language,
                                                     bool create_on_demand) {
   if (!m_valid)
     return nullptr;
 

source/Target/TargetList.cpp

 TargetList::~TargetList() {
   std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
   m_target_list.clear();
 }
 
 Status TargetList::CreateTarget(Debugger &debugger,
                                 llvm::StringRef user_exe_path,
                                 llvm::StringRef triple_str,
-                                bool get_dependent_files,
+                                LoadDependentFiles load_dependent_files,
                                 const OptionGroupPlatform *platform_options,
                                 TargetSP &target_sp) {
   return CreateTargetInternal(debugger, user_exe_path, triple_str,
-                              get_dependent_files, platform_options, target_sp,
+                              load_dependent_files, platform_options, target_sp,
                               false);
 }
 
 Status TargetList::CreateTarget(Debugger &debugger,
                                 llvm::StringRef user_exe_path,
                                 const ArchSpec &specified_arch,
-                                bool get_dependent_files,
+                                LoadDependentFiles load_dependent_files,
                                 PlatformSP &platform_sp, TargetSP &target_sp) {
   return CreateTargetInternal(debugger, user_exe_path, specified_arch,
-                              get_dependent_files, platform_sp, target_sp,
+                              load_dependent_files, platform_sp, target_sp,
                               false);
 }
 
 Status TargetList::CreateTargetInternal(
     Debugger &debugger, llvm::StringRef user_exe_path,
-    llvm::StringRef triple_str, bool get_dependent_files,
+    llvm::StringRef triple_str, LoadDependentFiles load_dependent_files,
     const OptionGroupPlatform *platform_options, TargetSP &target_sp,
     bool is_dummy_target) {
   Status error;
   PlatformSP platform_sp;
 
   // This is purposely left empty unless it is specified by triple_cstr. If not
   // initialized via triple_cstr, then the currently selected platform will set
   // the architecture correctly.
if (!platform_sp->IsCompatibleArchitecture(platform_arch, false,
         debugger.GetPlatformList().SetSelectedPlatform(platform_sp);
     }
   }
 
   if (!platform_arch.IsValid())
     platform_arch = arch;
 
   error = TargetList::CreateTargetInternal(
-      debugger, user_exe_path, platform_arch, get_dependent_files, platform_sp,
+      debugger, user_exe_path, platform_arch, load_dependent_files, platform_sp,
       target_sp, is_dummy_target);
   return error;
 }
 
 lldb::TargetSP TargetList::GetDummyTarget(lldb_private::Debugger &debugger) {
   // FIXME: Maybe the dummy target should be per-Debugger
   if (!m_dummy_target_sp || !m_dummy_target_sp->IsValid()) {
     ArchSpec arch(Target::GetDefaultArchitecture());
     if (!arch.IsValid())
       arch = HostInfo::GetArchitecture();
     Status err = CreateDummyTarget(
         debugger, arch.GetTriple().getTriple().c_str(), m_dummy_target_sp);
   }
 
   return m_dummy_target_sp;
 }
 
 Status TargetList::CreateDummyTarget(Debugger &debugger,
                                      llvm::StringRef specified_arch_name,
                                      lldb::TargetSP &target_sp) {
   PlatformSP host_platform_sp(Platform::GetHostPlatform());
   return CreateTargetInternal(
-      debugger, (const char *)nullptr, specified_arch_name, false,
+      debugger, (const char *)nullptr, specified_arch_name, eLoadDependentsNo,
       (const OptionGroupPlatform *)nullptr, target_sp, true);
 }
 
 Status TargetList::CreateTargetInternal(Debugger &debugger,
                                         llvm::StringRef user_exe_path,
                                         const ArchSpec &specified_arch,
-                                        bool get_dependent_files,
+                                        LoadDependentFiles load_dependent_files,
                                         lldb::PlatformSP &platform_sp,
                                         lldb::TargetSP &target_sp,
                                         bool is_dummy_target) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
       func_cat, "TargetList::CreateTarget (file = '%s', arch = '%s')",
       user_exe_path.str().c_str(), specified_arch.GetArchitectureName());
   Status error;
if (error.Success() && exe_module_sp) {
               arch.GetArchitectureName());
         } else {
           error.SetErrorStringWithFormat("unsupported file type \"%s\"",
                                          file.GetPath().c_str());
         }
         return error;
       }
       target_sp.reset(new Target(debugger, arch, platform_sp, is_dummy_target));
-      target_sp->SetExecutableModule(exe_module_sp, get_dependent_files);
+      target_sp->SetExecutableModule(exe_module_sp, load_dependent_files);
       if (user_exe_path_is_bundle)
         exe_module_sp->GetFileSpec().GetPath(resolved_bundle_exe_path,
                                              sizeof(resolved_bundle_exe_path));
     }
   } else {
     // No file was specified, just create an empty target with any arch if a
     // valid arch was specified
     target_sp.reset(new Target(debugger, arch, platform_sp, is_dummy_target));

tools/lldb-test/lldb-test.cpp

 static Error make_string_error(const char *Format, Args &&... args) {
   return llvm::make_error<llvm::StringError>(
       llvm::formatv(Format, std::forward<Args>(args)...).str(),
       llvm::inconvertibleErrorCode());
 }
 
 TargetSP opts::createTarget(Debugger &Dbg, const std::string &Filename) {
   TargetSP Target;
-  Status ST =
-      Dbg.GetTargetList().CreateTarget(Dbg, Filename, /*triple*/ "",
-                                       /*get_dependent_modules*/ false,
-                                       /*platform_options*/ nullptr, Target);
+  Status ST = Dbg.GetTargetList().CreateTarget(
+      Dbg, Filename, /*triple*/ "", eLoadDependentsNo,
   if (ST.Fail()) {
     errs() << formatv("Failed to create target '{0}: {1}\n", Filename, ST);
     exit(1);
   }
   return Target;
 }
 
 std::unique_ptr<MemoryBuffer> opts::openFile(const std::string &Filename) {