ObjectFileInterface.cpp Source File (original) (raw)

17#include

19#define DEBUG_TYPE "orc"

21namespace llvm {

22namespace orc {

26 assert(.InitSymbol && "I already has an init symbol");

27 size_t Counter = 0;

29 do {

30 std::string InitSymString;

32 << "$." << ObjFileName << ".__inits." << Counter++;

33 I.InitSymbol = ES.intern(InitSymString);

34 } while (I.SymbolFlags.count(I.InitSymbol));

37}

44 for (auto &Sym : Obj.symbols()) {

46 if (!SymFlagsOrErr)

52 continue;

56 continue;

59 if (auto SymType = Sym.getType()) {

61 continue;

62 } else

63 return SymType.takeError();

65 auto Name = Sym.getName();

66 if (!Name)

67 return Name.takeError();

69 if (!SymFlags)

70 return SymFlags.takeError();

73 if (Name->starts_with("l"))

76 I.SymbolFlags[ES.intern(*Name)] = std::move(*SymFlags);

77 }

79 for (auto &Sec : Obj.sections()) {

80 auto SecType = Obj.getSectionType(Sec);

83 break;

84 }

85 auto SegName = Obj.getSectionFinalSegmentName(Sec.getRawDataRefImpl());

86 auto SecName = cantFail(Obj.getSectionName(Sec.getRawDataRefImpl()));

89 break;

90 }

91 }

93 return I;

94}

100

101 for (auto &Sym : Obj.symbols()) {

103 if (!SymFlagsOrErr)

104

105 return SymFlagsOrErr.takeError();

106

107

109 continue;

110

111

113 continue;

114

115

116 if (auto SymType = Sym.getType()) {

118 continue;

119 } else

120 return SymType.takeError();

121

122 auto Name = Sym.getName();

123 if (!Name)

124 return Name.takeError();

125

127 if (!SymFlags)

128 return SymFlags.takeError();

129

130

133

134 I.SymbolFlags[ES.intern(std::move(*Name))] = std::move(*SymFlags);

135 }

136

138 for (auto &Sec : Obj.sections()) {

139 if (auto SecName = Sec.getName()) {

142 break;

143 }

144 }

145 }

146

147 return I;

148}

149

154 std::vector<std::optionalobject::coff\_aux\_section\_definition> ComdatDefs(

155 Obj.getNumberOfSections() + 1);

156 for (auto &Sym : Obj.symbols()) {

158 if (!SymFlagsOrErr)

159

160 return SymFlagsOrErr.takeError();

161

162

163 auto COFFSym = Obj.getCOFFSymbol(Sym);

164 bool IsWeak = false;

165 if (auto *Def = COFFSym.getSectionDefinition()) {

166 auto Sec = Obj.getSection(COFFSym.getSectionNumber());

167 if (!Sec)

168 return Sec.takeError();

171 ComdatDefs[COFFSym.getSectionNumber()] = *Def;

172 continue;

173 }

174 }

176 ComdatDefs[COFFSym.getSectionNumber()]) {

177 auto Def = ComdatDefs[COFFSym.getSectionNumber()];

179 IsWeak = true;

180 }

181 ComdatDefs[COFFSym.getSectionNumber()] = std::nullopt;

182 } else {

183

185 continue;

186 }

187

188

190 continue;

191

192

193 if (auto SymType = Sym.getType()) {

195 continue;

196 } else

197 return SymType.takeError();

198

199 auto Name = Sym.getName();

200 if (!Name)

201 return Name.takeError();

202

204 if (!SymFlags)

205 return SymFlags.takeError();

207

208

209 if (COFFSym.isWeakExternal())

211

212 if (IsWeak)

214

215 I.SymbolFlags[ES.intern(*Name)] = std::move(*SymFlags);

216 }

217

219 for (auto &Sec : Obj.sections()) {

220 if (auto SecName = Sec.getName()) {

223 break;

224 }

225 } else

226 return SecName.takeError();

227 }

228

229 return I;

230}

231

235

237

