1 //===-- DynamicLoaderStatic.cpp -------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Core/Module.h"
10 #include "lldb/Core/PluginManager.h"
11 #include "lldb/Core/Section.h"
12 #include "lldb/Symbol/ObjectFile.h"
13 #include "lldb/Target/SectionLoadList.h"
14 #include "lldb/Target/Target.h"
15 
16 #include "DynamicLoaderStatic.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 LLDB_PLUGIN_DEFINE(DynamicLoaderStatic)
22 
23 // Create an instance of this class. This function is filled into the plugin
24 // info class that gets handed out by the plugin factory and allows the lldb to
25 // instantiate an instance of this class.
26 DynamicLoader *DynamicLoaderStatic::CreateInstance(Process *process,
27                                                    bool force) {
28   bool create = force;
29   if (!create) {
30     const llvm::Triple &triple_ref =
31         process->GetTarget().GetArchitecture().GetTriple();
32     const llvm::Triple::OSType os_type = triple_ref.getOS();
33     const llvm::Triple::ArchType arch_type = triple_ref.getArch();
34     if (os_type == llvm::Triple::UnknownOS) {
35       // The WASM and Hexagon plugin check the ArchType rather than the OSType,
36       // so explicitly reject those here.
37       switch(arch_type) {
38         case llvm::Triple::hexagon:
39         case llvm::Triple::wasm32:
40         case llvm::Triple::wasm64:
41           break;
42         default:
43           create = true;
44       }
45     }
46   }
47 
48   if (!create) {
49     Module *exe_module = process->GetTarget().GetExecutableModulePointer();
50     if (exe_module) {
51       ObjectFile *object_file = exe_module->GetObjectFile();
52       if (object_file) {
53         create = (object_file->GetStrata() == ObjectFile::eStrataRawImage);
54       }
55     }
56   }
57 
58   if (create)
59     return new DynamicLoaderStatic(process);
60   return nullptr;
61 }
62 
63 // Constructor
64 DynamicLoaderStatic::DynamicLoaderStatic(Process *process)
65     : DynamicLoader(process) {}
66 
67 /// Called after attaching a process.
68 ///
69 /// Allow DynamicLoader plug-ins to execute some code after
70 /// attaching to a process.
71 void DynamicLoaderStatic::DidAttach() { LoadAllImagesAtFileAddresses(); }
72 
73 /// Called after attaching a process.
74 ///
75 /// Allow DynamicLoader plug-ins to execute some code after
76 /// attaching to a process.
77 void DynamicLoaderStatic::DidLaunch() { LoadAllImagesAtFileAddresses(); }
78 
79 void DynamicLoaderStatic::LoadAllImagesAtFileAddresses() {
80   const ModuleList &module_list = m_process->GetTarget().GetImages();
81 
82   ModuleList loaded_module_list;
83 
84   // Disable JIT for static dynamic loader targets
85   m_process->SetCanJIT(false);
86 
87   for (ModuleSP module_sp : module_list.Modules()) {
88     if (module_sp) {
89       bool changed = false;
90       ObjectFile *image_object_file = module_sp->GetObjectFile();
91       if (image_object_file) {
92         SectionList *section_list = image_object_file->GetSectionList();
93         if (section_list) {
94           // All sections listed in the dyld image info structure will all
95           // either be fixed up already, or they will all be off by a single
96           // slide amount that is determined by finding the first segment that
97           // is at file offset zero which also has bytes (a file size that is
98           // greater than zero) in the object file.
99 
100           // Determine the slide amount (if any)
101           const size_t num_sections = section_list->GetSize();
102           size_t sect_idx = 0;
103           for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
104             // Iterate through the object file sections to find the first
105             // section that starts of file offset zero and that has bytes in
106             // the file...
107             SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
108             if (section_sp) {
109               // If this section already has a load address set in the target,
110               // don't re-set it to the file address.  Something may have
111               // set it to a more correct value already.
112               if (m_process->GetTarget()
113                       .GetSectionLoadList()
114                       .GetSectionLoadAddress(section_sp) !=
115                   LLDB_INVALID_ADDRESS) {
116                 continue;
117               }
118               if (m_process->GetTarget().SetSectionLoadAddress(
119                       section_sp, section_sp->GetFileAddress()))
120                 changed = true;
121             }
122           }
123         }
124       }
125 
126       if (changed)
127         loaded_module_list.AppendIfNeeded(module_sp);
128     }
129   }
130 
131   m_process->GetTarget().ModulesDidLoad(loaded_module_list);
132 }
133 
134 ThreadPlanSP
135 DynamicLoaderStatic::GetStepThroughTrampolinePlan(Thread &thread,
136                                                   bool stop_others) {
137   return ThreadPlanSP();
138 }
139 
140 Status DynamicLoaderStatic::CanLoadImage() {
141   Status error;
142   error.SetErrorString("can't load images on with a static debug session");
143   return error;
144 }
145 
146 void DynamicLoaderStatic::Initialize() {
147   PluginManager::RegisterPlugin(GetPluginNameStatic(),
148                                 GetPluginDescriptionStatic(), CreateInstance);
149 }
150 
151 void DynamicLoaderStatic::Terminate() {
152   PluginManager::UnregisterPlugin(CreateInstance);
153 }
154 
155 lldb_private::ConstString DynamicLoaderStatic::GetPluginNameStatic() {
156   static ConstString g_name("static");
157   return g_name;
158 }
159 
160 const char *DynamicLoaderStatic::GetPluginDescriptionStatic() {
161   return "Dynamic loader plug-in that will load any images at the static "
162          "addresses contained in each image.";
163 }
164 
165 // PluginInterface protocol
166 lldb_private::ConstString DynamicLoaderStatic::GetPluginName() {
167   return GetPluginNameStatic();
168 }
169 
170 uint32_t DynamicLoaderStatic::GetPluginVersion() { return 1; }
171