1 //===-- DynamicLoaderDarwin.h -------------------------------*- C++ -*-===//
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 #ifndef LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERDARWIN_H
10 #define LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERDARWIN_H
11 
12 #include <map>
13 #include <mutex>
14 #include <vector>
15 
16 #include "lldb/Host/SafeMachO.h"
17 #include "lldb/Target/DynamicLoader.h"
18 #include "lldb/Target/Process.h"
19 #include "lldb/Utility/FileSpec.h"
20 #include "lldb/Utility/StructuredData.h"
21 #include "lldb/Utility/UUID.h"
22 
23 #include "llvm/ADT/Triple.h"
24 
25 namespace lldb_private {
26 
27 class DynamicLoaderDarwin : public lldb_private::DynamicLoader {
28 public:
29   DynamicLoaderDarwin(lldb_private::Process *process);
30 
31   ~DynamicLoaderDarwin() override;
32 
33   /// Called after attaching a process.
34   ///
35   /// Allow DynamicLoader plug-ins to execute some code after
36   /// attaching to a process.
37   void DidAttach() override;
38 
39   void DidLaunch() override;
40 
41   lldb::ThreadPlanSP GetStepThroughTrampolinePlan(lldb_private::Thread &thread,
42                                                   bool stop_others) override;
43 
44   void FindEquivalentSymbols(
45       lldb_private::Symbol *original_symbol,
46       lldb_private::ModuleList &module_list,
47       lldb_private::SymbolContextList &equivalent_symbols) override;
48 
49   lldb::addr_t GetThreadLocalData(const lldb::ModuleSP module,
50                                   const lldb::ThreadSP thread,
51                                   lldb::addr_t tls_file_addr) override;
52 
53   bool AlwaysRelyOnEHUnwindInfo(lldb_private::SymbolContext &sym_ctx) override;
54 
55   virtual void DoInitialImageFetch() = 0;
56 
57   virtual bool NeedToDoInitialImageFetch() = 0;
58 
59 protected:
60   void PrivateInitialize(lldb_private::Process *process);
61 
62   void PrivateProcessStateChanged(lldb_private::Process *process,
63                                   lldb::StateType state);
64 
65   void Clear(bool clear_process);
66 
67   // Clear method for classes derived from this one
68   virtual void DoClear() = 0;
69 
70   void SetDYLDModule(lldb::ModuleSP &dyld_module_sp);
71 
72   lldb::ModuleSP GetDYLDModule();
73 
74   void ClearDYLDModule();
75 
76   class Segment {
77   public:
Segment()78     Segment() : name() {}
79 
80     lldb_private::ConstString name;
81     lldb::addr_t vmaddr = LLDB_INVALID_ADDRESS;
82     lldb::addr_t vmsize = 0;
83     lldb::addr_t fileoff = 0;
84     lldb::addr_t filesize = 0;
85     uint32_t maxprot = 0;
86     uint32_t initprot = 0;
87     uint32_t nsects = 0;
88     uint32_t flags = 0;
89 
90     bool operator==(const Segment &rhs) const {
91       return name == rhs.name && vmaddr == rhs.vmaddr && vmsize == rhs.vmsize;
92     }
93 
94     void PutToLog(lldb_private::Log *log, lldb::addr_t slide) const;
95   };
96 
97   struct ImageInfo {
98     /// Address of mach header for this dylib.
99     lldb::addr_t address = LLDB_INVALID_ADDRESS;
100     /// The amount to slide all segments by if there is a global
101     /// slide.
102     lldb::addr_t slide = 0;
103     /// Modification date for this dylib.
104     lldb::addr_t mod_date = 0;
105     /// Resolved path for this dylib.
106     lldb_private::FileSpec file_spec;
107     /// UUID for this dylib if it has one, else all zeros.
108     lldb_private::UUID uuid;
109     /// The mach header for this image.
110     llvm::MachO::mach_header header;
111     /// All segment vmaddr and vmsize pairs for this executable (from
112     /// memory of inferior).
113     std::vector<Segment> segments;
114     /// The process stop ID that the sections for this image were
115     /// loaded.
116     uint32_t load_stop_id = 0;
117     /// LC_VERSION_MIN_... load command os type.
118     llvm::Triple::OSType os_type = llvm::Triple::OSType::UnknownOS;
119     /// LC_VERSION_MIN_... load command os environment.
120     llvm::Triple::EnvironmentType os_env =
121         llvm::Triple::EnvironmentType::UnknownEnvironment;
122     /// LC_VERSION_MIN_... SDK.
123     std::string min_version_os_sdk;
124 
125     ImageInfo() = default;
126 
ClearImageInfo127     void Clear(bool load_cmd_data_only) {
128       if (!load_cmd_data_only) {
129         address = LLDB_INVALID_ADDRESS;
130         slide = 0;
131         mod_date = 0;
132         file_spec.Clear();
133         ::memset(&header, 0, sizeof(header));
134       }
135       uuid.Clear();
136       segments.clear();
137       load_stop_id = 0;
138       os_type = llvm::Triple::OSType::UnknownOS;
139       os_env = llvm::Triple::EnvironmentType::UnknownEnvironment;
140       min_version_os_sdk.clear();
141     }
142 
143     bool operator==(const ImageInfo &rhs) const {
144       return address == rhs.address && slide == rhs.slide &&
145              mod_date == rhs.mod_date && file_spec == rhs.file_spec &&
146              uuid == rhs.uuid &&
147              memcmp(&header, &rhs.header, sizeof(header)) == 0 &&
148              segments == rhs.segments && os_type == rhs.os_type &&
149              os_env == rhs.os_env;
150     }
151 
UUIDValidImageInfo152     bool UUIDValid() const { return uuid.IsValid(); }
153 
GetAddressByteSizeImageInfo154     uint32_t GetAddressByteSize() {
155       if (header.cputype) {
156         if (header.cputype & llvm::MachO::CPU_ARCH_ABI64)
157           return 8;
158         else
159           return 4;
160       }
161       return 0;
162     }
163 
164     lldb_private::ArchSpec GetArchitecture() const;
165 
166     const Segment *FindSegment(lldb_private::ConstString name) const;
167 
168     void PutToLog(lldb_private::Log *log) const;
169 
170     typedef std::vector<ImageInfo> collection;
171     typedef collection::iterator iterator;
172     typedef collection::const_iterator const_iterator;
173   };
174 
175   bool UpdateImageLoadAddress(lldb_private::Module *module, ImageInfo &info);
176 
177   bool UnloadModuleSections(lldb_private::Module *module, ImageInfo &info);
178 
179   lldb::ModuleSP FindTargetModuleForImageInfo(ImageInfo &image_info,
180                                               bool can_create,
181                                               bool *did_create_ptr);
182 
183   void UnloadImages(const std::vector<lldb::addr_t> &solib_addresses);
184 
185   void UnloadAllImages();
186 
187   virtual bool SetNotificationBreakpoint() = 0;
188 
189   virtual void ClearNotificationBreakpoint() = 0;
190 
191   virtual bool DidSetNotificationBreakpoint() = 0;
192 
193   typedef std::map<uint64_t, lldb::addr_t> PthreadKeyToTLSMap;
194   typedef std::map<lldb::user_id_t, PthreadKeyToTLSMap> ThreadIDToTLSMap;
195 
GetMutex()196   std::recursive_mutex &GetMutex() const { return m_mutex; }
197 
198   lldb::ModuleSP GetPThreadLibraryModule();
199 
200   lldb_private::Address GetPthreadSetSpecificAddress();
201 
202   bool JSONImageInformationIntoImageInfo(
203       lldb_private::StructuredData::ObjectSP image_details,
204       ImageInfo::collection &image_infos);
205 
206   // If image_infos contains / may contain dyld or executable image, call this
207   // method
208   // to keep our internal record keeping of the special binaries up-to-date.
209   void
210   UpdateSpecialBinariesFromNewImageInfos(ImageInfo::collection &image_infos);
211 
212   // if image_info is a dyld binary, call this method
213   void UpdateDYLDImageInfoFromNewImageInfo(ImageInfo &image_info);
214 
215   // If image_infos contains / may contain executable image, call this method
216   // to keep our internal record keeping of the special dyld binary up-to-date.
217   void AddExecutableModuleIfInImageInfos(ImageInfo::collection &image_infos);
218 
219   bool AddModulesUsingImageInfos(ImageInfo::collection &image_infos);
220 
221   // Whether we should use the new dyld SPI to get shared library information,
222   // or read
223   // it directly out of the dyld_all_image_infos.  Whether we use the (newer)
224   // DynamicLoaderMacOS
225   // plugin or the (older) DynamicLoaderMacOSX plugin.
226   static bool UseDYLDSPI(lldb_private::Process *process);
227 
228   lldb::ModuleWP m_dyld_module_wp; // the dyld whose file type (mac, ios, etc)
229                                    // matches the process
230   lldb::ModuleWP m_libpthread_module_wp;
231   lldb_private::Address m_pthread_getspecific_addr;
232   ThreadIDToTLSMap m_tid_to_tls_map;
233   ImageInfo::collection
234       m_dyld_image_infos;              // Current shared libraries information
235   uint32_t m_dyld_image_infos_stop_id; // The process stop ID that
236                                        // "m_dyld_image_infos" is valid for
237   ImageInfo m_dyld;
238   mutable std::recursive_mutex m_mutex;
239 
240 private:
241   DynamicLoaderDarwin(const DynamicLoaderDarwin &) = delete;
242   const DynamicLoaderDarwin &operator=(const DynamicLoaderDarwin &) = delete;
243 };
244 
245 } // namespace lldb_private
246 
247 #endif // LLDB_SOURCE_PLUGINS_DYNAMICLOADER_MACOSX_DYLD_DYNAMICLOADERDARWIN_H
248