Archive builder that implements our multi format config. More...

Inheritance diagram for saq::bartleby::Bartleby::ArchiveWriter:

Public Member Functions
	ArchiveWriter (Bartleby &&B) noexcept
	Constructs an `ArchiveWriter` using a Bartleby handle.

llvm::Error	buildMachOUniversalBinarySlices (llvm::SmallVectorImpl< llvm::object::Slice > &Slices, ArchiveMap &Archives) noexcept
	Constructs the slices needed for a fat Mach-O.

llvm::Error	buildMachOUniversalBinary (llvm::StringRef OutFilepath) noexcept
	Builds a fat Mach-O file and writes the output to a file.

llvm::Expected< std::unique_ptr< llvm::MemoryBuffer > >	buildMachOUniversalBinary () noexcept
	Builds a fat Mach-O file and returns its content.

llvm::Error	build (llvm::StringRef OutFilepath) noexcept
	Builds the final archive and writes the content to a file.

llvm::Expected< std::unique_ptr< llvm::MemoryBuffer > >	build () noexcept
	Builds the final archive and returns its content.

const llvm::objcopy::CommonConfig &	getCommonConfig () const noexcept override

llvm::Expected< const llvm::objcopy::ELFConfig & >	getELFConfig () const noexcept override

llvm::Expected< const llvm::objcopy::COFFConfig & >	getCOFFConfig () const noexcept override

llvm::Expected< const llvm::objcopy::MachOConfig & >	getMachOConfig () const noexcept override

llvm::Expected< const llvm::objcopy::WasmConfig & >	getWasmConfig () const noexcept override

llvm::Expected< const llvm::objcopy::XCOFFConfig & >	getXCOFFConfig () const noexcept override

Detailed Description

Archive builder that implements our multi format config.

See https://llvm.org/doxygen/classllvm_1_1objcopy_1_1MultiFormatConfig.html.

Constructor & Destructor Documentation

◆ ArchiveWriter()

saq::bartleby::Bartleby::ArchiveWriter::ArchiveWriter ( Bartleby && B )

inlinenoexcept

Constructs an ArchiveWriter using a Bartleby handle.

Parameters

[in] B Bartleby handle.

                                       : Handle(std::move(B)) {
    const auto End = Handle.Symbols.end();
    for (auto Entry = Handle.Symbols.begin(); Entry != End; ++Entry) {
      const auto &Name = Entry->first();
      const auto &Sym = Entry->getValue();
      if (const auto OName = Sym.getOverwriteName(); OName) {
        LLVM_DEBUG(llvm::dbgs() << "bartleby is going to rename '" << Name
                                << "' into '" << *OName << "'\n");
        CommonConfig.SymbolsToRename[Name] = *OName;
      }
    }
  }

Member Function Documentation

◆ build() [1/2]

llvm::Expected< std::unique_ptr< llvm::MemoryBuffer > > saq::bartleby::Bartleby::ArchiveWriter::build ( )

inlinenoexcept

Builds the final archive and returns its content.

Returns: A memory buffer or an error.

                   {
    if (Handle.isMachOUniversalBinary()) {
      return buildMachOUniversalBinary();
    }
 
    if (auto Err = executeObjCopyOnObjects()) {
      return Err;
    }
 
    return llvm::writeArchiveToBuffer(ArMembers,
                                      /* WriteSymtab= */ true,
                                      ArMembers[0].detectKindFromObject(),
                                      /* Deterministic= */ true,
                                      /* Thin= */ false);
  }

◆ build() [2/2]

llvm::Error saq::bartleby::Bartleby::ArchiveWriter::build ( llvm::StringRef OutFilepath )

inlinenoexcept

Builds the final archive and writes the content to a file.

Parameters

OutFilepath Path to out file.

Returns: An error.

                                                                    {
    if (Handle.isMachOUniversalBinary()) {
      return buildMachOUniversalBinary(OutFilepath);
    }
 
    if (auto Err = executeObjCopyOnObjects()) {
      return Err;
    }
 
    return llvm::writeArchive(OutFilepath, ArMembers,
                              /* WriteSymtab= */ true,
                              ArMembers[0].detectKindFromObject(),
                              /* Deterministic= */ true,
                              /* Thin= */ false);
  }

◆ buildMachOUniversalBinary() [1/2]

llvm::Expected< std::unique_ptr< llvm::MemoryBuffer > > saq::bartleby::Bartleby::ArchiveWriter::buildMachOUniversalBinary ( )

inlinenoexcept

Builds a fat Mach-O file and returns its content.

Returns: A memory buffer, or an error.

                                       {
    llvm::SmallVector<llvm::object::Slice, 3> Slices;
    ArchiveMap Archives;
 
    if (auto Err = buildMachOUniversalBinarySlices(Slices, Archives)) {
      return Err;
    }
 
    llvm::SmallVector<char, 8192> Content;
    llvm::raw_svector_ostream OS(Content);
 
    if (auto Err = llvm::object::writeUniversalBinaryToStream(Slices, OS)) {
      return Err;
    }
 
    return std::make_unique<llvm::SmallVectorMemoryBuffer>(std::move(Content),
                                                           false);
  }

◆ buildMachOUniversalBinary() [2/2]

llvm::Error saq::bartleby::Bartleby::ArchiveWriter::buildMachOUniversalBinary ( llvm::StringRef OutFilepath )

inlinenoexcept

Builds a fat Mach-O file and writes the output to a file.

Parameters

OutFilepath Path to out file.

