1 //===-- llvm-libtool-darwin.cpp - a tool for creating libraries -----------===// 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 // A utility for creating static and dynamic libraries for Darwin. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/BinaryFormat/Magic.h" 14 #include "llvm/Object/ArchiveWriter.h" 15 #include "llvm/Object/MachO.h" 16 #include "llvm/Object/MachOUniversal.h" 17 #include "llvm/Object/MachOUniversalWriter.h" 18 #include "llvm/Object/ObjectFile.h" 19 #include "llvm/Support/CommandLine.h" 20 #include "llvm/Support/InitLLVM.h" 21 #include "llvm/Support/LineIterator.h" 22 #include "llvm/Support/WithColor.h" 23 #include "llvm/TextAPI/MachO/Architecture.h" 24 #include <map> 25 26 using namespace llvm; 27 using namespace llvm::object; 28 29 typedef std::map<uint64_t, std::vector<NewArchiveMember>> 30 MembersPerArchitectureMap; 31 32 cl::OptionCategory LibtoolCategory("llvm-libtool-darwin Options"); 33 34 static cl::opt<std::string> OutputFile("o", cl::desc("Specify output filename"), 35 cl::value_desc("filename"), 36 cl::cat(LibtoolCategory)); 37 38 static cl::list<std::string> InputFiles(cl::Positional, 39 cl::desc("<input files>"), 40 cl::ZeroOrMore, 41 cl::cat(LibtoolCategory)); 42 43 static cl::opt<std::string> ArchType( 44 "arch_only", cl::desc("Specify architecture type for output library"), 45 cl::value_desc("arch_type"), cl::ZeroOrMore, cl::cat(LibtoolCategory)); 46 47 enum class Operation { None, Static }; 48 49 static cl::opt<Operation> LibraryOperation( 50 cl::desc("Library Type: "), 51 cl::values( 52 clEnumValN(Operation::Static, "static", 53 "Produce a statically linked library from the input files")), 54 cl::init(Operation::None), cl::cat(LibtoolCategory)); 55 56 static cl::opt<bool> DeterministicOption( 57 "D", cl::desc("Use zero for timestamps and UIDs/GIDs (Default)"), 58 cl::init(false), cl::cat(LibtoolCategory)); 59 60 static cl::opt<bool> 61 NonDeterministicOption("U", cl::desc("Use actual timestamps and UIDs/GIDs"), 62 cl::init(false), cl::cat(LibtoolCategory)); 63 64 static cl::opt<std::string> 65 FileList("filelist", 66 cl::desc("Pass in file containing a list of filenames"), 67 cl::value_desc("listfile[,dirname]"), cl::cat(LibtoolCategory)); 68 69 static cl::list<std::string> Libraries( 70 "l", 71 cl::desc( 72 "l<x> searches for the library libx.a in the library search path. If" 73 " the string 'x' ends with '.o', then the library 'x' is searched for" 74 " without prepending 'lib' or appending '.a'"), 75 cl::ZeroOrMore, cl::Prefix, cl::cat(LibtoolCategory)); 76 77 static cl::list<std::string> LibrarySearchDirs( 78 "L", 79 cl::desc( 80 "L<dir> adds <dir> to the list of directories in which to search for" 81 " libraries"), 82 cl::ZeroOrMore, cl::Prefix, cl::cat(LibtoolCategory)); 83 84 static cl::opt<bool> 85 VersionOption("V", cl::desc("Print the version number and exit"), 86 cl::cat(LibtoolCategory)); 87 88 static const std::array<std::string, 3> StandardSearchDirs{ 89 "/lib", 90 "/usr/lib", 91 "/usr/local/lib", 92 }; 93 94 struct Config { 95 bool Deterministic = true; // Updated by 'D' and 'U' modifiers. 96 uint32_t ArchCPUType; 97 uint32_t ArchCPUSubtype; 98 }; 99 100 static Expected<std::string> searchForFile(const Twine &FileName) { 101 102 auto FindLib = 103 [FileName](ArrayRef<std::string> SearchDirs) -> Optional<std::string> { 104 for (StringRef Dir : SearchDirs) { 105 SmallString<128> Path; 106 sys::path::append(Path, Dir, FileName); 107 108 if (sys::fs::exists(Path)) 109 return std::string(Path); 110 } 111 return None; 112 }; 113 114 Optional<std::string> Found = FindLib(LibrarySearchDirs); 115 if (!Found) 116 Found = FindLib(StandardSearchDirs); 117 if (Found) 118 return *Found; 119 120 return createStringError(std::errc::invalid_argument, 121 "cannot locate file '%s'", FileName.str().c_str()); 122 } 123 124 static Error processCommandLineLibraries() { 125 for (StringRef BaseName : Libraries) { 126 Expected<std::string> FullPath = searchForFile( 127 BaseName.endswith(".o") ? BaseName.str() : "lib" + BaseName + ".a"); 128 if (!FullPath) 129 return FullPath.takeError(); 130 InputFiles.push_back(FullPath.get()); 131 } 132 133 return Error::success(); 134 } 135 136 static Error processFileList() { 137 StringRef FileName, DirName; 138 std::tie(FileName, DirName) = StringRef(FileList).rsplit(","); 139 140 ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr = 141 MemoryBuffer::getFileOrSTDIN(FileName, /*FileSize=*/-1, 142 /*RequiresNullTerminator=*/false); 143 if (std::error_code EC = FileOrErr.getError()) 144 return createFileError(FileName, errorCodeToError(EC)); 145 const MemoryBuffer &Ref = *FileOrErr.get(); 146 147 line_iterator I(Ref, /*SkipBlanks=*/false); 148 if (I.is_at_eof()) 149 return createStringError(std::errc::invalid_argument, 150 "file list file: '%s' is empty", 151 FileName.str().c_str()); 152 for (; !I.is_at_eof(); ++I) { 153 StringRef Line = *I; 154 if (Line.empty()) 155 return createStringError(std::errc::invalid_argument, 156 "file list file: '%s': filename cannot be empty", 157 FileName.str().c_str()); 158 159 SmallString<128> Path; 160 if (!DirName.empty()) 161 sys::path::append(Path, DirName, Line); 162 else 163 sys::path::append(Path, Line); 164 InputFiles.push_back(static_cast<std::string>(Path)); 165 } 166 return Error::success(); 167 } 168 169 static Error validateArchitectureName(StringRef ArchitectureName) { 170 if (!MachOObjectFile::isValidArch(ArchitectureName)) { 171 std::string Buf; 172 raw_string_ostream OS(Buf); 173 for (StringRef Arch : MachOObjectFile::getValidArchs()) 174 OS << Arch << " "; 175 176 return createStringError( 177 std::errc::invalid_argument, 178 "invalid architecture '%s': valid architecture names are %s", 179 ArchitectureName.str().c_str(), OS.str().c_str()); 180 } 181 return Error::success(); 182 } 183 184 static uint64_t getCPUID(uint32_t CPUType, uint32_t CPUSubtype) { 185 switch (CPUType) { 186 case MachO::CPU_TYPE_ARM: 187 case MachO::CPU_TYPE_ARM64: 188 case MachO::CPU_TYPE_ARM64_32: 189 case MachO::CPU_TYPE_X86_64: 190 // We consider CPUSubtype only for the above 4 CPUTypes to match cctools' 191 // libtool behavior. 192 return static_cast<uint64_t>(CPUType) << 32 | CPUSubtype; 193 default: 194 return CPUType; 195 } 196 } 197 198 // Check that a file's architecture [FileCPUType, FileCPUSubtype] 199 // matches the architecture specified under -arch_only flag. 200 static bool acceptFileArch(uint32_t FileCPUType, uint32_t FileCPUSubtype, 201 const Config &C) { 202 if (C.ArchCPUType != FileCPUType) 203 return false; 204 205 switch (C.ArchCPUType) { 206 case MachO::CPU_TYPE_ARM: 207 case MachO::CPU_TYPE_ARM64_32: 208 case MachO::CPU_TYPE_X86_64: 209 return C.ArchCPUSubtype == FileCPUSubtype; 210 211 case MachO::CPU_TYPE_ARM64: 212 if (C.ArchCPUSubtype == MachO::CPU_SUBTYPE_ARM64_ALL) 213 return FileCPUSubtype == MachO::CPU_SUBTYPE_ARM64_ALL || 214 FileCPUSubtype == MachO::CPU_SUBTYPE_ARM64_V8; 215 else 216 return C.ArchCPUSubtype == FileCPUSubtype; 217 218 default: 219 return true; 220 } 221 } 222 223 static Error verifyAndAddMachOObject(MembersPerArchitectureMap &Members, 224 NewArchiveMember Member, const Config &C) { 225 auto MBRef = Member.Buf->getMemBufferRef(); 226 Expected<std::unique_ptr<object::ObjectFile>> ObjOrErr = 227 object::ObjectFile::createObjectFile(MBRef); 228 229 // Throw error if not a valid object file. 230 if (!ObjOrErr) 231 return createFileError(Member.MemberName, ObjOrErr.takeError()); 232 233 // Throw error if not in Mach-O format. 234 if (!isa<object::MachOObjectFile>(**ObjOrErr)) 235 return createStringError(std::errc::invalid_argument, 236 "'%s': format not supported", 237 Member.MemberName.data()); 238 239 auto *O = dyn_cast<MachOObjectFile>(ObjOrErr->get()); 240 uint32_t FileCPUType, FileCPUSubtype; 241 std::tie(FileCPUType, FileCPUSubtype) = MachO::getCPUTypeFromArchitecture( 242 MachO::getArchitectureFromName(O->getArchTriple().getArchName())); 243 244 // If -arch_only is specified then skip this file if it doesn't match 245 // the architecture specified. 246 if (!ArchType.empty() && !acceptFileArch(FileCPUType, FileCPUSubtype, C)) { 247 return Error::success(); 248 } 249 250 uint64_t FileCPUID = getCPUID(FileCPUType, FileCPUSubtype); 251 Members[FileCPUID].push_back(std::move(Member)); 252 return Error::success(); 253 } 254 255 static Error addChildMember(MembersPerArchitectureMap &Members, 256 const object::Archive::Child &M, const Config &C) { 257 Expected<NewArchiveMember> NMOrErr = 258 NewArchiveMember::getOldMember(M, C.Deterministic); 259 if (!NMOrErr) 260 return NMOrErr.takeError(); 261 262 if (Error E = verifyAndAddMachOObject(Members, std::move(*NMOrErr), C)) 263 return E; 264 265 return Error::success(); 266 } 267 268 static Error processArchive(MembersPerArchitectureMap &Members, 269 object::Archive &Lib, StringRef FileName, 270 const Config &C) { 271 Error Err = Error::success(); 272 for (const object::Archive::Child &Child : Lib.children(Err)) 273 if (Error E = addChildMember(Members, Child, C)) 274 return createFileError(FileName, std::move(E)); 275 if (Err) 276 return createFileError(FileName, std::move(Err)); 277 278 return Error::success(); 279 } 280 281 static Error 282 addArchiveMembers(MembersPerArchitectureMap &Members, 283 std::vector<std::unique_ptr<MemoryBuffer>> &ArchiveBuffers, 284 NewArchiveMember NM, StringRef FileName, const Config &C) { 285 Expected<std::unique_ptr<Archive>> LibOrErr = 286 object::Archive::create(NM.Buf->getMemBufferRef()); 287 if (!LibOrErr) 288 return createFileError(FileName, LibOrErr.takeError()); 289 290 if (Error E = processArchive(Members, **LibOrErr, FileName, C)) 291 return E; 292 293 // Update vector ArchiveBuffers with the MemoryBuffers to transfer 294 // ownership. 295 ArchiveBuffers.push_back(std::move(NM.Buf)); 296 return Error::success(); 297 } 298 299 static Error addUniversalMembers( 300 MembersPerArchitectureMap &Members, 301 std::vector<std::unique_ptr<MemoryBuffer>> &UniversalBuffers, 302 NewArchiveMember NM, StringRef FileName, const Config &C) { 303 Expected<std::unique_ptr<MachOUniversalBinary>> BinaryOrErr = 304 MachOUniversalBinary::create(NM.Buf->getMemBufferRef()); 305 if (!BinaryOrErr) 306 return createFileError(FileName, BinaryOrErr.takeError()); 307 308 auto *UO = BinaryOrErr->get(); 309 for (const MachOUniversalBinary::ObjectForArch &O : UO->objects()) { 310 311 Expected<std::unique_ptr<MachOObjectFile>> MachOObjOrErr = 312 O.getAsObjectFile(); 313 if (MachOObjOrErr) { 314 NewArchiveMember NewMember = 315 NewArchiveMember(MachOObjOrErr->get()->getMemoryBufferRef()); 316 NewMember.MemberName = sys::path::filename(NewMember.MemberName); 317 318 if (Error E = verifyAndAddMachOObject(Members, std::move(NewMember), C)) 319 return E; 320 continue; 321 } 322 323 Expected<std::unique_ptr<Archive>> ArchiveOrError = O.getAsArchive(); 324 if (ArchiveOrError) { 325 // A universal file member can either be a MachOObjectFile or an Archive. 326 // In case we can successfully cast the member as an Archive, it is safe 327 // to throw away the error generated due to casting the object as a 328 // MachOObjectFile. 329 consumeError(MachOObjOrErr.takeError()); 330 331 if (Error E = processArchive(Members, **ArchiveOrError, FileName, C)) 332 return E; 333 continue; 334 } 335 336 Error CombinedError = 337 joinErrors(ArchiveOrError.takeError(), MachOObjOrErr.takeError()); 338 return createFileError(FileName, std::move(CombinedError)); 339 } 340 341 // Update vector UniversalBuffers with the MemoryBuffers to transfer 342 // ownership. 343 UniversalBuffers.push_back(std::move(NM.Buf)); 344 return Error::success(); 345 } 346 347 static Error addMember(MembersPerArchitectureMap &Members, 348 std::vector<std::unique_ptr<MemoryBuffer>> &FileBuffers, 349 StringRef FileName, const Config &C) { 350 Expected<NewArchiveMember> NMOrErr = 351 NewArchiveMember::getFile(FileName, C.Deterministic); 352 if (!NMOrErr) 353 return createFileError(FileName, NMOrErr.takeError()); 354 355 // For regular archives, use the basename of the object path for the member 356 // name. 357 NMOrErr->MemberName = sys::path::filename(NMOrErr->MemberName); 358 file_magic Magic = identify_magic(NMOrErr->Buf->getBuffer()); 359 360 // Flatten archives. 361 if (Magic == file_magic::archive) 362 return addArchiveMembers(Members, FileBuffers, std::move(*NMOrErr), 363 FileName, C); 364 365 // Flatten universal files. 366 if (Magic == file_magic::macho_universal_binary) 367 return addUniversalMembers(Members, FileBuffers, std::move(*NMOrErr), 368 FileName, C); 369 370 if (Error E = verifyAndAddMachOObject(Members, std::move(*NMOrErr), C)) 371 return E; 372 return Error::success(); 373 } 374 375 static Expected<SmallVector<Slice, 2>> 376 buildSlices(ArrayRef<OwningBinary<Archive>> OutputBinaries) { 377 SmallVector<Slice, 2> Slices; 378 379 for (const auto &OB : OutputBinaries) { 380 const Archive *A = OB.getBinary(); 381 Expected<Slice> ArchiveSlice = Slice::create(A); 382 if (!ArchiveSlice) 383 return ArchiveSlice.takeError(); 384 Slices.push_back(*ArchiveSlice); 385 } 386 return Slices; 387 } 388 389 static Error createStaticLibrary(const Config &C) { 390 MembersPerArchitectureMap NewMembers; 391 std::vector<std::unique_ptr<MemoryBuffer>> FileBuffers; 392 for (StringRef FileName : InputFiles) 393 if (Error E = addMember(NewMembers, FileBuffers, FileName, C)) 394 return E; 395 396 if (!ArchType.empty()) { 397 uint64_t ArchCPUID = getCPUID(C.ArchCPUType, C.ArchCPUSubtype); 398 if (NewMembers.find(ArchCPUID) == NewMembers.end()) 399 return createStringError(std::errc::invalid_argument, 400 "no library created (no object files in input " 401 "files matching -arch_only %s)", 402 ArchType.c_str()); 403 } 404 405 if (NewMembers.size() == 1) { 406 if (Error E = 407 writeArchive(OutputFile, NewMembers.begin()->second, 408 /*WriteSymtab=*/true, 409 /*Kind=*/object::Archive::K_DARWIN, C.Deterministic, 410 /*Thin=*/false)) 411 return E; 412 } else { 413 SmallVector<OwningBinary<Archive>, 2> OutputBinaries; 414 for (const std::pair<const uint64_t, std::vector<NewArchiveMember>> &M : 415 NewMembers) { 416 Expected<std::unique_ptr<MemoryBuffer>> OutputBufferOrErr = 417 writeArchiveToBuffer(M.second, 418 /*WriteSymtab=*/true, 419 /*Kind=*/object::Archive::K_DARWIN, 420 C.Deterministic, 421 /*Thin=*/false); 422 if (!OutputBufferOrErr) 423 return OutputBufferOrErr.takeError(); 424 std::unique_ptr<MemoryBuffer> &OutputBuffer = OutputBufferOrErr.get(); 425 426 Expected<std::unique_ptr<Archive>> ArchiveOrError = 427 Archive::create(OutputBuffer->getMemBufferRef()); 428 if (!ArchiveOrError) 429 return ArchiveOrError.takeError(); 430 std::unique_ptr<Archive> &A = ArchiveOrError.get(); 431 432 OutputBinaries.push_back( 433 OwningBinary<Archive>(std::move(A), std::move(OutputBuffer))); 434 } 435 436 Expected<SmallVector<Slice, 2>> Slices = buildSlices(OutputBinaries); 437 if (!Slices) 438 return Slices.takeError(); 439 440 llvm::stable_sort(*Slices); 441 if (Error E = writeUniversalBinary(*Slices, OutputFile)) 442 return E; 443 } 444 return Error::success(); 445 } 446 447 static Expected<Config> parseCommandLine(int Argc, char **Argv) { 448 Config C; 449 cl::ParseCommandLineOptions(Argc, Argv, "llvm-libtool-darwin\n"); 450 451 if (LibraryOperation == Operation::None) { 452 if (!VersionOption) { 453 std::string Error; 454 raw_string_ostream Stream(Error); 455 LibraryOperation.error("must be specified", "", Stream); 456 return createStringError(std::errc::invalid_argument, Error.c_str()); 457 } 458 return C; 459 } 460 461 if (OutputFile.empty()) { 462 std::string Error; 463 raw_string_ostream Stream(Error); 464 OutputFile.error("must be specified", "o", Stream); 465 return createStringError(std::errc::invalid_argument, Error.c_str()); 466 } 467 468 if (DeterministicOption && NonDeterministicOption) 469 return createStringError(std::errc::invalid_argument, 470 "cannot specify both -D and -U flags"); 471 else if (NonDeterministicOption) 472 C.Deterministic = false; 473 474 if (!Libraries.empty()) 475 if (Error E = processCommandLineLibraries()) 476 return std::move(E); 477 478 if (!FileList.empty()) 479 if (Error E = processFileList()) 480 return std::move(E); 481 482 if (InputFiles.empty()) 483 return createStringError(std::errc::invalid_argument, 484 "no input files specified"); 485 486 if (ArchType.getNumOccurrences()) { 487 if (Error E = validateArchitectureName(ArchType)) 488 return std::move(E); 489 490 std::tie(C.ArchCPUType, C.ArchCPUSubtype) = 491 MachO::getCPUTypeFromArchitecture( 492 MachO::getArchitectureFromName(ArchType)); 493 } 494 495 return C; 496 } 497 498 int main(int Argc, char **Argv) { 499 InitLLVM X(Argc, Argv); 500 cl::HideUnrelatedOptions({&LibtoolCategory, &ColorCategory}); 501 Expected<Config> ConfigOrErr = parseCommandLine(Argc, Argv); 502 if (!ConfigOrErr) { 503 WithColor::defaultErrorHandler(ConfigOrErr.takeError()); 504 return EXIT_FAILURE; 505 } 506 507 if (VersionOption) 508 cl::PrintVersionMessage(); 509 510 Config C = *ConfigOrErr; 511 switch (LibraryOperation) { 512 case Operation::None: 513 break; 514 case Operation::Static: 515 if (Error E = createStaticLibrary(C)) { 516 WithColor::defaultErrorHandler(std::move(E)); 517 return EXIT_FAILURE; 518 } 519 break; 520 } 521 } 522