MachOPlatform.h Source File (original) (raw)

32public:

41 std::vector<std::pair<ExecutorAddr, MachOJITDylibDepInfo>>;

87 std::vectorstd::string RPaths;

93 };

100

101

102 static inline std::unique_ptr

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

145 std::unique_ptr OrcRuntime,

147 MachOHeaderMUBuilder BuildMachOHeaderMU = buildSimpleMachOHeaderMU,

148 std::optional RuntimeAliases = std::nullopt);

149

150

153 const char *OrcRuntimePath, HeaderOptions PlatformJDOpts = {},

154 MachOHeaderMUBuilder BuildMachOHeaderMU = buildSimpleMachOHeaderMU,

155 std::optional RuntimeAliases = std::nullopt);

156

159

163

165

166

167

168 Error setupJITDylib(JITDylib &JD, HeaderOptions Opts);

169

174

175

176

177

179

180

182

183

185 standardRuntimeUtilityAliases();

186

187

188

190 standardLazyCompilationAliases();

191

192private:

194 std::tuple<ExecutorAddr, ExecutorAddr, MachOExecutorSymbolFlags>>;

195

196

197 struct BootstrapInfo {

198 std::condition_variable CV;

199 size_t ActiveGraphs = 0;

202 SymbolTableVector SymTab;

203 };

204

205

206

207

208 class LLVM_ABI MachOPlatformPlugin : public ObjectLinkingLayer::Plugin {

209 public:

210 MachOPlatformPlugin(MachOPlatform &MP) : MP(MP) {}

211

212 void modifyPassConfig(MaterializationResponsibility &MR,

213 jitlink::LinkGraph &G,

214 jitlink::PassConfiguration &Config) override;

215

216

217

218 Error notifyFailed(MaterializationResponsibility &MR) override {

219 return Error::success();

220 }

221

222 Error notifyRemovingResources(JITDylib &JD, ResourceKey K) override {

223 return Error::success();

224 }

225

226 void notifyTransferringResources(JITDylib &JD, ResourceKey DstKey,

227 ResourceKey SrcKey) override {}

228

229 private:

230 struct UnwindSections {

231 SmallVector CodeRanges;

232 ExecutorAddrRange DwarfSection;

233 ExecutorAddrRange CompactUnwindSection;

234 };

235

236 struct ObjCImageInfo {

238 uint32_t Flags = 0;

239

240

241 bool Finalized = false;

242 };

243

244 struct SymbolTablePair {

245 jitlink::Symbol *OriginalSym = nullptr;

246 jitlink::Symbol *NameSym = nullptr;

247 };

248 using JITSymTabVector = SmallVector;

249

250 Error bootstrapPipelineRecordRuntimeFunctions(jitlink::LinkGraph &G);

251 Error bootstrapPipelineEnd(jitlink::LinkGraph &G);

252

253 Error associateJITDylibHeaderSymbol(jitlink::LinkGraph &G,

254 MaterializationResponsibility &MR);

255

256 Error preserveImportantSections(jitlink::LinkGraph &G,

257 MaterializationResponsibility &MR);

258

259 Error processObjCImageInfo(jitlink::LinkGraph &G,

260 MaterializationResponsibility &MR);

261 Error mergeImageInfoFlags(jitlink::LinkGraph &G,

262 MaterializationResponsibility &MR,

263 ObjCImageInfo &Info, uint32_t NewFlags);

264

265 Error fixTLVSectionsAndEdges(jitlink::LinkGraph &G, JITDylib &JD);

266

267 std::optional findUnwindSectionInfo(jitlink::LinkGraph &G);

268 Error registerObjectPlatformSections(jitlink::LinkGraph &G, JITDylib &JD,

269 ExecutorAddr HeaderAddr,

270 bool InBootstrapPhase);

271

272 Error createObjCRuntimeObject(jitlink::LinkGraph &G);

273 Error populateObjCRuntimeObject(jitlink::LinkGraph &G,

274 MaterializationResponsibility &MR);

275

276 Error prepareSymbolTableRegistration(jitlink::LinkGraph &G,

277 JITSymTabVector &JITSymTabInfo);

278 Error addSymbolTableRegistration(jitlink::LinkGraph &G,

279 MaterializationResponsibility &MR,

280 JITSymTabVector &JITSymTabInfo,

281 bool InBootstrapPhase);

282

283 std::mutex PluginMutex;

284 MachOPlatform &MP;

285

286

287

288 DenseMap<JITDylib *, ObjCImageInfo> ObjCImageInfos;

289 };

