X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FELFWriter.cpp;h=4ad2f8bd53eeeb855a25ea9348a866d633fc6ec3;hb=a6b677d209013d82b03fa8da937296b6faae7de0;hp=47789c1ffe8d7062e33e8737de76c698bedad70f;hpb=5c2f789952ff315021afb10381f141f2ac3b1a6b;p=oota-llvm.git diff --git a/lib/CodeGen/ELFWriter.cpp b/lib/CodeGen/ELFWriter.cpp index 47789c1ffe8..4ad2f8bd53e 100644 --- a/lib/CodeGen/ELFWriter.cpp +++ b/lib/CodeGen/ELFWriter.cpp @@ -42,9 +42,13 @@ #include "llvm/CodeGen/ObjectCodeEmitter.h" #include "llvm/CodeGen/MachineCodeEmitter.h" #include "llvm/CodeGen/MachineConstantPool.h" +#include "llvm/MC/MCContext.h" +#include "llvm/MC/MCSectionELF.h" #include "llvm/Target/TargetAsmInfo.h" #include "llvm/Target/TargetData.h" #include "llvm/Target/TargetELFWriterInfo.h" +#include "llvm/Target/TargetLowering.h" +#include "llvm/Target/TargetLoweringObjectFile.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Support/Mangler.h" #include "llvm/Support/Streams.h" @@ -71,6 +75,8 @@ ObjectCodeEmitter *llvm::AddELFWriter(PassManagerBase &PM, ELFWriter::ELFWriter(raw_ostream &o, TargetMachine &tm) : MachineFunctionPass(&ID), O(o), TM(tm), + OutContext(*new MCContext()), + TLOF(TM.getTargetLowering()->getObjFileLowering()), is64Bit(TM.getTargetData()->getPointerSizeInBits() == 64), isLittleEndian(TM.getTargetData()->isLittleEndian()), ElfHdr(isLittleEndian, is64Bit) { @@ -87,11 +93,15 @@ ELFWriter::ELFWriter(raw_ostream &o, TargetMachine &tm) ELFWriter::~ELFWriter() { delete ElfCE; + delete &OutContext; } // doInitialization - Emit the file header and all of the global variables for // the module to the ELF file. bool ELFWriter::doInitialization(Module &M) { + // Initialize TargetLoweringObjectFile. + const_cast(TLOF).Initialize(OutContext, TM); + Mang = new Mangler(M); // ELF Header @@ -141,42 +151,93 @@ bool ELFWriter::doInitialization(Module &M) { // Add the null section, which is required to be first in the file. getNullSection(); + // The first entry in the symtab is the null symbol and the second + // is a local symbol containing the module/file name + SymbolList.push_back(new ELFSym()); + SymbolList.push_back(ELFSym::getFileSym()); + return false; } -// Get jump table section on the section name returned by TAI +// addGlobalSymbol - Add a global to be processed and to the global symbol +// lookup, use a zero index because the table index will be determined later. +void ELFWriter::addGlobalSymbol(const GlobalValue *GV, + bool AddToLookup /* = false */) { + PendingGlobals.insert(GV); + if (AddToLookup) + GblSymLookup[GV] = 0; +} + +// addExternalSymbol - Add the external to be processed and to the +// external symbol lookup, use a zero index because the symbol +// table index will be determined later +void ELFWriter::addExternalSymbol(const char *External) { + PendingExternals.insert(External); + ExtSymLookup[External] = 0; +} + +// getCtorSection - Get the static constructor section +ELFSection &ELFWriter::getCtorSection() { + const MCSectionELF *Ctor = (const MCSectionELF *)TLOF.getStaticCtorSection(); + return getSection(Ctor->getSectionName(), ELFSection::SHT_PROGBITS, + getElfSectionFlags(Ctor->getKind())); +} + +// getDtorSection - Get the static destructor section +ELFSection &ELFWriter::getDtorSection() { + const MCSectionELF *Dtor = (const MCSectionELF *)TLOF.getStaticDtorSection(); + return getSection(Dtor->getSectionName(), ELFSection::SHT_PROGBITS, + getElfSectionFlags(Dtor->getKind())); +} + +// getTextSection - Get the text section for the specified function +ELFSection &ELFWriter::getTextSection(Function *F) { + const MCSectionELF *Text = + (const MCSectionELF *)TLOF.SectionForGlobal(F, Mang, TM); + return getSection(Text->getSectionName(), ELFSection::SHT_PROGBITS, + getElfSectionFlags(Text->getKind())); +} + +// getJumpTableSection - Get a read only section for constants when +// emitting jump tables. TODO: add PIC support ELFSection &ELFWriter::getJumpTableSection() { - unsigned Align = TM.getTargetData()->getPointerABIAlignment(); - return getSection(TAI->getJumpTableDataSection(), + const MCSectionELF *JT = + (const MCSectionELF *)TLOF.getSectionForConstant(SectionKind::getReadOnly()); + return getSection(JT->getSectionName(), ELFSection::SHT_PROGBITS, - ELFSection::SHF_ALLOC, Align); + getElfSectionFlags(JT->getKind()), + TM.getTargetData()->getPointerABIAlignment()); } -// Get a constant pool section based on the section name returned by TAI +// getConstantPoolSection - Get a constant pool section based on the machine +// constant pool entry type and relocation info. ELFSection &ELFWriter::getConstantPoolSection(MachineConstantPoolEntry &CPE) { SectionKind Kind; switch (CPE.getRelocationInfo()) { default: llvm_unreachable("Unknown section kind"); case 2: Kind = SectionKind::getReadOnlyWithRel(); break; - case 1: Kind = SectionKind::getReadOnlyWithRelLocal(); break; + case 1: + Kind = SectionKind::getReadOnlyWithRelLocal(); + break; case 0: switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) { - case 4: Kind = SectionKind::getMergableConst4(); break; - case 8: Kind = SectionKind::getMergableConst8(); break; - case 16: Kind = SectionKind::getMergableConst16(); break; - default: Kind = SectionKind::getMergableConst(); break; + case 4: Kind = SectionKind::getMergeableConst4(); break; + case 8: Kind = SectionKind::getMergeableConst8(); break; + case 16: Kind = SectionKind::getMergeableConst16(); break; + default: Kind = SectionKind::getMergeableConst(); break; } } - - std::string CstPoolName = TAI->getSectionForMergableConstant(Kind)->getName(); - return getSection(CstPoolName, + + const MCSectionELF *CPSect = + (const MCSectionELF *)TLOF.getSectionForConstant(Kind); + return getSection(CPSect->getSectionName(), ELFSection::SHT_PROGBITS, - ELFSection::SHF_MERGE | ELFSection::SHF_ALLOC, + getElfSectionFlags(Kind), CPE.getAlignment()); } -// Return the relocation section of section 'S'. 'RelA' is true -// if the relocation section contains entries with addends. +// getRelocSection - Return the relocation section of section 'S'. 'RelA' +// is true if the relocation section contains entries with addends. ELFSection &ELFWriter::getRelocSection(ELFSection &S) { unsigned SectionHeaderTy = TEW->hasRelocationAddend() ? ELFSection::SHT_RELA : ELFSection::SHT_REL; @@ -208,7 +269,7 @@ unsigned ELFWriter::getGlobalELFBinding(const GlobalValue *GV) { if (GV->hasInternalLinkage()) return ELFSym::STB_LOCAL; - if (GV->hasWeakLinkage()) + if (GV->isWeakForLinker() && !GV->hasCommonLinkage()) return ELFSym::STB_WEAK; return ELFSym::STB_GLOBAL; @@ -226,48 +287,53 @@ unsigned ELFWriter::getGlobalELFType(const GlobalValue *GV) { } // getElfSectionFlags - Get the ELF Section Header flags based -// on the flags defined in ELFTargetAsmInfo. -unsigned ELFWriter::getElfSectionFlags(unsigned Flags) { - unsigned ElfSectionFlags = ELFSection::SHF_ALLOC; - - if (Flags & SectionFlags::Code) +// on the flags defined in SectionKind.h. +unsigned ELFWriter::getElfSectionFlags(SectionKind Kind, bool IsAlloc) { + unsigned ElfSectionFlags = 0; + + if (IsAlloc) + ElfSectionFlags |= ELFSection::SHF_ALLOC; + if (Kind.isText()) ElfSectionFlags |= ELFSection::SHF_EXECINSTR; - if (Flags & SectionFlags::Writable) + if (Kind.isWriteable()) ElfSectionFlags |= ELFSection::SHF_WRITE; - if (Flags & SectionFlags::Mergeable) + if (Kind.isMergeableConst() || Kind.isMergeableCString()) ElfSectionFlags |= ELFSection::SHF_MERGE; - if (Flags & SectionFlags::TLS) + if (Kind.isThreadLocal()) ElfSectionFlags |= ELFSection::SHF_TLS; - if (Flags & SectionFlags::Strings) + if (Kind.isMergeableCString()) ElfSectionFlags |= ELFSection::SHF_STRINGS; return ElfSectionFlags; } +// isUndefOrNull - The constant is either a null initialized value or an +// undefined one. +static bool isUndefOrNull(const Constant *CV) { + return (CV->isNullValue() || isa(CV)); +} + // isELFUndefSym - the symbol has no section and must be placed in // the symbol table with a reference to the null section. static bool isELFUndefSym(const GlobalValue *GV) { - return GV->isDeclaration(); + // Functions which make up until this point references are an undef symbol + return GV->isDeclaration() || (isa(GV)); } // isELFBssSym - for an undef or null value, the symbol must go to a bss // section if it's not weak for linker, otherwise it's a common sym. -static bool isELFBssSym(const GlobalVariable *GV) { +static bool isELFBssSym(const GlobalVariable *GV, SectionKind Kind) { const Constant *CV = GV->getInitializer(); - return ((CV->isNullValue() || isa(CV)) && !GV->isWeakForLinker()); + + return (!Kind.isMergeableCString() && + isUndefOrNull(CV) && + !GV->isWeakForLinker()); } // isELFCommonSym - for an undef or null value, the symbol must go to a // common section if it's weak for linker, otherwise bss. static bool isELFCommonSym(const GlobalVariable *GV) { - const Constant *CV = GV->getInitializer(); - return ((CV->isNullValue() || isa(CV)) && GV->isWeakForLinker()); -} - -// isELFDataSym - if the symbol is an initialized but no null constant -// it must go to some kind of data section gathered from TAI -static bool isELFDataSym(const Constant *CV) { - return (!(CV->isNullValue() || isa(CV))); + return (isUndefOrNull(GV->getInitializer()) && GV->isWeakForLinker()); } // EmitGlobal - Choose the right section for global and emit it @@ -279,20 +345,26 @@ void ELFWriter::EmitGlobal(const GlobalValue *GV) { // Handle ELF Bind, Visibility and Type for the current symbol unsigned SymBind = getGlobalELFBinding(GV); - ELFSym *GblSym = new ELFSym(GV); - GblSym->setBind(SymBind); - GblSym->setVisibility(getGlobalELFVisibility(GV)); - GblSym->setType(getGlobalELFType(GV)); + unsigned SymType = getGlobalELFType(GV); - if (isELFUndefSym(GV)) { - GblSym->SectionIdx = ELFSection::SHN_UNDEF; - } else { + // All undef symbols have the same binding, type and visibily and + // are classified regardless of their type. + ELFSym *GblSym = isELFUndefSym(GV) ? ELFSym::getUndefGV(GV, SymBind) + : ELFSym::getGV(GV, SymBind, SymType, getGlobalELFVisibility(GV)); + + if (!isELFUndefSym(GV)) { assert(isa(GV) && "GV not a global variable!"); const GlobalVariable *GVar = dyn_cast(GV); - // Get ELF section from TAI - const Section *S = TAI->SectionForGlobal(GV); - unsigned SectionFlags = getElfSectionFlags(S->getFlags()); + // Handle special llvm globals + if (EmitSpecialLLVMGlobal(GVar)) + return; + + // Get the ELF section where this global belongs from TLOF + const MCSectionELF *S = + (const MCSectionELF *)TLOF.SectionForGlobal(GV, Mang, TM); + SectionKind Kind = S->getKind(); + unsigned SectionFlags = getElfSectionFlags(Kind); // The symbol align should update the section alignment if needed const TargetData *TD = TM.getTargetData(); @@ -302,16 +374,18 @@ void ELFWriter::EmitGlobal(const GlobalValue *GV) { if (isELFCommonSym(GVar)) { GblSym->SectionIdx = ELFSection::SHN_COMMON; - getSection(S->getName(), ELFSection::SHT_NOBITS, SectionFlags, 1); + getSection(S->getSectionName(), + ELFSection::SHT_NOBITS, SectionFlags, 1); // A new linkonce section is created for each global in the // common section, the default alignment is 1 and the symbol // value contains its alignment. GblSym->Value = Align; - } else if (isELFBssSym(GVar)) { + } else if (isELFBssSym(GVar, Kind)) { ELFSection &ES = - getSection(S->getName(), ELFSection::SHT_NOBITS, SectionFlags); + getSection(S->getSectionName(), ELFSection::SHT_NOBITS, + SectionFlags); GblSym->SectionIdx = ES.SectionIdx; // Update the size with alignment and the next object can @@ -324,32 +398,35 @@ void ELFWriter::EmitGlobal(const GlobalValue *GV) { GblSym->Value = ES.Size; ES.Size += Size; - } else if (isELFDataSym(GV)) { + } else { // The symbol must go to some kind of data section ELFSection &ES = - getSection(S->getName(), ELFSection::SHT_PROGBITS, SectionFlags); + getSection(S->getSectionName(), ELFSection::SHT_PROGBITS, + SectionFlags); GblSym->SectionIdx = ES.SectionIdx; // GblSym->Value should contain the symbol offset inside the section, // and all symbols should start on their required alignment boundary ES.Align = std::max(ES.Align, Align); - GblSym->Value = (ES.size() + (Align-1)) & (-Align); - ES.emitAlignment(ES.Align); + ES.emitAlignment(Align); + GblSym->Value = ES.size(); // Emit the global to the data section 'ES' EmitGlobalConstant(GVar->getInitializer(), ES); } } - // Private symbols must never go to the symbol table. - unsigned SymIdx = 0; if (GV->hasPrivateLinkage()) { + // For a private symbols, keep track of the index inside the + // private list since it will never go to the symbol table and + // won't be patched up later. PrivateSyms.push_back(GblSym); - SymIdx = PrivateSyms.size()-1; + GblSymLookup[GV] = PrivateSyms.size()-1; } else { + // Non private symbol are left with zero indices until they are patched + // up during the symbol table emition (where the indicies are created). SymbolList.push_back(GblSym); + GblSymLookup[GV] = 0; } - - setGlobalSymLookup(GV, SymIdx); } void ELFWriter::EmitGlobalConstantStruct(const ConstantStruct *CVS, @@ -375,8 +452,7 @@ void ELFWriter::EmitGlobalConstantStruct(const ConstantStruct *CVS, // Insert padding - this may include padding to increase the size of the // current field up to the ABI size (if the struct is not packed) as well // as padding to ensure that the next field starts at the right offset. - for (unsigned p=0; p < padSize; p++) - GblS.emitByte(0); + GblS.emitZeros(padSize); } assert(sizeSoFar == cvsLayout->getSizeInBytes() && "Layout of constant struct may be incorrect!"); @@ -387,75 +463,232 @@ void ELFWriter::EmitGlobalConstant(const Constant *CV, ELFSection &GblS) { unsigned Size = TD->getTypeAllocSize(CV->getType()); if (const ConstantArray *CVA = dyn_cast(CV)) { - if (CVA->isString()) { - std::string GblStr = CVA->getAsString(); - GblStr.resize(GblStr.size()-1); - GblS.emitString(GblStr); - } else { // Not a string. Print the values in successive locations - for (unsigned i = 0, e = CVA->getNumOperands(); i != e; ++i) - EmitGlobalConstant(CVA->getOperand(i), GblS); - } + for (unsigned i = 0, e = CVA->getNumOperands(); i != e; ++i) + EmitGlobalConstant(CVA->getOperand(i), GblS); + return; + } else if (isa(CV)) { + GblS.emitZeros(Size); return; } else if (const ConstantStruct *CVS = dyn_cast(CV)) { EmitGlobalConstantStruct(CVS, GblS); return; } else if (const ConstantFP *CFP = dyn_cast(CV)) { - uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue(); + APInt Val = CFP->getValueAPF().bitcastToAPInt(); if (CFP->getType() == Type::DoubleTy) - GblS.emitWord64(Val); + GblS.emitWord64(Val.getZExtValue()); else if (CFP->getType() == Type::FloatTy) - GblS.emitWord32(Val); + GblS.emitWord32(Val.getZExtValue()); else if (CFP->getType() == Type::X86_FP80Ty) { - llvm_unreachable("X86_FP80Ty global emission not implemented"); + unsigned PadSize = TD->getTypeAllocSize(Type::X86_FP80Ty)- + TD->getTypeStoreSize(Type::X86_FP80Ty); + GblS.emitWordFP80(Val.getRawData(), PadSize); } else if (CFP->getType() == Type::PPC_FP128Ty) llvm_unreachable("PPC_FP128Ty global emission not implemented"); return; } else if (const ConstantInt *CI = dyn_cast(CV)) { - if (Size == 4) + if (Size == 1) + GblS.emitByte(CI->getZExtValue()); + else if (Size == 2) + GblS.emitWord16(CI->getZExtValue()); + else if (Size == 4) GblS.emitWord32(CI->getZExtValue()); - else if (Size == 8) - GblS.emitWord64(CI->getZExtValue()); - else - llvm_unreachable("LargeInt global emission not implemented"); + else + EmitGlobalConstantLargeInt(CI, GblS); return; } else if (const ConstantVector *CP = dyn_cast(CV)) { const VectorType *PTy = CP->getType(); for (unsigned I = 0, E = PTy->getNumElements(); I < E; ++I) EmitGlobalConstant(CP->getOperand(I), GblS); return; + } else if (const ConstantExpr *CE = dyn_cast(CV)) { + // Resolve a constant expression which returns a (Constant, Offset) + // pair. If 'Res.first' is a GlobalValue, emit a relocation with + // the offset 'Res.second', otherwise emit a global constant like + // it is always done for not contant expression types. + CstExprResTy Res = ResolveConstantExpr(CE); + const Constant *Op = Res.first; + + if (isa(Op)) + EmitGlobalDataRelocation(cast(Op), + TD->getTypeAllocSize(Op->getType()), + GblS, Res.second); + else + EmitGlobalConstant(Op, GblS); + + return; + } else if (CV->getType()->getTypeID() == Type::PointerTyID) { + // Fill the data entry with zeros or emit a relocation entry + if (isa(CV)) + GblS.emitZeros(Size); + else + EmitGlobalDataRelocation(cast(CV), + Size, GblS); + return; } else if (const GlobalValue *GV = dyn_cast(CV)) { // This is a constant address for a global variable or function and // therefore must be referenced using a relocation entry. + EmitGlobalDataRelocation(GV, Size, GblS); + return; + } - // Check if the referenced symbol is already emitted - if (GblSymLookup.find(GV) == GblSymLookup.end()) - EmitGlobal(GV); + std::string msg; + raw_string_ostream ErrorMsg(msg); + ErrorMsg << "Constant unimp for type: " << *CV->getType(); + llvm_report_error(ErrorMsg.str()); +} - // Create the relocation entry for the global value - MachineRelocation MR = - MachineRelocation::getGV(GblS.getCurrentPCOffset(), - TEW->getAbsoluteLabelMachineRelTy(), - const_cast(GV)); +// ResolveConstantExpr - Resolve the constant expression until it stop +// yielding other constant expressions. +CstExprResTy ELFWriter::ResolveConstantExpr(const Constant *CV) { + const TargetData *TD = TM.getTargetData(); + + // There ins't constant expression inside others anymore + if (!isa(CV)) + return std::make_pair(CV, 0); + + const ConstantExpr *CE = dyn_cast(CV); + switch (CE->getOpcode()) { + case Instruction::BitCast: + return ResolveConstantExpr(CE->getOperand(0)); + + case Instruction::GetElementPtr: { + const Constant *ptrVal = CE->getOperand(0); + SmallVector idxVec(CE->op_begin()+1, CE->op_end()); + int64_t Offset = TD->getIndexedOffset(ptrVal->getType(), &idxVec[0], + idxVec.size()); + return std::make_pair(ptrVal, Offset); + } + case Instruction::IntToPtr: { + Constant *Op = CE->getOperand(0); + Op = ConstantExpr::getIntegerCast(Op, TD->getIntPtrType(), false/*ZExt*/); + return ResolveConstantExpr(Op); + } + case Instruction::PtrToInt: { + Constant *Op = CE->getOperand(0); + const Type *Ty = CE->getType(); - // Fill the data entry with zeros - for (unsigned i=0; i < Size; ++i) - GblS.emitByte(0); + // We can emit the pointer value into this slot if the slot is an + // integer slot greater or equal to the size of the pointer. + if (TD->getTypeAllocSize(Ty) == TD->getTypeAllocSize(Op->getType())) + return ResolveConstantExpr(Op); - // Add the relocation entry for the current data section - GblS.addRelocation(MR); - return; - } else if (const ConstantExpr *CE = dyn_cast(CV)) { - if (CE->getOpcode() == Instruction::BitCast) { - EmitGlobalConstant(CE->getOperand(0), GblS); - return; + llvm_unreachable("Integer size less then pointer size"); + } + case Instruction::Add: + case Instruction::Sub: { + // Only handle cases where there's a constant expression with GlobalValue + // as first operand and ConstantInt as second, which are the cases we can + // solve direclty using a relocation entry. GlobalValue=Op0, CstInt=Op1 + // 1) Instruction::Add => (global) + CstInt + // 2) Instruction::Sub => (global) + -CstInt + const Constant *Op0 = CE->getOperand(0); + const Constant *Op1 = CE->getOperand(1); + assert(isa(Op1) && "Op1 must be a ConstantInt"); + + CstExprResTy Res = ResolveConstantExpr(Op0); + assert(isa(Res.first) && "Op0 must be a GlobalValue"); + + const APInt &RHS = cast(Op1)->getValue(); + switch (CE->getOpcode()) { + case Instruction::Add: + return std::make_pair(Res.first, RHS.getSExtValue()); + case Instruction::Sub: + return std::make_pair(Res.first, (-RHS).getSExtValue()); } - // See AsmPrinter::EmitConstantValueOnly for other ConstantExpr types - llvm_unreachable("Unsupported ConstantExpr type"); + } } - llvm_unreachable("Unknown global constant type"); + std::string msg(CE->getOpcodeName()); + raw_string_ostream ErrorMsg(msg); + ErrorMsg << ": Unsupported ConstantExpr type"; + llvm_report_error(ErrorMsg.str()); + + return std::make_pair(CV, 0); // silence warning } +void ELFWriter::EmitGlobalDataRelocation(const GlobalValue *GV, unsigned Size, + ELFSection &GblS, int64_t Offset) { + // Create the relocation entry for the global value + MachineRelocation MR = + MachineRelocation::getGV(GblS.getCurrentPCOffset(), + TEW->getAbsoluteLabelMachineRelTy(), + const_cast(GV), + Offset); + + // Fill the data entry with zeros + GblS.emitZeros(Size); + + // Add the relocation entry for the current data section + GblS.addRelocation(MR); +} + +void ELFWriter::EmitGlobalConstantLargeInt(const ConstantInt *CI, + ELFSection &S) { + const TargetData *TD = TM.getTargetData(); + unsigned BitWidth = CI->getBitWidth(); + assert(isPowerOf2_32(BitWidth) && + "Non-power-of-2-sized integers not handled!"); + + const uint64_t *RawData = CI->getValue().getRawData(); + uint64_t Val = 0; + for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) { + Val = (TD->isBigEndian()) ? RawData[e - i - 1] : RawData[i]; + S.emitWord64(Val); + } +} + +/// EmitSpecialLLVMGlobal - Check to see if the specified global is a +/// special global used by LLVM. If so, emit it and return true, otherwise +/// do nothing and return false. +bool ELFWriter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) { + if (GV->getName() == "llvm.used") + llvm_unreachable("not implemented yet"); + + // Ignore debug and non-emitted data. This handles llvm.compiler.used. + if (GV->getSection() == "llvm.metadata" || + GV->hasAvailableExternallyLinkage()) + return true; + + if (!GV->hasAppendingLinkage()) return false; + + assert(GV->hasInitializer() && "Not a special LLVM global!"); + + const TargetData *TD = TM.getTargetData(); + unsigned Align = TD->getPointerPrefAlignment(); + if (GV->getName() == "llvm.global_ctors") { + ELFSection &Ctor = getCtorSection(); + Ctor.emitAlignment(Align); + EmitXXStructorList(GV->getInitializer(), Ctor); + return true; + } + + if (GV->getName() == "llvm.global_dtors") { + ELFSection &Dtor = getDtorSection(); + Dtor.emitAlignment(Align); + EmitXXStructorList(GV->getInitializer(), Dtor); + return true; + } + + return false; +} + +/// EmitXXStructorList - Emit the ctor or dtor list. This just emits out the +/// function pointers, ignoring the init priority. +void ELFWriter::EmitXXStructorList(Constant *List, ELFSection &Xtor) { + // Should be an array of '{ int, void ()* }' structs. The first value is the + // init priority, which we ignore. + if (!isa(List)) return; + ConstantArray *InitList = cast(List); + for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) + if (ConstantStruct *CS = dyn_cast(InitList->getOperand(i))){ + if (CS->getNumOperands() != 2) return; // Not array of 2-element structs. + + if (CS->getOperand(1)->isNullValue()) + return; // Found a null terminator, exit printing. + // Emit the function pointer. + EmitGlobalConstant(CS->getOperand(1), Xtor); + } +} bool ELFWriter::runOnMachineFunction(MachineFunction &MF) { // Nothing to do here, this is all done through the ElfCE object above. @@ -477,10 +710,15 @@ bool ELFWriter::doFinalization(Module &M) { EmitGlobal(I); // Emit all pending globals - for (SetVector::const_iterator I = PendingGlobals.begin(), - E = PendingGlobals.end(); I != E; ++I) + for (PendingGblsIter I = PendingGlobals.begin(), E = PendingGlobals.end(); + I != E; ++I) EmitGlobal(*I); + // Emit all pending externals + for (PendingExtsIter I = PendingExternals.begin(), E = PendingExternals.end(); + I != E; ++I) + SymbolList.push_back(ELFSym::getExtSym(*I)); + // Emit non-executable stack note if (TAI->getNonexecutableStackDirective()) getNonExecStackSection(); @@ -488,18 +726,14 @@ bool ELFWriter::doFinalization(Module &M) { // Emit a symbol for each section created until now, skip null section for (unsigned i = 1, e = SectionList.size(); i < e; ++i) { ELFSection &ES = *SectionList[i]; - ELFSym *SectionSym = new ELFSym(0); + ELFSym *SectionSym = ELFSym::getSectionSym(); SectionSym->SectionIdx = ES.SectionIdx; - SectionSym->Size = 0; - SectionSym->setBind(ELFSym::STB_LOCAL); - SectionSym->setType(ELFSym::STT_SECTION); - SectionSym->setVisibility(ELFSym::STV_DEFAULT); SymbolList.push_back(SectionSym); ES.Sym = SymbolList.back(); } // Emit string table - EmitStringTable(); + EmitStringTable(M.getModuleIdentifier()); // Emit the symbol table now, if non-empty. EmitSymbolTable(); @@ -578,43 +812,45 @@ void ELFWriter::EmitRelocations() { // them needs a different approach to retrieve the symbol table index. if (MR.isGlobalValue()) { const GlobalValue *G = MR.getGlobalValue(); + int64_t GlobalOffset = MR.getConstantVal(); SymIdx = GblSymLookup[G]; if (G->hasPrivateLinkage()) { // If the target uses a section offset in the relocation: // SymIdx + Addend = section sym for global + section offset unsigned SectionIdx = PrivateSyms[SymIdx]->SectionIdx; - Addend = PrivateSyms[SymIdx]->Value; + Addend = PrivateSyms[SymIdx]->Value + GlobalOffset; SymIdx = SectionList[SectionIdx]->getSymbolTableIndex(); } else { - Addend = TEW->getDefaultAddendForRelTy(RelType); + Addend = TEW->getDefaultAddendForRelTy(RelType, GlobalOffset); } + } else if (MR.isExternalSymbol()) { + const char *ExtSym = MR.getExternalSymbol(); + SymIdx = ExtSymLookup[ExtSym]; + Addend = TEW->getDefaultAddendForRelTy(RelType); } else { // Get the symbol index for the section symbol unsigned SectionIdx = MR.getConstantVal(); SymIdx = SectionList[SectionIdx]->getSymbolTableIndex(); - Addend = (uint64_t)MR.getResultPointer(); + + // The symbol offset inside the section + int64_t SymOffset = (int64_t)MR.getResultPointer(); // For pc relative relocations where symbols are defined in the same // section they are referenced, ignore the relocation entry and patch // the relocatable field with the symbol offset directly. if (S.SectionIdx == SectionIdx && TEW->isPCRelativeRel(RelType)) { - int64_t Value = TEW->computeRelocation(Addend, RelOffset, RelType); + int64_t Value = TEW->computeRelocation(SymOffset, RelOffset, RelType); RelocateField(S, RelOffset, Value, RelTySize); continue; } - // Handle Jump Table Index relocation - if ((SectionIdx == getJumpTableSection().SectionIdx) && - TEW->hasCustomJumpTableIndexRelTy()) { - RelType = TEW->getJumpTableIndexRelTy(); - RelTySize = TEW->getRelocationTySize(RelType); - } + Addend = TEW->getDefaultAddendForRelTy(RelType, SymOffset); } // The target without addend on the relocation symbol must be // patched in the relocation place itself to contain the addend - if (!HasRelA) - RelocateField(S, RelOffset, Addend, RelTySize); + // otherwise write zeros to make sure there is no garbage there + RelocateField(S, RelOffset, HasRelA ? 0 : Addend, RelTySize); // Get the relocation entry and emit to the relocation section ELFRelocation Rel(RelOffset, SymIdx, RelType, HasRelA, Addend); @@ -680,7 +916,7 @@ void ELFWriter::EmitSectionHeader(BinaryObject &SHdrTab, /// EmitStringTable - If the current symbol table is non-empty, emit the string /// table for it -void ELFWriter::EmitStringTable() { +void ELFWriter::EmitStringTable(const std::string &ModuleName) { if (!SymbolList.size()) return; // Empty symbol table. ELFSection &StrTab = getStringTableSection(); @@ -692,9 +928,13 @@ void ELFWriter::EmitStringTable() { for (ELFSymIter I=SymbolList.begin(), E=SymbolList.end(); I != E; ++I) { ELFSym &Sym = *(*I); - // Use the name mangler to uniquify the LLVM symbol. std::string Name; - if (Sym.GV) Name.append(Mang->getMangledName(Sym.GV)); + if (Sym.isGlobalValue()) + Name.append(Mang->getMangledName(Sym.getGlobalValue())); + else if (Sym.isExternalSym()) + Name.append(Sym.getExternalSymbol()); + else if (Sym.isFileType()) + Name.append(ModuleName); if (Name.empty()) { Sym.NameIdx = 0; @@ -753,9 +993,6 @@ void ELFWriter::EmitSymbolTable() { // Size of each symtab entry. SymTab.EntSize = TEW->getSymTabEntrySize(); - // The first entry in the symtab is the null symbol - SymbolList.insert(SymbolList.begin(), new ELFSym(0)); - // Reorder the symbol table with local symbols first! unsigned FirstNonLocalSymbol = SortSymbols(); @@ -766,8 +1003,11 @@ void ELFWriter::EmitSymbolTable() { // Emit symbol to the symbol table EmitSymbol(SymTab, Sym); - // Record the symbol table index for each global value - if (Sym.GV) setGlobalSymLookup(Sym.GV, i); + // Record the symbol table index for each symbol + if (Sym.isGlobalValue()) + GblSymLookup[Sym.getGlobalValue()] = i; + else if (Sym.isExternalSym()) + ExtSymLookup[Sym.getExternalSymbol()] = i; // Keep track on the symbol index into the symbol table Sym.SymTabIdx = i;