1//===- InputFiles.h ---------------------------------------------*- C++ -*-===//
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#ifndef LLD_MACHO_INPUT_FILES_H
10#define LLD_MACHO_INPUT_FILES_H
11
12#include "MachOStructs.h"
13
14#include "lld/Common/LLVM.h"
15#include "llvm/ADT/DenseSet.h"
16#include "llvm/BinaryFormat/MachO.h"
17#include "llvm/Object/Archive.h"
18#include "llvm/Support/MemoryBuffer.h"
19#include "llvm/TextAPI/MachO/InterfaceFile.h"
20#include "llvm/TextAPI/MachO/TextAPIReader.h"
21
22#include <map>
23#include <vector>
24
25namespace lld {
26namespace macho {
27
28class InputSection;
29class Symbol;
30struct Reloc;
31
32// If .subsections_via_symbols is set, each InputSection will be split along
33// symbol boundaries. The keys of a SubsectionMap represent the offsets of
34// each subsection from the start of the original pre-split InputSection.
35using SubsectionMap = std::map<uint32_t, InputSection *>;
36
37class InputFile {
38public:
39  enum Kind {
40    ObjKind,
41    DylibKind,
42    ArchiveKind,
43  };
44
45  virtual ~InputFile() = default;
46  Kind kind() const { return fileKind; }
47  StringRef getName() const { return mb.getBufferIdentifier(); }
48
49  MemoryBufferRef mb;
50  std::vector<Symbol *> symbols;
51  ArrayRef<llvm::MachO::section_64> sectionHeaders;
52  std::vector<SubsectionMap> subsections;
53
54protected:
55  InputFile(Kind kind, MemoryBufferRef mb) : mb(mb), fileKind(kind) {}
56
57  void parseSections(ArrayRef<llvm::MachO::section_64>);
58
59  void parseSymbols(ArrayRef<lld::structs::nlist_64> nList, const char *strtab,
60                    bool subsectionsViaSymbols);
61
62  void parseRelocations(const llvm::MachO::section_64 &, SubsectionMap &);
63
64private:
65  const Kind fileKind;
66};
67
68// .o file
69class ObjFile : public InputFile {
70public:
71  explicit ObjFile(MemoryBufferRef mb);
72  static bool classof(const InputFile *f) { return f->kind() == ObjKind; }
73};
74
75// .dylib file
76class DylibFile : public InputFile {
77public:
78  explicit DylibFile(std::shared_ptr<llvm::MachO::InterfaceFile> interface,
79                     DylibFile *umbrella = nullptr);
80
81  // Mach-O dylibs can re-export other dylibs as sub-libraries, meaning that the
82  // symbols in those sub-libraries will be available under the umbrella
83  // library's namespace. Those sub-libraries can also have their own
84  // re-exports. When loading a re-exported dylib, `umbrella` should be set to
85  // the root dylib to ensure symbols in the child library are correctly bound
86  // to the root. On the other hand, if a dylib is being directly loaded
87  // (through an -lfoo flag), then `umbrella` should be a nullptr.
88  explicit DylibFile(MemoryBufferRef mb, DylibFile *umbrella = nullptr);
89
90  static bool classof(const InputFile *f) { return f->kind() == DylibKind; }
91
92  StringRef dylibName;
93  uint64_t ordinal = 0; // Ordinal numbering starts from 1, so 0 is a sentinel
94  bool reexport = false;
95  std::vector<DylibFile *> reexported;
96};
97
98// .a file
99class ArchiveFile : public InputFile {
100public:
101  explicit ArchiveFile(std::unique_ptr<llvm::object::Archive> &&file);
102  static bool classof(const InputFile *f) { return f->kind() == ArchiveKind; }
103  void fetch(const llvm::object::Archive::Symbol &sym);
104
105private:
106  std::unique_ptr<llvm::object::Archive> file;
107  // Keep track of children fetched from the archive by tracking
108  // which address offsets have been fetched already.
109  llvm::DenseSet<uint64_t> seen;
110};
111
112extern std::vector<InputFile *> inputFiles;
113
114llvm::Optional<MemoryBufferRef> readFile(StringRef path);
115
116} // namespace macho
117
118std::string toString(const macho::InputFile *file);
119} // namespace lld
120
121#endif
122