Bartleby.h

Go to the documentation of this file.

// Copyright 2023 SandboxAQ
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
 
#pragma once
 
#include "Bartleby/Symbol.h"
 
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/Object/Binary.h"
 
#include <unordered_set>
#include <variant>
 
namespace saq::bartleby {
 
struct ObjectFormat {
  llvm::Triple::ArchType Arch;
 
  llvm::Triple::SubArchType SubArch;
 
  llvm::Triple::ObjectFormatType FormatType;
 
  ObjectFormat(const llvm::Triple &Triple) noexcept;
 
  [[nodiscard]] uint64_t pack() const noexcept;
 
  bool operator==(const ObjectFormat &Other) const noexcept;
 
  bool matches(const llvm::Triple &Triple) const noexcept;
 
  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                       const ObjectFormat &Format) noexcept;
 
  struct Hash {
    inline size_t operator()(const ObjectFormat &ObjFormat) const noexcept {
      return static_cast<size_t>(ObjFormat.pack());
    }
  };
};
 
class Bartleby {
public:
  using SymbolMap = llvm::StringMap<Symbol>;
 
  Bartleby() noexcept;
 
  Bartleby(const Bartleby &) noexcept = delete;
  Bartleby(Bartleby &&) noexcept = default;
  Bartleby &operator=(const Bartleby &) noexcept = delete;
  Bartleby &operator=(Bartleby &&) noexcept = default;
  ~Bartleby() noexcept = default;
 
  [[nodiscard]] llvm::Error
  addBinary(llvm::object::OwningBinary<llvm::object::Binary> Binary) noexcept;
 
  [[nodiscard]] const SymbolMap &getSymbols() const noexcept { return Symbols; }
 
  size_t prefixGlobalAndDefinedSymbols(llvm::StringRef Prefix) noexcept;
 
  [[nodiscard]] static llvm::Error
  buildFinalArchive(Bartleby &&B, llvm::StringRef OutFilepath) noexcept;
 
  [[nodiscard]] static llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
  buildFinalArchive(Bartleby &&B) noexcept;
 
private:
  struct ObjectFile {
    llvm::object::ObjectFile *Handle;
 
    std::unique_ptr<llvm::object::Binary> Owner;
 
    llvm::SmallString<32> Name;
 
    uint32_t Alignment;
  };
 
  using ObjectFormatSet = std::unordered_set<ObjectFormat, ObjectFormat::Hash>;
 
  using ObjectFormatVariant =
      std::variant<std::monostate, ObjectFormat, ObjectFormatSet>;
 
  [[nodiscard]] bool isMachOUniversalBinary() const noexcept;
 
  [[nodiscard]] bool
  objectFormatMatches(const ObjectFormat &ObjFmt) const noexcept;
 
  [[nodiscard]] llvm::Error addMachOUniversalBinary(
      llvm::object::OwningBinary<llvm::object::Binary> OwningBinary) noexcept;
 
  SymbolMap Symbols;
 
  llvm::SmallVector<ObjectFile, 128> Objects;
 
  llvm::SmallVector<llvm::object::OwningBinary<llvm::object::Binary>, 128>
      OwnedBinaries;
 
  ObjectFormatVariant ObjFormat;
 
  // Forward declaration.
  class ArchiveWriter;
};
 
} // end namespace saq::bartleby