ELFNixPlatform.h Source File (original) (raw)

47 std::size_t

48 operator()(const std::pair<RuntimeFunction *, RuntimeFunction *> &key) const {

49 return std::hash<void *>()(key.first->Addr.toPtr<void *>()) ^

50 std::hash<void *>()(key.second->Addr.toPtr<void *>());

51 }

52};

55 std::size_t

56 operator()(const std::pair<RuntimeFunction *, RuntimeFunction *> &lhs,

57 const std::pair<RuntimeFunction *, RuntimeFunction *> &rhs) const {

58 return lhs.first == rhs.first && lhs.second == rhs.second;

59 }

60};

70public:

100

101

102

103

104

105

106

107

108

111 std::unique_ptr OrcRuntime,

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

113

114

117 const char *OrcRuntimePath,

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

119

122

128

129

130

131

134

135

137

138

140 standardRuntimeUtilityAliases();

141

142

143

145 standardLazyCompilationAliases();

146

147private:

148

149 struct BootstrapInfo {

150 std::mutex Mutex;

151 std::condition_variable CV;

152 size_t ActiveGraphs = 0;

155

156 void addArgumentsToRTFnMap(

160 std::lock_guardstd::mutex Lock(Mutex);

161 auto &argList = DeferredRTFnMap[std::make_pair(func1, func2)];

162 argList.emplace_back(arg1, arg2);

163 }

164 };

165

166

167

168

169 class LLVM_ABI ELFNixPlatformPlugin : public ObjectLinkingLayer::Plugin {

170 public:

171 ELFNixPlatformPlugin(ELFNixPlatform &MP) : MP(MP) {}

172

173 void modifyPassConfig(MaterializationResponsibility &MR,

174 jitlink::LinkGraph &G,

175 jitlink::PassConfiguration &Config) override;

176

177

178

179 Error notifyFailed(MaterializationResponsibility &MR) override {

180 return Error::success();

181 }

182

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

184 return Error::success();

185 }

186

187 void notifyTransferringResources(JITDylib &JD, ResourceKey DstKey,

188 ResourceKey SrcKey) override {}

189

190 private:

191 Error bootstrapPipelineStart(jitlink::LinkGraph &G);

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

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

194

195 void addDSOHandleSupportPasses(MaterializationResponsibility &MR,

196 jitlink::PassConfiguration &Config);

197

198 void addEHAndTLVSupportPasses(MaterializationResponsibility &MR,

199 jitlink::PassConfiguration &Config,

200 bool IsBootstrapping);

201

202 Error preserveInitSections(jitlink::LinkGraph &G,

203 MaterializationResponsibility &MR);

204

205 Error registerInitSections(jitlink::LinkGraph &G, JITDylib &JD,

206 bool IsBootstrapping);

207

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

209

210 std::mutex PluginMutex;

211 ELFNixPlatform &MP;

212 };

213

214 using PushInitializersSendResultFn =

215 unique_function<void(Expected)>;

216

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

218

219 static bool supportedTarget(const Triple &TT);

220

221 ELFNixPlatform(ObjectLinkingLayer &ObjLinkingLayer, JITDylib &PlatformJD,

222 std::unique_ptr OrcRuntimeGenerator,

223 Error &Err);

224

225

226 Error associateRuntimeSupportFunctions(JITDylib &PlatformJD);

227

228 void pushInitializersLoop(PushInitializersSendResultFn SendResult,

229 JITDylibSP JD);

230

231 void rt_recordInitializers(PushInitializersSendResultFn SendResult,

232 ExecutorAddr JDHeader);

233

234 void rt_lookupSymbol(SendSymbolAddressFn SendResult, ExecutorAddr Handle,

235 StringRef SymbolName);

236

237 Error registerPerObjectSections(jitlink::LinkGraph &G,

238 const ELFPerObjectSectionsToRegister &POSR,

239 bool IsBootstrapping);

240

241 Expected<uint64_t> createPThreadKey();

242

243 ExecutionSession &ES;

244 JITDylib &PlatformJD;

245 ObjectLinkingLayer &ObjLinkingLayer;

246

247 SymbolStringPtr DSOHandleSymbol;

248

250 ES.intern("__orc_rt_elfnix_platform_bootstrap")};

252 ES.intern("__orc_rt_elfnix_platform_shutdown")};

254 ES.intern("__orc_rt_elfnix_register_jitdylib")};

256 ES.intern("__orc_rt_elfnix_deregister_jitdylib")};

258 ES.intern("__orc_rt_elfnix_register_object_sections")};

260 ES.intern("__orc_rt_elfnix_deregister_object_sections")};

262 ES.intern("__orc_rt_elfnix_register_init_sections")};

264 ES.intern("__orc_rt_elfnix_deregister_init_sections")};

266 ES.intern("__orc_rt_elfnix_create_pthread_key")};

267

268 DenseMap<JITDylib *, SymbolLookupSet> RegisteredInitSymbols;

269

270

271

272 std::mutex PlatformMutex;

273 std::vector BootstrapPOSRs;

274

275 DenseMap<ExecutorAddr, JITDylib *> HandleAddrToJITDylib;

276 DenseMap<JITDylib *, ExecutorAddr> JITDylibToHandleAddr;

277 DenseMap<JITDylib *, uint64_t> JITDylibToPThreadKey;

278

279 std::atomic<BootstrapInfo *> Bootstrap;

280};

283

286

287template <>

290

291public:

293 return SPSELFPerObjectSectionsToRegister::AsArgList::size(

295 }

296

299 return SPSELFPerObjectSectionsToRegister::AsArgList::serialize(

301 }

302

305 return SPSELFPerObjectSectionsToRegister::AsArgList::deserialize(

307 }

308};

309

312

313}