Returns: An error.

                                                                {
    llvm::SmallVector<llvm::object::Slice, 3> Slices;
    ArchiveMap Archives;
 
    if (auto Err = buildMachOUniversalBinarySlices(Slices, Archives)) {
      return Err;
    }
 
    return llvm::object::writeUniversalBinary(Slices, OutFilepath);
  }

◆ buildMachOUniversalBinarySlices()

llvm::Error saq::bartleby::Bartleby::ArchiveWriter::buildMachOUniversalBinarySlices	(	llvm::SmallVectorImpl< llvm::object::Slice > &	Slices,
		ArchiveMap &	Archives
	)

inlinenoexcept

Constructs the slices needed for a fat Mach-O.

Parameters

[out]	Slices	Vector where to store slices.
[out]	Archives	Vector where to write archives.

Returns: An error.

                                     {
    assert(Handle.isMachOUniversalBinary());
 
    const auto &ObjFmtSet = std::get<ObjectFormatSet>(Handle.ObjFormat);
 
    LLVM_DEBUG(for (const auto &Fmt
                    : ObjFmtSet) {
      llvm::dbgs() << "object format in fat Mach-O: " << Fmt << '\n';
    });
 
    Archives.reserve(ObjFmtSet.size());
    Slices.reserve(ObjFmtSet.size());
 
    for (const auto &Obj : Handle.Objects) {
      const auto Triple = Obj.Handle->makeTriple();
      LLVM_DEBUG(llvm::dbgs()
                 << "got object, triple is " << Triple.str()
                 << ", object format is " << ObjectFormat{Triple} << '\n');
      assert(ObjFmtSet.count(Triple) == 1);
      auto FinalObjOrErr = executeObjCopyOnObject(Obj);
      if (!FinalObjOrErr) {
        return FinalObjOrErr.takeError();
      }
      auto &Ar = Archives[ObjectFormat{Triple}];
      Ar.Triple = Triple;
      Ar.Alignment = Obj.Alignment;
      auto &ArMember = Ar.Members.emplace_back();
      ArMember.Buf = std::move(*FinalObjOrErr);
      Ar.Name = std::make_unique<std::string>(Triple.str());
      ArMember.MemberName = *Ar.Name;
    }
 
    for (auto &[Fmt, Ar] : Archives) {
      if (auto BufferOrErr = llvm::writeArchiveToBuffer(
              Ar.Members,
              /* WriteSymtab= */ true, Ar.Members[0].detectKindFromObject(),
              /* Deterministic=*/true, /*Thin=*/false)) {
        Ar.OutBuffer = std::move(*BufferOrErr);
      } else {
        return BufferOrErr.takeError();
      }
 
      auto NewArOrErr = llvm::object::Archive::create(*Ar.OutBuffer);
      if (!NewArOrErr) {
        return NewArOrErr.takeError();
      }
 
      auto CPUTypeOrErr = llvm::MachO::getCPUType(Ar.Triple);
      if (!CPUTypeOrErr) {
        return CPUTypeOrErr.takeError();
      }
 
      auto CPUSubTypeOrErr = llvm::MachO::getCPUSubType(Ar.Triple);
      if (!CPUSubTypeOrErr) {
        return CPUSubTypeOrErr.takeError();
      }
      Ar.OutArchive = std::move(*NewArOrErr);
      Slices.emplace_back(*Ar.OutArchive, *CPUTypeOrErr, *CPUSubTypeOrErr,
                          Ar.Triple.str(), Ar.Alignment);
    }
 
    return llvm::Error::success();
  }

◆ getCOFFConfig()

llvm::Expected< const llvm::objcopy::COFFConfig & > saq::bartleby::Bartleby::ArchiveWriter::getCOFFConfig ( ) const

inlineoverridenoexcept

                                          {
    return COFFConfig;
  }

◆ getCommonConfig()

const llvm::objcopy::CommonConfig & saq::bartleby::Bartleby::ArchiveWriter::getCommonConfig ( ) const

inlineoverridenoexcept

                                                                           {
    return CommonConfig;
  }

◆ getELFConfig()

llvm::Expected< const llvm::objcopy::ELFConfig & > saq::bartleby::Bartleby::ArchiveWriter::getELFConfig ( ) const

inlineoverridenoexcept

                                         {
    return ELFConfig;
  }

◆ getMachOConfig()

llvm::Expected< const llvm::objcopy::MachOConfig & > saq::bartleby::Bartleby::ArchiveWriter::getMachOConfig ( ) const

inlineoverridenoexcept

                                           {
    return MachOConfig;
  }

◆ getWasmConfig()

llvm::Expected< const llvm::objcopy::WasmConfig & > saq::bartleby::Bartleby::ArchiveWriter::getWasmConfig ( ) const

inlineoverridenoexcept

                                          {
    return WasmConfig;
  }

◆ getXCOFFConfig()

llvm::Expected< const llvm::objcopy::XCOFFConfig & > saq::bartleby::Bartleby::ArchiveWriter::getXCOFFConfig ( ) const

inlineoverridenoexcept

                                           {
    return XCOFFConfig;
  }

The documentation for this class was generated from the following file:

bartleby/lib/Bartleby/ArchiveWriter.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ArchiveWriter()

Member Function Documentation

◆ build() [1/2]

◆ build() [2/2]

◆ buildMachOUniversalBinary() [1/2]

◆ buildMachOUniversalBinary() [2/2]

◆ buildMachOUniversalBinarySlices()

◆ getCOFFConfig()

◆ getCommonConfig()

◆ getELFConfig()

◆ getMachOConfig()

◆ getWasmConfig()

◆ getXCOFFConfig()