lld/wasm/InputChunks.h

   1 //===- InputChunks.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 // An InputChunks represents an indivisible opaque region of a input wasm file.
  10 // i.e. a single wasm data segment or a single wasm function.
  11 //
  12 // They are written directly to the mmap'd output file after which relocations
  13 // are applied.  Because each Chunk is independent they can be written in
  14 // parallel.
  15 //
  16 // Chunks are also unit on which garbage collection (--gc-sections) operates.
  17 //
  18 //===----------------------------------------------------------------------===//
  19
  20 #ifndef LLD_WASM_INPUT_CHUNKS_H
  21 #define LLD_WASM_INPUT_CHUNKS_H
  22
  23 #include "Config.h"
  24 #include "InputFiles.h"
  25 #include "lld/Common/ErrorHandler.h"
  26 #include "lld/Common/LLVM.h"
  27 #include "llvm/Object/Wasm.h"
  28
  29 namespace lld {
  30 namespace wasm {
  31
  32 class ObjFile;
  33 class OutputSegment;
  34 class OutputSection;
  35
  36 class InputChunk {
  37 public:
  38   enum Kind { DataSegment, Function, SyntheticFunction, Section };
  39
  40   Kind kind() const { return sectionKind; }
  41
  42   virtual uint32_t getSize() const { return data().size(); }
  43   virtual uint32_t getInputSize() const { return getSize(); };
  44
  45   virtual void writeTo(uint8_t *sectionStart) const;
  46
  47   ArrayRef<WasmRelocation> getRelocations() const { return relocations; }
  48   void setRelocations(ArrayRef<WasmRelocation> rs) { relocations = rs; }
  49
  50   virtual StringRef getName() const = 0;
  51   virtual StringRef getDebugName() const = 0;
  52   virtual uint32_t getComdat() const = 0;
  53   StringRef getComdatName() const;
  54   virtual uint32_t getInputSectionOffset() const = 0;
  55
  56   size_t getNumRelocations() const { return relocations.size(); }
  57   void writeRelocations(llvm::raw_ostream &os) const;
  58
  59   ObjFile *file;
  60   int32_t outputOffset = 0;
  61
  62   // Signals that the section is part of the output.  The garbage collector,
  63   // and COMDAT handling can set a sections' Live bit.
  64   // If GC is disabled, all sections start out as live by default.
  65   unsigned live : 1;
  66
  67   // Signals the chunk was discarded by COMDAT handling.
  68   unsigned discarded : 1;
  69
  70 protected:
  71   InputChunk(ObjFile *f, Kind k)
  72       : file(f), live(!config->gcSections), discarded(false), sectionKind(k) {}
  73   virtual ~InputChunk() = default;
  74   virtual ArrayRef<uint8_t> data() const = 0;
  75
  76   // Verifies the existing data at relocation targets matches our expectations.
  77   // This is performed only debug builds as an extra sanity check.
  78   void verifyRelocTargets() const;
  79
  80   ArrayRef<WasmRelocation> relocations;
  81   Kind sectionKind;
  82 };
  83
  84 // Represents a WebAssembly data segment which can be included as part of
  85 // an output data segments.  Note that in WebAssembly, unlike ELF and other
  86 // formats, used the term "data segment" to refer to the continuous regions of
  87 // memory that make on the data section. See:
  88 // https://webassembly.github.io/spec/syntax/modules.html#syntax-data
  89 //
  90 // For example, by default, clang will produce a separate data section for
  91 // each global variable.
  92 class InputSegment : public InputChunk {
  93 public:
  94   InputSegment(const WasmSegment &seg, ObjFile *f)
  95       : InputChunk(f, InputChunk::DataSegment), segment(seg) {}
  96
  97   static bool classof(const InputChunk *c) { return c->kind() == DataSegment; }
  98
  99   void generateRelocationCode(raw_ostream &os) const;
 100
 101   uint32_t getAlignment() const { return segment.Data.Alignment; }
 102   StringRef getName() const override { return segment.Data.Name; }
 103   StringRef getDebugName() const override { return StringRef(); }
 104   uint32_t getComdat() const override { return segment.Data.Comdat; }
 105   uint32_t getInputSectionOffset() const override {
 106     return segment.SectionOffset;
 107   }
 108
 109   const OutputSegment *outputSeg = nullptr;
 110   int32_t outputSegmentOffset = 0;
 111
 112 protected:
 113   ArrayRef<uint8_t> data() const override { return segment.Data.Content; }
 114
 115   const WasmSegment &segment;
 116 };
 117
 118 // Represents a single wasm function within and input file.  These are
 119 // combined to create the final output CODE section.
 120 class InputFunction : public InputChunk {
 121 public:
 122   InputFunction(const WasmSignature &s, const WasmFunction *func, ObjFile *f)
 123       : InputChunk(f, InputChunk::Function), signature(s), function(func) {}
 124
 125   static bool classof(const InputChunk *c) {
 126     return c->kind() == InputChunk::Function ||
 127            c->kind() == InputChunk::SyntheticFunction;
 128   }
 129
 130   void writeTo(uint8_t *sectionStart) const override;
 131   StringRef getName() const override { return function->SymbolName; }
 132   StringRef getDebugName() const override { return function->DebugName; }
 133   llvm::Optional<StringRef> getExportName() const {
 134     return function ? function->ExportName : llvm::Optional<StringRef>();
 135   }
 136   uint32_t getComdat() const override { return function->Comdat; }
 137   uint32_t getFunctionInputOffset() const { return getInputSectionOffset(); }
 138   uint32_t getFunctionCodeOffset() const { return function->CodeOffset; }
 139   uint32_t getSize() const override {
 140     if (config->compressRelocations && file) {
 141       assert(compressedSize);
 142       return compressedSize;
 143     }
 144     return data().size();
 145   }
 146   uint32_t getInputSize() const override { return function->Size; }
 147   uint32_t getFunctionIndex() const { return functionIndex.getValue(); }
 148   bool hasFunctionIndex() const { return functionIndex.hasValue(); }
 149   void setFunctionIndex(uint32_t index);
 150   uint32_t getInputSectionOffset() const override {
 151     return function->CodeSectionOffset;
 152   }
 153   uint32_t getTableIndex() const { return tableIndex.getValue(); }
 154   bool hasTableIndex() const { return tableIndex.hasValue(); }
 155   void setTableIndex(uint32_t index);
 156
 157   // The size of a given input function can depend on the values of the
 158   // LEB relocations within it.  This finalizeContents method is called after
 159   // all the symbol values have be calculated but before getSize() is ever
 160   // called.
 161   void calculateSize();
 162
 163   const WasmSignature &signature;
 164
 165 protected:
 166   ArrayRef<uint8_t> data() const override {
 167     assert(!config->compressRelocations);
 168     return file->codeSection->Content.slice(getInputSectionOffset(),
 169                                             function->Size);
 170   }
 171
 172   const WasmFunction *function;
 173   llvm::Optional<uint32_t> functionIndex;
 174   llvm::Optional<uint32_t> tableIndex;
 175   uint32_t compressedFuncSize = 0;
 176   uint32_t compressedSize = 0;
 177 };
 178
 179 class SyntheticFunction : public InputFunction {
 180 public:
 181   SyntheticFunction(const WasmSignature &s, StringRef name,
 182                     StringRef debugName = {})
 183       : InputFunction(s, nullptr, nullptr), name(name), debugName(debugName) {
 184     sectionKind = InputChunk::SyntheticFunction;
 185   }
 186
 187   static bool classof(const InputChunk *c) {
 188     return c->kind() == InputChunk::SyntheticFunction;
 189   }
 190
 191   StringRef getName() const override { return name; }
 192   StringRef getDebugName() const override { return debugName; }
 193   uint32_t getComdat() const override { return UINT32_MAX; }
 194
 195   void setBody(ArrayRef<uint8_t> body_) { body = body_; }
 196
 197 protected:
 198   ArrayRef<uint8_t> data() const override { return body; }
 199
 200   StringRef name;
 201   StringRef debugName;
 202   ArrayRef<uint8_t> body;
 203 };
 204
 205 // Represents a single Wasm Section within an input file.
 206 class InputSection : public InputChunk {
 207 public:
 208   InputSection(const WasmSection &s, ObjFile *f)
 209       : InputChunk(f, InputChunk::Section), section(s) {
 210     assert(section.Type == llvm::wasm::WASM_SEC_CUSTOM);
 211   }
 212
 213   StringRef getName() const override { return section.Name; }
 214   StringRef getDebugName() const override { return StringRef(); }
 215   uint32_t getComdat() const override { return UINT32_MAX; }
 216
 217   OutputSection *outputSec = nullptr;
 218
 219 protected:
 220   ArrayRef<uint8_t> data() const override { return section.Content; }
 221
 222   // Offset within the input section.  This is only zero since this chunk
 223   // type represents an entire input section, not part of one.
 224   uint32_t getInputSectionOffset() const override { return 0; }
 225
 226   const WasmSection &section;
 227 };
 228
 229 } // namespace wasm
 230
 231 std::string toString(const wasm::InputChunk *);
 232 StringRef relocTypeToString(uint8_t relocType);
 233
 234 } // namespace lld
 235
 236 #endif // LLD_WASM_INPUT_CHUNKS_H