2018-01-10 09:13:34 +08:00
|
|
|
//===- InputChunks.h --------------------------------------------*- C++ -*-===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2018-01-10 09:13:34 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2018-02-23 13:08:53 +08:00
|
|
|
// An InputChunks represents an indivisible opaque region of a input wasm file.
|
|
|
|
// i.e. a single wasm data segment or a single wasm function.
|
|
|
|
//
|
|
|
|
// They are written directly to the mmap'd output file after which relocations
|
|
|
|
// are applied. Because each Chunk is independent they can be written in
|
|
|
|
// parallel.
|
|
|
|
//
|
|
|
|
// Chunks are also unit on which garbage collection (--gc-sections) operates.
|
2018-01-10 09:13:34 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef LLD_WASM_INPUT_CHUNKS_H
|
|
|
|
#define LLD_WASM_INPUT_CHUNKS_H
|
|
|
|
|
2018-01-31 09:45:47 +08:00
|
|
|
#include "Config.h"
|
2018-01-10 09:13:34 +08:00
|
|
|
#include "InputFiles.h"
|
|
|
|
#include "lld/Common/ErrorHandler.h"
|
2018-11-27 09:08:16 +08:00
|
|
|
#include "lld/Common/LLVM.h"
|
2018-01-10 09:13:34 +08:00
|
|
|
#include "llvm/Object/Wasm.h"
|
|
|
|
|
|
|
|
namespace lld {
|
|
|
|
namespace wasm {
|
|
|
|
|
|
|
|
class ObjFile;
|
|
|
|
class OutputSegment;
|
|
|
|
|
|
|
|
class InputChunk {
|
|
|
|
public:
|
2018-04-11 00:12:49 +08:00
|
|
|
enum Kind { DataSegment, Function, SyntheticFunction, Section };
|
2018-01-29 03:57:01 +08:00
|
|
|
|
2018-02-09 15:12:29 +08:00
|
|
|
Kind kind() const { return SectionKind; }
|
2018-01-29 03:57:01 +08:00
|
|
|
|
2018-05-19 07:28:05 +08:00
|
|
|
virtual uint32_t getSize() const { return data().size(); }
|
2018-08-23 01:50:51 +08:00
|
|
|
virtual uint32_t getInputSize() const { return getSize(); };
|
2018-01-10 09:13:34 +08:00
|
|
|
|
2018-05-19 07:28:05 +08:00
|
|
|
virtual void writeTo(uint8_t *SectionStart) const;
|
2018-01-11 03:22:42 +08:00
|
|
|
|
2018-01-23 09:25:56 +08:00
|
|
|
ArrayRef<WasmRelocation> getRelocations() const { return Relocations; }
|
2018-08-23 01:50:51 +08:00
|
|
|
void setRelocations(ArrayRef<WasmRelocation> Rs) { Relocations = Rs; }
|
2018-01-11 03:22:42 +08:00
|
|
|
|
2018-01-29 03:57:03 +08:00
|
|
|
virtual StringRef getName() const = 0;
|
2018-04-21 01:09:18 +08:00
|
|
|
virtual StringRef getDebugName() const = 0;
|
2018-03-14 23:45:11 +08:00
|
|
|
virtual uint32_t getComdat() const = 0;
|
|
|
|
StringRef getComdatName() const;
|
2018-08-23 01:50:51 +08:00
|
|
|
virtual uint32_t getInputSectionOffset() const = 0;
|
2018-01-13 06:25:17 +08:00
|
|
|
|
2018-02-20 12:26:26 +08:00
|
|
|
size_t NumRelocations() const { return Relocations.size(); }
|
|
|
|
void writeRelocations(llvm::raw_ostream &OS) const;
|
|
|
|
|
2018-02-01 07:48:14 +08:00
|
|
|
ObjFile *File;
|
2018-02-20 12:26:26 +08:00
|
|
|
int32_t OutputOffset = 0;
|
2018-01-31 09:45:47 +08:00
|
|
|
|
2018-02-14 04:29:38 +08:00
|
|
|
// Signals that the section is part of the output. The garbage collector,
|
|
|
|
// and COMDAT handling can set a sections' Live bit.
|
|
|
|
// If GC is disabled, all sections start out as live by default.
|
2018-01-31 09:45:47 +08:00
|
|
|
unsigned Live : 1;
|
2018-01-11 03:22:42 +08:00
|
|
|
|
|
|
|
protected:
|
2018-02-01 07:48:14 +08:00
|
|
|
InputChunk(ObjFile *F, Kind K)
|
2018-01-31 09:45:47 +08:00
|
|
|
: File(F), Live(!Config->GcSections), SectionKind(K) {}
|
2018-01-11 03:22:42 +08:00
|
|
|
virtual ~InputChunk() = default;
|
2018-01-13 08:22:00 +08:00
|
|
|
virtual ArrayRef<uint8_t> data() const = 0;
|
2018-01-10 09:13:34 +08:00
|
|
|
|
2018-05-05 08:18:43 +08:00
|
|
|
// Verifies the existing data at relocation targets matches our expectations.
|
|
|
|
// This is performed only debug builds as an extra sanity check.
|
|
|
|
void verifyRelocTargets() const;
|
|
|
|
|
2018-08-23 01:50:51 +08:00
|
|
|
ArrayRef<WasmRelocation> Relocations;
|
2018-01-29 03:57:01 +08:00
|
|
|
Kind SectionKind;
|
2018-01-10 09:13:34 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
// Represents a WebAssembly data segment which can be included as part of
|
|
|
|
// an output data segments. Note that in WebAssembly, unlike ELF and other
|
|
|
|
// formats, used the term "data segment" to refer to the continous regions of
|
|
|
|
// memory that make on the data section. See:
|
|
|
|
// https://webassembly.github.io/spec/syntax/modules.html#syntax-data
|
|
|
|
//
|
|
|
|
// For example, by default, clang will produce a separate data section for
|
|
|
|
// each global variable.
|
|
|
|
class InputSegment : public InputChunk {
|
|
|
|
public:
|
2018-02-01 07:48:14 +08:00
|
|
|
InputSegment(const WasmSegment &Seg, ObjFile *F)
|
2018-01-29 03:57:01 +08:00
|
|
|
: InputChunk(F, InputChunk::DataSegment), Segment(Seg) {}
|
|
|
|
|
|
|
|
static bool classof(const InputChunk *C) { return C->kind() == DataSegment; }
|
2018-01-10 09:13:34 +08:00
|
|
|
|
|
|
|
uint32_t getAlignment() const { return Segment.Data.Alignment; }
|
2018-01-29 03:57:03 +08:00
|
|
|
StringRef getName() const override { return Segment.Data.Name; }
|
2018-04-21 01:09:18 +08:00
|
|
|
StringRef getDebugName() const override { return StringRef(); }
|
2018-03-14 23:45:11 +08:00
|
|
|
uint32_t getComdat() const override { return Segment.Data.Comdat; }
|
2018-08-23 01:50:51 +08:00
|
|
|
uint32_t getInputSectionOffset() const override {
|
|
|
|
return Segment.SectionOffset;
|
|
|
|
}
|
2018-01-10 09:13:34 +08:00
|
|
|
|
2018-02-28 08:20:29 +08:00
|
|
|
const OutputSegment *OutputSeg = nullptr;
|
2018-01-11 03:22:42 +08:00
|
|
|
int32_t OutputSegmentOffset = 0;
|
|
|
|
|
2018-01-10 09:13:34 +08:00
|
|
|
protected:
|
2018-01-13 08:22:00 +08:00
|
|
|
ArrayRef<uint8_t> data() const override { return Segment.Data.Content; }
|
2018-01-13 06:25:17 +08:00
|
|
|
|
2018-01-10 09:13:34 +08:00
|
|
|
const WasmSegment &Segment;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Represents a single wasm function within and input file. These are
|
|
|
|
// combined to create the final output CODE section.
|
|
|
|
class InputFunction : public InputChunk {
|
|
|
|
public:
|
2018-03-07 21:28:16 +08:00
|
|
|
InputFunction(const WasmSignature &S, const WasmFunction *Func, ObjFile *F)
|
2018-01-29 03:57:01 +08:00
|
|
|
: InputChunk(F, InputChunk::Function), Signature(S), Function(Func) {}
|
|
|
|
|
2018-01-29 03:57:02 +08:00
|
|
|
static bool classof(const InputChunk *C) {
|
2018-03-10 00:43:05 +08:00
|
|
|
return C->kind() == InputChunk::Function ||
|
|
|
|
C->kind() == InputChunk::SyntheticFunction;
|
2018-01-29 03:57:02 +08:00
|
|
|
}
|
2018-01-10 09:13:34 +08:00
|
|
|
|
2018-05-19 07:28:05 +08:00
|
|
|
void writeTo(uint8_t *SectionStart) const override;
|
2018-04-21 01:09:18 +08:00
|
|
|
StringRef getName() const override { return Function->SymbolName; }
|
|
|
|
StringRef getDebugName() const override { return Function->DebugName; }
|
2018-03-14 23:45:11 +08:00
|
|
|
uint32_t getComdat() const override { return Function->Comdat; }
|
2018-05-05 07:14:42 +08:00
|
|
|
uint32_t getFunctionInputOffset() const { return getInputSectionOffset(); }
|
2018-05-16 06:27:50 +08:00
|
|
|
uint32_t getFunctionCodeOffset() const { return Function->CodeOffset; }
|
2018-05-19 07:28:05 +08:00
|
|
|
uint32_t getSize() const override {
|
2018-09-27 08:46:54 +08:00
|
|
|
if (Config->CompressRelocations && File) {
|
2018-05-19 07:28:05 +08:00
|
|
|
assert(CompressedSize);
|
|
|
|
return CompressedSize;
|
|
|
|
}
|
|
|
|
return data().size();
|
|
|
|
}
|
2018-08-23 01:50:51 +08:00
|
|
|
uint32_t getInputSize() const override { return Function->Size; }
|
2018-03-13 03:56:23 +08:00
|
|
|
uint32_t getFunctionIndex() const { return FunctionIndex.getValue(); }
|
|
|
|
bool hasFunctionIndex() const { return FunctionIndex.hasValue(); }
|
|
|
|
void setFunctionIndex(uint32_t Index);
|
2018-08-23 01:50:51 +08:00
|
|
|
uint32_t getInputSectionOffset() const override {
|
|
|
|
return Function->CodeSectionOffset;
|
|
|
|
}
|
2018-01-25 05:45:25 +08:00
|
|
|
uint32_t getTableIndex() const { return TableIndex.getValue(); }
|
|
|
|
bool hasTableIndex() const { return TableIndex.hasValue(); }
|
|
|
|
void setTableIndex(uint32_t Index);
|
2018-01-10 09:13:34 +08:00
|
|
|
|
2018-05-19 07:28:05 +08:00
|
|
|
// The size of a given input function can depend on the values of the
|
|
|
|
// LEB relocations within it. This finalizeContents method is called after
|
|
|
|
// all the symbol values have be calcualted but before getSize() is ever
|
|
|
|
// called.
|
|
|
|
void calculateSize();
|
|
|
|
|
2018-01-10 09:13:34 +08:00
|
|
|
const WasmSignature &Signature;
|
|
|
|
|
|
|
|
protected:
|
2018-01-13 08:22:00 +08:00
|
|
|
ArrayRef<uint8_t> data() const override {
|
2018-09-27 08:46:54 +08:00
|
|
|
assert(!Config->CompressRelocations);
|
2018-01-18 02:49:11 +08:00
|
|
|
return File->CodeSection->Content.slice(getInputSectionOffset(),
|
|
|
|
Function->Size);
|
2018-01-13 08:22:00 +08:00
|
|
|
}
|
2018-05-19 07:28:05 +08:00
|
|
|
|
2018-01-13 02:35:13 +08:00
|
|
|
const WasmFunction *Function;
|
2018-03-13 03:56:23 +08:00
|
|
|
llvm::Optional<uint32_t> FunctionIndex;
|
2018-01-25 05:45:25 +08:00
|
|
|
llvm::Optional<uint32_t> TableIndex;
|
2018-05-19 07:28:05 +08:00
|
|
|
uint32_t CompressedFuncSize = 0;
|
|
|
|
uint32_t CompressedSize = 0;
|
2018-01-10 09:13:34 +08:00
|
|
|
};
|
|
|
|
|
2018-01-13 02:35:13 +08:00
|
|
|
class SyntheticFunction : public InputFunction {
|
|
|
|
public:
|
2018-04-21 01:09:18 +08:00
|
|
|
SyntheticFunction(const WasmSignature &S, StringRef Name,
|
|
|
|
StringRef DebugName = {})
|
|
|
|
: InputFunction(S, nullptr, nullptr), Name(Name), DebugName(DebugName) {
|
2018-03-10 00:43:05 +08:00
|
|
|
SectionKind = InputChunk::SyntheticFunction;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool classof(const InputChunk *C) {
|
|
|
|
return C->kind() == InputChunk::SyntheticFunction;
|
|
|
|
}
|
2018-01-18 04:19:04 +08:00
|
|
|
|
|
|
|
StringRef getName() const override { return Name; }
|
2018-04-21 01:09:18 +08:00
|
|
|
StringRef getDebugName() const override { return DebugName; }
|
2018-03-14 23:45:11 +08:00
|
|
|
uint32_t getComdat() const override { return UINT32_MAX; }
|
2018-01-13 02:35:13 +08:00
|
|
|
|
2018-03-10 00:43:05 +08:00
|
|
|
void setBody(ArrayRef<uint8_t> Body_) { Body = Body_; }
|
|
|
|
|
2018-01-13 02:35:13 +08:00
|
|
|
protected:
|
2018-03-07 18:37:50 +08:00
|
|
|
ArrayRef<uint8_t> data() const override { return Body; }
|
2018-01-13 08:22:00 +08:00
|
|
|
|
2018-01-18 04:19:04 +08:00
|
|
|
StringRef Name;
|
2018-04-21 01:09:18 +08:00
|
|
|
StringRef DebugName;
|
2018-03-07 18:37:50 +08:00
|
|
|
ArrayRef<uint8_t> Body;
|
2018-01-13 02:35:13 +08:00
|
|
|
};
|
|
|
|
|
2018-04-11 00:12:49 +08:00
|
|
|
// Represents a single Wasm Section within an input file.
|
|
|
|
class InputSection : public InputChunk {
|
|
|
|
public:
|
2018-04-13 04:31:35 +08:00
|
|
|
InputSection(const WasmSection &S, ObjFile *F)
|
|
|
|
: InputChunk(F, InputChunk::Section), Section(S) {
|
|
|
|
assert(Section.Type == llvm::wasm::WASM_SEC_CUSTOM);
|
|
|
|
}
|
2018-04-11 00:12:49 +08:00
|
|
|
|
|
|
|
StringRef getName() const override { return Section.Name; }
|
2018-04-21 01:09:18 +08:00
|
|
|
StringRef getDebugName() const override { return StringRef(); }
|
2018-04-11 00:12:49 +08:00
|
|
|
uint32_t getComdat() const override { return UINT32_MAX; }
|
|
|
|
|
|
|
|
protected:
|
2018-04-13 04:31:35 +08:00
|
|
|
ArrayRef<uint8_t> data() const override { return Section.Content; }
|
2018-04-11 00:12:49 +08:00
|
|
|
|
|
|
|
// Offset within the input section. This is only zero since this chunk
|
|
|
|
// type represents an entire input section, not part of one.
|
|
|
|
uint32_t getInputSectionOffset() const override { return 0; }
|
|
|
|
|
|
|
|
const WasmSection &Section;
|
|
|
|
};
|
|
|
|
|
2018-01-10 09:13:34 +08:00
|
|
|
} // namespace wasm
|
2018-02-20 06:29:48 +08:00
|
|
|
|
|
|
|
std::string toString(const wasm::InputChunk *);
|
2019-03-30 06:56:39 +08:00
|
|
|
StringRef relocTypeToString(uint8_t RelocType);
|
|
|
|
|
2018-01-10 09:13:34 +08:00
|
|
|
} // namespace lld
|
|
|
|
|
|
|
|
#endif // LLD_WASM_INPUT_CHUNKS_H
|