X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FELFWriter.cpp;h=27f23f45cc0677af6a4466367e17eee8cb30e127;hb=990f032907ae171cc3d465a694e8e6d2a6545f57;hp=b58fc1ff0a907049586562cee7467e7e858477e2;hpb=ed0c4ecf05e8fed9d76ed649c2dba0a238032a00;p=oota-llvm.git diff --git a/lib/CodeGen/ELFWriter.cpp b/lib/CodeGen/ELFWriter.cpp index b58fc1ff0a9..27f23f45cc0 100644 --- a/lib/CodeGen/ELFWriter.cpp +++ b/lib/CodeGen/ELFWriter.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by Chris Lattner 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. // //===----------------------------------------------------------------------===// // @@ -31,14 +31,33 @@ // //===----------------------------------------------------------------------===// -#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; +char ELFWriter::ID = 0; +/// AddELFWriter - Concrete function to add the ELF writer to the function pass +/// manager. +MachineCodeEmitter *llvm::AddELFWriter(PassManagerBase &PM, + std::ostream &O, + TargetMachine &TM) { + ELFWriter *EW = new ELFWriter(O, TM); + PM.add(EW); + return &EW->getMachineCodeEmitter(); +} + //===----------------------------------------------------------------------===// // ELFCodeEmitter Implementation //===----------------------------------------------------------------------===// @@ -48,53 +67,59 @@ namespace llvm { /// 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: - ELFCodeEmitter(ELFWriter &ew) : EW(ew), OutBuffer(0) {} + explicit ELFCodeEmitter(ELFWriter &ew) : EW(ew), TM(EW.TM), OutBuffer(0) {} void startFunction(MachineFunction &F); - void finishFunction(MachineFunction &F); + bool finishFunction(MachineFunction &F); - void emitConstantPool(MachineConstantPool *MCP) { - if (MCP->isEmpty()) return; - assert(0 && "unimp"); - } - virtual void emitByte(unsigned char B) { - OutBuffer->push_back(B); - } - virtual void emitWordAt(unsigned W, unsigned *Ptr) { - assert(0 && "ni"); - } - virtual void emitWord(unsigned W) { - assert(0 && "ni"); - } - virtual uint64_t getCurrentPCValue() { - return OutBuffer->size(); - } - virtual uint64_t getCurrentPCOffset() { - return OutBuffer->size()-FnStart; - } void addRelocation(const MachineRelocation &MR) { assert(0 && "relo not handled yet!"); } - virtual uint64_t getConstantPoolEntryAddress(unsigned Index) { + + 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 unsigned char* allocateGlobal(unsigned size, unsigned alignment) { - assert(0 && "Globals not implemented yet!"); + virtual intptr_t getMachineBasicBlockAddress(MachineBasicBlock *MBB) const { + assert(0 && "JT not implementated yet!"); return 0; } + virtual intptr_t getLabelAddress(uint64_t Label) const { + assert(0 && "Label address not implementated yet!"); + abort(); + return 0; + } + + virtual void emitLabel(uint64_t LabelID) { + assert(0 && "emit Label not implementated yet!"); + abort(); + } + + + virtual void setModuleInfo(llvm::MachineModuleInfo* MMI) { } + + /// JIT SPECIFIC FUNCTIONS - DO NOT IMPLEMENT THESE HERE! - void startFunctionStub(unsigned StubSize) { + void startFunctionStub(const GlobalValue* F, unsigned StubSize, + unsigned Alignment = 1) { assert(0 && "JIT specific function called!"); abort(); } - void *finishFunctionStub(const Function *F) { + void *finishFunctionStub(const GlobalValue *F) { assert(0 && "JIT specific function called!"); abort(); return 0; @@ -112,21 +137,26 @@ void ELFCodeEmitter::startFunction(MachineFunction &F) { 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. - size_t SectionOff = OutBuffer->size(); - ELFWriter::align(*OutBuffer, Align); - + OutputBuffer OB(*OutBuffer, + TM.getTargetData()->getPointerSizeInBits() == 64, + TM.getTargetData()->isLittleEndian()); + OB.align(Align); FnStart = OutBuffer->size(); } /// finishFunction - This callback is invoked after the function is completely /// finished. -void ELFCodeEmitter::finishFunction(MachineFunction &F) { +bool ELFCodeEmitter::finishFunction(MachineFunction &F) { // We now know the size of the function, add a symbol to represent it. ELFWriter::ELFSym FnSym(F.getFunction()); @@ -151,23 +181,24 @@ void ELFCodeEmitter::finishFunction(MachineFunction &F) { FnSym.SetType(ELFWriter::ELFSym::STT_FUNC); FnSym.SectionIdx = ES->SectionIdx; - FnSym.Value = FnStart; // Value = Offset from start of Section. + 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; } //===----------------------------------------------------------------------===// // ELFWriter Implementation //===----------------------------------------------------------------------===// -ELFWriter::ELFWriter(std::ostream &o, TargetMachine &tm) : O(o), TM(tm) { - e_machine = 0; // e_machine defaults to 'No Machine' +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. - is64Bit = TM.getTargetData().getPointerSizeInBits() == 64; - isLittleEndian = TM.getTargetData().isLittleEndian(); + is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64; + isLittleEndian = TM.getTargetData()->isLittleEndian(); // Create the machine code emitter object for this target. MCE = new ELFCodeEmitter(*this); @@ -185,37 +216,38 @@ bool ELFWriter::doInitialization(Module &M) { // Local alias to shortenify coming code. std::vector &FH = FileHeader; - - outbyte(FH, 0x7F); // EI_MAG0 - outbyte(FH, 'E'); // EI_MAG1 - outbyte(FH, 'L'); // EI_MAG2 - outbyte(FH, 'F'); // EI_MAG3 - outbyte(FH, is64Bit ? 2 : 1); // EI_CLASS - outbyte(FH, isLittleEndian ? 1 : 2); // EI_DATA - outbyte(FH, 1); // EI_VERSION + 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. - outhalf(FH, 1); // e_type = ET_REL - outhalf(FH, e_machine); // e_machine = whatever the target wants - outword(FH, 1); // e_version = 1 - outaddr(FH, 0); // e_entry = 0 -> no entry point in .o file - outaddr(FH, 0); // e_phoff = 0 -> no program header for .o + FHOut.outhalf(1); // e_type = ET_REL + FHOut.outhalf(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(); - outaddr(FH, 0); // e_shoff - outword(FH, e_flags); // e_flags = whatever the target wants + FHOut.outaddr(0); // e_shoff + FHOut.outword(e_flags); // e_flags = whatever the target wants - outhalf(FH, is64Bit ? 64 : 52); // e_ehsize = ELF header size - outhalf(FH, 0); // e_phentsize = prog header entry size - outhalf(FH, 0); // e_phnum = # prog header entries = 0 - outhalf(FH, is64Bit ? 64 : 40); // e_shentsize = sect hdr entry size + 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 ELFHeader_e_shnum_Offset = FH.size(); - outhalf(FH, 0); // e_shnum = # of section header ents + FHOut.outhalf(0); // e_shnum = # of section header ents ELFHeader_e_shstrndx_Offset = FH.size(); - outhalf(FH, 0); // e_shstrndx = Section # of '.shstrtab' + FHOut.outhalf(0); // e_shstrndx = Section # of '.shstrtab' // Add the null section, which is required to be first in the file. getSection("", 0, 0); @@ -241,8 +273,8 @@ void ELFWriter::EmitGlobal(GlobalVariable *GV) { } const Type *GVType = (const Type*)GV->getType(); - unsigned Align = TM.getTargetData().getTypeAlignment(GVType); - unsigned Size = TM.getTargetData().getTypeSize(GVType); + 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. @@ -250,7 +282,8 @@ void ELFWriter::EmitGlobal(GlobalVariable *GV) { // 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()) { + if (GV->hasLinkOnceLinkage() || GV->hasWeakLinkage() || + GV->hasCommonLinkage()) { ELFSym CommonSym(GV); // Value for common symbols is the alignment required. CommonSym.Value = Align; @@ -281,7 +314,7 @@ void ELFWriter::EmitGlobal(GlobalVariable *GV) { BSSSym.SetType(ELFSym::STT_OBJECT); switch (GV->getLinkage()) { - default: // weak/linkonce handled above + default: // weak/linkonce/common handled above assert(0 && "Unexpected linkage type!"); case GlobalValue::AppendingLinkage: // FIXME: This should be improved! case GlobalValue::ExternalLinkage: @@ -355,9 +388,10 @@ void ELFWriter::EmitSymbolTable() { StrTab.Align = 1; DataBuffer &StrTabBuf = StrTab.SectionData; + OutputBuffer StrTabOut(StrTabBuf, is64Bit, isLittleEndian); // Set the zero'th symbol to a null byte, as required. - outbyte(StrTabBuf, 0); + StrTabOut.outbyte(0); SymbolTable[0].NameIdx = 0; unsigned Index = 1; for (unsigned i = 1, e = SymbolTable.size(); i != e; ++i) { @@ -390,26 +424,27 @@ void ELFWriter::EmitSymbolTable() { 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]; - outword(SymTabBuf, Sym.NameIdx); - outaddr32(SymTabBuf, Sym.Value); - outword(SymTabBuf, Sym.Size); - outbyte(SymTabBuf, Sym.Info); - outbyte(SymTabBuf, Sym.Other); - outhalf(SymTabBuf, Sym.SectionIdx); + 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]; - outword(SymTabBuf, Sym.NameIdx); - outbyte(SymTabBuf, Sym.Info); - outbyte(SymTabBuf, Sym.Other); - outhalf(SymTabBuf, Sym.SectionIdx); - outaddr64(SymTabBuf, Sym.Value); - outxword(SymTabBuf, Sym.Size); + SymTabOut.outword(Sym.NameIdx); + SymTabOut.outbyte(Sym.Info); + SymTabOut.outbyte(Sym.Other); + SymTabOut.outhalf(Sym.SectionIdx); + SymTabOut.outaddr64(Sym.Value); + SymTabOut.outxword(Sym.Size); } } @@ -425,7 +460,8 @@ void ELFWriter::EmitSectionTableStringTable() { // Now that we know which section number is the .shstrtab section, update the // e_shstrndx entry in the ELF header. - fixhalf(FileHeader, SHStrTab.SectionIdx, 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. @@ -476,11 +512,12 @@ void ELFWriter::OutputSectionsAndSectionTable() { // Now that we know where all of the sections will be emitted, set the e_shnum // entry in the ELF header. - fixhalf(FileHeader, NumSections, ELFHeader_e_shnum_Offset); + 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. - fixaddr(FileHeader, FileOff, ELFHeader_e_shoff_Offset); + 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! @@ -489,6 +526,7 @@ void ELFWriter::OutputSectionsAndSectionTable() { 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()) { @@ -502,16 +540,16 @@ void ELFWriter::OutputSectionsAndSectionTable() { O.write((char*)&S.SectionData[0], S.SectionData.size()); FileOff += S.SectionData.size(); - outword(Table, S.NameIdx); // sh_name - Symbol table name idx - outword(Table, S.Type); // sh_type - Section contents & semantics - outword(Table, S.Flags); // sh_flags - Section flags. - outaddr(Table, S.Addr); // sh_addr - The mem addr this section is in. - outaddr(Table, S.Offset); // sh_offset - Offset from the file start. - outword(Table, S.Size); // sh_size - The section size. - outword(Table, S.Link); // sh_link - Section header table index link. - outword(Table, S.Info); // sh_info - Auxillary information. - outword(Table, S.Align); // sh_addralign - Alignment of section. - outword(Table, S.EntSize); // sh_entsize - Size of entries in the section. + 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(); }