X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FELFWriter.cpp;h=908abe5f1bba032e318bf3bcb2ffb7e2691c2f56;hb=e984e504b5f3090ab270cbdab02638ac3a2afb21;hp=268e4cc1a63ea185c57b25b73ad15ce9bba21aa9;hpb=35f0a4f24e1d7ded182bd557503a9035fb540a58;p=oota-llvm.git diff --git a/lib/CodeGen/ELFWriter.cpp b/lib/CodeGen/ELFWriter.cpp index 268e4cc1a63..908abe5f1bb 100644 --- a/lib/CodeGen/ELFWriter.cpp +++ b/lib/CodeGen/ELFWriter.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -11,220 +11,537 @@ // the ELF file in the following order: // // #1. ELF Header -// #2. '.data' section -// #3. '.bss' section +// #2. '.text' section +// #3. '.data' section +// #4. '.bss' section (conceptual position in file) // ... // #X. '.shstrtab' section // #Y. Section Table // // The entries in the section table are laid out as: // #0. Null entry [required] -// #1. ".data" entry - global variables with initializers. [ if needed ] -// #2. ".bss" entry - global variables without initializers. [ if needed ] -// #3. ".text" entry - the program code +// #1. ".text" entry - the program code +// #2. ".data" entry - global variables with initializers. [ if needed ] +// #3. ".bss" entry - global variables without initializers. [ if needed ] // ... // #N. ".shstrtab" entry - String table for the section names. - // // NOTE: This code should eventually be extended to support 64-bit ELF (this // won't be hard), but we haven't done so yet! // //===----------------------------------------------------------------------===// -#include "llvm/CodeGen/ELFWriter.h" +#include "ELFWriter.h" #include "llvm/Module.h" +#include "llvm/PassManager.h" +#include "llvm/CodeGen/FileWriters.h" +#include "llvm/CodeGen/MachineCodeEmitter.h" +#include "llvm/CodeGen/MachineConstantPool.h" +#include "llvm/CodeGen/MachineFunctionPass.h" +#include "llvm/Target/TargetData.h" +#include "llvm/Target/TargetELFWriterInfo.h" #include "llvm/Target/TargetMachine.h" +#include "llvm/Support/Mangler.h" +#include "llvm/Support/OutputBuffer.h" +#include "llvm/Support/Streams.h" +#include using namespace llvm; -ELFWriter::ELFWriter(std::ostream &o, TargetMachine &tm) : O(o), TM(tm) { - e_machine = 0; // e_machine defaults to 'No Machine' - e_flags = 0; // e_flags defaults to 0, no flags. +char ELFWriter::ID = 0; +/// AddELFWriter - Concrete function to add the ELF writer to the function pass +/// manager. +MachineCodeEmitter *llvm::AddELFWriter(FunctionPassManager &FPM, + std::ostream &O, + TargetMachine &TM) { + ELFWriter *EW = new ELFWriter(O, TM); + FPM.add(EW); + return &EW->getMachineCodeEmitter(); +} + +//===----------------------------------------------------------------------===// +// ELFCodeEmitter Implementation +//===----------------------------------------------------------------------===// - is64Bit = TM.getTargetData().getPointerSizeInBits() == 64; - isLittleEndian = TM.getTargetData().isLittleEndian(); +namespace llvm { + /// ELFCodeEmitter - This class is used by the ELFWriter to emit the code for + /// functions to the ELF file. + class ELFCodeEmitter : public MachineCodeEmitter { + ELFWriter &EW; + TargetMachine &TM; + ELFWriter::ELFSection *ES; // Section to write to. + std::vector *OutBuffer; + size_t FnStart; + public: + explicit ELFCodeEmitter(ELFWriter &ew) : EW(ew), TM(EW.TM), OutBuffer(0) {} + + void startFunction(MachineFunction &F); + bool finishFunction(MachineFunction &F); + + void addRelocation(const MachineRelocation &MR) { + assert(0 && "relo not handled yet!"); + } + + virtual void StartMachineBasicBlock(MachineBasicBlock *MBB) { + } + + virtual intptr_t getConstantPoolEntryAddress(unsigned Index) const { + assert(0 && "CP not implementated yet!"); + return 0; + } + virtual intptr_t getJumpTableEntryAddress(unsigned Index) const { + assert(0 && "JT not implementated yet!"); + return 0; + } + + virtual intptr_t getMachineBasicBlockAddress(MachineBasicBlock *MBB) const { + assert(0 && "JT not implementated yet!"); + return 0; + } + + /// JIT SPECIFIC FUNCTIONS - DO NOT IMPLEMENT THESE HERE! + void startFunctionStub(unsigned StubSize, unsigned Alignment = 1) { + assert(0 && "JIT specific function called!"); + abort(); + } + void *finishFunctionStub(const Function *F) { + assert(0 && "JIT specific function called!"); + abort(); + return 0; + } + }; } -// doInitialization - Emit the file header and all of the global variables for -// the module to the ELF file. -bool ELFWriter::doInitialization(Module &M) { - outbyte(0x7F); // EI_MAG0 - outbyte('E'); // EI_MAG1 - outbyte('L'); // EI_MAG2 - outbyte('F'); // EI_MAG3 - outbyte(is64Bit ? 2 : 1); // EI_CLASS - outbyte(isLittleEndian ? 1 : 2); // EI_DATA - outbyte(1); // EI_VERSION - for (unsigned i = OutputBuffer.size(); i != 16; ++i) - outbyte(0); // EI_PAD up to 16 bytes. - - // This should change for shared objects. - outhalf(1); // e_type = ET_REL - outhalf(e_machine); // e_machine = whatever the target wants - outword(1); // e_version = 1 - outaddr(0); // e_entry = 0 -> no entry point in .o file - outaddr(0); // e_phoff = 0 -> no program header for .o - - ELFHeader_e_shoff_Offset = OutputBuffer.size(); - outaddr(0); // e_shoff - outword(e_flags); // e_flags = whatever the target wants - - assert(!is64Bit && "These sizes need to be adjusted for 64-bit!"); - outhalf(52); // e_ehsize = ELF header size - outhalf(0); // e_phentsize = prog header entry size - outhalf(0); // e_phnum = # prog header entries = 0 - outhalf(40); // e_shentsize = sect header entry size - - - ELFHeader_e_shnum_Offset = OutputBuffer.size(); - outhalf(0); // e_shnum = # of section header ents - ELFHeader_e_shstrndx_Offset = OutputBuffer.size(); - outhalf(0); // e_shstrndx = Section # of '.shstrtab' - - // Add the null section. - SectionList.push_back(ELFSection()); - - // Okay, the ELF header has been completed, emit the .data section next. - ELFSection DataSection(".data", OutputBuffer.size()); - for (Module::global_iterator I = M.global_begin(), E = M.global_end(); - I != E; ++I) - EmitDATASectionGlobal(I); +/// startFunction - This callback is invoked when a new machine function is +/// about to be emitted. +void ELFCodeEmitter::startFunction(MachineFunction &F) { + // Align the output buffer to the appropriate alignment. + unsigned Align = 16; // FIXME: GENERICIZE!! + // Get the ELF Section that this function belongs in. + ES = &EW.getSection(".text", ELFWriter::ELFSection::SHT_PROGBITS, + ELFWriter::ELFSection::SHF_EXECINSTR | + ELFWriter::ELFSection::SHF_ALLOC); + OutBuffer = &ES->SectionData; + cerr << "FIXME: This code needs to be updated for changes in the " + << "CodeEmitter interfaces. In particular, this should set " + << "BufferBegin/BufferEnd/CurBufferPtr, not deal with OutBuffer!"; + abort(); + + // Upgrade the section alignment if required. + if (ES->Align < Align) ES->Align = Align; + + // Add padding zeros to the end of the buffer to make sure that the + // function will start on the correct byte alignment within the section. + OutputBuffer OB(*OutBuffer, + TM.getTargetData()->getPointerSizeInBits() == 64, + TM.getTargetData()->isLittleEndian()); + OB.align(Align); + FnStart = OutBuffer->size(); +} - // If the .data section is nonempty, add it to our list. - if ((DataSection.Size = OutputBuffer.size()-DataSection.Offset)) { - DataSection.Align = 4; // FIXME: Compute! - SectionList.push_back(DataSection); +/// finishFunction - This callback is invoked after the function is completely +/// finished. +bool ELFCodeEmitter::finishFunction(MachineFunction &F) { + // We now know the size of the function, add a symbol to represent it. + ELFWriter::ELFSym FnSym(F.getFunction()); + + // Figure out the binding (linkage) of the symbol. + switch (F.getFunction()->getLinkage()) { + default: + // appending linkage is illegal for functions. + assert(0 && "Unknown linkage type!"); + case GlobalValue::ExternalLinkage: + FnSym.SetBind(ELFWriter::ELFSym::STB_GLOBAL); + break; + case GlobalValue::LinkOnceLinkage: + case GlobalValue::WeakLinkage: + FnSym.SetBind(ELFWriter::ELFSym::STB_WEAK); + break; + case GlobalValue::InternalLinkage: + FnSym.SetBind(ELFWriter::ELFSym::STB_LOCAL); + break; } - // Okay, emit the .bss section next. - ELFSection BSSSection(".bss", OutputBuffer.size()); - for (Module::global_iterator I = M.global_begin(), E = M.global_end(); - I != E; ++I) - EmitBSSSectionGlobal(I); + ES->Size = OutBuffer->size(); - // If the .bss section is nonempty, add it to our list. - if ((BSSSection.Size = OutputBuffer.size()-BSSSection.Offset)) { - BSSSection.Align = 4; // FIXME: Compute! - SectionList.push_back(BSSSection); - } + FnSym.SetType(ELFWriter::ELFSym::STT_FUNC); + FnSym.SectionIdx = ES->SectionIdx; + FnSym.Value = FnStart; // Value = Offset from start of Section. + FnSym.Size = OutBuffer->size()-FnStart; + // Finally, add it to the symtab. + EW.SymbolTable.push_back(FnSym); return false; } -// isCOMM - A global variable should be emitted to the common area if it is zero -// initialized and has linkage that permits it to be merged with other globals. -static bool isCOMM(GlobalVariable *GV) { - return GV->getInitializer()->isNullValue() && - (GV->hasLinkOnceLinkage() || GV->hasInternalLinkage() || - GV->hasWeakLinkage()); -} +//===----------------------------------------------------------------------===// +// ELFWriter Implementation +//===----------------------------------------------------------------------===// + +ELFWriter::ELFWriter(std::ostream &o, TargetMachine &tm) + : MachineFunctionPass((intptr_t)&ID), O(o), TM(tm) { + e_flags = 0; // e_flags defaults to 0, no flags. -// EmitDATASectionGlobal - Emit a global variable to the .data section if it -// belongs there. -void ELFWriter::EmitDATASectionGlobal(GlobalVariable *GV) { - if (!GV->hasInitializer()) return; + is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64; + isLittleEndian = TM.getTargetData()->isLittleEndian(); - // Do not emit a symbol here if it should be emitted to the common area. - if (isCOMM(GV)) return; + // Create the machine code emitter object for this target. + MCE = new ELFCodeEmitter(*this); + NumSections = 0; +} - EmitGlobal(GV); +ELFWriter::~ELFWriter() { + delete MCE; } -void ELFWriter::EmitBSSSectionGlobal(GlobalVariable *GV) { - if (!GV->hasInitializer()) return; +// doInitialization - Emit the file header and all of the global variables for +// the module to the ELF file. +bool ELFWriter::doInitialization(Module &M) { + Mang = new Mangler(M); + + // Local alias to shortenify coming code. + std::vector &FH = FileHeader; + OutputBuffer FHOut(FH, is64Bit, isLittleEndian); + + FHOut.outbyte(0x7F); // EI_MAG0 + FHOut.outbyte('E'); // EI_MAG1 + FHOut.outbyte('L'); // EI_MAG2 + FHOut.outbyte('F'); // EI_MAG3 + FHOut.outbyte(is64Bit ? 2 : 1); // EI_CLASS + FHOut.outbyte(isLittleEndian ? 1 : 2); // EI_DATA + FHOut.outbyte(1); // EI_VERSION + FH.resize(16); // EI_PAD up to 16 bytes. + + // This should change for shared objects. + FHOut.outhalf(1); // e_type = ET_REL + FHOut.outword(TM.getELFWriterInfo()->getEMachine()); // target-defined + FHOut.outword(1); // e_version = 1 + FHOut.outaddr(0); // e_entry = 0 -> no entry point in .o file + FHOut.outaddr(0); // e_phoff = 0 -> no program header for .o + + ELFHeader_e_shoff_Offset = FH.size(); + FHOut.outaddr(0); // e_shoff + FHOut.outword(e_flags); // e_flags = whatever the target wants + + FHOut.outhalf(is64Bit ? 64 : 52); // e_ehsize = ELF header size + FHOut.outhalf(0); // e_phentsize = prog header entry size + FHOut.outhalf(0); // e_phnum = # prog header entries = 0 + FHOut.outhalf(is64Bit ? 64 : 40); // e_shentsize = sect hdr entry size - // FIXME: We don't support BSS yet! - return; - EmitGlobal(GV); + ELFHeader_e_shnum_Offset = FH.size(); + FHOut.outhalf(0); // e_shnum = # of section header ents + ELFHeader_e_shstrndx_Offset = FH.size(); + FHOut.outhalf(0); // e_shstrndx = Section # of '.shstrtab' + + // Add the null section, which is required to be first in the file. + getSection("", 0, 0); + + // Start up the symbol table. The first entry in the symtab is the null + // entry. + SymbolTable.push_back(ELFSym(0)); + + return false; } void ELFWriter::EmitGlobal(GlobalVariable *GV) { + // If this is an external global, emit it now. TODO: Note that it would be + // better to ignore the symbol here and only add it to the symbol table if + // referenced. + if (!GV->hasInitializer()) { + ELFSym ExternalSym(GV); + ExternalSym.SetBind(ELFSym::STB_GLOBAL); + ExternalSym.SetType(ELFSym::STT_NOTYPE); + ExternalSym.SectionIdx = ELFSection::SHN_UNDEF; + SymbolTable.push_back(ExternalSym); + return; + } + + const Type *GVType = (const Type*)GV->getType(); + unsigned Align = TM.getTargetData()->getPreferredAlignment(GV); + unsigned Size = TM.getTargetData()->getABITypeSize(GVType); + + // If this global has a zero initializer, it is part of the .bss or common + // section. + if (GV->getInitializer()->isNullValue()) { + // If this global is part of the common block, add it now. Variables are + // part of the common block if they are zero initialized and allowed to be + // merged with other symbols. + if (GV->hasLinkOnceLinkage() || GV->hasWeakLinkage()) { + ELFSym CommonSym(GV); + // Value for common symbols is the alignment required. + CommonSym.Value = Align; + CommonSym.Size = Size; + CommonSym.SetBind(ELFSym::STB_GLOBAL); + CommonSym.SetType(ELFSym::STT_OBJECT); + // TODO SOMEDAY: add ELF visibility. + CommonSym.SectionIdx = ELFSection::SHN_COMMON; + SymbolTable.push_back(CommonSym); + return; + } + + // Otherwise, this symbol is part of the .bss section. Emit it now. + + // Handle alignment. Ensure section is aligned at least as much as required + // by this symbol. + ELFSection &BSSSection = getBSSSection(); + BSSSection.Align = std::max(BSSSection.Align, Align); + + // Within the section, emit enough virtual padding to get us to an alignment + // boundary. + if (Align) + BSSSection.Size = (BSSSection.Size + Align - 1) & ~(Align-1); + + ELFSym BSSSym(GV); + BSSSym.Value = BSSSection.Size; + BSSSym.Size = Size; + BSSSym.SetType(ELFSym::STT_OBJECT); + + switch (GV->getLinkage()) { + default: // weak/linkonce handled above + assert(0 && "Unexpected linkage type!"); + case GlobalValue::AppendingLinkage: // FIXME: This should be improved! + case GlobalValue::ExternalLinkage: + BSSSym.SetBind(ELFSym::STB_GLOBAL); + break; + case GlobalValue::InternalLinkage: + BSSSym.SetBind(ELFSym::STB_LOCAL); + break; + } + + // Set the idx of the .bss section + BSSSym.SectionIdx = BSSSection.SectionIdx; + SymbolTable.push_back(BSSSym); + + // Reserve space in the .bss section for this symbol. + BSSSection.Size += Size; + return; + } + + // FIXME: handle .rodata + //assert(!GV->isConstant() && "unimp"); + + // FIXME: handle .data + //assert(0 && "unimp"); } bool ELFWriter::runOnMachineFunction(MachineFunction &MF) { + // Nothing to do here, this is all done through the MCE object above. return false; } /// doFinalization - Now that the module has been completely processed, emit /// the ELF file to 'O'. bool ELFWriter::doFinalization(Module &M) { + // Okay, the ELF header and .text sections have been completed, build the + // .data, .bss, and "common" sections next. + for (Module::global_iterator I = M.global_begin(), E = M.global_end(); + I != E; ++I) + EmitGlobal(I); + + // Emit the symbol table now, if non-empty. + EmitSymbolTable(); + + // FIXME: Emit the relocations now. + // Emit the string table for the sections in the ELF file we have. EmitSectionTableStringTable(); - // Emit the .o file section table. - EmitSectionTable(); + // Emit the sections to the .o file, and emit the section table for the file. + OutputSectionsAndSectionTable(); - // Emit the .o file to the specified stream. - O.write((char*)&OutputBuffer[0], OutputBuffer.size()); + // We are done with the abstract symbols. + SectionList.clear(); + NumSections = 0; - // Free the output buffer. - std::vector().swap(OutputBuffer); + // Release the name mangler object. + delete Mang; Mang = 0; return false; } +/// EmitSymbolTable - If the current symbol table is non-empty, emit the string +/// table for it and then the symbol table itself. +void ELFWriter::EmitSymbolTable() { + if (SymbolTable.size() == 1) return; // Only the null entry. + + // FIXME: compact all local symbols to the start of the symtab. + unsigned FirstNonLocalSymbol = 1; + + ELFSection &StrTab = getSection(".strtab", ELFSection::SHT_STRTAB, 0); + StrTab.Align = 1; + + DataBuffer &StrTabBuf = StrTab.SectionData; + OutputBuffer StrTabOut(StrTabBuf, is64Bit, isLittleEndian); + + // Set the zero'th symbol to a null byte, as required. + StrTabOut.outbyte(0); + SymbolTable[0].NameIdx = 0; + unsigned Index = 1; + for (unsigned i = 1, e = SymbolTable.size(); i != e; ++i) { + // Use the name mangler to uniquify the LLVM symbol. + std::string Name = Mang->getValueName(SymbolTable[i].GV); + + if (Name.empty()) { + SymbolTable[i].NameIdx = 0; + } else { + SymbolTable[i].NameIdx = Index; + + // Add the name to the output buffer, including the null terminator. + StrTabBuf.insert(StrTabBuf.end(), Name.begin(), Name.end()); + + // Add a null terminator. + StrTabBuf.push_back(0); + + // Keep track of the number of bytes emitted to this section. + Index += Name.size()+1; + } + } + assert(Index == StrTabBuf.size()); + StrTab.Size = Index; + + // Now that we have emitted the string table and know the offset into the + // string table of each symbol, emit the symbol table itself. + ELFSection &SymTab = getSection(".symtab", ELFSection::SHT_SYMTAB, 0); + SymTab.Align = is64Bit ? 8 : 4; + SymTab.Link = SymTab.SectionIdx; // Section Index of .strtab. + SymTab.Info = FirstNonLocalSymbol; // First non-STB_LOCAL symbol. + SymTab.EntSize = 16; // Size of each symtab entry. FIXME: wrong for ELF64 + DataBuffer &SymTabBuf = SymTab.SectionData; + OutputBuffer SymTabOut(SymTabBuf, is64Bit, isLittleEndian); + + if (!is64Bit) { // 32-bit and 64-bit formats are shuffled a bit. + for (unsigned i = 0, e = SymbolTable.size(); i != e; ++i) { + ELFSym &Sym = SymbolTable[i]; + SymTabOut.outword(Sym.NameIdx); + SymTabOut.outaddr32(Sym.Value); + SymTabOut.outword(Sym.Size); + SymTabOut.outbyte(Sym.Info); + SymTabOut.outbyte(Sym.Other); + SymTabOut.outhalf(Sym.SectionIdx); + } + } else { + for (unsigned i = 0, e = SymbolTable.size(); i != e; ++i) { + ELFSym &Sym = SymbolTable[i]; + SymTabOut.outword(Sym.NameIdx); + SymTabOut.outbyte(Sym.Info); + SymTabOut.outbyte(Sym.Other); + SymTabOut.outhalf(Sym.SectionIdx); + SymTabOut.outaddr64(Sym.Value); + SymTabOut.outxword(Sym.Size); + } + } + + SymTab.Size = SymTabBuf.size(); +} + /// EmitSectionTableStringTable - This method adds and emits a section for the /// ELF Section Table string table: the string table that holds all of the /// section names. void ELFWriter::EmitSectionTableStringTable() { // First step: add the section for the string table to the list of sections: - SectionList.push_back(ELFSection(".shstrtab", OutputBuffer.size())); - SectionList.back().Type = 3; // SHT_STRTAB + ELFSection &SHStrTab = getSection(".shstrtab", ELFSection::SHT_STRTAB, 0); // Now that we know which section number is the .shstrtab section, update the // e_shstrndx entry in the ELF header. - fixhalf(SectionList.size()-1, ELFHeader_e_shstrndx_Offset); + OutputBuffer FHOut(FileHeader, is64Bit, isLittleEndian); + FHOut.fixhalf(SHStrTab.SectionIdx, ELFHeader_e_shstrndx_Offset); // Set the NameIdx of each section in the string table and emit the bytes for // the string table. unsigned Index = 0; + DataBuffer &Buf = SHStrTab.SectionData; - for (unsigned i = 0, e = SectionList.size(); i != e; ++i) { + for (std::list::iterator I = SectionList.begin(), + E = SectionList.end(); I != E; ++I) { // Set the index into the table. Note if we have lots of entries with // common suffixes, we could memoize them here if we cared. - SectionList[i].NameIdx = Index; + I->NameIdx = Index; // Add the name to the output buffer, including the null terminator. - OutputBuffer.insert(OutputBuffer.end(), SectionList[i].Name.begin(), - SectionList[i].Name.end()); + Buf.insert(Buf.end(), I->Name.begin(), I->Name.end()); + // Add a null terminator. - OutputBuffer.push_back(0); + Buf.push_back(0); // Keep track of the number of bytes emitted to this section. - Index += SectionList[i].Name.size()+1; + Index += I->Name.size()+1; } // Set the size of .shstrtab now that we know what it is. - SectionList.back().Size = Index; + assert(Index == Buf.size()); + SHStrTab.Size = Index; } -/// EmitSectionTable - Now that we have emitted the entire contents of the file -/// (all of the sections), emit the section table which informs the reader where -/// the boundaries are. -void ELFWriter::EmitSectionTable() { - // Now that all of the sections have been emitted, set the e_shnum entry in - // the ELF header. - fixhalf(SectionList.size(), ELFHeader_e_shnum_Offset); - - // Now that we know the offset in the file of the section table (which we emit - // next), update the e_shoff address in the ELF header. - fixaddr(OutputBuffer.size(), ELFHeader_e_shoff_Offset); - - // Emit all of the section table entries. - for (unsigned i = 0, e = SectionList.size(); i != e; ++i) { - const ELFSection &S = SectionList[i]; - outword(S.NameIdx); // sh_name - Symbol table name idx - outword(S.Type); // sh_type - Section contents & semantics - outword(S.Flags); // sh_flags - Section flags. - outaddr(S.Addr); // sh_addr - The mem address this section appears in. - outaddr(S.Offset); // sh_offset - The offset from the start of the file. - outword(S.Size); // sh_size - The section size. - outword(S.Link); // sh_link - Section header table index link. - outword(S.Info); // sh_info - Auxillary information. - outword(S.Align); // sh_addralign - Alignment of section. - outword(S.EntSize); // sh_entsize - Size of each entry in the section. +/// OutputSectionsAndSectionTable - Now that we have constructed the file header +/// and all of the sections, emit these to the ostream destination and emit the +/// SectionTable. +void ELFWriter::OutputSectionsAndSectionTable() { + // Pass #1: Compute the file offset for each section. + size_t FileOff = FileHeader.size(); // File header first. + + // Emit all of the section data in order. + for (std::list::iterator I = SectionList.begin(), + E = SectionList.end(); I != E; ++I) { + // Align FileOff to whatever the alignment restrictions of the section are. + if (I->Align) + FileOff = (FileOff+I->Align-1) & ~(I->Align-1); + I->Offset = FileOff; + FileOff += I->SectionData.size(); } - // Release the memory allocated for the section list. - std::vector().swap(SectionList); + // Align Section Header. + unsigned TableAlign = is64Bit ? 8 : 4; + FileOff = (FileOff+TableAlign-1) & ~(TableAlign-1); + + // Now that we know where all of the sections will be emitted, set the e_shnum + // entry in the ELF header. + OutputBuffer FHOut(FileHeader, is64Bit, isLittleEndian); + FHOut.fixhalf(NumSections, ELFHeader_e_shnum_Offset); + + // Now that we know the offset in the file of the section table, update the + // e_shoff address in the ELF header. + FHOut.fixaddr(FileOff, ELFHeader_e_shoff_Offset); + + // Now that we know all of the data in the file header, emit it and all of the + // sections! + O.write((char*)&FileHeader[0], FileHeader.size()); + FileOff = FileHeader.size(); + DataBuffer().swap(FileHeader); + + DataBuffer Table; + OutputBuffer TableOut(Table, is64Bit, isLittleEndian); + + // Emit all of the section data and build the section table itself. + while (!SectionList.empty()) { + const ELFSection &S = *SectionList.begin(); + + // Align FileOff to whatever the alignment restrictions of the section are. + if (S.Align) + for (size_t NewFileOff = (FileOff+S.Align-1) & ~(S.Align-1); + FileOff != NewFileOff; ++FileOff) + O.put((char)0xAB); + O.write((char*)&S.SectionData[0], S.SectionData.size()); + FileOff += S.SectionData.size(); + + TableOut.outword(S.NameIdx); // sh_name - Symbol table name idx + TableOut.outword(S.Type); // sh_type - Section contents & semantics + TableOut.outword(S.Flags); // sh_flags - Section flags. + TableOut.outaddr(S.Addr); // sh_addr - The mem addr this section is in. + TableOut.outaddr(S.Offset); // sh_offset - Offset from the file start. + TableOut.outword(S.Size); // sh_size - The section size. + TableOut.outword(S.Link); // sh_link - Section header table index link. + TableOut.outword(S.Info); // sh_info - Auxillary information. + TableOut.outword(S.Align); // sh_addralign - Alignment of section. + TableOut.outword(S.EntSize); // sh_entsize - Size of entries in the section + + SectionList.pop_front(); + } + + // Align output for the section table. + for (size_t NewFileOff = (FileOff+TableAlign-1) & ~(TableAlign-1); + FileOff != NewFileOff; ++FileOff) + O.put((char)0xAB); + + // Emit the section table itself. + O.write((char*)&Table[0], Table.size()); }