1 | //===- llvm/MC/MCELFObjectWriter.h - ELF Object Writer ----------*- 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 LLVM_MC_MCELFOBJECTWRITER_H |
10 | #define LLVM_MC_MCELFOBJECTWRITER_H |
11 | |
12 | #include "llvm/BinaryFormat/ELF.h" |
13 | #include "llvm/MC/MCObjectWriter.h" |
14 | #include "llvm/MC/MCSectionELF.h" |
15 | #include "llvm/Support/Casting.h" |
16 | #include "llvm/Support/raw_ostream.h" |
17 | #include "llvm/TargetParser/Triple.h" |
18 | #include <cstdint> |
19 | #include <vector> |
20 | |
21 | namespace llvm { |
22 | |
23 | class MCAssembler; |
24 | class MCContext; |
25 | class MCFixup; |
26 | class MCSymbol; |
27 | class MCSymbolELF; |
28 | class MCValue; |
29 | |
30 | struct ELFRelocationEntry { |
31 | uint64_t Offset; // Where is the relocation. |
32 | const MCSymbolELF *Symbol; // The symbol to relocate with. |
33 | unsigned Type; // The type of the relocation. |
34 | uint64_t Addend; // The addend to use. |
35 | const MCSymbolELF *OriginalSymbol; // The original value of Symbol if we changed it. |
36 | uint64_t OriginalAddend; // The original value of addend. |
37 | |
38 | ELFRelocationEntry(uint64_t Offset, const MCSymbolELF *Symbol, unsigned Type, |
39 | uint64_t Addend, const MCSymbolELF *OriginalSymbol, |
40 | uint64_t OriginalAddend) |
41 | : Offset(Offset), Symbol(Symbol), Type(Type), Addend(Addend), |
42 | OriginalSymbol(OriginalSymbol), OriginalAddend(OriginalAddend) {} |
43 | |
44 | void print(raw_ostream &Out) const { |
45 | Out << "Off=" << Offset << ", Sym=" << Symbol << ", Type=" << Type |
46 | << ", Addend=" << Addend << ", OriginalSymbol=" << OriginalSymbol |
47 | << ", OriginalAddend=" << OriginalAddend; |
48 | } |
49 | |
50 | LLVM_DUMP_METHOD void dump() const { print(Out&: errs()); } |
51 | }; |
52 | |
53 | class MCELFObjectTargetWriter : public MCObjectTargetWriter { |
54 | const uint8_t OSABI; |
55 | const uint8_t ABIVersion; |
56 | const uint16_t EMachine; |
57 | const unsigned HasRelocationAddend : 1; |
58 | const unsigned Is64Bit : 1; |
59 | |
60 | protected: |
61 | MCELFObjectTargetWriter(bool Is64Bit_, uint8_t OSABI_, uint16_t EMachine_, |
62 | bool HasRelocationAddend_, uint8_t ABIVersion_ = 0); |
63 | |
64 | public: |
65 | virtual ~MCELFObjectTargetWriter() = default; |
66 | |
67 | Triple::ObjectFormatType getFormat() const override { return Triple::ELF; } |
68 | static bool classof(const MCObjectTargetWriter *W) { |
69 | return W->getFormat() == Triple::ELF; |
70 | } |
71 | |
72 | static uint8_t getOSABI(Triple::OSType OSType) { |
73 | switch (OSType) { |
74 | case Triple::HermitCore: |
75 | return ELF::ELFOSABI_STANDALONE; |
76 | case Triple::PS4: |
77 | case Triple::FreeBSD: |
78 | return ELF::ELFOSABI_FREEBSD; |
79 | case Triple::Solaris: |
80 | return ELF::ELFOSABI_SOLARIS; |
81 | default: |
82 | return ELF::ELFOSABI_NONE; |
83 | } |
84 | } |
85 | |
86 | virtual unsigned getRelocType(MCContext &Ctx, const MCValue &Target, |
87 | const MCFixup &Fixup, bool IsPCRel) const = 0; |
88 | |
89 | virtual bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym, |
90 | unsigned Type) const; |
91 | |
92 | virtual void sortRelocs(const MCAssembler &Asm, |
93 | std::vector<ELFRelocationEntry> &Relocs); |
94 | |
95 | virtual void addTargetSectionFlags(MCContext &Ctx, MCSectionELF &Sec); |
96 | |
97 | /// \name Accessors |
98 | /// @{ |
99 | uint8_t getOSABI() const { return OSABI; } |
100 | uint8_t getABIVersion() const { return ABIVersion; } |
101 | uint16_t getEMachine() const { return EMachine; } |
102 | bool hasRelocationAddend() const { return HasRelocationAddend; } |
103 | bool is64Bit() const { return Is64Bit; } |
104 | /// @} |
105 | |
106 | // Instead of changing everyone's API we pack the N64 Type fields |
107 | // into the existing 32 bit data unsigned. |
108 | #define R_TYPE_SHIFT 0 |
109 | #define R_TYPE_MASK 0xffffff00 |
110 | #define R_TYPE2_SHIFT 8 |
111 | #define R_TYPE2_MASK 0xffff00ff |
112 | #define R_TYPE3_SHIFT 16 |
113 | #define R_TYPE3_MASK 0xff00ffff |
114 | #define R_SSYM_SHIFT 24 |
115 | #define R_SSYM_MASK 0x00ffffff |
116 | |
117 | // N64 relocation type accessors |
118 | uint8_t getRType(uint32_t Type) const { |
119 | return (unsigned)((Type >> R_TYPE_SHIFT) & 0xff); |
120 | } |
121 | uint8_t getRType2(uint32_t Type) const { |
122 | return (unsigned)((Type >> R_TYPE2_SHIFT) & 0xff); |
123 | } |
124 | uint8_t getRType3(uint32_t Type) const { |
125 | return (unsigned)((Type >> R_TYPE3_SHIFT) & 0xff); |
126 | } |
127 | uint8_t (uint32_t Type) const { |
128 | return (unsigned)((Type >> R_SSYM_SHIFT) & 0xff); |
129 | } |
130 | |
131 | // N64 relocation type setting |
132 | static unsigned setRTypes(unsigned Value1, unsigned Value2, unsigned Value3) { |
133 | return ((Value1 & 0xff) << R_TYPE_SHIFT) | |
134 | ((Value2 & 0xff) << R_TYPE2_SHIFT) | |
135 | ((Value3 & 0xff) << R_TYPE3_SHIFT); |
136 | } |
137 | unsigned (unsigned Value, unsigned Type) const { |
138 | return (Type & R_SSYM_MASK) | ((Value & 0xff) << R_SSYM_SHIFT); |
139 | } |
140 | |
141 | // On AArch64, return a new section to be added to the ELF object that |
142 | // contains relocations used to describe every symbol that should have memory |
143 | // tags applied. Returns nullptr if no such section is necessary (i.e. there's |
144 | // no tagged globals). |
145 | virtual MCSectionELF *getMemtagRelocsSection(MCContext &Ctx) const { |
146 | return nullptr; |
147 | } |
148 | }; |
149 | |
150 | /// Construct a new ELF writer instance. |
151 | /// |
152 | /// \param MOTW - The target specific ELF writer subclass. |
153 | /// \param OS - The stream to write to. |
154 | /// \returns The constructed object writer. |
155 | std::unique_ptr<MCObjectWriter> |
156 | createELFObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW, |
157 | raw_pwrite_stream &OS, bool IsLittleEndian); |
158 | |
159 | std::unique_ptr<MCObjectWriter> |
160 | createELFDwoObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW, |
161 | raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS, |
162 | bool IsLittleEndian); |
163 | |
164 | } // end namespace llvm |
165 | |
166 | #endif // LLVM_MC_MCELFOBJECTWRITER_H |
167 | |