238 for (auto &Sym : Obj.symbols()) {

240 if (!SymFlagsOrErr)

241 return SymFlagsOrErr.takeError();

242 uint32_t Flags = *SymFlagsOrErr;

243

244

246 continue;

248 continue;

249

253

255 continue;

256

257 auto Name = Sym.getName();

258 if (!Name)

259 return Name.takeError();

261 if (!SymFlags)

262 return SymFlags.takeError();

263

264

265

266

267

268

269

271

272 I.SymbolFlags[ES.intern(std::move(*Name))] = std::move(*SymFlags);

273 }

274

275 return I;

276}

277

282

283 for (auto &Sym : Obj.symbols()) {

285 if (!SymFlagsOrErr)

286

287 return SymFlagsOrErr.takeError();

288

289

291 continue;

292

293

295 continue;

296

297

298 if (auto SymType = Sym.getType()) {

300 continue;

301 } else

302 return SymType.takeError();

303

304 auto Name = Sym.getName();

305 if (!Name)

306 return Name.takeError();

307

309 if (!SymFlags)

310 return SymFlags.takeError();

311

312 I.SymbolFlags[ES.intern(*Name)] = std::move(*SymFlags);

313 }

314

315 return I;

316}

317

321

322 if (!Obj)

323 return Obj.takeError();

324

333

335}

336

337}

338}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

Tagged union holding either a T or a Error.

Error takeError()

Take ownership of the stored error.

Flags for symbols in the JIT.

static LLVM_ABI Expected< JITSymbolFlags > fromObjectSymbol(const object::SymbolRef &Symbol)

Construct a JITSymbolFlags value based on the flags of the given libobject symbol.

@ MaterializationSideEffectsOnly

StringRef - Represent a constant reference to a string, i.e.

This class is the base class for all object file types.

static Expected< OwningBinary< ObjectFile > > createObjectFile(StringRef ObjectPath)

An ExecutionSession represents a running JIT program.

SymbolStringPtr intern(StringRef SymName)

Add a symbol name to the SymbolStringPool and return a pointer to it.

Pointer to a pooled string representing a symbol name.

A raw_ostream that writes to an std::string.

@ IMAGE_COMDAT_SELECT_NODUPLICATES

@ IMAGE_COMDAT_SELECT_ASSOCIATIVE

bool isReservedSectionNumber(int32_t SectionNumber)

@ S_MOD_INIT_FUNC_POINTERS

S_MOD_INIT_FUNC_POINTERS - Section with only function pointers for initialization.

LLVM_ABI void addInitSymbol(MaterializationUnit::Interface &I, ExecutionSession &ES, StringRef ObjFileName)

Adds an initializer symbol to the given MU interface.

Definition ObjectFileInterface.cpp:24

static Expected< MaterializationUnit::Interface > getMachOObjectFileSymbolInfo(ExecutionSession &ES, const object::MachOObjectFile &Obj)

Definition ObjectFileInterface.cpp:40

Expected< MaterializationUnit::Interface > getGenericObjectFileSymbolInfo(ExecutionSession &ES, const object::ObjectFile &Obj)

Definition ObjectFileInterface.cpp:279

static Expected< MaterializationUnit::Interface > getELFObjectFileSymbolInfo(ExecutionSession &ES, const object::ELFObjectFileBase &Obj)

Definition ObjectFileInterface.cpp:97

Expected< MaterializationUnit::Interface > getXCOFFObjectFileSymbolInfo(ExecutionSession &ES, const object::ObjectFile &Obj)

Definition ObjectFileInterface.cpp:233

LLVM_ABI bool isMachOInitializerSection(StringRef SegName, StringRef SecName)

LLVM_ABI Expected< MaterializationUnit::Interface > getObjectFileInterface(ExecutionSession &ES, MemoryBufferRef ObjBuffer)

Returns a MaterializationUnit::Interface for the object file contained in the given buffer,...

Definition ObjectFileInterface.cpp:319

LLVM_ABI bool isCOFFInitializerSection(StringRef Name)

static Expected< MaterializationUnit::Interface > getCOFFObjectFileSymbolInfo(ExecutionSession &ES, const object::COFFObjectFile &Obj)

Definition ObjectFileInterface.cpp:151

LLVM_ABI bool isELFInitializerSection(StringRef SecName)

This is an optimization pass for GlobalISel generic memory operations.

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

void cantFail(Error Err, const char *Msg=nullptr)

Report a fatal error if Err is a failure value.