1 //===-- DynamicLoaderWindowsDYLD.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 "DynamicLoaderWindowsDYLD.h"
10 
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/PluginManager.h"
13 #include "lldb/Target/ExecutionContext.h"
14 #include "lldb/Target/Platform.h"
15 #include "lldb/Target/Process.h"
16 #include "lldb/Target/RegisterContext.h"
17 #include "lldb/Target/Target.h"
18 #include "lldb/Target/ThreadPlanStepInstruction.h"
19 #include "lldb/Utility/LLDBLog.h"
20 #include "lldb/Utility/Log.h"
21 
22 #include "llvm/ADT/Triple.h"
23 
24 using namespace lldb;
25 using namespace lldb_private;
26 
27 LLDB_PLUGIN_DEFINE(DynamicLoaderWindowsDYLD)
28 
29 DynamicLoaderWindowsDYLD::DynamicLoaderWindowsDYLD(Process *process)
30     : DynamicLoader(process) {}
31 
32 DynamicLoaderWindowsDYLD::~DynamicLoaderWindowsDYLD() = default;
33 
34 void DynamicLoaderWindowsDYLD::Initialize() {
35   PluginManager::RegisterPlugin(GetPluginNameStatic(),
36                                 GetPluginDescriptionStatic(), CreateInstance);
37 }
38 
39 void DynamicLoaderWindowsDYLD::Terminate() {}
40 
41 llvm::StringRef DynamicLoaderWindowsDYLD::GetPluginDescriptionStatic() {
42   return "Dynamic loader plug-in that watches for shared library "
43          "loads/unloads in Windows processes.";
44 }
45 
46 DynamicLoader *DynamicLoaderWindowsDYLD::CreateInstance(Process *process,
47                                                         bool force) {
48   bool should_create = force;
49   if (!should_create) {
50     const llvm::Triple &triple_ref =
51         process->GetTarget().GetArchitecture().GetTriple();
52     if (triple_ref.getOS() == llvm::Triple::Win32)
53       should_create = true;
54   }
55 
56   if (should_create)
57     return new DynamicLoaderWindowsDYLD(process);
58 
59   return nullptr;
60 }
61 
62 void DynamicLoaderWindowsDYLD::OnLoadModule(lldb::ModuleSP module_sp,
63                                             const ModuleSpec module_spec,
64                                             lldb::addr_t module_addr) {
65 
66   // Resolve the module unless we already have one.
67   if (!module_sp) {
68     Status error;
69     module_sp = m_process->GetTarget().GetOrCreateModule(module_spec,
70                                              true /* notify */, &error);
71     if (error.Fail())
72       return;
73   }
74 
75   m_loaded_modules[module_sp] = module_addr;
76   UpdateLoadedSectionsCommon(module_sp, module_addr, false);
77   ModuleList module_list;
78   module_list.Append(module_sp);
79   m_process->GetTarget().ModulesDidLoad(module_list);
80 }
81 
82 void DynamicLoaderWindowsDYLD::OnUnloadModule(lldb::addr_t module_addr) {
83   Address resolved_addr;
84   if (!m_process->GetTarget().ResolveLoadAddress(module_addr, resolved_addr))
85     return;
86 
87   ModuleSP module_sp = resolved_addr.GetModule();
88   if (module_sp) {
89     m_loaded_modules.erase(module_sp);
90     UnloadSectionsCommon(module_sp);
91     ModuleList module_list;
92     module_list.Append(module_sp);
93     m_process->GetTarget().ModulesDidUnload(module_list, false);
94   }
95 }
96 
97 lldb::addr_t DynamicLoaderWindowsDYLD::GetLoadAddress(ModuleSP executable) {
98   // First, see if the load address is already cached.
99   auto it = m_loaded_modules.find(executable);
100   if (it != m_loaded_modules.end() && it->second != LLDB_INVALID_ADDRESS)
101     return it->second;
102 
103   lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
104 
105   // Second, try to get it through the process plugins.  For a remote process,
106   // the remote platform will be responsible for providing it.
107   FileSpec file_spec(executable->GetPlatformFileSpec());
108   bool is_loaded = false;
109   Status status =
110       m_process->GetFileLoadAddress(file_spec, is_loaded, load_addr);
111   // Servers other than lldb server could respond with a bogus address.
112   if (status.Success() && is_loaded && load_addr != LLDB_INVALID_ADDRESS) {
113     m_loaded_modules[executable] = load_addr;
114     return load_addr;
115   }
116 
117   return LLDB_INVALID_ADDRESS;
118 }
119 
120 void DynamicLoaderWindowsDYLD::DidAttach() {
121   Log *log = GetLog(LLDBLog::DynamicLoader);
122   LLDB_LOGF(log, "DynamicLoaderWindowsDYLD::%s()", __FUNCTION__);
123 
124   ModuleSP executable = GetTargetExecutable();
125 
126   if (!executable.get())
127     return;
128 
129   // Try to fetch the load address of the file from the process, since there
130   // could be randomization of the load address.
131   lldb::addr_t load_addr = GetLoadAddress(executable);
132   if (load_addr == LLDB_INVALID_ADDRESS)
133     return;
134 
135   // Request the process base address.
136   lldb::addr_t image_base = m_process->GetImageInfoAddress();
137   if (image_base == load_addr)
138     return;
139 
140   // Rebase the process's modules if there is a mismatch.
141   UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_addr, false);
142 
143   ModuleList module_list;
144   module_list.Append(executable);
145   m_process->GetTarget().ModulesDidLoad(module_list);
146   auto error = m_process->LoadModules();
147   LLDB_LOG_ERROR(log, std::move(error), "failed to load modules: {0}");
148 }
149 
150 void DynamicLoaderWindowsDYLD::DidLaunch() {
151   Log *log = GetLog(LLDBLog::DynamicLoader);
152   LLDB_LOGF(log, "DynamicLoaderWindowsDYLD::%s()", __FUNCTION__);
153 
154   ModuleSP executable = GetTargetExecutable();
155   if (!executable.get())
156     return;
157 
158   lldb::addr_t load_addr = GetLoadAddress(executable);
159   if (load_addr != LLDB_INVALID_ADDRESS) {
160     // Update the loaded sections so that the breakpoints can be resolved.
161     UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_addr, false);
162 
163     ModuleList module_list;
164     module_list.Append(executable);
165     m_process->GetTarget().ModulesDidLoad(module_list);
166     auto error = m_process->LoadModules();
167     LLDB_LOG_ERROR(log, std::move(error), "failed to load modules: {0}");
168   }
169 }
170 
171 Status DynamicLoaderWindowsDYLD::CanLoadImage() { return Status(); }
172 
173 ThreadPlanSP
174 DynamicLoaderWindowsDYLD::GetStepThroughTrampolinePlan(Thread &thread,
175                                                        bool stop) {
176   auto arch = m_process->GetTarget().GetArchitecture();
177   if (arch.GetMachine() != llvm::Triple::x86) {
178     return ThreadPlanSP();
179   }
180 
181   uint64_t pc = thread.GetRegisterContext()->GetPC();
182   // Max size of an instruction in x86 is 15 bytes.
183   AddressRange range(pc, 2 * 15);
184 
185   DisassemblerSP disassembler_sp = Disassembler::DisassembleRange(
186       arch, nullptr, nullptr, m_process->GetTarget(), range);
187   if (!disassembler_sp) {
188     return ThreadPlanSP();
189   }
190 
191   InstructionList *insn_list = &disassembler_sp->GetInstructionList();
192   if (insn_list == nullptr) {
193     return ThreadPlanSP();
194   }
195 
196   // First instruction in a x86 Windows trampoline is going to be an indirect
197   // jump through the IAT and the next one will be a nop (usually there for
198   // alignment purposes). e.g.:
199   //     0x70ff4cfc <+956>: jmpl   *0x7100c2a8
200   //     0x70ff4d02 <+962>: nop
201 
202   auto first_insn = insn_list->GetInstructionAtIndex(0);
203   auto second_insn = insn_list->GetInstructionAtIndex(1);
204 
205   ExecutionContext exe_ctx(m_process->GetTarget());
206   if (first_insn == nullptr || second_insn == nullptr ||
207       strcmp(first_insn->GetMnemonic(&exe_ctx), "jmpl") != 0 ||
208       strcmp(second_insn->GetMnemonic(&exe_ctx), "nop") != 0) {
209     return ThreadPlanSP();
210   }
211 
212   assert(first_insn->DoesBranch() && !second_insn->DoesBranch());
213 
214   return ThreadPlanSP(new ThreadPlanStepInstruction(
215       thread, false, false, eVoteNoOpinion, eVoteNoOpinion));
216 }
217