blob: ca79d9dcaf80b0096c164641152024a87c1695f2 [file] [log] [blame]
Chris Lattner35f0a4f2005-06-27 06:29:00 +00001//===-- ELFWriter.cpp - Target-independent ELF Writer code ----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner4ee451d2007-12-29 20:36:04 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner35f0a4f2005-06-27 06:29:00 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the target-independent ELF writer. This file writes out
11// the ELF file in the following order:
12//
13// #1. ELF Header
Chris Lattner80ed8fa2005-07-07 07:02:20 +000014// #2. '.text' section
15// #3. '.data' section
16// #4. '.bss' section (conceptual position in file)
Chris Lattner35f0a4f2005-06-27 06:29:00 +000017// ...
18// #X. '.shstrtab' section
19// #Y. Section Table
20//
21// The entries in the section table are laid out as:
22// #0. Null entry [required]
Chris Lattner80ed8fa2005-07-07 07:02:20 +000023// #1. ".text" entry - the program code
24// #2. ".data" entry - global variables with initializers. [ if needed ]
25// #3. ".bss" entry - global variables without initializers. [ if needed ]
Chris Lattner35f0a4f2005-06-27 06:29:00 +000026// ...
27// #N. ".shstrtab" entry - String table for the section names.
Chris Lattner35f0a4f2005-06-27 06:29:00 +000028//
Chris Lattner35f0a4f2005-06-27 06:29:00 +000029//===----------------------------------------------------------------------===//
30
Bruno Cardoso Lopesa029a272009-06-07 21:22:38 +000031#define DEBUG_TYPE "elfwriter"
Bruno Cardoso Lopes45f5d642009-07-02 18:29:24 +000032#include "ELF.h"
Bill Wendling8f84f1f2007-02-08 01:35:27 +000033#include "ELFWriter.h"
Bruno Cardoso Lopes4cb31432009-06-03 17:47:27 +000034#include "ELFCodeEmitter.h"
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +000035#include "llvm/Constants.h"
Chris Lattner35f0a4f2005-06-27 06:29:00 +000036#include "llvm/Module.h"
Bill Wendling8f84f1f2007-02-08 01:35:27 +000037#include "llvm/PassManager.h"
Chris Lattner02b73ab2009-01-04 20:19:20 +000038#include "llvm/DerivedTypes.h"
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +000039#include "llvm/CodeGen/BinaryObject.h"
Bill Wendling8f84f1f2007-02-08 01:35:27 +000040#include "llvm/CodeGen/FileWriters.h"
Chris Lattneraa507db2005-07-11 05:17:18 +000041#include "llvm/CodeGen/MachineCodeEmitter.h"
Bruno Cardoso Lopesac57e6e2009-07-06 05:09:34 +000042#include "llvm/CodeGen/ObjectCodeEmitter.h"
43#include "llvm/CodeGen/MachineCodeEmitter.h"
Chris Lattneraa507db2005-07-11 05:17:18 +000044#include "llvm/CodeGen/MachineConstantPool.h"
Chris Lattnerf26e03b2009-07-31 17:42:42 +000045#include "llvm/MC/MCContext.h"
Chris Lattnera87dea42009-07-31 18:48:30 +000046#include "llvm/MC/MCSection.h"
Bruno Cardoso Lopes45f5d642009-07-02 18:29:24 +000047#include "llvm/Target/TargetAsmInfo.h"
Owen Anderson07000c62006-05-12 06:33:49 +000048#include "llvm/Target/TargetData.h"
Bruno Cardoso Lopes45f5d642009-07-02 18:29:24 +000049#include "llvm/Target/TargetELFWriterInfo.h"
Chris Lattnerf0144122009-07-28 03:13:23 +000050#include "llvm/Target/TargetLowering.h"
51#include "llvm/Target/TargetLoweringObjectFile.h"
Chris Lattner35f0a4f2005-06-27 06:29:00 +000052#include "llvm/Target/TargetMachine.h"
Chris Lattner5acd1202005-07-11 03:11:47 +000053#include "llvm/Support/Mangler.h"
Bill Wendlingbdc679d2006-11-29 00:39:47 +000054#include "llvm/Support/Streams.h"
Owen Andersoncb371882008-08-21 00:14:44 +000055#include "llvm/Support/raw_ostream.h"
Bruno Cardoso Lopesa029a272009-06-07 21:22:38 +000056#include "llvm/Support/Debug.h"
Torok Edwinc25e7582009-07-11 20:10:48 +000057#include "llvm/Support/ErrorHandling.h"
Bruno Cardoso Lopes6933d3e2009-07-06 09:26:48 +000058
Chris Lattner35f0a4f2005-06-27 06:29:00 +000059using namespace llvm;
60
Devang Patel19974732007-05-03 01:11:54 +000061char ELFWriter::ID = 0;
Bruno Cardoso Lopes6933d3e2009-07-06 09:26:48 +000062
63/// AddELFWriter - Add the ELF writer to the function pass manager
Bruno Cardoso Lopesac57e6e2009-07-06 05:09:34 +000064ObjectCodeEmitter *llvm::AddELFWriter(PassManagerBase &PM,
Bruno Cardoso Lopes6933d3e2009-07-06 09:26:48 +000065 raw_ostream &O,
66 TargetMachine &TM) {
Bill Wendling8f84f1f2007-02-08 01:35:27 +000067 ELFWriter *EW = new ELFWriter(O, TM);
Dan Gohmanbfae8312008-03-11 22:29:46 +000068 PM.add(EW);
Bruno Cardoso Lopes6933d3e2009-07-06 09:26:48 +000069 return EW->getObjectCodeEmitter();
Bill Wendling8f84f1f2007-02-08 01:35:27 +000070}
71
Chris Lattner0e180502005-07-11 06:34:30 +000072//===----------------------------------------------------------------------===//
Chris Lattner0e180502005-07-11 06:34:30 +000073// ELFWriter Implementation
74//===----------------------------------------------------------------------===//
Chris Lattneraa507db2005-07-11 05:17:18 +000075
Bruno Cardoso Lopes4cb31432009-06-03 17:47:27 +000076ELFWriter::ELFWriter(raw_ostream &o, TargetMachine &tm)
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +000077 : MachineFunctionPass(&ID), O(o), TM(tm),
Chris Lattnerf26e03b2009-07-31 17:42:42 +000078 OutContext(*new MCContext()),
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +000079 TLOF(TM.getTargetLowering()->getObjFileLowering()),
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +000080 is64Bit(TM.getTargetData()->getPointerSizeInBits() == 64),
81 isLittleEndian(TM.getTargetData()->isLittleEndian()),
82 ElfHdr(isLittleEndian, is64Bit) {
Chris Lattneraa507db2005-07-11 05:17:18 +000083
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +000084 TAI = TM.getTargetAsmInfo();
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +000085 TEW = TM.getELFWriterInfo();
Bruno Cardoso Lopesa029a272009-06-07 21:22:38 +000086
Bruno Cardoso Lopes6933d3e2009-07-06 09:26:48 +000087 // Create the object code emitter object for this target.
88 ElfCE = new ELFCodeEmitter(*this);
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +000089
90 // Inital number of sections
Chris Lattner5f48ff72005-07-16 08:01:13 +000091 NumSections = 0;
Chris Lattneraa507db2005-07-11 05:17:18 +000092}
93
94ELFWriter::~ELFWriter() {
Bruno Cardoso Lopes6933d3e2009-07-06 09:26:48 +000095 delete ElfCE;
Chris Lattnerf26e03b2009-07-31 17:42:42 +000096 delete &OutContext;
Chris Lattner35f0a4f2005-06-27 06:29:00 +000097}
98
99// doInitialization - Emit the file header and all of the global variables for
100// the module to the ELF file.
101bool ELFWriter::doInitialization(Module &M) {
Chris Lattnerf26e03b2009-07-31 17:42:42 +0000102 // Initialize TargetLoweringObjectFile.
Chris Lattnerf26e03b2009-07-31 17:42:42 +0000103 const_cast<TargetLoweringObjectFile&>(TLOF).Initialize(OutContext, TM);
104
Chris Lattner5acd1202005-07-11 03:11:47 +0000105 Mang = new Mangler(M);
106
Bruno Cardoso Lopesf5b0c5a2009-06-06 03:56:29 +0000107 // ELF Header
108 // ----------
109 // Fields e_shnum e_shstrndx are only known after all section have
110 // been emitted. They locations in the ouput buffer are recorded so
111 // to be patched up later.
112 //
113 // Note
114 // ----
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000115 // emitWord method behaves differently for ELF32 and ELF64, writing
Bruno Cardoso Lopesf5b0c5a2009-06-06 03:56:29 +0000116 // 4 bytes in the former and 8 in the last for *_off and *_addr elf types
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000117
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000118 ElfHdr.emitByte(0x7f); // e_ident[EI_MAG0]
119 ElfHdr.emitByte('E'); // e_ident[EI_MAG1]
120 ElfHdr.emitByte('L'); // e_ident[EI_MAG2]
121 ElfHdr.emitByte('F'); // e_ident[EI_MAG3]
Bruno Cardoso Lopesf5b0c5a2009-06-06 03:56:29 +0000122
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000123 ElfHdr.emitByte(TEW->getEIClass()); // e_ident[EI_CLASS]
124 ElfHdr.emitByte(TEW->getEIData()); // e_ident[EI_DATA]
125 ElfHdr.emitByte(EV_CURRENT); // e_ident[EI_VERSION]
126 ElfHdr.emitAlignment(16); // e_ident[EI_NIDENT-EI_PAD]
Bruno Cardoso Lopesf5b0c5a2009-06-06 03:56:29 +0000127
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000128 ElfHdr.emitWord16(ET_REL); // e_type
129 ElfHdr.emitWord16(TEW->getEMachine()); // e_machine = target
130 ElfHdr.emitWord32(EV_CURRENT); // e_version
131 ElfHdr.emitWord(0); // e_entry, no entry point in .o file
132 ElfHdr.emitWord(0); // e_phoff, no program header for .o
133 ELFHdr_e_shoff_Offset = ElfHdr.size();
134 ElfHdr.emitWord(0); // e_shoff = sec hdr table off in bytes
135 ElfHdr.emitWord32(TEW->getEFlags()); // e_flags = whatever the target wants
136 ElfHdr.emitWord16(TEW->getHdrSize()); // e_ehsize = ELF header size
137 ElfHdr.emitWord16(0); // e_phentsize = prog header entry size
138 ElfHdr.emitWord16(0); // e_phnum = # prog header entries = 0
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000139
Bruno Cardoso Lopesa029a272009-06-07 21:22:38 +0000140 // e_shentsize = Section header entry size
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000141 ElfHdr.emitWord16(TEW->getSHdrSize());
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000142
Bruno Cardoso Lopesf5b0c5a2009-06-06 03:56:29 +0000143 // e_shnum = # of section header ents
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000144 ELFHdr_e_shnum_Offset = ElfHdr.size();
145 ElfHdr.emitWord16(0); // Placeholder
Jeff Cohen00b168892005-07-27 06:12:32 +0000146
Bruno Cardoso Lopesf5b0c5a2009-06-06 03:56:29 +0000147 // e_shstrndx = Section # of '.shstrtab'
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000148 ELFHdr_e_shstrndx_Offset = ElfHdr.size();
149 ElfHdr.emitWord16(0); // Placeholder
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000150
Chris Lattner5f48ff72005-07-16 08:01:13 +0000151 // Add the null section, which is required to be first in the file.
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000152 getNullSection();
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000153
Bruno Cardoso Lopes50bc2042009-07-28 19:25:33 +0000154 // The first entry in the symtab is the null symbol and the second
155 // is a local symbol containing the module/file name
156 SymbolList.push_back(new ELFSym());
157 SymbolList.push_back(ELFSym::getFileSym());
158
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000159 return false;
160}
161
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000162// addGlobalSymbol - Add a global to be processed and to the global symbol
163// lookup, use a zero index because the table index will be determined later.
164void ELFWriter::addGlobalSymbol(const GlobalValue *GV,
165 bool AddToLookup /* = false */) {
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000166 PendingGlobals.insert(GV);
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000167 if (AddToLookup)
168 GblSymLookup[GV] = 0;
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000169}
170
171// addExternalSymbol - Add the external to be processed and to the
172// external symbol lookup, use a zero index because the symbol
173// table index will be determined later
174void ELFWriter::addExternalSymbol(const char *External) {
175 PendingExternals.insert(External);
176 ExtSymLookup[External] = 0;
177}
178
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000179// getCtorSection - Get the static constructor section
180ELFSection &ELFWriter::getCtorSection() {
181 const MCSection *Ctor = TLOF.getStaticCtorSection();
Chris Lattner93b6db32009-08-08 23:39:42 +0000182 return getSection(((MCSectionELF*)Ctor)->getName(), ELFSection::SHT_PROGBITS,
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000183 getElfSectionFlags(Ctor->getKind()));
Bruno Cardoso Lopese2b0ecd2009-07-18 23:24:01 +0000184}
185
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000186// getDtorSection - Get the static destructor section
187ELFSection &ELFWriter::getDtorSection() {
188 const MCSection *Dtor = TLOF.getStaticDtorSection();
Chris Lattner93b6db32009-08-08 23:39:42 +0000189 return getSection(((MCSectionELF*)Dtor)->getName(), ELFSection::SHT_PROGBITS,
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000190 getElfSectionFlags(Dtor->getKind()));
191}
192
193// getTextSection - Get the text section for the specified function
194ELFSection &ELFWriter::getTextSection(Function *F) {
195 const MCSection *Text = TLOF.SectionForGlobal(F, Mang, TM);
Chris Lattner93b6db32009-08-08 23:39:42 +0000196 return getSection(((MCSectionELF*)Text)->getName(), ELFSection::SHT_PROGBITS,
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000197 getElfSectionFlags(Text->getKind()));
198}
199
200// getJumpTableSection - Get a read only section for constants when
201// emitting jump tables. TODO: add PIC support
202ELFSection &ELFWriter::getJumpTableSection() {
203 const MCSection *JT = TLOF.getSectionForConstant(SectionKind::getReadOnly());
Chris Lattner93b6db32009-08-08 23:39:42 +0000204 return getSection(((MCSectionELF*)JT)->getName(),
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000205 ELFSection::SHT_PROGBITS,
206 getElfSectionFlags(JT->getKind()),
207 TM.getTargetData()->getPointerABIAlignment());
208}
209
210// getConstantPoolSection - Get a constant pool section based on the machine
211// constant pool entry type and relocation info.
Bruno Cardoso Lopese2b0ecd2009-07-18 23:24:01 +0000212ELFSection &ELFWriter::getConstantPoolSection(MachineConstantPoolEntry &CPE) {
Chris Lattner5c2f7892009-07-26 06:26:55 +0000213 SectionKind Kind;
214 switch (CPE.getRelocationInfo()) {
215 default: llvm_unreachable("Unknown section kind");
Chris Lattner27981192009-08-01 23:57:16 +0000216 case 2: Kind = SectionKind::getReadOnlyWithRel(); break;
Chris Lattner4c509222009-07-26 07:00:12 +0000217 case 1:
Chris Lattner27981192009-08-01 23:57:16 +0000218 Kind = SectionKind::getReadOnlyWithRelLocal();
Chris Lattner4c509222009-07-26 07:00:12 +0000219 break;
Chris Lattner5c2f7892009-07-26 06:26:55 +0000220 case 0:
221 switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) {
Chris Lattner27981192009-08-01 23:57:16 +0000222 case 4: Kind = SectionKind::getMergeableConst4(); break;
223 case 8: Kind = SectionKind::getMergeableConst8(); break;
224 case 16: Kind = SectionKind::getMergeableConst16(); break;
225 default: Kind = SectionKind::getMergeableConst(); break;
Chris Lattner5c2f7892009-07-26 06:26:55 +0000226 }
227 }
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000228
Chris Lattner93b6db32009-08-08 23:39:42 +0000229 const MCSection *CPSect = TLOF.getSectionForConstant(Kind);
230 return getSection(((MCSectionELF*)CPSect)->getName(),
Bruno Cardoso Lopese2b0ecd2009-07-18 23:24:01 +0000231 ELFSection::SHT_PROGBITS,
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000232 getElfSectionFlags(Kind),
Bruno Cardoso Lopese2b0ecd2009-07-18 23:24:01 +0000233 CPE.getAlignment());
234}
235
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000236// getRelocSection - Return the relocation section of section 'S'. 'RelA'
237// is true if the relocation section contains entries with addends.
Bruno Cardoso Lopes0a38dc52009-07-20 08:52:02 +0000238ELFSection &ELFWriter::getRelocSection(ELFSection &S) {
239 unsigned SectionHeaderTy = TEW->hasRelocationAddend() ?
240 ELFSection::SHT_RELA : ELFSection::SHT_REL;
241 std::string RelSName(".rel");
242 if (TEW->hasRelocationAddend())
243 RelSName.append("a");
244 RelSName.append(S.getName());
245
246 return getSection(RelSName, SectionHeaderTy, 0, TEW->getPrefELFAlignment());
247}
248
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000249// getGlobalELFVisibility - Returns the ELF specific visibility type
Bruno Cardoso Lopes45f5d642009-07-02 18:29:24 +0000250unsigned ELFWriter::getGlobalELFVisibility(const GlobalValue *GV) {
251 switch (GV->getVisibility()) {
252 default:
Torok Edwinc23197a2009-07-14 16:55:14 +0000253 llvm_unreachable("unknown visibility type");
Bruno Cardoso Lopes45f5d642009-07-02 18:29:24 +0000254 case GlobalValue::DefaultVisibility:
255 return ELFSym::STV_DEFAULT;
256 case GlobalValue::HiddenVisibility:
257 return ELFSym::STV_HIDDEN;
258 case GlobalValue::ProtectedVisibility:
259 return ELFSym::STV_PROTECTED;
260 }
Bruno Cardoso Lopes45f5d642009-07-02 18:29:24 +0000261 return 0;
262}
263
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000264// getGlobalELFBinding - Returns the ELF specific binding type
265unsigned ELFWriter::getGlobalELFBinding(const GlobalValue *GV) {
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000266 if (GV->hasInternalLinkage())
267 return ELFSym::STB_LOCAL;
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000268
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000269 if (GV->isWeakForLinker() && !GV->hasCommonLinkage())
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000270 return ELFSym::STB_WEAK;
271
272 return ELFSym::STB_GLOBAL;
273}
274
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000275// getGlobalELFType - Returns the ELF specific type for a global
276unsigned ELFWriter::getGlobalELFType(const GlobalValue *GV) {
277 if (GV->isDeclaration())
278 return ELFSym::STT_NOTYPE;
279
280 if (isa<Function>(GV))
281 return ELFSym::STT_FUNC;
282
283 return ELFSym::STT_OBJECT;
284}
285
286// getElfSectionFlags - Get the ELF Section Header flags based
Chris Lattner9ba8c682009-08-02 04:33:09 +0000287// on the flags defined in SectionKind.h.
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000288unsigned ELFWriter::getElfSectionFlags(SectionKind Kind, bool IsAlloc) {
289 unsigned ElfSectionFlags = 0;
290
291 if (IsAlloc)
292 ElfSectionFlags |= ELFSection::SHF_ALLOC;
Chris Lattner5fe575f2009-07-27 05:32:16 +0000293 if (Kind.isText())
Bruno Cardoso Lopes0b1308f2009-07-03 04:36:26 +0000294 ElfSectionFlags |= ELFSection::SHF_EXECINSTR;
Chris Lattner5fe575f2009-07-27 05:32:16 +0000295 if (Kind.isWriteable())
Bruno Cardoso Lopes0b1308f2009-07-03 04:36:26 +0000296 ElfSectionFlags |= ELFSection::SHF_WRITE;
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000297 if (Kind.isMergeableConst() || Kind.isMergeableCString())
Bruno Cardoso Lopes0b1308f2009-07-03 04:36:26 +0000298 ElfSectionFlags |= ELFSection::SHF_MERGE;
Chris Lattner5fe575f2009-07-27 05:32:16 +0000299 if (Kind.isThreadLocal())
Bruno Cardoso Lopes0b1308f2009-07-03 04:36:26 +0000300 ElfSectionFlags |= ELFSection::SHF_TLS;
Chris Lattner5fe575f2009-07-27 05:32:16 +0000301 if (Kind.isMergeableCString())
Bruno Cardoso Lopes0b1308f2009-07-03 04:36:26 +0000302 ElfSectionFlags |= ELFSection::SHF_STRINGS;
303
304 return ElfSectionFlags;
305}
306
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000307// isUndefOrNull - The constant is either a null initialized value or an
308// undefined one.
309static bool isUndefOrNull(const Constant *CV) {
310 return (CV->isNullValue() || isa<UndefValue>(CV));
311}
312
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000313// isELFUndefSym - the symbol has no section and must be placed in
314// the symbol table with a reference to the null section.
315static bool isELFUndefSym(const GlobalValue *GV) {
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000316 // Functions which make up until this point references are an undef symbol
317 return GV->isDeclaration() || (isa<Function>(GV));
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000318}
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000319
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000320// isELFBssSym - for an undef or null value, the symbol must go to a bss
321// section if it's not weak for linker, otherwise it's a common sym.
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000322static bool isELFBssSym(const GlobalVariable *GV, SectionKind Kind) {
Bruno Cardoso Lopes68491c12009-07-21 06:51:32 +0000323 const Constant *CV = GV->getInitializer();
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000324
325 return (!Kind.isMergeableCString() &&
326 isUndefOrNull(CV) &&
327 !GV->isWeakForLinker());
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000328}
329
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000330// isELFCommonSym - for an undef or null value, the symbol must go to a
331// common section if it's weak for linker, otherwise bss.
Bruno Cardoso Lopes68491c12009-07-21 06:51:32 +0000332static bool isELFCommonSym(const GlobalVariable *GV) {
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000333 return (isUndefOrNull(GV->getInitializer()) && GV->isWeakForLinker());
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000334}
335
336// EmitGlobal - Choose the right section for global and emit it
337void ELFWriter::EmitGlobal(const GlobalValue *GV) {
338
Bruno Cardoso Lopes68491c12009-07-21 06:51:32 +0000339 // Check if the referenced symbol is already emitted
340 if (GblSymLookup.find(GV) != GblSymLookup.end())
341 return;
342
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000343 // Handle ELF Bind, Visibility and Type for the current symbol
344 unsigned SymBind = getGlobalELFBinding(GV);
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000345 unsigned SymType = getGlobalELFType(GV);
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000346
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000347 // All undef symbols have the same binding, type and visibily and
348 // are classified regardless of their type.
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000349 ELFSym *GblSym = isELFUndefSym(GV) ? ELFSym::getUndefGV(GV, SymBind)
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000350 : ELFSym::getGV(GV, SymBind, SymType, getGlobalELFVisibility(GV));
351
352 if (!isELFUndefSym(GV)) {
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000353 assert(isa<GlobalVariable>(GV) && "GV not a global variable!");
354 const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV);
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000355
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000356 // Handle special llvm globals
357 if (EmitSpecialLLVMGlobal(GVar))
358 return;
Chris Lattnerf0144122009-07-28 03:13:23 +0000359
Bruno Cardoso Lopes50bc2042009-07-28 19:25:33 +0000360 // Get the ELF section where this global belongs from TLOF
Chris Lattnera87dea42009-07-31 18:48:30 +0000361 const MCSection *S = TLOF.SectionForGlobal(GV, Mang, TM);
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000362 SectionKind Kind = ((MCSectionELF*)S)->getKind();
363 unsigned SectionFlags = getElfSectionFlags(Kind);
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000364
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000365 // The symbol align should update the section alignment if needed
366 const TargetData *TD = TM.getTargetData();
367 unsigned Align = TD->getPreferredAlignment(GVar);
368 unsigned Size = TD->getTypeAllocSize(GVar->getInitializer()->getType());
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000369 GblSym->Size = Size;
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000370
Bruno Cardoso Lopes68491c12009-07-21 06:51:32 +0000371 if (isELFCommonSym(GVar)) {
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000372 GblSym->SectionIdx = ELFSection::SHN_COMMON;
Chris Lattner93b6db32009-08-08 23:39:42 +0000373 getSection(((MCSectionELF*)S)->getName(),
374 ELFSection::SHT_NOBITS, SectionFlags, 1);
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000375
376 // A new linkonce section is created for each global in the
377 // common section, the default alignment is 1 and the symbol
378 // value contains its alignment.
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000379 GblSym->Value = Align;
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000380
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000381 } else if (isELFBssSym(GVar, Kind)) {
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000382 ELFSection &ES =
Chris Lattner93b6db32009-08-08 23:39:42 +0000383 getSection(((MCSectionELF*)S)->getName(), ELFSection::SHT_NOBITS,
384 SectionFlags);
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000385 GblSym->SectionIdx = ES.SectionIdx;
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000386
387 // Update the size with alignment and the next object can
388 // start in the right offset in the section
389 if (Align) ES.Size = (ES.Size + Align-1) & ~(Align-1);
390 ES.Align = std::max(ES.Align, Align);
391
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000392 // GblSym->Value should contain the virtual offset inside the section.
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000393 // Virtual because the BSS space is not allocated on ELF objects
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000394 GblSym->Value = ES.Size;
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000395 ES.Size += Size;
396
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000397 } else { // The symbol must go to some kind of data section
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000398 ELFSection &ES =
Chris Lattner93b6db32009-08-08 23:39:42 +0000399 getSection(((MCSectionELF*)S)->getName(), ELFSection::SHT_PROGBITS,
400 SectionFlags);
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000401 GblSym->SectionIdx = ES.SectionIdx;
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000402
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000403 // GblSym->Value should contain the symbol offset inside the section,
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000404 // and all symbols should start on their required alignment boundary
405 ES.Align = std::max(ES.Align, Align);
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000406 ES.emitAlignment(Align);
407 GblSym->Value = ES.size();
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000408
409 // Emit the global to the data section 'ES'
410 EmitGlobalConstant(GVar->getInitializer(), ES);
411 }
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000412 }
413
Bruno Cardoso Lopes171375f2009-07-18 19:30:09 +0000414 if (GV->hasPrivateLinkage()) {
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000415 // For a private symbols, keep track of the index inside the
416 // private list since it will never go to the symbol table and
417 // won't be patched up later.
Bruno Cardoso Lopes171375f2009-07-18 19:30:09 +0000418 PrivateSyms.push_back(GblSym);
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000419 GblSymLookup[GV] = PrivateSyms.size()-1;
Bruno Cardoso Lopes171375f2009-07-18 19:30:09 +0000420 } else {
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000421 // Non private symbol are left with zero indices until they are patched
422 // up during the symbol table emition (where the indicies are created).
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000423 SymbolList.push_back(GblSym);
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000424 GblSymLookup[GV] = 0;
Bruno Cardoso Lopes171375f2009-07-18 19:30:09 +0000425 }
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000426}
427
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000428void ELFWriter::EmitGlobalConstantStruct(const ConstantStruct *CVS,
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000429 ELFSection &GblS) {
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000430
431 // Print the fields in successive locations. Pad to align if needed!
432 const TargetData *TD = TM.getTargetData();
433 unsigned Size = TD->getTypeAllocSize(CVS->getType());
434 const StructLayout *cvsLayout = TD->getStructLayout(CVS->getType());
435 uint64_t sizeSoFar = 0;
436 for (unsigned i = 0, e = CVS->getNumOperands(); i != e; ++i) {
437 const Constant* field = CVS->getOperand(i);
438
439 // Check if padding is needed and insert one or more 0s.
440 uint64_t fieldSize = TD->getTypeAllocSize(field->getType());
441 uint64_t padSize = ((i == e-1 ? Size : cvsLayout->getElementOffset(i+1))
442 - cvsLayout->getElementOffset(i)) - fieldSize;
443 sizeSoFar += fieldSize + padSize;
444
445 // Now print the actual field value.
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000446 EmitGlobalConstant(field, GblS);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000447
448 // Insert padding - this may include padding to increase the size of the
449 // current field up to the ABI size (if the struct is not packed) as well
450 // as padding to ensure that the next field starts at the right offset.
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000451 GblS.emitZeros(padSize);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000452 }
453 assert(sizeSoFar == cvsLayout->getSizeInBytes() &&
454 "Layout of constant struct may be incorrect!");
455}
456
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000457void ELFWriter::EmitGlobalConstant(const Constant *CV, ELFSection &GblS) {
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000458 const TargetData *TD = TM.getTargetData();
459 unsigned Size = TD->getTypeAllocSize(CV->getType());
460
461 if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) {
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000462 for (unsigned i = 0, e = CVA->getNumOperands(); i != e; ++i)
463 EmitGlobalConstant(CVA->getOperand(i), GblS);
464 return;
465 } else if (isa<ConstantAggregateZero>(CV)) {
466 GblS.emitZeros(Size);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000467 return;
468 } else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) {
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000469 EmitGlobalConstantStruct(CVS, GblS);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000470 return;
471 } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000472 APInt Val = CFP->getValueAPF().bitcastToAPInt();
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000473 if (CFP->getType() == Type::DoubleTy)
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000474 GblS.emitWord64(Val.getZExtValue());
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000475 else if (CFP->getType() == Type::FloatTy)
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000476 GblS.emitWord32(Val.getZExtValue());
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000477 else if (CFP->getType() == Type::X86_FP80Ty) {
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000478 unsigned PadSize = TD->getTypeAllocSize(Type::X86_FP80Ty)-
479 TD->getTypeStoreSize(Type::X86_FP80Ty);
480 GblS.emitWordFP80(Val.getRawData(), PadSize);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000481 } else if (CFP->getType() == Type::PPC_FP128Ty)
Torok Edwinc23197a2009-07-14 16:55:14 +0000482 llvm_unreachable("PPC_FP128Ty global emission not implemented");
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000483 return;
484 } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000485 if (Size == 1)
486 GblS.emitByte(CI->getZExtValue());
487 else if (Size == 2)
488 GblS.emitWord16(CI->getZExtValue());
489 else if (Size == 4)
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000490 GblS.emitWord32(CI->getZExtValue());
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000491 else
492 EmitGlobalConstantLargeInt(CI, GblS);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000493 return;
494 } else if (const ConstantVector *CP = dyn_cast<ConstantVector>(CV)) {
495 const VectorType *PTy = CP->getType();
496 for (unsigned I = 0, E = PTy->getNumElements(); I < E; ++I)
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000497 EmitGlobalConstant(CP->getOperand(I), GblS);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000498 return;
Bruno Cardoso Lopes68491c12009-07-21 06:51:32 +0000499 } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000500 switch (CE->getOpcode()) {
501 case Instruction::BitCast: {
Bruno Cardoso Lopes68491c12009-07-21 06:51:32 +0000502 EmitGlobalConstant(CE->getOperand(0), GblS);
503 return;
504 }
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000505 case Instruction::GetElementPtr: {
506 const Constant *ptrVal = CE->getOperand(0);
507 SmallVector<Value*, 8> idxVec(CE->op_begin()+1, CE->op_end());
508 int64_t Offset = TD->getIndexedOffset(ptrVal->getType(), &idxVec[0],
509 idxVec.size());
510 EmitGlobalDataRelocation(cast<const GlobalValue>(ptrVal),
511 TD->getTypeAllocSize(ptrVal->getType()),
512 GblS, Offset);
513 return;
514 }
515 case Instruction::IntToPtr: {
516 Constant *Op = CE->getOperand(0);
517 Op = ConstantExpr::getIntegerCast(Op, TD->getIntPtrType(), false/*ZExt*/);
518 EmitGlobalConstant(Op, GblS);
519 return;
520 }
521 }
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000522 std::string msg(CE->getOpcodeName());
523 raw_string_ostream ErrorMsg(msg);
524 ErrorMsg << ": Unsupported ConstantExpr type";
525 llvm_report_error(ErrorMsg.str());
526 } else if (CV->getType()->getTypeID() == Type::PointerTyID) {
527 // Fill the data entry with zeros or emit a relocation entry
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000528 if (isa<ConstantPointerNull>(CV))
529 GblS.emitZeros(Size);
530 else
531 EmitGlobalDataRelocation(cast<const GlobalValue>(CV),
532 Size, GblS);
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000533 return;
534 } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) {
535 // This is a constant address for a global variable or function and
536 // therefore must be referenced using a relocation entry.
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000537 EmitGlobalDataRelocation(GV, Size, GblS);
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000538 return;
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000539 }
Bruno Cardoso Lopes68491c12009-07-21 06:51:32 +0000540
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000541 std::string msg;
542 raw_string_ostream ErrorMsg(msg);
543 ErrorMsg << "Constant unimp for type: " << *CV->getType();
544 llvm_report_error(ErrorMsg.str());
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000545}
546
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000547void ELFWriter::EmitGlobalDataRelocation(const GlobalValue *GV, unsigned Size,
548 ELFSection &GblS, uint64_t Offset) {
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000549 // Create the relocation entry for the global value
550 MachineRelocation MR =
551 MachineRelocation::getGV(GblS.getCurrentPCOffset(),
552 TEW->getAbsoluteLabelMachineRelTy(),
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000553 const_cast<GlobalValue*>(GV),
554 Offset);
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000555
556 // Fill the data entry with zeros
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000557 GblS.emitZeros(Size);
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000558
559 // Add the relocation entry for the current data section
560 GblS.addRelocation(MR);
561}
562
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000563void ELFWriter::EmitGlobalConstantLargeInt(const ConstantInt *CI,
564 ELFSection &S) {
565 const TargetData *TD = TM.getTargetData();
566 unsigned BitWidth = CI->getBitWidth();
567 assert(isPowerOf2_32(BitWidth) &&
568 "Non-power-of-2-sized integers not handled!");
569
570 const uint64_t *RawData = CI->getValue().getRawData();
571 uint64_t Val = 0;
572 for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) {
573 Val = (TD->isBigEndian()) ? RawData[e - i - 1] : RawData[i];
574 S.emitWord64(Val);
575 }
576}
577
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000578/// EmitSpecialLLVMGlobal - Check to see if the specified global is a
579/// special global used by LLVM. If so, emit it and return true, otherwise
580/// do nothing and return false.
581bool ELFWriter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) {
582 if (GV->getName() == "llvm.used")
583 llvm_unreachable("not implemented yet");
584
585 // Ignore debug and non-emitted data. This handles llvm.compiler.used.
586 if (GV->getSection() == "llvm.metadata" ||
587 GV->hasAvailableExternallyLinkage())
588 return true;
589
590 if (!GV->hasAppendingLinkage()) return false;
591
592 assert(GV->hasInitializer() && "Not a special LLVM global!");
593
594 const TargetData *TD = TM.getTargetData();
595 unsigned Align = TD->getPointerPrefAlignment();
596 if (GV->getName() == "llvm.global_ctors") {
597 ELFSection &Ctor = getCtorSection();
598 Ctor.emitAlignment(Align);
599 EmitXXStructorList(GV->getInitializer(), Ctor);
600 return true;
601 }
602
603 if (GV->getName() == "llvm.global_dtors") {
604 ELFSection &Dtor = getDtorSection();
605 Dtor.emitAlignment(Align);
606 EmitXXStructorList(GV->getInitializer(), Dtor);
607 return true;
608 }
609
610 return false;
611}
612
613/// EmitXXStructorList - Emit the ctor or dtor list. This just emits out the
614/// function pointers, ignoring the init priority.
615void ELFWriter::EmitXXStructorList(Constant *List, ELFSection &Xtor) {
616 // Should be an array of '{ int, void ()* }' structs. The first value is the
617 // init priority, which we ignore.
618 if (!isa<ConstantArray>(List)) return;
619 ConstantArray *InitList = cast<ConstantArray>(List);
620 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
621 if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){
622 if (CS->getNumOperands() != 2) return; // Not array of 2-element structs.
623
624 if (CS->getOperand(1)->isNullValue())
625 return; // Found a null terminator, exit printing.
626 // Emit the function pointer.
627 EmitGlobalConstant(CS->getOperand(1), Xtor);
628 }
629}
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000630
631bool ELFWriter::runOnMachineFunction(MachineFunction &MF) {
Bruno Cardoso Lopes6933d3e2009-07-06 09:26:48 +0000632 // Nothing to do here, this is all done through the ElfCE object above.
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000633 return false;
634}
635
636/// doFinalization - Now that the module has been completely processed, emit
637/// the ELF file to 'O'.
638bool ELFWriter::doFinalization(Module &M) {
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000639 // Emit .data section placeholder
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000640 getDataSection();
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000641
642 // Emit .bss section placeholder
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000643 getBSSSection();
644
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000645 // Build and emit data, bss and "common" sections.
Chris Lattner5f48ff72005-07-16 08:01:13 +0000646 for (Module::global_iterator I = M.global_begin(), E = M.global_end();
Bruno Cardoso Lopes68491c12009-07-21 06:51:32 +0000647 I != E; ++I)
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000648 EmitGlobal(I);
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000649
650 // Emit all pending globals
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000651 for (PendingGblsIter I = PendingGlobals.begin(), E = PendingGlobals.end();
652 I != E; ++I)
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000653 EmitGlobal(*I);
Chris Lattner80ed8fa2005-07-07 07:02:20 +0000654
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000655 // Emit all pending externals
656 for (PendingExtsIter I = PendingExternals.begin(), E = PendingExternals.end();
657 I != E; ++I)
658 SymbolList.push_back(ELFSym::getExtSym(*I));
659
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000660 // Emit non-executable stack note
661 if (TAI->getNonexecutableStackDirective())
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000662 getNonExecStackSection();
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000663
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000664 // Emit a symbol for each section created until now, skip null section
665 for (unsigned i = 1, e = SectionList.size(); i < e; ++i) {
666 ELFSection &ES = *SectionList[i];
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000667 ELFSym *SectionSym = ELFSym::getSectionSym();
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000668 SectionSym->SectionIdx = ES.SectionIdx;
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000669 SymbolList.push_back(SectionSym);
670 ES.Sym = SymbolList.back();
Bruno Cardoso Lopesa5e0abd2009-06-25 07:36:24 +0000671 }
672
Bruno Cardoso Lopesc236a342009-06-22 19:29:56 +0000673 // Emit string table
Bruno Cardoso Lopesdf0b6502009-07-27 19:32:57 +0000674 EmitStringTable(M.getModuleIdentifier());
Bruno Cardoso Lopesc236a342009-06-22 19:29:56 +0000675
Chris Lattner80ed8fa2005-07-07 07:02:20 +0000676 // Emit the symbol table now, if non-empty.
677 EmitSymbolTable();
678
Bruno Cardoso Lopesa029a272009-06-07 21:22:38 +0000679 // Emit the relocation sections.
680 EmitRelocations();
Chris Lattner80ed8fa2005-07-07 07:02:20 +0000681
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000682 // Emit the sections string table.
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000683 EmitSectionTableStringTable();
684
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000685 // Dump the sections and section table to the .o file.
Chris Lattner5f48ff72005-07-16 08:01:13 +0000686 OutputSectionsAndSectionTable();
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000687
Chris Lattner5f48ff72005-07-16 08:01:13 +0000688 // We are done with the abstract symbols.
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000689 SymbolList.clear();
Chris Lattner5f48ff72005-07-16 08:01:13 +0000690 SectionList.clear();
691 NumSections = 0;
Chris Lattner5acd1202005-07-11 03:11:47 +0000692
693 // Release the name mangler object.
694 delete Mang; Mang = 0;
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000695 return false;
696}
697
Bruno Cardoso Lopes0a38dc52009-07-20 08:52:02 +0000698// RelocateField - Patch relocatable field with 'Offset' in 'BO'
699// using a 'Value' of known 'Size'
700void ELFWriter::RelocateField(BinaryObject &BO, uint32_t Offset,
701 int64_t Value, unsigned Size) {
702 if (Size == 32)
703 BO.fixWord32(Value, Offset);
704 else if (Size == 64)
705 BO.fixWord64(Value, Offset);
706 else
707 llvm_unreachable("don't know howto patch relocatable field");
708}
709
Bruno Cardoso Lopesa029a272009-06-07 21:22:38 +0000710/// EmitRelocations - Emit relocations
711void ELFWriter::EmitRelocations() {
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000712
Bruno Cardoso Lopes0a38dc52009-07-20 08:52:02 +0000713 // True if the target uses the relocation entry to hold the addend,
714 // otherwise the addend is written directly to the relocatable field.
715 bool HasRelA = TEW->hasRelocationAddend();
716
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000717 // Create Relocation sections for each section which needs it.
Bruno Cardoso Lopesb674dbe2009-07-17 18:02:30 +0000718 for (unsigned i=0, e=SectionList.size(); i != e; ++i) {
719 ELFSection &S = *SectionList[i];
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000720
721 // This section does not have relocations
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000722 if (!S.hasRelocations()) continue;
Bruno Cardoso Lopes0a38dc52009-07-20 08:52:02 +0000723 ELFSection &RelSec = getRelocSection(S);
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000724
725 // 'Link' - Section hdr idx of the associated symbol table
726 // 'Info' - Section hdr idx of the section to which the relocation applies
727 ELFSection &SymTab = getSymbolTableSection();
728 RelSec.Link = SymTab.SectionIdx;
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000729 RelSec.Info = S.SectionIdx;
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000730 RelSec.EntSize = TEW->getRelocationEntrySize();
731
732 // Get the relocations from Section
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000733 std::vector<MachineRelocation> Relos = S.getRelocations();
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000734 for (std::vector<MachineRelocation>::iterator MRI = Relos.begin(),
735 MRE = Relos.end(); MRI != MRE; ++MRI) {
736 MachineRelocation &MR = *MRI;
737
Bruno Cardoso Lopes0a38dc52009-07-20 08:52:02 +0000738 // Relocatable field offset from the section start
739 unsigned RelOffset = MR.getMachineCodeOffset();
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000740
741 // Symbol index in the symbol table
742 unsigned SymIdx = 0;
743
Bruno Cardoso Lopes0a38dc52009-07-20 08:52:02 +0000744 // Target specific relocation field type and size
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000745 unsigned RelType = TEW->getRelocationType(MR.getRelocationType());
Bruno Cardoso Lopes0a38dc52009-07-20 08:52:02 +0000746 unsigned RelTySize = TEW->getRelocationTySize(RelType);
Bruno Cardoso Lopesa5e0abd2009-06-25 07:36:24 +0000747 int64_t Addend = 0;
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000748
749 // There are several machine relocations types, and each one of
750 // them needs a different approach to retrieve the symbol table index.
751 if (MR.isGlobalValue()) {
752 const GlobalValue *G = MR.getGlobalValue();
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000753 int64_t GlobalOffset = MR.getConstantVal();
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000754 SymIdx = GblSymLookup[G];
Bruno Cardoso Lopes171375f2009-07-18 19:30:09 +0000755 if (G->hasPrivateLinkage()) {
756 // If the target uses a section offset in the relocation:
757 // SymIdx + Addend = section sym for global + section offset
758 unsigned SectionIdx = PrivateSyms[SymIdx]->SectionIdx;
Bruno Cardoso Lopes3e0094d2009-08-08 17:29:04 +0000759 Addend = PrivateSyms[SymIdx]->Value + GlobalOffset;
Bruno Cardoso Lopes171375f2009-07-18 19:30:09 +0000760 SymIdx = SectionList[SectionIdx]->getSymbolTableIndex();
761 } else {
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000762 Addend = TEW->getDefaultAddendForRelTy(RelType, GlobalOffset);
Bruno Cardoso Lopes171375f2009-07-18 19:30:09 +0000763 }
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000764 } else if (MR.isExternalSymbol()) {
765 const char *ExtSym = MR.getExternalSymbol();
766 SymIdx = ExtSymLookup[ExtSym];
767 Addend = TEW->getDefaultAddendForRelTy(RelType);
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000768 } else {
Bruno Cardoso Lopese2b0ecd2009-07-18 23:24:01 +0000769 // Get the symbol index for the section symbol
Bruno Cardoso Lopesa5e0abd2009-06-25 07:36:24 +0000770 unsigned SectionIdx = MR.getConstantVal();
Bruno Cardoso Lopes0a38dc52009-07-20 08:52:02 +0000771 SymIdx = SectionList[SectionIdx]->getSymbolTableIndex();
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000772
773 // The symbol offset inside the section
774 int64_t SymOffset = (int64_t)MR.getResultPointer();
Bruno Cardoso Lopes0a38dc52009-07-20 08:52:02 +0000775
776 // For pc relative relocations where symbols are defined in the same
777 // section they are referenced, ignore the relocation entry and patch
778 // the relocatable field with the symbol offset directly.
779 if (S.SectionIdx == SectionIdx && TEW->isPCRelativeRel(RelType)) {
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000780 int64_t Value = TEW->computeRelocation(SymOffset, RelOffset, RelType);
Bruno Cardoso Lopes0a38dc52009-07-20 08:52:02 +0000781 RelocateField(S, RelOffset, Value, RelTySize);
782 continue;
783 }
Bruno Cardoso Lopese2b0ecd2009-07-18 23:24:01 +0000784
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000785 Addend = TEW->getDefaultAddendForRelTy(RelType, SymOffset);
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000786 }
787
Bruno Cardoso Lopes171375f2009-07-18 19:30:09 +0000788 // The target without addend on the relocation symbol must be
789 // patched in the relocation place itself to contain the addend
Bruno Cardoso Lopes52d08512009-08-05 06:57:03 +0000790 // otherwise write zeros to make sure there is no garbage there
791 RelocateField(S, RelOffset, HasRelA ? 0 : Addend, RelTySize);
Bruno Cardoso Lopes171375f2009-07-18 19:30:09 +0000792
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000793 // Get the relocation entry and emit to the relocation section
Bruno Cardoso Lopes0a38dc52009-07-20 08:52:02 +0000794 ELFRelocation Rel(RelOffset, SymIdx, RelType, HasRelA, Addend);
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000795 EmitRelocation(RelSec, Rel, HasRelA);
796 }
797 }
798}
799
800/// EmitRelocation - Write relocation 'Rel' to the relocation section 'Rel'
801void ELFWriter::EmitRelocation(BinaryObject &RelSec, ELFRelocation &Rel,
802 bool HasRelA) {
803 RelSec.emitWord(Rel.getOffset());
804 RelSec.emitWord(Rel.getInfo(is64Bit));
805 if (HasRelA)
806 RelSec.emitWord(Rel.getAddend());
Bruno Cardoso Lopesa029a272009-06-07 21:22:38 +0000807}
808
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000809/// EmitSymbol - Write symbol 'Sym' to the symbol table 'SymbolTable'
810void ELFWriter::EmitSymbol(BinaryObject &SymbolTable, ELFSym &Sym) {
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000811 if (is64Bit) {
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000812 SymbolTable.emitWord32(Sym.NameIdx);
813 SymbolTable.emitByte(Sym.Info);
814 SymbolTable.emitByte(Sym.Other);
815 SymbolTable.emitWord16(Sym.SectionIdx);
816 SymbolTable.emitWord64(Sym.Value);
817 SymbolTable.emitWord64(Sym.Size);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000818 } else {
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000819 SymbolTable.emitWord32(Sym.NameIdx);
820 SymbolTable.emitWord32(Sym.Value);
821 SymbolTable.emitWord32(Sym.Size);
822 SymbolTable.emitByte(Sym.Info);
823 SymbolTable.emitByte(Sym.Other);
824 SymbolTable.emitWord16(Sym.SectionIdx);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000825 }
826}
827
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000828/// EmitSectionHeader - Write section 'Section' header in 'SHdrTab'
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000829/// Section Header Table
Bruno Cardoso Lopesd2910662009-07-13 22:40:39 +0000830void ELFWriter::EmitSectionHeader(BinaryObject &SHdrTab,
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000831 const ELFSection &SHdr) {
832 SHdrTab.emitWord32(SHdr.NameIdx);
833 SHdrTab.emitWord32(SHdr.Type);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000834 if (is64Bit) {
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000835 SHdrTab.emitWord64(SHdr.Flags);
836 SHdrTab.emitWord(SHdr.Addr);
837 SHdrTab.emitWord(SHdr.Offset);
838 SHdrTab.emitWord64(SHdr.Size);
839 SHdrTab.emitWord32(SHdr.Link);
840 SHdrTab.emitWord32(SHdr.Info);
841 SHdrTab.emitWord64(SHdr.Align);
842 SHdrTab.emitWord64(SHdr.EntSize);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000843 } else {
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000844 SHdrTab.emitWord32(SHdr.Flags);
845 SHdrTab.emitWord(SHdr.Addr);
846 SHdrTab.emitWord(SHdr.Offset);
847 SHdrTab.emitWord32(SHdr.Size);
848 SHdrTab.emitWord32(SHdr.Link);
849 SHdrTab.emitWord32(SHdr.Info);
850 SHdrTab.emitWord32(SHdr.Align);
851 SHdrTab.emitWord32(SHdr.EntSize);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000852 }
853}
854
Bruno Cardoso Lopesc236a342009-06-22 19:29:56 +0000855/// EmitStringTable - If the current symbol table is non-empty, emit the string
856/// table for it
Bruno Cardoso Lopesdf0b6502009-07-27 19:32:57 +0000857void ELFWriter::EmitStringTable(const std::string &ModuleName) {
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000858 if (!SymbolList.size()) return; // Empty symbol table.
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000859 ELFSection &StrTab = getStringTableSection();
Chris Lattner5f48ff72005-07-16 08:01:13 +0000860
Chris Lattner80ed8fa2005-07-07 07:02:20 +0000861 // Set the zero'th symbol to a null byte, as required.
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000862 StrTab.emitByte(0);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000863
Bruno Cardoso Lopesb674dbe2009-07-17 18:02:30 +0000864 // Walk on the symbol list and write symbol names into the string table.
Chris Lattner80ed8fa2005-07-07 07:02:20 +0000865 unsigned Index = 1;
Bruno Cardoso Lopes115934e2009-07-16 06:26:41 +0000866 for (ELFSymIter I=SymbolList.begin(), E=SymbolList.end(); I != E; ++I) {
867 ELFSym &Sym = *(*I);
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000868
Bruno Cardoso Lopesa5e0abd2009-06-25 07:36:24 +0000869 std::string Name;
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000870 if (Sym.isGlobalValue())
Bruno Cardoso Lopesdf0b6502009-07-27 19:32:57 +0000871 // Use the name mangler to uniquify the LLVM symbol.
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000872 Name.append(Mang->getMangledName(Sym.getGlobalValue()));
873 else if (Sym.isExternalSym())
874 Name.append(Sym.getExternalSymbol());
Bruno Cardoso Lopesdf0b6502009-07-27 19:32:57 +0000875 else if (Sym.isFileType())
876 Name.append(ModuleName);
Chris Lattner80ed8fa2005-07-07 07:02:20 +0000877
878 if (Name.empty()) {
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000879 Sym.NameIdx = 0;
Chris Lattner80ed8fa2005-07-07 07:02:20 +0000880 } else {
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000881 Sym.NameIdx = Index;
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000882 StrTab.emitString(Name);
Chris Lattner80ed8fa2005-07-07 07:02:20 +0000883
884 // Keep track of the number of bytes emitted to this section.
885 Index += Name.size()+1;
886 }
887 }
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000888 assert(Index == StrTab.size());
Chris Lattner5f48ff72005-07-16 08:01:13 +0000889 StrTab.Size = Index;
Bruno Cardoso Lopesc236a342009-06-22 19:29:56 +0000890}
Chris Lattner80ed8fa2005-07-07 07:02:20 +0000891
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000892// SortSymbols - On the symbol table local symbols must come before
893// all other symbols with non-local bindings. The return value is
894// the position of the first non local symbol.
895unsigned ELFWriter::SortSymbols() {
Bruno Cardoso Lopes115934e2009-07-16 06:26:41 +0000896 unsigned FirstNonLocalSymbol;
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000897 std::vector<ELFSym*> LocalSyms, OtherSyms;
898
Bruno Cardoso Lopes115934e2009-07-16 06:26:41 +0000899 for (ELFSymIter I=SymbolList.begin(), E=SymbolList.end(); I != E; ++I) {
900 if ((*I)->isLocalBind())
901 LocalSyms.push_back(*I);
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000902 else
Bruno Cardoso Lopes115934e2009-07-16 06:26:41 +0000903 OtherSyms.push_back(*I);
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000904 }
905 SymbolList.clear();
906 FirstNonLocalSymbol = LocalSyms.size();
907
Bruno Cardoso Lopes115934e2009-07-16 06:26:41 +0000908 for (unsigned i = 0; i < FirstNonLocalSymbol; ++i)
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000909 SymbolList.push_back(LocalSyms[i]);
910
Bruno Cardoso Lopes115934e2009-07-16 06:26:41 +0000911 for (ELFSymIter I=OtherSyms.begin(), E=OtherSyms.end(); I != E; ++I)
912 SymbolList.push_back(*I);
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000913
914 LocalSyms.clear();
915 OtherSyms.clear();
916
917 return FirstNonLocalSymbol;
918}
919
Bruno Cardoso Lopesc236a342009-06-22 19:29:56 +0000920/// EmitSymbolTable - Emit the symbol table itself.
921void ELFWriter::EmitSymbolTable() {
922 if (!SymbolList.size()) return; // Empty symbol table.
923
Chris Lattner80ed8fa2005-07-07 07:02:20 +0000924 // Now that we have emitted the string table and know the offset into the
925 // string table of each symbol, emit the symbol table itself.
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000926 ELFSection &SymTab = getSymbolTableSection();
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000927 SymTab.Align = TEW->getPrefELFAlignment();
Bruno Cardoso Lopesc236a342009-06-22 19:29:56 +0000928
929 // Section Index of .strtab.
930 SymTab.Link = getStringTableSection().SectionIdx;
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000931
932 // Size of each symtab entry.
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000933 SymTab.EntSize = TEW->getSymTabEntrySize();
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +0000934
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000935 // Reorder the symbol table with local symbols first!
936 unsigned FirstNonLocalSymbol = SortSymbols();
937
938 // Emit all the symbols to the symbol table.
939 for (unsigned i = 0, e = SymbolList.size(); i < e; ++i) {
940 ELFSym &Sym = *SymbolList[i];
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000941
942 // Emit symbol to the symbol table
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000943 EmitSymbol(SymTab, Sym);
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000944
Bruno Cardoso Lopes746e3bb2009-07-27 18:54:47 +0000945 // Record the symbol table index for each symbol
946 if (Sym.isGlobalValue())
947 GblSymLookup[Sym.getGlobalValue()] = i;
948 else if (Sym.isExternalSym())
949 ExtSymLookup[Sym.getExternalSymbol()] = i;
Bruno Cardoso Lopesa5e0abd2009-06-25 07:36:24 +0000950
951 // Keep track on the symbol index into the symbol table
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000952 Sym.SymTabIdx = i;
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000953 }
954
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000955 // One greater than the symbol table index of the last local symbol
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +0000956 SymTab.Info = FirstNonLocalSymbol;
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000957 SymTab.Size = SymTab.size();
Chris Lattner80ed8fa2005-07-07 07:02:20 +0000958}
959
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000960/// EmitSectionTableStringTable - This method adds and emits a section for the
961/// ELF Section Table string table: the string table that holds all of the
962/// section names.
963void ELFWriter::EmitSectionTableStringTable() {
964 // First step: add the section for the string table to the list of sections:
Bruno Cardoso Lopese39493e2009-06-23 04:39:27 +0000965 ELFSection &SHStrTab = getSectionHeaderStringTableSection();
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000966
967 // Now that we know which section number is the .shstrtab section, update the
968 // e_shstrndx entry in the ELF header.
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000969 ElfHdr.fixWord16(SHStrTab.SectionIdx, ELFHdr_e_shstrndx_Offset);
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000970
971 // Set the NameIdx of each section in the string table and emit the bytes for
972 // the string table.
973 unsigned Index = 0;
974
Bruno Cardoso Lopes115934e2009-07-16 06:26:41 +0000975 for (ELFSectionIter I=SectionList.begin(), E=SectionList.end(); I != E; ++I) {
976 ELFSection &S = *(*I);
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000977 // Set the index into the table. Note if we have lots of entries with
978 // common suffixes, we could memoize them here if we cared.
Bruno Cardoso Lopes115934e2009-07-16 06:26:41 +0000979 S.NameIdx = Index;
980 SHStrTab.emitString(S.getName());
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000981
982 // Keep track of the number of bytes emitted to this section.
Bruno Cardoso Lopes115934e2009-07-16 06:26:41 +0000983 Index += S.getName().size()+1;
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000984 }
985
986 // Set the size of .shstrtab now that we know what it is.
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000987 assert(Index == SHStrTab.size());
Chris Lattner5f48ff72005-07-16 08:01:13 +0000988 SHStrTab.Size = Index;
Chris Lattner35f0a4f2005-06-27 06:29:00 +0000989}
990
Chris Lattner5f48ff72005-07-16 08:01:13 +0000991/// OutputSectionsAndSectionTable - Now that we have constructed the file header
992/// and all of the sections, emit these to the ostream destination and emit the
993/// SectionTable.
994void ELFWriter::OutputSectionsAndSectionTable() {
995 // Pass #1: Compute the file offset for each section.
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +0000996 size_t FileOff = ElfHdr.size(); // File header first.
Chris Lattner5f48ff72005-07-16 08:01:13 +0000997
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +0000998 // Adjust alignment of all section if needed, skip the null section.
999 for (unsigned i=1, e=SectionList.size(); i < e; ++i) {
1000 ELFSection &ES = *SectionList[i];
1001 if (!ES.size()) {
1002 ES.Offset = FileOff;
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +00001003 continue;
1004 }
1005
Bruno Cardoso Lopesa029a272009-06-07 21:22:38 +00001006 // Update Section size
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +00001007 if (!ES.Size)
1008 ES.Size = ES.size();
Bruno Cardoso Lopesa029a272009-06-07 21:22:38 +00001009
Chris Lattner5f48ff72005-07-16 08:01:13 +00001010 // Align FileOff to whatever the alignment restrictions of the section are.
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +00001011 if (ES.Align)
1012 FileOff = (FileOff+ES.Align-1) & ~(ES.Align-1);
Bruno Cardoso Lopesa029a272009-06-07 21:22:38 +00001013
Bruno Cardoso Lopes4b70fab2009-07-15 20:49:10 +00001014 ES.Offset = FileOff;
1015 FileOff += ES.Size;
Chris Lattner35f0a4f2005-06-27 06:29:00 +00001016 }
1017
Chris Lattner5f48ff72005-07-16 08:01:13 +00001018 // Align Section Header.
Bruno Cardoso Lopes0d3193e2009-06-22 19:16:16 +00001019 unsigned TableAlign = TEW->getPrefELFAlignment();
Chris Lattner5f48ff72005-07-16 08:01:13 +00001020 FileOff = (FileOff+TableAlign-1) & ~(TableAlign-1);
1021
1022 // Now that we know where all of the sections will be emitted, set the e_shnum
1023 // entry in the ELF header.
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +00001024 ElfHdr.fixWord16(NumSections, ELFHdr_e_shnum_Offset);
Jeff Cohen00b168892005-07-27 06:12:32 +00001025
Chris Lattner5f48ff72005-07-16 08:01:13 +00001026 // Now that we know the offset in the file of the section table, update the
1027 // e_shoff address in the ELF header.
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +00001028 ElfHdr.fixWord(FileOff, ELFHdr_e_shoff_Offset);
Jeff Cohen00b168892005-07-27 06:12:32 +00001029
Chris Lattner5f48ff72005-07-16 08:01:13 +00001030 // Now that we know all of the data in the file header, emit it and all of the
1031 // sections!
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +00001032 O.write((char *)&ElfHdr.getData()[0], ElfHdr.size());
1033 FileOff = ElfHdr.size();
Chris Lattner5f48ff72005-07-16 08:01:13 +00001034
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +00001035 // Section Header Table blob
1036 BinaryObject SHdrTable(isLittleEndian, is64Bit);
Chris Lattner5f48ff72005-07-16 08:01:13 +00001037
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +00001038 // Emit all of sections to the file and build the section header table.
Bruno Cardoso Lopes115934e2009-07-16 06:26:41 +00001039 for (ELFSectionIter I=SectionList.begin(), E=SectionList.end(); I != E; ++I) {
1040 ELFSection &S = *(*I);
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +00001041 DOUT << "SectionIdx: " << S.SectionIdx << ", Name: " << S.getName()
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +00001042 << ", Size: " << S.Size << ", Offset: " << S.Offset
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +00001043 << ", SectionData Size: " << S.size() << "\n";
Chris Lattner5f48ff72005-07-16 08:01:13 +00001044
1045 // Align FileOff to whatever the alignment restrictions of the section are.
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +00001046 if (S.size()) {
Bruno Cardoso Lopese39493e2009-06-23 04:39:27 +00001047 if (S.Align) {
1048 for (size_t NewFileOff = (FileOff+S.Align-1) & ~(S.Align-1);
1049 FileOff != NewFileOff; ++FileOff)
1050 O << (char)0xAB;
1051 }
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +00001052 O.write((char *)&S.getData()[0], S.Size);
Bruno Cardoso Lopesc997d452009-06-11 19:16:03 +00001053 FileOff += S.Size;
1054 }
Bruno Cardoso Lopesa029a272009-06-07 21:22:38 +00001055
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +00001056 EmitSectionHeader(SHdrTable, S);
Chris Lattner5f48ff72005-07-16 08:01:13 +00001057 }
1058
1059 // Align output for the section table.
1060 for (size_t NewFileOff = (FileOff+TableAlign-1) & ~(TableAlign-1);
1061 FileOff != NewFileOff; ++FileOff)
Owen Andersoncb371882008-08-21 00:14:44 +00001062 O << (char)0xAB;
Jeff Cohen00b168892005-07-27 06:12:32 +00001063
Chris Lattner5f48ff72005-07-16 08:01:13 +00001064 // Emit the section table itself.
Bruno Cardoso Lopesae9163f2009-06-14 07:53:21 +00001065 O.write((char *)&SHdrTable.getData()[0], SHdrTable.size());
Chris Lattner35f0a4f2005-06-27 06:29:00 +00001066}