blob: 230d3d775b13be775f2db4a5dc93187401dc1a3d [file] [log] [blame]
Nick Lewycky4288f9e2013-03-09 09:32:16 +00001//===- lib/MC/ELFObjectWriter.cpp - ELF File Writer -----------------------===//
Matt Fleming6c1ad482010-08-16 18:57:57 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements ELF object file writer information.
11//
12//===----------------------------------------------------------------------===//
13
Chandler Carruthed0881b2012-12-03 16:50:05 +000014#include "llvm/MC/MCELFObjectWriter.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000015#include "llvm/ADT/STLExtras.h"
Rafael Espindola29abd972011-12-22 03:38:00 +000016#include "llvm/ADT/SmallPtrSet.h"
17#include "llvm/ADT/SmallString.h"
Matt Fleming6c1ad482010-08-16 18:57:57 +000018#include "llvm/ADT/StringMap.h"
Evan Cheng5928e692011-07-25 23:24:55 +000019#include "llvm/MC/MCAsmBackend.h"
David Blaikie8019bf82014-04-10 21:53:53 +000020#include "llvm/MC/MCAsmInfo.h"
Matt Fleming6c1ad482010-08-16 18:57:57 +000021#include "llvm/MC/MCAsmLayout.h"
Rafael Espindola29abd972011-12-22 03:38:00 +000022#include "llvm/MC/MCAssembler.h"
Matt Fleming6c1ad482010-08-16 18:57:57 +000023#include "llvm/MC/MCContext.h"
Matt Fleming6c1ad482010-08-16 18:57:57 +000024#include "llvm/MC/MCExpr.h"
Craig Topper6e80c282012-03-26 06:58:25 +000025#include "llvm/MC/MCFixupKindInfo.h"
26#include "llvm/MC/MCObjectWriter.h"
Matt Fleming6c1ad482010-08-16 18:57:57 +000027#include "llvm/MC/MCSectionELF.h"
Rafael Espindolaa8695762015-06-02 00:25:12 +000028#include "llvm/MC/MCSymbolELF.h"
Matt Fleming6c1ad482010-08-16 18:57:57 +000029#include "llvm/MC/MCValue.h"
Rafael Espindola97de4742014-07-03 02:01:39 +000030#include "llvm/MC/StringTableBuilder.h"
David Blaikie8019bf82014-04-10 21:53:53 +000031#include "llvm/Support/Compression.h"
Matt Fleming6c1ad482010-08-16 18:57:57 +000032#include "llvm/Support/Debug.h"
Matt Fleming6c1ad482010-08-16 18:57:57 +000033#include "llvm/Support/ELF.h"
Chandler Carruthd9903882015-01-14 11:23:27 +000034#include "llvm/Support/Endian.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000035#include "llvm/Support/ErrorHandling.h"
Rafael Espindolafc063e82015-10-22 18:32:06 +000036#include "llvm/Support/StringSaver.h"
Matt Fleming6c1ad482010-08-16 18:57:57 +000037#include <vector>
38using namespace llvm;
39
Jason W Kimc09e7262011-05-11 22:53:06 +000040#undef DEBUG_TYPE
41#define DEBUG_TYPE "reloc-info"
42
Rafael Espindola29abd972011-12-22 03:38:00 +000043namespace {
Rafael Espindola0ce09712014-03-25 22:43:53 +000044
Rafael Espindola10be0832014-03-25 23:44:25 +000045typedef DenseMap<const MCSectionELF *, uint32_t> SectionIndexMapTy;
46
Rafael Espindola91fd2772015-04-29 21:09:32 +000047class ELFObjectWriter;
48
Rafael Espindola10be0832014-03-25 23:44:25 +000049class SymbolTableWriter {
Rafael Espindola91fd2772015-04-29 21:09:32 +000050 ELFObjectWriter &EWriter;
Rafael Espindola10be0832014-03-25 23:44:25 +000051 bool Is64Bit;
Rafael Espindola10be0832014-03-25 23:44:25 +000052
Rafael Espindola91fd2772015-04-29 21:09:32 +000053 // indexes we are going to write to .symtab_shndx.
54 std::vector<uint32_t> ShndxIndexes;
Rafael Espindola10be0832014-03-25 23:44:25 +000055
56 // The numbel of symbols written so far.
57 unsigned NumWritten;
58
59 void createSymtabShndx();
60
Rafael Espindola91fd2772015-04-29 21:09:32 +000061 template <typename T> void write(T Value);
Rafael Espindola10be0832014-03-25 23:44:25 +000062
63public:
Rafael Espindola91fd2772015-04-29 21:09:32 +000064 SymbolTableWriter(ELFObjectWriter &EWriter, bool Is64Bit);
Rafael Espindola10be0832014-03-25 23:44:25 +000065
66 void writeSymbol(uint32_t name, uint8_t info, uint64_t value, uint64_t size,
67 uint8_t other, uint32_t shndx, bool Reserved);
Rafael Espindola91fd2772015-04-29 21:09:32 +000068
69 ArrayRef<uint32_t> getShndxIndexes() const { return ShndxIndexes; }
Rafael Espindola10be0832014-03-25 23:44:25 +000070};
71
Rafael Espindola29abd972011-12-22 03:38:00 +000072class ELFObjectWriter : public MCObjectWriter {
Rafael Espindola29abd972011-12-22 03:38:00 +000073 static bool isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind);
Duncan P. N. Exon Smith469f9db2015-05-20 04:39:01 +000074 static uint64_t SymbolValue(const MCSymbol &Sym, const MCAsmLayout &Layout);
Rafael Espindola95fb9b92015-06-02 20:38:46 +000075 static bool isInSymtab(const MCAsmLayout &Layout, const MCSymbolELF &Symbol,
Rafael Espindola29abd972011-12-22 03:38:00 +000076 bool Used, bool Renamed);
Rafael Espindola29abd972011-12-22 03:38:00 +000077
Rafael Espindola6cd21802015-04-07 22:35:40 +000078 /// Helper struct for containing some precomputed information on symbols.
Rafael Espindola29abd972011-12-22 03:38:00 +000079 struct ELFSymbolData {
Rafael Espindolaa8695762015-06-02 00:25:12 +000080 const MCSymbolELF *Symbol;
Rafael Espindola29abd972011-12-22 03:38:00 +000081 uint32_t SectionIndex;
Hans Wennborg83e6e1e2014-04-30 16:25:02 +000082 StringRef Name;
Rafael Espindola29abd972011-12-22 03:38:00 +000083
84 // Support lexicographic sorting.
85 bool operator<(const ELFSymbolData &RHS) const {
Rafael Espindola95fb9b92015-06-02 20:38:46 +000086 unsigned LHSType = Symbol->getType();
87 unsigned RHSType = RHS.Symbol->getType();
Rafael Espindolab6613022014-10-17 01:48:58 +000088 if (LHSType == ELF::STT_SECTION && RHSType != ELF::STT_SECTION)
89 return false;
90 if (LHSType != ELF::STT_SECTION && RHSType == ELF::STT_SECTION)
91 return true;
92 if (LHSType == ELF::STT_SECTION && RHSType == ELF::STT_SECTION)
93 return SectionIndex < RHS.SectionIndex;
Hans Wennborg83e6e1e2014-04-30 16:25:02 +000094 return Name < RHS.Name;
Rafael Espindola29abd972011-12-22 03:38:00 +000095 }
96 };
97
Rafael Espindola29abd972011-12-22 03:38:00 +000098 /// The target specific ELF writer instance.
Ahmed Charles56440fd2014-03-06 05:51:42 +000099 std::unique_ptr<MCELFObjectTargetWriter> TargetObjectWriter;
Rafael Espindola29abd972011-12-22 03:38:00 +0000100
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000101 DenseMap<const MCSymbolELF *, const MCSymbolELF *> Renames;
Rafael Espindola29abd972011-12-22 03:38:00 +0000102
Rafael Espindola34948e52015-04-30 00:45:46 +0000103 llvm::DenseMap<const MCSectionELF *, std::vector<ELFRelocationEntry>>
104 Relocations;
Rafael Espindola29abd972011-12-22 03:38:00 +0000105
106 /// @}
107 /// @name Symbol Table Data
108 /// @{
109
Rafael Espindolafc063e82015-10-22 18:32:06 +0000110 BumpPtrAllocator Alloc;
111 StringSaver VersionSymSaver{Alloc};
Rafael Espindola21956e42015-10-23 21:48:05 +0000112 StringTableBuilder StrTabBuilder{StringTableBuilder::ELF};
Rafael Espindola29abd972011-12-22 03:38:00 +0000113
114 /// @}
115
Rafael Espindola29abd972011-12-22 03:38:00 +0000116 // This holds the symbol table index of the last local symbol.
117 unsigned LastLocalSymbolIndex;
118 // This holds the .strtab section index.
119 unsigned StringTableIndex;
120 // This holds the .symtab section index.
121 unsigned SymbolTableIndex;
Rafael Espindola29abd972011-12-22 03:38:00 +0000122
Rafael Espindola03d7abb2015-04-30 20:53:27 +0000123 // Sections in the order they are to be output in the section table.
Rafael Espindola08850b32015-05-25 21:56:55 +0000124 std::vector<const MCSectionELF *> SectionTable;
125 unsigned addToSectionTable(const MCSectionELF *Sec);
Rafael Espindola29abd972011-12-22 03:38:00 +0000126
Rafael Espindola29abd972011-12-22 03:38:00 +0000127 // TargetObjectWriter wrappers.
Rafael Espindola29abd972011-12-22 03:38:00 +0000128 bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
129 bool hasRelocationAddend() const {
130 return TargetObjectWriter->hasRelocationAddend();
131 }
Rafael Espindola29abd972011-12-22 03:38:00 +0000132 unsigned GetRelocType(const MCValue &Target, const MCFixup &Fixup,
Rafael Espindolac03f44c2014-03-27 20:49:35 +0000133 bool IsPCRel) const {
134 return TargetObjectWriter->GetRelocType(Target, Fixup, IsPCRel);
Rafael Espindola29abd972011-12-22 03:38:00 +0000135 }
136
Rafael Espindolab20fbb82015-06-05 18:21:00 +0000137 void align(unsigned Alignment);
138
Rafael Espindola29abd972011-12-22 03:38:00 +0000139 public:
Rafael Espindola5560a4c2015-04-14 22:14:34 +0000140 ELFObjectWriter(MCELFObjectTargetWriter *MOTW, raw_pwrite_stream &OS,
Rafael Espindola0ce09712014-03-25 22:43:53 +0000141 bool IsLittleEndian)
Rafael Espindolae2b355d2015-05-28 15:20:00 +0000142 : MCObjectWriter(OS, IsLittleEndian), TargetObjectWriter(MOTW) {}
Rafael Espindola29abd972011-12-22 03:38:00 +0000143
Yaron Keren7773a722015-03-23 18:35:01 +0000144 void reset() override {
Yaron Keren7773a722015-03-23 18:35:01 +0000145 Renames.clear();
146 Relocations.clear();
Yaron Keren7773a722015-03-23 18:35:01 +0000147 StrTabBuilder.clear();
Yaron Kerenf3465e12015-05-13 15:17:19 +0000148 SectionTable.clear();
Yaron Keren7773a722015-03-23 18:35:01 +0000149 MCObjectWriter::reset();
150 }
151
Alexander Kornienkof817c1c2015-04-11 02:11:45 +0000152 ~ELFObjectWriter() override;
Rafael Espindola29abd972011-12-22 03:38:00 +0000153
154 void WriteWord(uint64_t W) {
155 if (is64Bit())
Jim Grosbach36e60e92015-06-04 22:24:41 +0000156 write64(W);
Rafael Espindola29abd972011-12-22 03:38:00 +0000157 else
Jim Grosbach36e60e92015-06-04 22:24:41 +0000158 write32(W);
Rafael Espindola29abd972011-12-22 03:38:00 +0000159 }
160
Rafael Espindola91fd2772015-04-29 21:09:32 +0000161 template <typename T> void write(T Val) {
162 if (IsLittleEndian)
David Majnemerabdb2d2a2015-09-01 16:19:03 +0000163 support::endian::Writer<support::little>(getStream()).write(Val);
Rafael Espindola91fd2772015-04-29 21:09:32 +0000164 else
David Majnemerabdb2d2a2015-09-01 16:19:03 +0000165 support::endian::Writer<support::big>(getStream()).write(Val);
Rafael Espindola91fd2772015-04-29 21:09:32 +0000166 }
167
Rafael Espindola8c7829b2015-04-29 20:39:37 +0000168 void writeHeader(const MCAssembler &Asm);
Rafael Espindola29abd972011-12-22 03:38:00 +0000169
Rafael Espindolae48421f2015-05-28 20:25:29 +0000170 void writeSymbol(SymbolTableWriter &Writer, uint32_t StringIndex,
171 ELFSymbolData &MSD, const MCAsmLayout &Layout);
Rafael Espindola29abd972011-12-22 03:38:00 +0000172
Rafael Espindola91fd2772015-04-29 21:09:32 +0000173 // Start and end offset of each section
Rafael Espindolabda19802015-04-30 14:21:49 +0000174 typedef std::map<const MCSectionELF *, std::pair<uint64_t, uint64_t>>
175 SectionOffsetsTy;
Rafael Espindola91fd2772015-04-29 21:09:32 +0000176
Rafael Espindolab60c8292014-04-29 12:46:50 +0000177 bool shouldRelocateWithSymbol(const MCAssembler &Asm,
178 const MCSymbolRefExpr *RefA,
Duncan P. N. Exon Smith469f9db2015-05-20 04:39:01 +0000179 const MCSymbol *Sym, uint64_t C,
Rafael Espindola5904e122014-03-29 06:26:49 +0000180 unsigned Type) const;
181
Jim Grosbach36e60e92015-06-04 22:24:41 +0000182 void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
Craig Topper34a61bc2014-03-08 07:02:02 +0000183 const MCFragment *Fragment, const MCFixup &Fixup,
Rafael Espindola5904e122014-03-29 06:26:49 +0000184 MCValue Target, bool &IsPCRel,
185 uint64_t &FixedValue) override;
Rafael Espindola29abd972011-12-22 03:38:00 +0000186
Rafael Espindola89feff32015-04-28 22:59:58 +0000187 // Map from a signature symbol to the group section index
188 typedef DenseMap<const MCSymbol *, unsigned> RevGroupMapTy;
Rafael Espindola29abd972011-12-22 03:38:00 +0000189
Rafael Espindola022bb762014-03-24 03:43:21 +0000190 /// Compute the symbol table data
Rafael Espindola29abd972011-12-22 03:38:00 +0000191 ///
Rafael Espindola073ee7d2012-08-27 16:04:24 +0000192 /// \param Asm - The assembler.
193 /// \param SectionIndexMap - Maps a section to its index.
194 /// \param RevGroupMap - Maps a signature symbol to the group section.
Rafael Espindola022bb762014-03-24 03:43:21 +0000195 void computeSymbolTable(MCAssembler &Asm, const MCAsmLayout &Layout,
Rafael Espindola29abd972011-12-22 03:38:00 +0000196 const SectionIndexMapTy &SectionIndexMap,
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000197 const RevGroupMapTy &RevGroupMap,
198 SectionOffsetsTy &SectionOffsets);
Rafael Espindola29abd972011-12-22 03:38:00 +0000199
Rafael Espindola0a82ad72015-05-21 20:43:13 +0000200 MCSectionELF *createRelocationSection(MCContext &Ctx,
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000201 const MCSectionELF &Sec);
Rafael Espindola29abd972011-12-22 03:38:00 +0000202
Rafael Espindolab1863912015-04-30 21:10:06 +0000203 const MCSectionELF *createStringTable(MCContext &Ctx);
Rafael Espindola29abd972011-12-22 03:38:00 +0000204
Jim Grosbach56ed0bb2015-06-04 23:25:54 +0000205 void executePostLayoutBinding(MCAssembler &Asm,
Craig Topper34a61bc2014-03-08 07:02:02 +0000206 const MCAsmLayout &Layout) override;
Rafael Espindola29abd972011-12-22 03:38:00 +0000207
Rafael Espindola57c80832015-06-04 20:55:49 +0000208 void writeSectionHeader(const MCAsmLayout &Layout,
Rafael Espindola29abd972011-12-22 03:38:00 +0000209 const SectionIndexMapTy &SectionIndexMap,
Rafael Espindolaa8201692015-04-28 15:26:21 +0000210 const SectionOffsetsTy &SectionOffsets);
Rafael Espindola29abd972011-12-22 03:38:00 +0000211
Rafael Espindolae15b1b72015-05-27 13:30:50 +0000212 void writeSectionData(const MCAssembler &Asm, MCSection &Sec,
Rafael Espindola868b3f42015-04-30 21:51:58 +0000213 const MCAsmLayout &Layout);
214
Rafael Espindola29abd972011-12-22 03:38:00 +0000215 void WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
Rafael Espindola868b3f42015-04-30 21:51:58 +0000216 uint64_t Address, uint64_t Offset, uint64_t Size,
217 uint32_t Link, uint32_t Info, uint64_t Alignment,
218 uint64_t EntrySize);
Rafael Espindola29abd972011-12-22 03:38:00 +0000219
Rafael Espindola34948e52015-04-30 00:45:46 +0000220 void writeRelocations(const MCAssembler &Asm, const MCSectionELF &Sec);
Rafael Espindola29abd972011-12-22 03:38:00 +0000221
Jim Grosbach36e60e92015-06-04 22:24:41 +0000222 bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
Duncan P. N. Exon Smithd81ba532015-05-16 01:01:55 +0000223 const MCSymbol &SymA,
224 const MCFragment &FB,
225 bool InSet,
226 bool IsPCRel) const override;
Rafael Espindola29abd972011-12-22 03:38:00 +0000227
Duncan P. N. Exon Smith5266ad92015-05-20 15:10:03 +0000228 bool isWeak(const MCSymbol &Sym) const override;
Rafael Espindolaf275ad82015-03-25 13:16:53 +0000229
Jim Grosbach36e60e92015-06-04 22:24:41 +0000230 void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
Rafael Espindolae92c1bf2015-05-21 19:42:35 +0000231 void writeSection(const SectionIndexMapTy &SectionIndexMap,
Rafael Espindola28687582015-05-21 19:36:43 +0000232 uint32_t GroupSymbolIndex, uint64_t Offset, uint64_t Size,
Rafael Espindola29abd972011-12-22 03:38:00 +0000233 const MCSectionELF &Section);
234 };
Alexander Kornienkof00654e2015-06-23 09:49:53 +0000235}
Rafael Espindola29abd972011-12-22 03:38:00 +0000236
Rafael Espindolab20fbb82015-06-05 18:21:00 +0000237void ELFObjectWriter::align(unsigned Alignment) {
David Majnemerabdb2d2a2015-09-01 16:19:03 +0000238 uint64_t Padding = OffsetToAlignment(getStream().tell(), Alignment);
Rafael Espindolab20fbb82015-06-05 18:21:00 +0000239 WriteZeros(Padding);
240}
241
Rafael Espindola08850b32015-05-25 21:56:55 +0000242unsigned ELFObjectWriter::addToSectionTable(const MCSectionELF *Sec) {
Rafael Espindola03d7abb2015-04-30 20:53:27 +0000243 SectionTable.push_back(Sec);
Rafael Espindola5960cee2015-05-22 23:58:30 +0000244 StrTabBuilder.add(Sec->getSectionName());
Rafael Espindola03d7abb2015-04-30 20:53:27 +0000245 return SectionTable.size();
246}
247
Rafael Espindola10be0832014-03-25 23:44:25 +0000248void SymbolTableWriter::createSymtabShndx() {
Rafael Espindola91fd2772015-04-29 21:09:32 +0000249 if (!ShndxIndexes.empty())
Rafael Espindola10be0832014-03-25 23:44:25 +0000250 return;
251
Rafael Espindola91fd2772015-04-29 21:09:32 +0000252 ShndxIndexes.resize(NumWritten);
Rafael Espindola10be0832014-03-25 23:44:25 +0000253}
254
Rafael Espindola91fd2772015-04-29 21:09:32 +0000255template <typename T> void SymbolTableWriter::write(T Value) {
256 EWriter.write(Value);
Rafael Espindola10be0832014-03-25 23:44:25 +0000257}
258
Rafael Espindola91fd2772015-04-29 21:09:32 +0000259SymbolTableWriter::SymbolTableWriter(ELFObjectWriter &EWriter, bool Is64Bit)
260 : EWriter(EWriter), Is64Bit(Is64Bit), NumWritten(0) {}
Rafael Espindola10be0832014-03-25 23:44:25 +0000261
262void SymbolTableWriter::writeSymbol(uint32_t name, uint8_t info, uint64_t value,
263 uint64_t size, uint8_t other,
264 uint32_t shndx, bool Reserved) {
265 bool LargeIndex = shndx >= ELF::SHN_LORESERVE && !Reserved;
266
267 if (LargeIndex)
268 createSymtabShndx();
269
Rafael Espindola91fd2772015-04-29 21:09:32 +0000270 if (!ShndxIndexes.empty()) {
Rafael Espindola10be0832014-03-25 23:44:25 +0000271 if (LargeIndex)
Rafael Espindola91fd2772015-04-29 21:09:32 +0000272 ShndxIndexes.push_back(shndx);
Rafael Espindola10be0832014-03-25 23:44:25 +0000273 else
Rafael Espindola91fd2772015-04-29 21:09:32 +0000274 ShndxIndexes.push_back(0);
Rafael Espindola10be0832014-03-25 23:44:25 +0000275 }
276
277 uint16_t Index = LargeIndex ? uint16_t(ELF::SHN_XINDEX) : shndx;
278
Rafael Espindola10be0832014-03-25 23:44:25 +0000279 if (Is64Bit) {
Rafael Espindola91fd2772015-04-29 21:09:32 +0000280 write(name); // st_name
281 write(info); // st_info
282 write(other); // st_other
283 write(Index); // st_shndx
284 write(value); // st_value
285 write(size); // st_size
Rafael Espindola10be0832014-03-25 23:44:25 +0000286 } else {
Rafael Espindola91fd2772015-04-29 21:09:32 +0000287 write(name); // st_name
288 write(uint32_t(value)); // st_value
289 write(uint32_t(size)); // st_size
290 write(info); // st_info
291 write(other); // st_other
292 write(Index); // st_shndx
Rafael Espindola10be0832014-03-25 23:44:25 +0000293 }
294
295 ++NumWritten;
296}
297
Jan Sjödin30a52de2011-02-28 21:45:04 +0000298bool ELFObjectWriter::isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind) {
299 const MCFixupKindInfo &FKI =
300 Asm.getBackend().getFixupKindInfo((MCFixupKind) Kind);
301
302 return FKI.Flags & MCFixupKindInfo::FKF_IsPCRel;
303}
304
Jason W Kim96f4c012010-11-15 16:18:39 +0000305ELFObjectWriter::~ELFObjectWriter()
306{}
307
Matt Fleming6c1ad482010-08-16 18:57:57 +0000308// Emit the ELF header.
Rafael Espindola8c7829b2015-04-29 20:39:37 +0000309void ELFObjectWriter::writeHeader(const MCAssembler &Asm) {
Matt Fleming6c1ad482010-08-16 18:57:57 +0000310 // ELF Header
311 // ----------
312 //
313 // Note
314 // ----
315 // emitWord method behaves differently for ELF32 and ELF64, writing
316 // 4 bytes in the former and 8 in the latter.
317
Jim Grosbach36e60e92015-06-04 22:24:41 +0000318 writeBytes(ELF::ElfMagic); // e_ident[EI_MAG0] to e_ident[EI_MAG3]
Matt Fleming6c1ad482010-08-16 18:57:57 +0000319
Jim Grosbach36e60e92015-06-04 22:24:41 +0000320 write8(is64Bit() ? ELF::ELFCLASS64 : ELF::ELFCLASS32); // e_ident[EI_CLASS]
Matt Fleming6c1ad482010-08-16 18:57:57 +0000321
322 // e_ident[EI_DATA]
Jim Grosbach36e60e92015-06-04 22:24:41 +0000323 write8(isLittleEndian() ? ELF::ELFDATA2LSB : ELF::ELFDATA2MSB);
Matt Fleming6c1ad482010-08-16 18:57:57 +0000324
Jim Grosbach36e60e92015-06-04 22:24:41 +0000325 write8(ELF::EV_CURRENT); // e_ident[EI_VERSION]
Roman Divacky3b727f52010-09-09 17:57:50 +0000326 // e_ident[EI_OSABI]
Jim Grosbach36e60e92015-06-04 22:24:41 +0000327 write8(TargetObjectWriter->getOSABI());
328 write8(0); // e_ident[EI_ABIVERSION]
Matt Fleming6c1ad482010-08-16 18:57:57 +0000329
330 WriteZeros(ELF::EI_NIDENT - ELF::EI_PAD);
331
Jim Grosbach36e60e92015-06-04 22:24:41 +0000332 write16(ELF::ET_REL); // e_type
Matt Fleming6c1ad482010-08-16 18:57:57 +0000333
Jim Grosbach36e60e92015-06-04 22:24:41 +0000334 write16(TargetObjectWriter->getEMachine()); // e_machine = target
Matt Fleming6c1ad482010-08-16 18:57:57 +0000335
Jim Grosbach36e60e92015-06-04 22:24:41 +0000336 write32(ELF::EV_CURRENT); // e_version
Matt Fleming6c1ad482010-08-16 18:57:57 +0000337 WriteWord(0); // e_entry, no entry point in .o file
338 WriteWord(0); // e_phoff, no program header for .o
Rafael Espindola642a2212015-04-14 22:54:16 +0000339 WriteWord(0); // e_shoff = sec hdr table off in bytes
Matt Fleming6c1ad482010-08-16 18:57:57 +0000340
Jason W Kim4761fba2011-02-04 21:41:11 +0000341 // e_flags = whatever the target wants
Jim Grosbach36e60e92015-06-04 22:24:41 +0000342 write32(Asm.getELFHeaderEFlags());
Matt Fleming6c1ad482010-08-16 18:57:57 +0000343
344 // e_ehsize = ELF header size
Jim Grosbach36e60e92015-06-04 22:24:41 +0000345 write16(is64Bit() ? sizeof(ELF::Elf64_Ehdr) : sizeof(ELF::Elf32_Ehdr));
Matt Fleming6c1ad482010-08-16 18:57:57 +0000346
Jim Grosbach36e60e92015-06-04 22:24:41 +0000347 write16(0); // e_phentsize = prog header entry size
348 write16(0); // e_phnum = # prog header entries = 0
Matt Fleming6c1ad482010-08-16 18:57:57 +0000349
350 // e_shentsize = Section header entry size
Jim Grosbach36e60e92015-06-04 22:24:41 +0000351 write16(is64Bit() ? sizeof(ELF::Elf64_Shdr) : sizeof(ELF::Elf32_Shdr));
Matt Fleming6c1ad482010-08-16 18:57:57 +0000352
353 // e_shnum = # of section header ents
Jim Grosbach36e60e92015-06-04 22:24:41 +0000354 write16(0);
Matt Fleming6c1ad482010-08-16 18:57:57 +0000355
356 // e_shstrndx = Section # of '.shstrtab'
Rafael Espindola5960cee2015-05-22 23:58:30 +0000357 assert(StringTableIndex < ELF::SHN_LORESERVE);
Jim Grosbach36e60e92015-06-04 22:24:41 +0000358 write16(StringTableIndex);
Matt Fleming6c1ad482010-08-16 18:57:57 +0000359}
360
Duncan P. N. Exon Smith469f9db2015-05-20 04:39:01 +0000361uint64_t ELFObjectWriter::SymbolValue(const MCSymbol &Sym,
Jan Sjödin30a52de2011-02-28 21:45:04 +0000362 const MCAsmLayout &Layout) {
Rafael Espindola4d37b2a2015-05-29 21:45:01 +0000363 if (Sym.isCommon() && Sym.isExternal())
Rafael Espindola14672502015-05-29 17:48:04 +0000364 return Sym.getCommonAlignment();
Rafael Espindola9735f4f2010-09-27 21:23:02 +0000365
Rafael Espindolafee224f2014-04-30 21:51:13 +0000366 uint64_t Res;
Duncan P. N. Exon Smith469f9db2015-05-20 04:39:01 +0000367 if (!Layout.getSymbolOffset(Sym, Res))
Rafael Espindola553e5eb2014-04-30 16:59:35 +0000368 return 0;
369
Duncan P. N. Exon Smith469f9db2015-05-20 04:39:01 +0000370 if (Layout.getAssembler().isThumbFunc(&Sym))
Rafael Espindola66f96fe2014-03-21 22:00:29 +0000371 Res |= 1;
Rafael Espindola9735f4f2010-09-27 21:23:02 +0000372
Rafael Espindola66f96fe2014-03-21 22:00:29 +0000373 return Res;
Rafael Espindola9735f4f2010-09-27 21:23:02 +0000374}
375
Jim Grosbach56ed0bb2015-06-04 23:25:54 +0000376void ELFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
Rafael Espindola93e3cf02010-12-07 00:27:36 +0000377 const MCAsmLayout &Layout) {
Rafael Espindolaeb0c2c12010-10-27 15:18:17 +0000378 // The presence of symbol versions causes undefined symbols and
379 // versions declared with @@@ to be renamed.
380
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000381 for (const MCSymbol &A : Asm.symbols()) {
382 const auto &Alias = cast<MCSymbolELF>(A);
Rafael Espindola6cd76e62010-10-28 18:33:03 +0000383 // Not an alias.
Rafael Espindola6efaf112014-04-28 17:05:36 +0000384 if (!Alias.isVariable())
Rafael Espindola6cd76e62010-10-28 18:33:03 +0000385 continue;
Rafael Espindola6efaf112014-04-28 17:05:36 +0000386 auto *Ref = dyn_cast<MCSymbolRefExpr>(Alias.getVariableValue());
387 if (!Ref)
388 continue;
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000389 const auto &Symbol = cast<MCSymbolELF>(Ref->getSymbol());
Rafael Espindola6cd76e62010-10-28 18:33:03 +0000390
Benjamin Kramer14807272010-10-27 19:53:52 +0000391 StringRef AliasName = Alias.getName();
Rafael Espindolaeb0c2c12010-10-27 15:18:17 +0000392 size_t Pos = AliasName.find('@');
393 if (Pos == StringRef::npos)
394 continue;
395
Rafael Espindola6cd76e62010-10-28 18:33:03 +0000396 // Aliases defined with .symvar copy the binding from the symbol they alias.
397 // This is the first place we are able to copy this information.
Rafael Espindola4d37b2a2015-05-29 21:45:01 +0000398 Alias.setExternal(Symbol.isExternal());
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000399 Alias.setBinding(Symbol.getBinding());
Rafael Espindola6cd76e62010-10-28 18:33:03 +0000400
Benjamin Kramer14807272010-10-27 19:53:52 +0000401 StringRef Rest = AliasName.substr(Pos);
Rafael Espindolaeb0c2c12010-10-27 15:18:17 +0000402 if (!Symbol.isUndefined() && !Rest.startswith("@@@"))
403 continue;
404
Rafael Espindola26496e62010-10-27 17:56:18 +0000405 // FIXME: produce a better error message.
406 if (Symbol.isUndefined() && Rest.startswith("@@") &&
407 !Rest.startswith("@@@"))
408 report_fatal_error("A @@ version cannot be undefined");
409
Benjamin Kramer14807272010-10-27 19:53:52 +0000410 Renames.insert(std::make_pair(&Symbol, &Alias));
Rafael Espindolaeb0c2c12010-10-27 15:18:17 +0000411 }
412}
413
Roman Divacky5a1c5492014-01-07 20:17:03 +0000414static uint8_t mergeTypeForSet(uint8_t origType, uint8_t newType) {
415 uint8_t Type = newType;
416
417 // Propagation rules:
418 // IFUNC > FUNC > OBJECT > NOTYPE
419 // TLS_OBJECT > OBJECT > NOTYPE
420 //
421 // dont let the new type degrade the old type
422 switch (origType) {
423 default:
424 break;
425 case ELF::STT_GNU_IFUNC:
426 if (Type == ELF::STT_FUNC || Type == ELF::STT_OBJECT ||
427 Type == ELF::STT_NOTYPE || Type == ELF::STT_TLS)
428 Type = ELF::STT_GNU_IFUNC;
429 break;
430 case ELF::STT_FUNC:
431 if (Type == ELF::STT_OBJECT || Type == ELF::STT_NOTYPE ||
432 Type == ELF::STT_TLS)
433 Type = ELF::STT_FUNC;
434 break;
435 case ELF::STT_OBJECT:
436 if (Type == ELF::STT_NOTYPE)
437 Type = ELF::STT_OBJECT;
438 break;
439 case ELF::STT_TLS:
440 if (Type == ELF::STT_OBJECT || Type == ELF::STT_NOTYPE ||
441 Type == ELF::STT_GNU_IFUNC || Type == ELF::STT_FUNC)
442 Type = ELF::STT_TLS;
443 break;
444 }
445
446 return Type;
447}
448
Rafael Espindolae48421f2015-05-28 20:25:29 +0000449void ELFObjectWriter::writeSymbol(SymbolTableWriter &Writer,
450 uint32_t StringIndex, ELFSymbolData &MSD,
Daniel Dunbarfe0c28f2010-11-13 07:33:40 +0000451 const MCAsmLayout &Layout) {
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000452 const auto &Symbol = cast<MCSymbolELF>(*MSD.Symbol);
Rafael Espindolaa8695762015-06-02 00:25:12 +0000453 const MCSymbolELF *Base =
454 cast_or_null<MCSymbolELF>(Layout.getBaseSymbol(Symbol));
Rafael Espindola85a84912014-03-26 00:16:43 +0000455
456 // This has to be in sync with when computeSymbolTable uses SHN_ABS or
457 // SHN_COMMON.
Rafael Espindola4d37b2a2015-05-29 21:45:01 +0000458 bool IsReserved = !Base || Symbol.isCommon();
Rafael Espindola3fe87a12010-10-31 00:16:26 +0000459
Jack Carter2f8d9d92013-02-19 21:57:35 +0000460 // Binding and Type share the same byte as upper and lower nibbles
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000461 uint8_t Binding = Symbol.getBinding();
462 uint8_t Type = Symbol.getType();
Rafael Espindolaa6e3a592014-03-23 03:33:20 +0000463 if (Base) {
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000464 Type = mergeTypeForSet(Type, Base->getType());
Rafael Espindolaa6e3a592014-03-23 03:33:20 +0000465 }
Rafael Espindolaf8794ff2015-06-04 00:47:43 +0000466 uint8_t Info = (Binding << 4) | Type;
Jack Carter2f8d9d92013-02-19 21:57:35 +0000467
Joerg Sonnenbergerfc184732013-10-29 01:06:17 +0000468 // Other and Visibility share the same byte with Visibility using the lower
Jack Carter2f8d9d92013-02-19 21:57:35 +0000469 // 2 bits
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000470 uint8_t Visibility = Symbol.getVisibility();
Rafael Espindola8c006ee2015-06-04 05:59:23 +0000471 uint8_t Other = Symbol.getOther() | Visibility;
Rafael Espindola5f2d6a52010-10-06 21:02:29 +0000472
Duncan P. N. Exon Smith469f9db2015-05-20 04:39:01 +0000473 uint64_t Value = SymbolValue(*MSD.Symbol, Layout);
Matt Fleming6c1ad482010-08-16 18:57:57 +0000474 uint64_t Size = 0;
Matt Fleming6c1ad482010-08-16 18:57:57 +0000475
Rafael Espindola7c23cba2015-05-29 17:24:52 +0000476 const MCExpr *ESize = MSD.Symbol->getSize();
Rafael Espindolaa041ef12014-03-27 00:28:24 +0000477 if (!ESize && Base)
Rafael Espindola7c23cba2015-05-29 17:24:52 +0000478 ESize = Base->getSize();
Rafael Espindolaf0591c12010-09-21 00:24:38 +0000479
Rafael Espindola73c0ae72010-12-22 16:03:00 +0000480 if (ESize) {
481 int64_t Res;
Rafael Espindola94a88d72015-04-06 15:27:57 +0000482 if (!ESize->evaluateKnownAbsolute(Res, Layout))
Rafael Espindola73c0ae72010-12-22 16:03:00 +0000483 report_fatal_error("Size expression must be absolute.");
484 Size = Res;
Matt Fleming6c1ad482010-08-16 18:57:57 +0000485 }
486
487 // Write out the symbol table entry
Rafael Espindolae48421f2015-05-28 20:25:29 +0000488 Writer.writeSymbol(StringIndex, Info, Value, Size, Other, MSD.SectionIndex,
489 IsReserved);
Matt Fleming6c1ad482010-08-16 18:57:57 +0000490}
491
Rafael Espindola5904e122014-03-29 06:26:49 +0000492// It is always valid to create a relocation with a symbol. It is preferable
493// to use a relocation with a section if that is possible. Using the section
494// allows us to omit some local symbols from the symbol table.
Rafael Espindolab60c8292014-04-29 12:46:50 +0000495bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
496 const MCSymbolRefExpr *RefA,
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000497 const MCSymbol *S, uint64_t C,
Rafael Espindola5904e122014-03-29 06:26:49 +0000498 unsigned Type) const {
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000499 const auto *Sym = cast_or_null<MCSymbolELF>(S);
Rafael Espindola5904e122014-03-29 06:26:49 +0000500 // A PCRel relocation to an absolute value has no symbol (or section). We
501 // represent that with a relocation to a null section.
502 if (!RefA)
503 return false;
Rafael Espindola240028d2010-11-14 23:53:26 +0000504
Rafael Espindola5904e122014-03-29 06:26:49 +0000505 MCSymbolRefExpr::VariantKind Kind = RefA->getKind();
506 switch (Kind) {
507 default:
508 break;
509 // The .odp creation emits a relocation against the symbol ".TOC." which
510 // create a R_PPC64_TOC relocation. However the relocation symbol name
511 // in final object creation should be NULL, since the symbol does not
512 // really exist, it is just the reference to TOC base for the current
513 // object file. Since the symbol is undefined, returning false results
514 // in a relocation with a null section which is the desired result.
515 case MCSymbolRefExpr::VK_PPC_TOCBASE:
516 return false;
517
518 // These VariantKind cause the relocation to refer to something other than
519 // the symbol itself, like a linker generated table. Since the address of
520 // symbol is not relevant, we cannot replace the symbol with the
521 // section and patch the difference in the addend.
522 case MCSymbolRefExpr::VK_GOT:
523 case MCSymbolRefExpr::VK_PLT:
524 case MCSymbolRefExpr::VK_GOTPCREL:
525 case MCSymbolRefExpr::VK_Mips_GOT:
526 case MCSymbolRefExpr::VK_PPC_GOT_LO:
527 case MCSymbolRefExpr::VK_PPC_GOT_HI:
528 case MCSymbolRefExpr::VK_PPC_GOT_HA:
529 return true;
Rafael Espindola240028d2010-11-14 23:53:26 +0000530 }
Rafael Espindola240028d2010-11-14 23:53:26 +0000531
Rafael Espindola5904e122014-03-29 06:26:49 +0000532 // An undefined symbol is not in any section, so the relocation has to point
533 // to the symbol itself.
Duncan P. N. Exon Smith469f9db2015-05-20 04:39:01 +0000534 assert(Sym && "Expected a symbol");
535 if (Sym->isUndefined())
Rafael Espindola5904e122014-03-29 06:26:49 +0000536 return true;
537
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000538 unsigned Binding = Sym->getBinding();
Rafael Espindola5904e122014-03-29 06:26:49 +0000539 switch(Binding) {
540 default:
541 llvm_unreachable("Invalid Binding");
542 case ELF::STB_LOCAL:
543 break;
544 case ELF::STB_WEAK:
545 // If the symbol is weak, it might be overridden by a symbol in another
546 // file. The relocation has to point to the symbol so that the linker
547 // can update it.
548 return true;
549 case ELF::STB_GLOBAL:
550 // Global ELF symbols can be preempted by the dynamic linker. The relocation
551 // has to point to the symbol for a reason analogous to the STB_WEAK case.
552 return true;
Rafael Espindola8c3039b2010-11-15 16:33:49 +0000553 }
Rafael Espindola75d65b92010-09-25 05:42:19 +0000554
Rafael Espindola5904e122014-03-29 06:26:49 +0000555 // If a relocation points to a mergeable section, we have to be careful.
556 // If the offset is zero, a relocation with the section will encode the
557 // same information. With a non-zero offset, the situation is different.
558 // For example, a relocation can point 42 bytes past the end of a string.
559 // If we change such a relocation to use the section, the linker would think
560 // that it pointed to another string and subtracting 42 at runtime will
561 // produce the wrong value.
Duncan P. N. Exon Smith469f9db2015-05-20 04:39:01 +0000562 auto &Sec = cast<MCSectionELF>(Sym->getSection());
Rafael Espindola5904e122014-03-29 06:26:49 +0000563 unsigned Flags = Sec.getFlags();
564 if (Flags & ELF::SHF_MERGE) {
565 if (C != 0)
566 return true;
Rafael Espindolab1b49782014-04-02 12:15:20 +0000567
568 // It looks like gold has a bug (http://sourceware.org/PR16794) and can
569 // only handle section relocations to mergeable sections if using RELA.
570 if (!hasRelocationAddend())
571 return true;
Rafael Espindola9f75d5d2010-11-24 21:57:39 +0000572 }
573
Rafael Espindola5904e122014-03-29 06:26:49 +0000574 // Most TLS relocations use a got, so they need the symbol. Even those that
Rafael Espindola11527a12014-10-06 12:33:27 +0000575 // are just an offset (@tpoff), require a symbol in gold versions before
576 // 5efeedf61e4fe720fd3e9a08e6c91c10abb66d42 (2014-09-26) which fixed
577 // http://sourceware.org/PR16773.
Rafael Espindola5904e122014-03-29 06:26:49 +0000578 if (Flags & ELF::SHF_TLS)
579 return true;
Rafael Espindolad7565c32010-10-05 23:57:26 +0000580
Rafael Espindola9ef84412014-04-11 19:18:01 +0000581 // If the symbol is a thumb function the final relocation must set the lowest
582 // bit. With a symbol that is done by just having the symbol have that bit
583 // set, so we would lose the bit if we relocated with the section.
584 // FIXME: We could use the section but add the bit to the relocation value.
Duncan P. N. Exon Smith469f9db2015-05-20 04:39:01 +0000585 if (Asm.isThumbFunc(Sym))
Rafael Espindola9ef84412014-04-11 19:18:01 +0000586 return true;
587
Rafael Espindolaece40ca2015-05-29 18:26:09 +0000588 if (TargetObjectWriter->needsRelocateWithSymbol(*Sym, Type))
Rafael Espindola5904e122014-03-29 06:26:49 +0000589 return true;
590 return false;
Rafael Espindola75d65b92010-09-25 05:42:19 +0000591}
592
Rafael Espindoladb8a5862015-04-17 20:05:17 +0000593// True if the assembler knows nothing about the final value of the symbol.
594// This doesn't cover the comdat issues, since in those cases the assembler
595// can at least know that all symbols in the section will move together.
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000596static bool isWeak(const MCSymbolELF &Sym) {
597 if (Sym.getType() == ELF::STT_GNU_IFUNC)
Rafael Espindolaa635d832015-04-17 08:46:11 +0000598 return true;
599
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000600 switch (Sym.getBinding()) {
Rafael Espindolaa635d832015-04-17 08:46:11 +0000601 default:
602 llvm_unreachable("Unknown binding");
603 case ELF::STB_LOCAL:
604 return false;
605 case ELF::STB_GLOBAL:
Rafael Espindoladb8a5862015-04-17 20:05:17 +0000606 return false;
Rafael Espindolaa635d832015-04-17 08:46:11 +0000607 case ELF::STB_WEAK:
608 case ELF::STB_GNU_UNIQUE:
609 return true;
610 }
Rafael Espindolac9e70682015-03-24 23:48:44 +0000611}
612
Jim Grosbach36e60e92015-06-04 22:24:41 +0000613void ELFObjectWriter::recordRelocation(MCAssembler &Asm,
Jason W Kim495c2bb2010-12-06 21:57:34 +0000614 const MCAsmLayout &Layout,
615 const MCFragment *Fragment,
Rafael Espindola26585542015-01-19 21:11:14 +0000616 const MCFixup &Fixup, MCValue Target,
617 bool &IsPCRel, uint64_t &FixedValue) {
Rafael Espindola7549f872015-05-26 00:36:57 +0000618 const MCSectionELF &FixupSection = cast<MCSectionELF>(*Fragment->getParent());
Rafael Espindola5904e122014-03-29 06:26:49 +0000619 uint64_t C = Target.getConstant();
620 uint64_t FixupOffset = Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
Jason W Kim495c2bb2010-12-06 21:57:34 +0000621
Rafael Espindola5904e122014-03-29 06:26:49 +0000622 if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
623 assert(RefB->getKind() == MCSymbolRefExpr::VK_None &&
624 "Should not have constructed this");
Jason W Kim495c2bb2010-12-06 21:57:34 +0000625
Rafael Espindola5904e122014-03-29 06:26:49 +0000626 // Let A, B and C being the components of Target and R be the location of
627 // the fixup. If the fixup is not pcrel, we want to compute (A - B + C).
628 // If it is pcrel, we want to compute (A - B + C - R).
Jason W Kim495c2bb2010-12-06 21:57:34 +0000629
Rafael Espindola5904e122014-03-29 06:26:49 +0000630 // In general, ELF has no relocations for -B. It can only represent (A + C)
631 // or (A + C - R). If B = R + K and the relocation is not pcrel, we can
632 // replace B to implement it: (A - R - K + C)
633 if (IsPCRel)
Jim Grosbach6f482002015-05-18 18:43:14 +0000634 Asm.getContext().reportFatalError(
Rafael Espindola5904e122014-03-29 06:26:49 +0000635 Fixup.getLoc(),
636 "No relocation available to represent this relative expression");
David Majnemera45a1762014-01-06 07:39:46 +0000637
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000638 const auto &SymB = cast<MCSymbolELF>(RefB->getSymbol());
Jason W Kim495c2bb2010-12-06 21:57:34 +0000639
Rafael Espindola5904e122014-03-29 06:26:49 +0000640 if (SymB.isUndefined())
Jim Grosbach6f482002015-05-18 18:43:14 +0000641 Asm.getContext().reportFatalError(
Rafael Espindola5904e122014-03-29 06:26:49 +0000642 Fixup.getLoc(),
643 Twine("symbol '") + SymB.getName() +
644 "' can not be undefined in a subtraction expression");
Jason W Kim495c2bb2010-12-06 21:57:34 +0000645
Rafael Espindola5904e122014-03-29 06:26:49 +0000646 assert(!SymB.isAbsolute() && "Should have been folded");
647 const MCSection &SecB = SymB.getSection();
Rafael Espindola34948e52015-04-30 00:45:46 +0000648 if (&SecB != &FixupSection)
Jim Grosbach6f482002015-05-18 18:43:14 +0000649 Asm.getContext().reportFatalError(
Rafael Espindola5904e122014-03-29 06:26:49 +0000650 Fixup.getLoc(), "Cannot represent a difference across sections");
Jason W Kim495c2bb2010-12-06 21:57:34 +0000651
Rafael Espindolae3b2acf2015-05-29 18:47:23 +0000652 if (::isWeak(SymB))
Jim Grosbach6f482002015-05-18 18:43:14 +0000653 Asm.getContext().reportFatalError(
Rafael Espindolac9e70682015-03-24 23:48:44 +0000654 Fixup.getLoc(), "Cannot represent a subtraction with a weak symbol");
655
Duncan P. N. Exon Smith2a404832015-05-19 23:53:20 +0000656 uint64_t SymBOffset = Layout.getSymbolOffset(SymB);
Rafael Espindola5904e122014-03-29 06:26:49 +0000657 uint64_t K = SymBOffset - FixupOffset;
658 IsPCRel = true;
659 C -= K;
Jason W Kim495c2bb2010-12-06 21:57:34 +0000660 }
661
Rafael Espindola5904e122014-03-29 06:26:49 +0000662 // We either rejected the fixup or folded B into C at this point.
663 const MCSymbolRefExpr *RefA = Target.getSymA();
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000664 const auto *SymA = RefA ? cast<MCSymbolELF>(&RefA->getSymbol()) : nullptr;
Rafael Espindola5904e122014-03-29 06:26:49 +0000665
Rafael Espindola212fdde2015-06-03 21:52:06 +0000666 bool ViaWeakRef = false;
667 if (SymA && SymA->isVariable()) {
668 const MCExpr *Expr = SymA->getVariableValue();
669 if (const auto *Inner = dyn_cast<MCSymbolRefExpr>(Expr)) {
670 if (Inner->getKind() == MCSymbolRefExpr::VK_WEAKREF) {
671 SymA = cast<MCSymbolELF>(&Inner->getSymbol());
672 ViaWeakRef = true;
673 }
674 }
675 }
676
Rafael Espindolac03f44c2014-03-27 20:49:35 +0000677 unsigned Type = GetRelocType(Target, Fixup, IsPCRel);
Duncan P. N. Exon Smith469f9db2015-05-20 04:39:01 +0000678 bool RelocateWithSymbol = shouldRelocateWithSymbol(Asm, RefA, SymA, C, Type);
Rafael Espindola5904e122014-03-29 06:26:49 +0000679 if (!RelocateWithSymbol && SymA && !SymA->isUndefined())
Duncan P. N. Exon Smith2a404832015-05-19 23:53:20 +0000680 C += Layout.getSymbolOffset(*SymA);
Rafael Espindola5904e122014-03-29 06:26:49 +0000681
682 uint64_t Addend = 0;
683 if (hasRelocationAddend()) {
684 Addend = C;
685 C = 0;
686 }
687
688 FixedValue = C;
689
Rafael Espindola5904e122014-03-29 06:26:49 +0000690 if (!RelocateWithSymbol) {
691 const MCSection *SecA =
692 (SymA && !SymA->isUndefined()) ? &SymA->getSection() : nullptr;
Rafael Espindolab6613022014-10-17 01:48:58 +0000693 auto *ELFSec = cast_or_null<MCSectionELF>(SecA);
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000694 const auto *SectionSymbol =
695 ELFSec ? cast<MCSymbolELF>(ELFSec->getBeginSymbol()) : nullptr;
Rafael Espindolaa401eee2015-06-04 15:33:30 +0000696 if (SectionSymbol)
697 SectionSymbol->setUsedInReloc();
Rafael Espindolab6613022014-10-17 01:48:58 +0000698 ELFRelocationEntry Rec(FixupOffset, SectionSymbol, Type, Addend);
Rafael Espindola34948e52015-04-30 00:45:46 +0000699 Relocations[&FixupSection].push_back(Rec);
Rafael Espindola5904e122014-03-29 06:26:49 +0000700 return;
701 }
Roman Divackydfbecd12011-08-04 19:08:19 +0000702
Rafael Espindola5904e122014-03-29 06:26:49 +0000703 if (SymA) {
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000704 if (const MCSymbolELF *R = Renames.lookup(SymA))
Rafael Espindola5904e122014-03-29 06:26:49 +0000705 SymA = R;
Rafael Espindolad7facaf2011-08-04 13:05:26 +0000706
Rafael Espindola212fdde2015-06-03 21:52:06 +0000707 if (ViaWeakRef)
708 SymA->setIsWeakrefUsedInReloc();
Rafael Espindola5904e122014-03-29 06:26:49 +0000709 else
Rafael Espindolaada43f62015-06-03 21:30:10 +0000710 SymA->setUsedInReloc();
Rafael Espindola5904e122014-03-29 06:26:49 +0000711 }
712 ELFRelocationEntry Rec(FixupOffset, SymA, Type, Addend);
Rafael Espindola34948e52015-04-30 00:45:46 +0000713 Relocations[&FixupSection].push_back(Rec);
Rafael Espindola5904e122014-03-29 06:26:49 +0000714 return;
Jason W Kim495c2bb2010-12-06 21:57:34 +0000715}
716
Rafael Espindola3b5ee552014-04-28 13:39:57 +0000717bool ELFObjectWriter::isInSymtab(const MCAsmLayout &Layout,
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000718 const MCSymbolELF &Symbol, bool Used,
Rafael Espindola3b5ee552014-04-28 13:39:57 +0000719 bool Renamed) {
Rafael Espindola7fadc0e2014-03-20 02:12:01 +0000720 if (Symbol.isVariable()) {
721 const MCExpr *Expr = Symbol.getVariableValue();
722 if (const MCSymbolRefExpr *Ref = dyn_cast<MCSymbolRefExpr>(Expr)) {
723 if (Ref->getKind() == MCSymbolRefExpr::VK_WEAKREF)
724 return false;
725 }
726 }
Rafael Espindola16145972010-11-01 14:28:48 +0000727
Rafael Espindolaee8d1512010-10-19 19:31:37 +0000728 if (Used)
729 return true;
730
Rafael Espindolaeb0c2c12010-10-27 15:18:17 +0000731 if (Renamed)
732 return false;
733
Rafael Espindolaef1e8632015-06-03 21:23:21 +0000734 if (Symbol.isVariable() && Symbol.isUndefined()) {
735 // FIXME: this is here just to diagnose the case of a var = commmon_sym.
736 Layout.getBaseSymbol(Symbol);
737 return false;
Rafael Espindola3b5ee552014-04-28 13:39:57 +0000738 }
Rafael Espindola9e18e962011-02-23 20:22:07 +0000739
Rafael Espindolaef1e8632015-06-03 21:23:21 +0000740 if (Symbol.isUndefined() && !Symbol.isBindingSet())
Rafael Espindolaa5efd6a2010-10-27 14:44:52 +0000741 return false;
742
Rafael Espindolaee8d1512010-10-19 19:31:37 +0000743 if (Symbol.isTemporary())
Rafael Espindolab1d07892010-10-05 18:01:23 +0000744 return false;
745
Rafael Espindolaa401eee2015-06-04 15:33:30 +0000746 if (Symbol.getType() == ELF::STT_SECTION)
747 return false;
748
Rafael Espindolab1d07892010-10-05 18:01:23 +0000749 return true;
750}
751
Rafael Espindolaea1b3942015-04-07 19:00:17 +0000752void ELFObjectWriter::computeSymbolTable(
753 MCAssembler &Asm, const MCAsmLayout &Layout,
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000754 const SectionIndexMapTy &SectionIndexMap, const RevGroupMapTy &RevGroupMap,
755 SectionOffsetsTy &SectionOffsets) {
Rafael Espindola5960cee2015-05-22 23:58:30 +0000756 MCContext &Ctx = Asm.getContext();
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000757 SymbolTableWriter Writer(*this, is64Bit());
758
Rafael Espindola5960cee2015-05-22 23:58:30 +0000759 // Symbol table
760 unsigned EntrySize = is64Bit() ? ELF::SYMENTRY_SIZE64 : ELF::SYMENTRY_SIZE32;
761 MCSectionELF *SymtabSection =
762 Ctx.getELFSection(".symtab", ELF::SHT_SYMTAB, 0, EntrySize, "");
763 SymtabSection->setAlignment(is64Bit() ? 8 : 4);
764 SymbolTableIndex = addToSectionTable(SymtabSection);
765
Rafael Espindolab20fbb82015-06-05 18:21:00 +0000766 align(SymtabSection->getAlignment());
David Majnemerabdb2d2a2015-09-01 16:19:03 +0000767 uint64_t SecStart = getStream().tell();
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000768
769 // The first entry is the undefined symbol entry.
770 Writer.writeSymbol(0, 0, 0, 0, 0, 0, false);
771
Rafael Espindolacfbd35c2015-05-28 20:11:34 +0000772 std::vector<ELFSymbolData> LocalSymbolData;
773 std::vector<ELFSymbolData> ExternalSymbolData;
Rafael Espindolacfbd35c2015-05-28 20:11:34 +0000774
Rafael Espindolabee6e9f2010-10-14 16:34:44 +0000775 // Add the data for the symbols.
Rafael Espindola5960cee2015-05-22 23:58:30 +0000776 bool HasLargeSectionIndex = false;
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000777 for (const MCSymbol &S : Asm.symbols()) {
778 const auto &Symbol = cast<MCSymbolELF>(S);
Rafael Espindolaada43f62015-06-03 21:30:10 +0000779 bool Used = Symbol.isUsedInReloc();
Rafael Espindola212fdde2015-06-03 21:52:06 +0000780 bool WeakrefUsed = Symbol.isWeakrefUsedInReloc();
Rafael Espindola8c52a9b2015-06-03 21:41:59 +0000781 bool isSignature = Symbol.isSignature();
Rafael Espindola7d0ba342010-11-14 04:17:37 +0000782
Duncan P. N. Exon Smith469f9db2015-05-20 04:39:01 +0000783 if (!isInSymtab(Layout, Symbol, Used || WeakrefUsed || isSignature,
Rafael Espindolaeb0c2c12010-10-27 15:18:17 +0000784 Renames.count(&Symbol)))
Matt Fleming6c1ad482010-08-16 18:57:57 +0000785 continue;
786
Rafael Espindola6dff8142015-06-25 20:10:45 +0000787 if (Symbol.isTemporary() && Symbol.isUndefined())
788 Ctx.reportFatalError(SMLoc(), "Undefined temporary");
789
Matt Fleming6c1ad482010-08-16 18:57:57 +0000790 ELFSymbolData MSD;
Rafael Espindolaa8695762015-06-02 00:25:12 +0000791 MSD.Symbol = cast<MCSymbolELF>(&Symbol);
Matt Fleming6c1ad482010-08-16 18:57:57 +0000792
Rafael Espindola8c52a9b2015-06-03 21:41:59 +0000793 bool Local = Symbol.getBinding() == ELF::STB_LOCAL;
Rafael Espindola6dff8142015-06-25 20:10:45 +0000794 assert(Local || !Symbol.isTemporary());
795
Rafael Espindolaf4b44302015-05-29 15:07:27 +0000796 if (Symbol.isAbsolute()) {
Rafael Espindola022bb762014-03-24 03:43:21 +0000797 MSD.SectionIndex = ELF::SHN_ABS;
Rafael Espindola14672502015-05-29 17:48:04 +0000798 } else if (Symbol.isCommon()) {
Rafael Espindolabee6e9f2010-10-14 16:34:44 +0000799 assert(!Local);
Rafael Espindolaf0591c12010-09-21 00:24:38 +0000800 MSD.SectionIndex = ELF::SHN_COMMON;
Rafael Espindolaf4b44302015-05-29 15:07:27 +0000801 } else if (Symbol.isUndefined()) {
Rafael Espindola5960cee2015-05-22 23:58:30 +0000802 if (isSignature && !Used) {
Rafael Espindola89feff32015-04-28 22:59:58 +0000803 MSD.SectionIndex = RevGroupMap.lookup(&Symbol);
Rafael Espindola5960cee2015-05-22 23:58:30 +0000804 if (MSD.SectionIndex >= ELF::SHN_LORESERVE)
805 HasLargeSectionIndex = true;
806 } else {
Rafael Espindola7d0ba342010-11-14 04:17:37 +0000807 MSD.SectionIndex = ELF::SHN_UNDEF;
Rafael Espindola5960cee2015-05-22 23:58:30 +0000808 }
Matt Fleming6c1ad482010-08-16 18:57:57 +0000809 } else {
Rafael Espindolad6340032010-11-10 21:51:05 +0000810 const MCSectionELF &Section =
Rafael Espindolaf4b44302015-05-29 15:07:27 +0000811 static_cast<const MCSectionELF &>(Symbol.getSection());
Rafael Espindolad6340032010-11-10 21:51:05 +0000812 MSD.SectionIndex = SectionIndexMap.lookup(&Section);
Matt Fleming6c1ad482010-08-16 18:57:57 +0000813 assert(MSD.SectionIndex && "Invalid section index!");
Rafael Espindola5960cee2015-05-22 23:58:30 +0000814 if (MSD.SectionIndex >= ELF::SHN_LORESERVE)
815 HasLargeSectionIndex = true;
Rafael Espindolafbcf0db2010-10-15 15:39:06 +0000816 }
817
Rafael Espindola5a67ed12015-01-22 14:20:45 +0000818 // The @@@ in symbol version is replaced with @ in undefined symbols and @@
819 // in defined ones.
820 //
821 // FIXME: All name handling should be done before we get to the writer,
NAKAMURA Takumib01d86b2015-02-25 11:02:00 +0000822 // including dealing with GNU-style version suffixes. Fixing this isn't
Rafael Espindola5a67ed12015-01-22 14:20:45 +0000823 // trivial.
824 //
825 // We thus have to be careful to not perform the symbol version replacement
826 // blindly:
827 //
828 // The ELF format is used on Windows by the MCJIT engine. Thus, on
829 // Windows, the ELFObjectWriter can encounter symbols mangled using the MS
830 // Visual Studio C++ name mangling scheme. Symbols mangled using the MSVC
831 // C++ name mangling can legally have "@@@" as a sub-string. In that case,
832 // the EFLObjectWriter should not interpret the "@@@" sub-string as
833 // specifying GNU-style symbol versioning. The ELFObjectWriter therefore
834 // checks for the MSVC C++ name mangling prefix which is either "?", "@?",
835 // "__imp_?" or "__imp_@?".
836 //
837 // It would have been interesting to perform the MS mangling prefix check
838 // only when the target triple is of the form *-pc-windows-elf. But, it
839 // seems that this information is not easily accessible from the
840 // ELFObjectWriter.
Rafael Espindolaeb0c2c12010-10-27 15:18:17 +0000841 StringRef Name = Symbol.getName();
Evgeniy Stepanov9e0d41a2015-06-22 23:36:03 +0000842 SmallString<32> Buf;
Rafael Espindola5a67ed12015-01-22 14:20:45 +0000843 if (!Name.startswith("?") && !Name.startswith("@?") &&
844 !Name.startswith("__imp_?") && !Name.startswith("__imp_@?")) {
845 // This symbol isn't following the MSVC C++ name mangling convention. We
846 // can thus safely interpret the @@@ in symbol names as specifying symbol
847 // versioning.
Rafael Espindola5a67ed12015-01-22 14:20:45 +0000848 size_t Pos = Name.find("@@@");
849 if (Pos != StringRef::npos) {
850 Buf += Name.substr(0, Pos);
851 unsigned Skip = MSD.SectionIndex == ELF::SHN_UNDEF ? 2 : 1;
852 Buf += Name.substr(Pos + Skip);
Rafael Espindolafc063e82015-10-22 18:32:06 +0000853 Name = VersionSymSaver.save(Buf.c_str());
Rafael Espindola5a67ed12015-01-22 14:20:45 +0000854 }
Rafael Espindolaeb0c2c12010-10-27 15:18:17 +0000855 }
Rafael Espindolab6613022014-10-17 01:48:58 +0000856
857 // Sections have their own string table
Rafael Espindolafc063e82015-10-22 18:32:06 +0000858 if (Symbol.getType() != ELF::STT_SECTION) {
859 MSD.Name = Name;
860 StrTabBuilder.add(Name);
861 }
Rafael Espindolaeb0c2c12010-10-27 15:18:17 +0000862
Rafael Espindola10d23872015-05-29 14:20:40 +0000863 if (Local)
Rafael Espindolaa5efd6a2010-10-27 14:44:52 +0000864 LocalSymbolData.push_back(MSD);
865 else
866 ExternalSymbolData.push_back(MSD);
Matt Fleming6c1ad482010-08-16 18:57:57 +0000867 }
868
Rafael Espindola2cd19512015-07-02 16:59:57 +0000869 // This holds the .symtab_shndx section index.
870 unsigned SymtabShndxSectionIndex = 0;
871
Rafael Espindola5960cee2015-05-22 23:58:30 +0000872 if (HasLargeSectionIndex) {
873 MCSectionELF *SymtabShndxSection =
874 Ctx.getELFSection(".symtab_shndxr", ELF::SHT_SYMTAB_SHNDX, 0, 4, "");
875 SymtabShndxSectionIndex = addToSectionTable(SymtabShndxSection);
876 SymtabShndxSection->setAlignment(4);
877 }
878
Rafael Espindola1fd36272015-05-28 19:29:15 +0000879 ArrayRef<std::string> FileNames = Asm.getFileNames();
880 for (const std::string &Name : FileNames)
Rafael Espindola66f3c9c2015-05-28 18:03:20 +0000881 StrTabBuilder.add(Name);
Hans Wennborg83e6e1e2014-04-30 16:25:02 +0000882
Rafael Espindola21956e42015-10-23 21:48:05 +0000883 StrTabBuilder.finalize();
Hans Wennborg83e6e1e2014-04-30 16:25:02 +0000884
Rafael Espindola0cbea292015-05-28 20:00:13 +0000885 for (const std::string &Name : FileNames)
886 Writer.writeSymbol(StrTabBuilder.getOffset(Name),
887 ELF::STT_FILE | ELF::STB_LOCAL, 0, 0, ELF::STV_DEFAULT,
888 ELF::SHN_ABS, true);
889
Matt Fleming6c1ad482010-08-16 18:57:57 +0000890 // Symbols are required to be in lexicographic order.
891 array_pod_sort(LocalSymbolData.begin(), LocalSymbolData.end());
892 array_pod_sort(ExternalSymbolData.begin(), ExternalSymbolData.end());
Matt Fleming6c1ad482010-08-16 18:57:57 +0000893
894 // Set the symbol indices. Local symbols must come before all other
895 // symbols with non-local bindings.
Rafael Espindola1fd36272015-05-28 19:29:15 +0000896 unsigned Index = FileNames.size() + 1;
Rafael Espindola0e3decf2010-11-14 03:12:24 +0000897
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000898 for (ELFSymbolData &MSD : LocalSymbolData) {
Daniel Jasper41de8022015-06-23 11:31:32 +0000899 unsigned StringIndex = MSD.Symbol->getType() == ELF::STT_SECTION
900 ? 0
901 : StrTabBuilder.getOffset(MSD.Name);
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000902 MSD.Symbol->setIndex(Index++);
Rafael Espindolae48421f2015-05-28 20:25:29 +0000903 writeSymbol(Writer, StringIndex, MSD, Layout);
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000904 }
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000905
906 // Write the symbol table entries.
Rafael Espindola0cbea292015-05-28 20:00:13 +0000907 LastLocalSymbolIndex = Index;
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000908
Rafael Espindoladcda9972015-05-28 19:43:20 +0000909 for (ELFSymbolData &MSD : ExternalSymbolData) {
Rafael Espindolae48421f2015-05-28 20:25:29 +0000910 unsigned StringIndex = StrTabBuilder.getOffset(MSD.Name);
Rafael Espindola0cbea292015-05-28 20:00:13 +0000911 MSD.Symbol->setIndex(Index++);
Rafael Espindolae48421f2015-05-28 20:25:29 +0000912 writeSymbol(Writer, StringIndex, MSD, Layout);
Rafael Espindola95fb9b92015-06-02 20:38:46 +0000913 assert(MSD.Symbol->getBinding() != ELF::STB_LOCAL);
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000914 }
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000915
David Majnemerabdb2d2a2015-09-01 16:19:03 +0000916 uint64_t SecEnd = getStream().tell();
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000917 SectionOffsets[SymtabSection] = std::make_pair(SecStart, SecEnd);
918
919 ArrayRef<uint32_t> ShndxIndexes = Writer.getShndxIndexes();
920 if (ShndxIndexes.empty()) {
921 assert(SymtabShndxSectionIndex == 0);
922 return;
923 }
924 assert(SymtabShndxSectionIndex != 0);
925
David Majnemerabdb2d2a2015-09-01 16:19:03 +0000926 SecStart = getStream().tell();
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000927 const MCSectionELF *SymtabShndxSection =
928 SectionTable[SymtabShndxSectionIndex - 1];
929 for (uint32_t Index : ShndxIndexes)
930 write(Index);
David Majnemerabdb2d2a2015-09-01 16:19:03 +0000931 SecEnd = getStream().tell();
Rafael Espindolaaa486e92015-05-28 17:54:01 +0000932 SectionOffsets[SymtabShndxSection] = std::make_pair(SecStart, SecEnd);
Matt Fleming6c1ad482010-08-16 18:57:57 +0000933}
934
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000935MCSectionELF *
Rafael Espindola0a82ad72015-05-21 20:43:13 +0000936ELFObjectWriter::createRelocationSection(MCContext &Ctx,
Rafael Espindolabda19802015-04-30 14:21:49 +0000937 const MCSectionELF &Sec) {
Rafael Espindola34948e52015-04-30 00:45:46 +0000938 if (Relocations[&Sec].empty())
Rafael Espindolabda19802015-04-30 14:21:49 +0000939 return nullptr;
Rafael Espindola1557fd62011-03-20 18:44:20 +0000940
Rafael Espindola34948e52015-04-30 00:45:46 +0000941 const StringRef SectionName = Sec.getSectionName();
Rafael Espindolaead85492015-02-17 20:31:13 +0000942 std::string RelaSectionName = hasRelocationAddend() ? ".rela" : ".rel";
943 RelaSectionName += SectionName;
Benjamin Kramerfd054152010-08-17 17:56:13 +0000944
Rafael Espindolaead85492015-02-17 20:31:13 +0000945 unsigned EntrySize;
946 if (hasRelocationAddend())
947 EntrySize = is64Bit() ? sizeof(ELF::Elf64_Rela) : sizeof(ELF::Elf32_Rela);
948 else
949 EntrySize = is64Bit() ? sizeof(ELF::Elf64_Rel) : sizeof(ELF::Elf32_Rel);
Matt Fleming6c1ad482010-08-16 18:57:57 +0000950
Rafael Espindolaead85492015-02-17 20:31:13 +0000951 unsigned Flags = 0;
Rafael Espindola34948e52015-04-30 00:45:46 +0000952 if (Sec.getFlags() & ELF::SHF_GROUP)
Rafael Espindolaead85492015-02-17 20:31:13 +0000953 Flags = ELF::SHF_GROUP;
Rafael Espindolaead85492015-02-17 20:31:13 +0000954
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000955 MCSectionELF *RelaSection = Ctx.createELFRelSection(
Rafael Espindolaead85492015-02-17 20:31:13 +0000956 RelaSectionName, hasRelocationAddend() ? ELF::SHT_RELA : ELF::SHT_REL,
Rafael Espindola34948e52015-04-30 00:45:46 +0000957 Flags, EntrySize, Sec.getGroup(), &Sec);
Rafael Espindola0a82ad72015-05-21 20:43:13 +0000958 RelaSection->setAlignment(is64Bit() ? 8 : 4);
Rafael Espindolabda19802015-04-30 14:21:49 +0000959 return RelaSection;
Rafael Espindola1557fd62011-03-20 18:44:20 +0000960}
Matt Fleming6c1ad482010-08-16 18:57:57 +0000961
David Blaikie8019bf82014-04-10 21:53:53 +0000962// Include the debug info compression header:
963// "ZLIB" followed by 8 bytes representing the uncompressed size of the section,
964// useful for consumers to preallocate a buffer to decompress into.
David Blaikie76d3a3c2014-04-18 21:52:26 +0000965static bool
David Blaikiee06e8012014-04-11 22:11:50 +0000966prependCompressionHeader(uint64_t Size,
967 SmallVectorImpl<char> &CompressedContents) {
Benjamin Kramer7149aab2015-03-01 18:09:56 +0000968 const StringRef Magic = "ZLIB";
David Blaikie76d3a3c2014-04-18 21:52:26 +0000969 if (Size <= Magic.size() + sizeof(Size) + CompressedContents.size())
970 return false;
David Blaikie8019bf82014-04-10 21:53:53 +0000971 if (sys::IsLittleEndianHost)
Artyom Skrobov9aea8432014-06-14 13:18:07 +0000972 sys::swapByteOrder(Size);
David Blaikie8019bf82014-04-10 21:53:53 +0000973 CompressedContents.insert(CompressedContents.begin(),
974 Magic.size() + sizeof(Size), 0);
975 std::copy(Magic.begin(), Magic.end(), CompressedContents.begin());
976 std::copy(reinterpret_cast<char *>(&Size),
977 reinterpret_cast<char *>(&Size + 1),
978 CompressedContents.begin() + Magic.size());
David Blaikie76d3a3c2014-04-18 21:52:26 +0000979 return true;
David Blaikie8019bf82014-04-10 21:53:53 +0000980}
981
Rafael Espindolae15b1b72015-05-27 13:30:50 +0000982void ELFObjectWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec,
Rafael Espindola868b3f42015-04-30 21:51:58 +0000983 const MCAsmLayout &Layout) {
Rafael Espindolae15b1b72015-05-27 13:30:50 +0000984 MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
Rafael Espindola868b3f42015-04-30 21:51:58 +0000985 StringRef SectionName = Section.getSectionName();
David Blaikie8019bf82014-04-10 21:53:53 +0000986
Rafael Espindola868b3f42015-04-30 21:51:58 +0000987 // Compressing debug_frame requires handling alignment fragments which is
988 // more work (possibly generalizing MCAssembler.cpp:writeFragment to allow
989 // for writing to arbitrary buffers) for little benefit.
990 if (!Asm.getContext().getAsmInfo()->compressDebugSections() ||
991 !SectionName.startswith(".debug_") || SectionName == ".debug_frame") {
Rafael Espindola64acc7f2015-05-26 02:17:21 +0000992 Asm.writeSectionData(&Section, Layout);
Rafael Espindola868b3f42015-04-30 21:51:58 +0000993 return;
994 }
995
David Majnemerabdb2d2a2015-09-01 16:19:03 +0000996 SmallVector<char, 128> UncompressedData;
997 raw_svector_ostream VecOS(UncompressedData);
998 raw_pwrite_stream &OldStream = getStream();
999 setStream(VecOS);
1000 Asm.writeSectionData(&Section, Layout);
1001 setStream(OldStream);
David Blaikie8019bf82014-04-10 21:53:53 +00001002
Rafael Espindola868b3f42015-04-30 21:51:58 +00001003 SmallVector<char, 128> CompressedContents;
David Blaikie8019bf82014-04-10 21:53:53 +00001004 zlib::Status Success = zlib::compress(
1005 StringRef(UncompressedData.data(), UncompressedData.size()),
1006 CompressedContents);
Rafael Espindola868b3f42015-04-30 21:51:58 +00001007 if (Success != zlib::StatusOK) {
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001008 getStream() << UncompressedData;
David Blaikie8019bf82014-04-10 21:53:53 +00001009 return;
Rafael Espindola868b3f42015-04-30 21:51:58 +00001010 }
David Blaikie8019bf82014-04-10 21:53:53 +00001011
Rafael Espindola868b3f42015-04-30 21:51:58 +00001012 if (!prependCompressionHeader(UncompressedData.size(), CompressedContents)) {
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001013 getStream() << UncompressedData;
Rafael Espindola868b3f42015-04-30 21:51:58 +00001014 return;
1015 }
David Blaikie8019bf82014-04-10 21:53:53 +00001016 Asm.getContext().renameELFSection(&Section,
1017 (".z" + SectionName.drop_front(1)).str());
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001018 getStream() << CompressedContents;
David Blaikie8019bf82014-04-10 21:53:53 +00001019}
1020
Daniel Dunbarfe0c28f2010-11-13 07:33:40 +00001021void ELFObjectWriter::WriteSecHdrEntry(uint32_t Name, uint32_t Type,
1022 uint64_t Flags, uint64_t Address,
1023 uint64_t Offset, uint64_t Size,
1024 uint32_t Link, uint32_t Info,
1025 uint64_t Alignment,
1026 uint64_t EntrySize) {
Jim Grosbach36e60e92015-06-04 22:24:41 +00001027 write32(Name); // sh_name: index into string table
1028 write32(Type); // sh_type
Matt Fleming6c1ad482010-08-16 18:57:57 +00001029 WriteWord(Flags); // sh_flags
1030 WriteWord(Address); // sh_addr
1031 WriteWord(Offset); // sh_offset
1032 WriteWord(Size); // sh_size
Jim Grosbach36e60e92015-06-04 22:24:41 +00001033 write32(Link); // sh_link
1034 write32(Info); // sh_info
Matt Fleming6c1ad482010-08-16 18:57:57 +00001035 WriteWord(Alignment); // sh_addralign
1036 WriteWord(EntrySize); // sh_entsize
1037}
1038
Rafael Espindolab8cbb262015-04-30 00:30:40 +00001039void ELFObjectWriter::writeRelocations(const MCAssembler &Asm,
Rafael Espindola34948e52015-04-30 00:45:46 +00001040 const MCSectionELF &Sec) {
1041 std::vector<ELFRelocationEntry> &Relocs = Relocations[&Sec];
Akira Hatanaka64ad2cf2012-03-23 23:06:45 +00001042
Petar Jovanovic0380d0b2015-04-14 13:23:34 +00001043 // Sort the relocation entries. Most targets just sort by Offset, but some
1044 // (e.g., MIPS) have additional constraints.
1045 TargetObjectWriter->sortRelocs(Asm, Relocs);
Matt Fleming6c1ad482010-08-16 18:57:57 +00001046
1047 for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
Rafael Espindola5904e122014-03-29 06:26:49 +00001048 const ELFRelocationEntry &Entry = Relocs[e - i - 1];
Rafael Espindola5e9ed902015-05-28 20:53:09 +00001049 unsigned Index = Entry.Symbol ? Entry.Symbol->getIndex() : 0;
Rafael Espindola5904e122014-03-29 06:26:49 +00001050
Rafael Espindolafdaae0d2010-12-18 03:27:34 +00001051 if (is64Bit()) {
Rafael Espindolab8cbb262015-04-30 00:30:40 +00001052 write(Entry.Offset);
Jack Carter8ad0c272012-06-27 22:28:30 +00001053 if (TargetObjectWriter->isN64()) {
Rafael Espindolab8cbb262015-04-30 00:30:40 +00001054 write(uint32_t(Index));
Benjamin Kramer6c3c3492010-09-09 18:01:29 +00001055
Rafael Espindolab8cbb262015-04-30 00:30:40 +00001056 write(TargetObjectWriter->getRSsym(Entry.Type));
1057 write(TargetObjectWriter->getRType3(Entry.Type));
1058 write(TargetObjectWriter->getRType2(Entry.Type));
1059 write(TargetObjectWriter->getRType(Entry.Type));
Rafael Espindola5904e122014-03-29 06:26:49 +00001060 } else {
Jack Carter8ad0c272012-06-27 22:28:30 +00001061 struct ELF::Elf64_Rela ERE64;
Rafael Espindola5904e122014-03-29 06:26:49 +00001062 ERE64.setSymbolAndType(Index, Entry.Type);
Rafael Espindolab8cbb262015-04-30 00:30:40 +00001063 write(ERE64.r_info);
Jack Carter8ad0c272012-06-27 22:28:30 +00001064 }
Rafael Espindolafdaae0d2010-12-18 03:27:34 +00001065 if (hasRelocationAddend())
Rafael Espindolab8cbb262015-04-30 00:30:40 +00001066 write(Entry.Addend);
Benjamin Kramer6c3c3492010-09-09 18:01:29 +00001067 } else {
Rafael Espindolab8cbb262015-04-30 00:30:40 +00001068 write(uint32_t(Entry.Offset));
Benjamin Kramer6c3c3492010-09-09 18:01:29 +00001069
Rafael Espindolabce26a12010-10-05 15:11:03 +00001070 struct ELF::Elf32_Rela ERE32;
Rafael Espindola5904e122014-03-29 06:26:49 +00001071 ERE32.setSymbolAndType(Index, Entry.Type);
Rafael Espindolab8cbb262015-04-30 00:30:40 +00001072 write(ERE32.r_info);
Benjamin Kramer6c3c3492010-09-09 18:01:29 +00001073
Rafael Espindolafdaae0d2010-12-18 03:27:34 +00001074 if (hasRelocationAddend())
Rafael Espindolab8cbb262015-04-30 00:30:40 +00001075 write(uint32_t(Entry.Addend));
Benjamin Kramer6c3c3492010-09-09 18:01:29 +00001076 }
Matt Fleming6c1ad482010-08-16 18:57:57 +00001077 }
1078}
1079
Rafael Espindolab1863912015-04-30 21:10:06 +00001080const MCSectionELF *ELFObjectWriter::createStringTable(MCContext &Ctx) {
Rafael Espindola08850b32015-05-25 21:56:55 +00001081 const MCSectionELF *StrtabSection = SectionTable[StringTableIndex - 1];
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001082 getStream() << StrTabBuilder.data();
Rafael Espindolabda19802015-04-30 14:21:49 +00001083 return StrtabSection;
Rafael Espindolaa3e9a222010-11-11 18:13:52 +00001084}
1085
Rafael Espindolae92c1bf2015-05-21 19:42:35 +00001086void ELFObjectWriter::writeSection(const SectionIndexMapTy &SectionIndexMap,
1087 uint32_t GroupSymbolIndex, uint64_t Offset,
1088 uint64_t Size, const MCSectionELF &Section) {
Rafael Espindola5a8d7812010-11-10 23:36:59 +00001089 uint64_t sh_link = 0;
1090 uint64_t sh_info = 0;
1091
1092 switch(Section.getType()) {
Rafael Espindola86fe2fe2015-04-06 03:16:51 +00001093 default:
1094 // Nothing to do.
1095 break;
1096
Rafael Espindola5a8d7812010-11-10 23:36:59 +00001097 case ELF::SHT_DYNAMIC:
Rafael Espindola74ef4802015-04-30 21:20:06 +00001098 llvm_unreachable("SHT_DYNAMIC in a relocatable object");
Rafael Espindola5a8d7812010-11-10 23:36:59 +00001099
1100 case ELF::SHT_REL:
1101 case ELF::SHT_RELA: {
Rafael Espindola3a7c0eb2015-02-17 20:37:50 +00001102 sh_link = SymbolTableIndex;
Rafael Espindola5a8d7812010-11-10 23:36:59 +00001103 assert(sh_link && ".symtab not found");
Rafael Espindolab73b70e2015-04-06 03:09:30 +00001104 const MCSectionELF *InfoSection = Section.getAssociatedSection();
Rafael Espindola5a8d7812010-11-10 23:36:59 +00001105 sh_info = SectionIndexMap.lookup(InfoSection);
1106 break;
1107 }
1108
1109 case ELF::SHT_SYMTAB:
1110 case ELF::SHT_DYNSYM:
1111 sh_link = StringTableIndex;
1112 sh_info = LastLocalSymbolIndex;
1113 break;
1114
1115 case ELF::SHT_SYMTAB_SHNDX:
1116 sh_link = SymbolTableIndex;
1117 break;
1118
Nick Lewyckyc6ac5f72011-10-07 23:28:32 +00001119 case ELF::SHT_GROUP:
Rafael Espindolaa3e9a222010-11-11 18:13:52 +00001120 sh_link = SymbolTableIndex;
1121 sh_info = GroupSymbolIndex;
1122 break;
Rafael Espindola5a8d7812010-11-10 23:36:59 +00001123 }
1124
Logan Chien4b724422013-02-05 14:18:59 +00001125 if (TargetObjectWriter->getEMachine() == ELF::EM_ARM &&
Rafael Espindola61e8ce32015-04-06 04:25:18 +00001126 Section.getType() == ELF::SHT_ARM_EXIDX)
1127 sh_link = SectionIndexMap.lookup(Section.getAssociatedSection());
Logan Chien4b724422013-02-05 14:18:59 +00001128
Rafael Espindola5960cee2015-05-22 23:58:30 +00001129 WriteSecHdrEntry(StrTabBuilder.getOffset(Section.getSectionName()),
Rafael Espindola28687582015-05-21 19:36:43 +00001130 Section.getType(), Section.getFlags(), 0, Offset, Size,
1131 sh_link, sh_info, Section.getAlignment(),
1132 Section.getEntrySize());
Rafael Espindola5a8d7812010-11-10 23:36:59 +00001133}
1134
Rafael Espindola7fe7e052015-02-17 20:40:59 +00001135void ELFObjectWriter::writeSectionHeader(
Rafael Espindola57c80832015-06-04 20:55:49 +00001136 const MCAsmLayout &Layout, const SectionIndexMapTy &SectionIndexMap,
Rafael Espindolaa8201692015-04-28 15:26:21 +00001137 const SectionOffsetsTy &SectionOffsets) {
Rafael Espindolab1863912015-04-30 21:10:06 +00001138 const unsigned NumSections = SectionTable.size();
Rafael Espindolaa3e9a222010-11-11 18:13:52 +00001139
Matt Fleming6c1ad482010-08-16 18:57:57 +00001140 // Null section first.
Rafael Espindola3fe87a12010-10-31 00:16:26 +00001141 uint64_t FirstSectionSize =
Rafael Espindolabf0db6c2015-04-15 13:07:47 +00001142 (NumSections + 1) >= ELF::SHN_LORESERVE ? NumSections + 1 : 0;
Rafael Espindola88d1f632015-04-29 20:25:24 +00001143 WriteSecHdrEntry(0, 0, 0, 0, 0, FirstSectionSize, 0, 0, 0, 0);
Matt Fleming6c1ad482010-08-16 18:57:57 +00001144
Rafael Espindola08850b32015-05-25 21:56:55 +00001145 for (const MCSectionELF *Section : SectionTable) {
Rafael Espindolaa3e9a222010-11-11 18:13:52 +00001146 uint32_t GroupSymbolIndex;
Rafael Espindola03d7abb2015-04-30 20:53:27 +00001147 unsigned Type = Section->getType();
1148 if (Type != ELF::SHT_GROUP)
Rafael Espindolaa3e9a222010-11-11 18:13:52 +00001149 GroupSymbolIndex = 0;
1150 else
Rafael Espindola5e9ed902015-05-28 20:53:09 +00001151 GroupSymbolIndex = Section->getGroup()->getIndex();
Matt Fleming6c1ad482010-08-16 18:57:57 +00001152
Rafael Espindolabda19802015-04-30 14:21:49 +00001153 const std::pair<uint64_t, uint64_t> &Offsets =
Rafael Espindola03d7abb2015-04-30 20:53:27 +00001154 SectionOffsets.find(Section)->second;
Rafael Espindola1aa20fc2015-05-21 19:46:39 +00001155 uint64_t Size;
Rafael Espindola5a1e80b2015-05-26 02:00:36 +00001156 if (Type == ELF::SHT_NOBITS)
1157 Size = Layout.getSectionAddressSize(Section);
1158 else
Rafael Espindola1aa20fc2015-05-21 19:46:39 +00001159 Size = Offsets.second - Offsets.first;
Rafael Espindola60ebca92010-12-02 03:09:06 +00001160
Rafael Espindolae92c1bf2015-05-21 19:42:35 +00001161 writeSection(SectionIndexMap, GroupSymbolIndex, Offsets.first, Size,
Rafael Espindola28687582015-05-21 19:36:43 +00001162 *Section);
Matt Fleming6c1ad482010-08-16 18:57:57 +00001163 }
1164}
1165
Jim Grosbach36e60e92015-06-04 22:24:41 +00001166void ELFObjectWriter::writeObject(MCAssembler &Asm,
Rafael Espindola1557fd62011-03-20 18:44:20 +00001167 const MCAsmLayout &Layout) {
Rafael Espindolabda19802015-04-30 14:21:49 +00001168 MCContext &Ctx = Asm.getContext();
Rafael Espindola5960cee2015-05-22 23:58:30 +00001169 MCSectionELF *StrtabSection =
1170 Ctx.getELFSection(".strtab", ELF::SHT_STRTAB, 0);
1171 StringTableIndex = addToSectionTable(StrtabSection);
Rafael Espindolabda19802015-04-30 14:21:49 +00001172
Rafael Espindola1557fd62011-03-20 18:44:20 +00001173 RevGroupMapTy RevGroupMap;
1174 SectionIndexMapTy SectionIndexMap;
1175
Rafael Espindolabda19802015-04-30 14:21:49 +00001176 std::map<const MCSymbol *, std::vector<const MCSectionELF *>> GroupMembers;
Rafael Espindola1557fd62011-03-20 18:44:20 +00001177
Rafael Espindola1557fd62011-03-20 18:44:20 +00001178 // Write out the ELF header ...
Rafael Espindola8c7829b2015-04-29 20:39:37 +00001179 writeHeader(Asm);
Rafael Espindola1557fd62011-03-20 18:44:20 +00001180
Rafael Espindola7230f802015-04-08 11:41:24 +00001181 // ... then the sections ...
Rafael Espindolabda19802015-04-30 14:21:49 +00001182 SectionOffsetsTy SectionOffsets;
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001183 std::vector<MCSectionELF *> Groups;
1184 std::vector<MCSectionELF *> Relocations;
Rafael Espindolae15b1b72015-05-27 13:30:50 +00001185 for (MCSection &Sec : Asm) {
1186 MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
Rafael Espindolabda19802015-04-30 14:21:49 +00001187
Rafael Espindolab20fbb82015-06-05 18:21:00 +00001188 align(Section.getAlignment());
Rafael Espindola1557fd62011-03-20 18:44:20 +00001189
Rafael Espindola642a2212015-04-14 22:54:16 +00001190 // Remember the offset into the file for this section.
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001191 uint64_t SecStart = getStream().tell();
Rafael Espindolab8cbb262015-04-30 00:30:40 +00001192
Rafael Espindola0ccf9b72015-06-02 21:30:13 +00001193 const MCSymbolELF *SignatureSymbol = Section.getGroup();
Rafael Espindolae15b1b72015-05-27 13:30:50 +00001194 writeSectionData(Asm, Section, Layout);
Rafael Espindolab8cbb262015-04-30 00:30:40 +00001195
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001196 uint64_t SecEnd = getStream().tell();
Rafael Espindolabda19802015-04-30 14:21:49 +00001197 SectionOffsets[&Section] = std::make_pair(SecStart, SecEnd);
1198
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001199 MCSectionELF *RelSection = createRelocationSection(Ctx, Section);
Rafael Espindolabda19802015-04-30 14:21:49 +00001200
1201 if (SignatureSymbol) {
Rafael Espindolab5d316b2015-05-29 20:21:02 +00001202 Asm.registerSymbol(*SignatureSymbol);
Rafael Espindolabda19802015-04-30 14:21:49 +00001203 unsigned &GroupIdx = RevGroupMap[SignatureSymbol];
1204 if (!GroupIdx) {
Rafael Espindola0709a7b2015-05-21 19:20:38 +00001205 MCSectionELF *Group = Ctx.createELFGroupSection(SignatureSymbol);
Rafael Espindola03d7abb2015-04-30 20:53:27 +00001206 GroupIdx = addToSectionTable(Group);
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001207 Group->setAlignment(4);
1208 Groups.push_back(Group);
Rafael Espindolabda19802015-04-30 14:21:49 +00001209 }
Rafael Espindola7830fc82015-06-05 17:54:25 +00001210 std::vector<const MCSectionELF *> &Members =
1211 GroupMembers[SignatureSymbol];
1212 Members.push_back(&Section);
Rafael Espindolabda19802015-04-30 14:21:49 +00001213 if (RelSection)
Rafael Espindola7830fc82015-06-05 17:54:25 +00001214 Members.push_back(RelSection);
Rafael Espindolabda19802015-04-30 14:21:49 +00001215 }
1216
Rafael Espindola03d7abb2015-04-30 20:53:27 +00001217 SectionIndexMap[&Section] = addToSectionTable(&Section);
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001218 if (RelSection) {
Rafael Espindola03d7abb2015-04-30 20:53:27 +00001219 SectionIndexMap[RelSection] = addToSectionTable(RelSection);
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001220 Relocations.push_back(RelSection);
1221 }
Rafael Espindolabda19802015-04-30 14:21:49 +00001222 }
1223
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001224 for (MCSectionELF *Group : Groups) {
Rafael Espindolab20fbb82015-06-05 18:21:00 +00001225 align(Group->getAlignment());
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001226
1227 // Remember the offset into the file for this section.
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001228 uint64_t SecStart = getStream().tell();
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001229
1230 const MCSymbol *SignatureSymbol = Group->getGroup();
1231 assert(SignatureSymbol);
1232 write(uint32_t(ELF::GRP_COMDAT));
1233 for (const MCSectionELF *Member : GroupMembers[SignatureSymbol]) {
1234 uint32_t SecIndex = SectionIndexMap.lookup(Member);
1235 write(SecIndex);
1236 }
1237
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001238 uint64_t SecEnd = getStream().tell();
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001239 SectionOffsets[Group] = std::make_pair(SecStart, SecEnd);
1240 }
1241
1242 // Compute symbol table information.
Rafael Espindolaaa486e92015-05-28 17:54:01 +00001243 computeSymbolTable(Asm, Layout, SectionIndexMap, RevGroupMap, SectionOffsets);
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001244
1245 for (MCSectionELF *RelSection : Relocations) {
Rafael Espindolab20fbb82015-06-05 18:21:00 +00001246 align(RelSection->getAlignment());
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001247
1248 // Remember the offset into the file for this section.
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001249 uint64_t SecStart = getStream().tell();
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001250
1251 writeRelocations(Asm, *RelSection->getAssociatedSection());
1252
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001253 uint64_t SecEnd = getStream().tell();
Rafael Espindola0a82ad72015-05-21 20:43:13 +00001254 SectionOffsets[RelSection] = std::make_pair(SecStart, SecEnd);
Rafael Espindola642a2212015-04-14 22:54:16 +00001255 }
1256
Rafael Espindola88d1f632015-04-29 20:25:24 +00001257 {
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001258 uint64_t SecStart = getStream().tell();
Rafael Espindolab1863912015-04-30 21:10:06 +00001259 const MCSectionELF *Sec = createStringTable(Ctx);
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001260 uint64_t SecEnd = getStream().tell();
Rafael Espindolabda19802015-04-30 14:21:49 +00001261 SectionOffsets[Sec] = std::make_pair(SecStart, SecEnd);
Rafael Espindola88abc392015-04-29 20:34:31 +00001262 }
1263
Rafael Espindola642a2212015-04-14 22:54:16 +00001264 uint64_t NaturalAlignment = is64Bit() ? 8 : 4;
Rafael Espindolab20fbb82015-06-05 18:21:00 +00001265 align(NaturalAlignment);
Rafael Espindola1557fd62011-03-20 18:44:20 +00001266
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001267 const unsigned SectionHeaderOffset = getStream().tell();
Rafael Espindola642a2212015-04-14 22:54:16 +00001268
Rafael Espindola1557fd62011-03-20 18:44:20 +00001269 // ... then the section header table ...
Rafael Espindola57c80832015-06-04 20:55:49 +00001270 writeSectionHeader(Layout, SectionIndexMap, SectionOffsets);
Rafael Espindola642a2212015-04-14 22:54:16 +00001271
Rafael Espindola03d7abb2015-04-30 20:53:27 +00001272 uint16_t NumSections = (SectionTable.size() + 1 >= ELF::SHN_LORESERVE)
Aaron Ballman9cab7322015-04-30 14:03:12 +00001273 ? (uint16_t)ELF::SHN_UNDEF
Rafael Espindola03d7abb2015-04-30 20:53:27 +00001274 : SectionTable.size() + 1;
Rafael Espindola8c7829b2015-04-29 20:39:37 +00001275 if (sys::IsLittleEndianHost != IsLittleEndian)
1276 sys::swapByteOrder(NumSections);
1277 unsigned NumSectionsOffset;
1278
Rafael Espindola642a2212015-04-14 22:54:16 +00001279 if (is64Bit()) {
1280 uint64_t Val = SectionHeaderOffset;
1281 if (sys::IsLittleEndianHost != IsLittleEndian)
1282 sys::swapByteOrder(Val);
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001283 getStream().pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
1284 offsetof(ELF::Elf64_Ehdr, e_shoff));
Rafael Espindola8c7829b2015-04-29 20:39:37 +00001285 NumSectionsOffset = offsetof(ELF::Elf64_Ehdr, e_shnum);
Rafael Espindola642a2212015-04-14 22:54:16 +00001286 } else {
1287 uint32_t Val = SectionHeaderOffset;
1288 if (sys::IsLittleEndianHost != IsLittleEndian)
1289 sys::swapByteOrder(Val);
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001290 getStream().pwrite(reinterpret_cast<char *>(&Val), sizeof(Val),
1291 offsetof(ELF::Elf32_Ehdr, e_shoff));
Rafael Espindola8c7829b2015-04-29 20:39:37 +00001292 NumSectionsOffset = offsetof(ELF::Elf32_Ehdr, e_shnum);
Rafael Espindola642a2212015-04-14 22:54:16 +00001293 }
David Majnemerabdb2d2a2015-09-01 16:19:03 +00001294 getStream().pwrite(reinterpret_cast<char *>(&NumSections),
1295 sizeof(NumSections), NumSectionsOffset);
Rafael Espindola1557fd62011-03-20 18:44:20 +00001296}
1297
Jim Grosbach36e60e92015-06-04 22:24:41 +00001298bool ELFObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
Rafael Espindola95fb9b92015-06-02 20:38:46 +00001299 const MCAssembler &Asm, const MCSymbol &SA, const MCFragment &FB,
Rafael Espindola35d61892015-04-17 21:15:17 +00001300 bool InSet, bool IsPCRel) const {
Rafael Espindola95fb9b92015-06-02 20:38:46 +00001301 const auto &SymA = cast<MCSymbolELF>(SA);
Rafael Espindola35d61892015-04-17 21:15:17 +00001302 if (IsPCRel) {
1303 assert(!InSet);
Rafael Espindolae3b2acf2015-05-29 18:47:23 +00001304 if (::isWeak(SymA))
Rafael Espindola35d61892015-04-17 21:15:17 +00001305 return false;
1306 }
Jim Grosbach36e60e92015-06-04 22:24:41 +00001307 return MCObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(Asm, SymA, FB,
Rafael Espindola35d61892015-04-17 21:15:17 +00001308 InSet, IsPCRel);
Eli Friedmand92d17b2011-03-03 07:24:36 +00001309}
1310
Rafael Espindola95fb9b92015-06-02 20:38:46 +00001311bool ELFObjectWriter::isWeak(const MCSymbol &S) const {
1312 const auto &Sym = cast<MCSymbolELF>(S);
Rafael Espindolae3b2acf2015-05-29 18:47:23 +00001313 if (::isWeak(Sym))
Rafael Espindoladb8a5862015-04-17 20:05:17 +00001314 return true;
1315
Rafael Espindoladb8a5862015-04-17 20:05:17 +00001316 // It is invalid to replace a reference to a global in a comdat
1317 // with a reference to a local since out of comdat references
1318 // to a local are forbidden.
1319 // We could try to return false for more cases, like the reference
1320 // being in the same comdat or Sym being an alias to another global,
1321 // but it is not clear if it is worth the effort.
Rafael Espindola95fb9b92015-06-02 20:38:46 +00001322 if (Sym.getBinding() != ELF::STB_GLOBAL)
Rafael Espindola29c82702015-04-20 12:44:06 +00001323 return false;
Rafael Espindoladb8a5862015-04-17 20:05:17 +00001324
Rafael Espindola29c82702015-04-20 12:44:06 +00001325 if (!Sym.isInSection())
1326 return false;
1327
1328 const auto &Sec = cast<MCSectionELF>(Sym.getSection());
1329 return Sec.getGroup();
Rafael Espindolaf275ad82015-03-25 13:16:53 +00001330}
1331
Rafael Espindola6b5e56c2010-12-17 17:45:22 +00001332MCObjectWriter *llvm::createELFObjectWriter(MCELFObjectTargetWriter *MOTW,
Rafael Espindola5560a4c2015-04-14 22:14:34 +00001333 raw_pwrite_stream &OS,
Rafael Espindolafdaae0d2010-12-18 03:27:34 +00001334 bool IsLittleEndian) {
Rafael Espindola34a68af2011-12-22 03:24:43 +00001335 return new ELFObjectWriter(MOTW, OS, IsLittleEndian);
Rafael Espindolab264d332011-12-21 17:30:17 +00001336}