290

291 using GetJITDylibHeaderSendResultFn =

292 unique_function<void(Expected)>;

293 using GetJITDylibNameSendResultFn =

294 unique_function<void(Expected)>;

295 using PushInitializersSendResultFn =

296 unique_function<void(Expected)>;

297 using SendSymbolAddressFn = unique_function<void(Expected)>;

298 using PushSymbolsInSendResultFn = unique_function<void(Error)>;

299

300 static bool supportedTarget(const Triple &TT);

301

302 static jitlink::Edge::Kind getPointerEdgeKind(jitlink::LinkGraph &G);

303

304 static MachOExecutorSymbolFlags flagsForSymbol(jitlink::Symbol &Sym);

305

306 MachOPlatform(ObjectLinkingLayer &ObjLinkingLayer, JITDylib &PlatformJD,

307 std::unique_ptr OrcRuntimeGenerator,

308 HeaderOptions PlatformJDOpts,

309 MachOHeaderMUBuilder BuildMachOHeaderMU, Error &Err);

310

311

312 Error associateRuntimeSupportFunctions();

313

314

315

316

317 void pushInitializersLoop(PushInitializersSendResultFn SendResult,

318 JITDylibSP JD);

319

320

321 void rt_pushInitializers(PushInitializersSendResultFn SendResult,

322 ExecutorAddr JDHeaderAddr);

323

324

325

326

327

328 void rt_pushSymbols(PushSymbolsInSendResultFn SendResult, ExecutorAddr Handle,

329 const std::vector<std::pair<StringRef, bool>> &Symbols);

330

331

332 Expected<uint64_t> createPThreadKey();

333

334 ExecutionSession &ES;

335 JITDylib &PlatformJD;

336 ObjectLinkingLayer &ObjLinkingLayer;

337 MachOHeaderMUBuilder BuildMachOHeaderMU;

338

339 SymbolStringPtr MachOHeaderStartSymbol = ES.intern("___dso_handle");

340

343 SymbolStringPtr Name;

344 ExecutorAddr Addr;

345 };

346

348 ES.intern("___orc_rt_macho_platform_bootstrap")};

350 ES.intern("___orc_rt_macho_platform_shutdown")};

352 ES.intern("___orc_rt_macho_register_ehframe_section")};

354 ES.intern("___orc_rt_macho_deregister_ehframe_section")};

356 ES.intern("___orc_rt_macho_register_jitdylib")};

358 ES.intern("___orc_rt_macho_deregister_jitdylib")};

360 ES.intern("___orc_rt_macho_register_object_symbol_table")};

362 ES.intern("___orc_rt_macho_deregister_object_symbol_table")};

364 ES.intern("___orc_rt_macho_register_object_platform_sections")};

366 ES.intern("___orc_rt_macho_deregister_object_platform_sections")};

368 ES.intern("___orc_rt_macho_create_pthread_key")};

370 ES.intern("___orc_rt_macho_register_objc_runtime_object")};

372 ES.intern("___orc_rt_macho_deregister_objc_runtime_object")};

373

374 DenseMap<JITDylib *, SymbolLookupSet> RegisteredInitSymbols;

375

376 std::mutex PlatformMutex;

377 bool ForceEHFrames = false;

378 BootstrapInfo *Bootstrap = nullptr;

379 DenseMap<JITDylib *, ExecutorAddr> JITDylibToHeaderAddr;

380 DenseMap<ExecutorAddr, JITDylib *> HeaderAddrToJITDylib;

381 DenseMap<JITDylib *, uint64_t> JITDylibToPThreadKey;

382};

386public:

390 void materialize(std::unique_ptr R) override;

392

393protected:

396

399

400private:

401 struct HeaderSymbol {

402 const char *Name;

404 };

405

406 static constexpr HeaderSymbol AdditionalHeaderSymbols[] = {

407 {"___mh_executable_header", 0}};

408

409 void addMachOHeader(JITDylib &JD, jitlink::LinkGraph &G,

410 const SymbolStringPtr &InitializerSymbol);

411 static MaterializationUnit::Interface

412 createHeaderInterface(MachOPlatform &MOP,

413 const SymbolStringPtr &HeaderStartSymbol);

414};

420 return std::make_unique(MOP, MOP.MachOHeaderStartSymbol,

421 std::move(Opts));

422}