1 //===------ ObjectFileInterface.cpp - MU interface utils for objects ------===// 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 "llvm/ExecutionEngine/Orc/ObjectFileInterface.h" 10 #include "llvm/ExecutionEngine/Orc/ELFNixPlatform.h" 11 #include "llvm/ExecutionEngine/Orc/MachOPlatform.h" 12 #include "llvm/Object/COFF.h" 13 #include "llvm/Object/ELFObjectFile.h" 14 #include "llvm/Object/MachO.h" 15 #include "llvm/Object/ObjectFile.h" 16 #include "llvm/Support/Debug.h" 17 18 #define DEBUG_TYPE "orc" 19 20 namespace llvm { 21 namespace orc { 22 23 void addInitSymbol(MaterializationUnit::Interface &I, ExecutionSession &ES, 24 StringRef ObjFileName) { 25 assert(!I.InitSymbol && "I already has an init symbol"); 26 size_t Counter = 0; 27 28 do { 29 std::string InitSymString; 30 raw_string_ostream(InitSymString) 31 << "$." << ObjFileName << ".__inits." << Counter++; 32 I.InitSymbol = ES.intern(InitSymString); 33 } while (I.SymbolFlags.count(I.InitSymbol)); 34 35 I.SymbolFlags[I.InitSymbol] = JITSymbolFlags::MaterializationSideEffectsOnly; 36 } 37 38 static Expected<MaterializationUnit::Interface> 39 getMachOObjectFileSymbolInfo(ExecutionSession &ES, 40 const object::MachOObjectFile &Obj) { 41 MaterializationUnit::Interface I; 42 43 for (auto &Sym : Obj.symbols()) { 44 Expected<uint32_t> SymFlagsOrErr = Sym.getFlags(); 45 if (!SymFlagsOrErr) 46 // TODO: Test this error. 47 return SymFlagsOrErr.takeError(); 48 49 // Skip symbols not defined in this object file. 50 if (*SymFlagsOrErr & object::BasicSymbolRef::SF_Undefined) 51 continue; 52 53 // Skip symbols that are not global. 54 if (!(*SymFlagsOrErr & object::BasicSymbolRef::SF_Global)) 55 continue; 56 57 // Skip symbols that have type SF_File. 58 if (auto SymType = Sym.getType()) { 59 if (*SymType == object::SymbolRef::ST_File) 60 continue; 61 } else 62 return SymType.takeError(); 63 64 auto Name = Sym.getName(); 65 if (!Name) 66 return Name.takeError(); 67 auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym); 68 if (!SymFlags) 69 return SymFlags.takeError(); 70 71 // Strip the 'exported' flag from MachO linker-private symbols. 72 if (Name->startswith("l")) 73 *SymFlags &= ~JITSymbolFlags::Exported; 74 75 I.SymbolFlags[ES.intern(*Name)] = std::move(*SymFlags); 76 } 77 78 for (auto &Sec : Obj.sections()) { 79 auto SecType = Obj.getSectionType(Sec); 80 if ((SecType & MachO::SECTION_TYPE) == MachO::S_MOD_INIT_FUNC_POINTERS) { 81 addInitSymbol(I, ES, Obj.getFileName()); 82 break; 83 } 84 auto SegName = Obj.getSectionFinalSegmentName(Sec.getRawDataRefImpl()); 85 auto SecName = cantFail(Obj.getSectionName(Sec.getRawDataRefImpl())); 86 if (MachOPlatform::isInitializerSection(SegName, SecName)) { 87 addInitSymbol(I, ES, Obj.getFileName()); 88 break; 89 } 90 } 91 92 return I; 93 } 94 95 static Expected<MaterializationUnit::Interface> 96 getELFObjectFileSymbolInfo(ExecutionSession &ES, 97 const object::ELFObjectFileBase &Obj) { 98 MaterializationUnit::Interface I; 99 100 for (auto &Sym : Obj.symbols()) { 101 Expected<uint32_t> SymFlagsOrErr = Sym.getFlags(); 102 if (!SymFlagsOrErr) 103 // TODO: Test this error. 104 return SymFlagsOrErr.takeError(); 105 106 // Skip symbols not defined in this object file. 107 if (*SymFlagsOrErr & object::BasicSymbolRef::SF_Undefined) 108 continue; 109 110 // Skip symbols that are not global. 111 if (!(*SymFlagsOrErr & object::BasicSymbolRef::SF_Global)) 112 continue; 113 114 // Skip symbols that have type SF_File. 115 if (auto SymType = Sym.getType()) { 116 if (*SymType == object::SymbolRef::ST_File) 117 continue; 118 } else 119 return SymType.takeError(); 120 121 auto Name = Sym.getName(); 122 if (!Name) 123 return Name.takeError(); 124 125 auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym); 126 if (!SymFlags) 127 return SymFlags.takeError(); 128 129 // ELF STB_GNU_UNIQUE should map to Weak for ORC. 130 if (Sym.getBinding() == ELF::STB_GNU_UNIQUE) 131 *SymFlags |= JITSymbolFlags::Weak; 132 133 I.SymbolFlags[ES.intern(*Name)] = std::move(*SymFlags); 134 } 135 136 SymbolStringPtr InitSymbol; 137 for (auto &Sec : Obj.sections()) { 138 if (auto SecName = Sec.getName()) { 139 if (ELFNixPlatform::isInitializerSection(*SecName)) { 140 addInitSymbol(I, ES, Obj.getFileName()); 141 break; 142 } 143 } 144 } 145 146 return I; 147 } 148 149 static Expected<MaterializationUnit::Interface> 150 getCOFFObjectFileSymbolInfo(ExecutionSession &ES, 151 const object::COFFObjectFile &Obj) { 152 MaterializationUnit::Interface I; 153 154 for (auto &Sym : Obj.symbols()) { 155 Expected<uint32_t> SymFlagsOrErr = Sym.getFlags(); 156 if (!SymFlagsOrErr) 157 // TODO: Test this error. 158 return SymFlagsOrErr.takeError(); 159 160 // Skip symbols not defined in this object file. 161 if (*SymFlagsOrErr & object::BasicSymbolRef::SF_Undefined) 162 continue; 163 164 // Skip symbols that are not global. 165 if (!(*SymFlagsOrErr & object::BasicSymbolRef::SF_Global)) 166 continue; 167 168 // Skip symbols that have type SF_File. 169 if (auto SymType = Sym.getType()) { 170 if (*SymType == object::SymbolRef::ST_File) 171 continue; 172 } else 173 return SymType.takeError(); 174 175 auto Name = Sym.getName(); 176 if (!Name) 177 return Name.takeError(); 178 179 auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym); 180 if (!SymFlags) 181 return SymFlags.takeError(); 182 *SymFlags |= JITSymbolFlags::Exported; 183 auto COFFSym = Obj.getCOFFSymbol(Sym); 184 185 // Weak external is always a function 186 if (COFFSym.isWeakExternal()) { 187 *SymFlags |= JITSymbolFlags::Callable; 188 } 189 190 I.SymbolFlags[ES.intern(*Name)] = std::move(*SymFlags); 191 } 192 193 // FIXME: handle init symbols 194 195 return I; 196 } 197 198 Expected<MaterializationUnit::Interface> 199 getGenericObjectFileSymbolInfo(ExecutionSession &ES, 200 const object::ObjectFile &Obj) { 201 MaterializationUnit::Interface I; 202 203 for (auto &Sym : Obj.symbols()) { 204 Expected<uint32_t> SymFlagsOrErr = Sym.getFlags(); 205 if (!SymFlagsOrErr) 206 // TODO: Test this error. 207 return SymFlagsOrErr.takeError(); 208 209 // Skip symbols not defined in this object file. 210 if (*SymFlagsOrErr & object::BasicSymbolRef::SF_Undefined) 211 continue; 212 213 // Skip symbols that are not global. 214 if (!(*SymFlagsOrErr & object::BasicSymbolRef::SF_Global)) 215 continue; 216 217 // Skip symbols that have type SF_File. 218 if (auto SymType = Sym.getType()) { 219 if (*SymType == object::SymbolRef::ST_File) 220 continue; 221 } else 222 return SymType.takeError(); 223 224 auto Name = Sym.getName(); 225 if (!Name) 226 return Name.takeError(); 227 228 auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym); 229 if (!SymFlags) 230 return SymFlags.takeError(); 231 232 I.SymbolFlags[ES.intern(*Name)] = std::move(*SymFlags); 233 } 234 235 return I; 236 } 237 238 Expected<MaterializationUnit::Interface> 239 getObjectFileInterface(ExecutionSession &ES, MemoryBufferRef ObjBuffer) { 240 auto Obj = object::ObjectFile::createObjectFile(ObjBuffer); 241 242 if (!Obj) 243 return Obj.takeError(); 244 245 if (auto *MachOObj = dyn_cast<object::MachOObjectFile>(Obj->get())) 246 return getMachOObjectFileSymbolInfo(ES, *MachOObj); 247 else if (auto *ELFObj = dyn_cast<object::ELFObjectFileBase>(Obj->get())) 248 return getELFObjectFileSymbolInfo(ES, *ELFObj); 249 else if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj->get())) 250 return getCOFFObjectFileSymbolInfo(ES, *COFFObj); 251 252 return getGenericObjectFileSymbolInfo(ES, **Obj); 253 } 254 255 } // End namespace orc. 256 } // End namespace llvm. 257