X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FMachOWriter.cpp;h=9389088f20790cf826ec904ecc331eae96f19ce9;hb=be6781b5d00107f4b60797c3ebdc0aab110487ff;hp=0a8825a4e4d1e2d0175422aef5a9d0e107158151;hpb=157c4eeb4d81140ce8c4dbff630828546d62d599;p=oota-llvm.git diff --git a/lib/CodeGen/MachOWriter.cpp b/lib/CodeGen/MachOWriter.cpp index 0a8825a4e4d..9389088f207 100644 --- a/lib/CodeGen/MachOWriter.cpp +++ b/lib/CodeGen/MachOWriter.cpp @@ -22,23 +22,34 @@ // //===----------------------------------------------------------------------===// +#include "MachOWriter.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.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/MachineJumpTableInfo.h" -#include "llvm/CodeGen/MachOWriter.h" -#include "llvm/ExecutionEngine/ExecutionEngine.h" #include "llvm/Target/TargetAsmInfo.h" #include "llvm/Target/TargetJITInfo.h" -#include "llvm/Target/TargetObjInfo.h" #include "llvm/Support/Mangler.h" #include "llvm/Support/MathExtras.h" +#include "llvm/Support/OutputBuffer.h" #include "llvm/Support/Streams.h" #include using namespace llvm; +/// AddMachOWriter - Concrete function to add the Mach-O writer to the function +/// pass manager. +MachineCodeEmitter *llvm::AddMachOWriter(FunctionPassManager &FPM, + std::ostream &O, + TargetMachine &TM) { + MachOWriter *MOW = new MachOWriter(O, TM); + FPM.add(MOW); + return &MOW->getMachineCodeEmitter(); +} + //===----------------------------------------------------------------------===// // MachOCodeEmitter Implementation //===----------------------------------------------------------------------===// @@ -50,12 +61,11 @@ namespace llvm { MachOWriter &MOW; /// Target machine description. - /// TargetMachine &TM; - /// Target object writer info. - /// - const TargetObjInfo *TOI; + /// is64Bit/isLittleEndian - This information is inferred from the target + /// machine directly, indicating what header values and flags to set. + bool is64Bit, isLittleEndian; /// Relocations - These are the relocations that the function needs, as /// emitted. @@ -79,13 +89,13 @@ namespace llvm { std::vector MBBLocations; public: - MachOCodeEmitter(MachOWriter &mow, TargetMachine &tm) : MOW(mow), TM(tm) { - // Create the target object info object for this target. - TOI = TM.getTargetObjInfo(); + MachOCodeEmitter(MachOWriter &mow) : MOW(mow), TM(MOW.TM) { + is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64; + isLittleEndian = TM.getTargetData()->isLittleEndian(); } - virtual void startFunction(MachineFunction &F); - virtual bool finishFunction(MachineFunction &F); + virtual void startFunction(MachineFunction &MF); + virtual bool finishFunction(MachineFunction &MF); virtual void addRelocation(const MachineRelocation &MR) { Relocations.push_back(MR); @@ -130,12 +140,15 @@ namespace llvm { /// startFunction - This callback is invoked when a new machine function is /// about to be emitted. -void MachOCodeEmitter::startFunction(MachineFunction &F) { +void MachOCodeEmitter::startFunction(MachineFunction &MF) { + const TargetData *TD = TM.getTargetData(); + const Function *F = MF.getFunction(); + // Align the output buffer to the appropriate alignment, power of 2. - // FIXME: MachineFunction or TargetData should probably carry an alignment - // field for functions that we can query here instead of hard coding 4 in both - // the object writer and asm printer. - unsigned Align = 4; + unsigned FnAlign = F->getAlignment(); + unsigned TDAlign = TD->getPrefTypeAlignment(F->getType()); + unsigned Align = Log2_32(std::max(FnAlign, TDAlign)); + assert(!(Align & (Align-1)) && "Alignment is not a power of two!"); // Get the Mach-O Section that this function belongs in. MachOWriter::MachOSection *MOS = MOW.getTextSection(); @@ -145,6 +158,15 @@ void MachOCodeEmitter::startFunction(MachineFunction &F) { BufferBegin = &MOS->SectionData[0]; BufferEnd = BufferBegin + MOS->SectionData.capacity(); + // Upgrade the section alignment if required. + if (MOS->align < Align) MOS->align = Align; + + // Round the size up to the correct alignment for starting the new function. + if ((MOS->size & ((1 << Align) - 1)) != 0) { + MOS->size += (1 << Align); + MOS->size &= ~((1 << Align) - 1); + } + // FIXME: Using MOS->size directly here instead of calculating it from the // output buffer size (impossible because the code emitter deals only in raw // bytes) forces us to manually synchronize size and write padding zero bytes @@ -154,9 +176,6 @@ void MachOCodeEmitter::startFunction(MachineFunction &F) { // AddSymbolToSection to prevent calling it on the text section. CurBufferPtr = BufferBegin + MOS->size; - // Upgrade the section alignment if required. - if (MOS->align < Align) MOS->align = Align; - // Clear per-function data structures. CPLocations.clear(); CPSections.clear(); @@ -166,21 +185,24 @@ void MachOCodeEmitter::startFunction(MachineFunction &F) { /// finishFunction - This callback is invoked after the function is completely /// finished. -bool MachOCodeEmitter::finishFunction(MachineFunction &F) { +bool MachOCodeEmitter::finishFunction(MachineFunction &MF) { // Get the Mach-O Section that this function belongs in. MachOWriter::MachOSection *MOS = MOW.getTextSection(); - MOS->size += CurBufferPtr - BufferBegin; - // Get a symbol for the function to add to the symbol table - const GlobalValue *FuncV = F.getFunction(); + // FIXME: it seems like we should call something like AddSymbolToSection + // in startFunction rather than changing the section size and symbol n_value + // here. + const GlobalValue *FuncV = MF.getFunction(); MachOSym FnSym(FuncV, MOW.Mang->getValueName(FuncV), MOS->Index, TM); - + FnSym.n_value = MOS->size; + MOS->size = CurBufferPtr - BufferBegin; + // Emit constant pool to appropriate section(s) - emitConstantPool(F.getConstantPool()); + emitConstantPool(MF.getConstantPool()); // Emit jump tables to appropriate section - emitJumpTables(F.getJumpTableInfo()); + emitJumpTables(MF.getJumpTableInfo()); // If we have emitted any relocations to function-specific objects such as // basic blocks, constant pools entries, or jump tables, record their @@ -202,7 +224,10 @@ bool MachOCodeEmitter::finishFunction(MachineFunction &F) { Addr = getConstantPoolEntryAddress(MR.getConstantPoolIndex()); MR.setConstantVal(CPSections[MR.getConstantPoolIndex()]); MR.setResultPointer((void*)Addr); - } else if (!MR.isGlobalValue()) { + } else if (MR.isGlobalValue()) { + // FIXME: This should be a set or something that uniques + MOW.PendingGlobals.push_back(MR.getGlobalValue()); + } else { assert(0 && "Unhandled relocation type"); } MOS->Relocations.push_back(MR); @@ -234,9 +259,11 @@ void MachOCodeEmitter::emitConstantPool(MachineConstantPool *MCP) { // "giant object for PIC" optimization. for (unsigned i = 0, e = CP.size(); i != e; ++i) { const Type *Ty = CP[i].getType(); - unsigned Size = TM.getTargetData()->getTypeSize(Ty); + unsigned Size = TM.getTargetData()->getABITypeSize(Ty); + + MachOWriter::MachOSection *Sec = MOW.getConstSection(CP[i].Val.ConstVal); + OutputBuffer SecDataOut(Sec->SectionData, is64Bit, isLittleEndian); - MachOWriter::MachOSection *Sec = MOW.getConstSection(Ty); CPLocations.push_back(Sec->SectionData.size()); CPSections.push_back(Sec->Index); @@ -247,7 +274,7 @@ void MachOCodeEmitter::emitConstantPool(MachineConstantPool *MCP) { // FIXME: need alignment? // FIXME: share between here and AddSymbolToSection? for (unsigned j = 0; j < Size; ++j) - TOI->outbyte(Sec->SectionData, 0); + SecDataOut.outbyte(0); MOW.InitMem(CP[i].Val.ConstVal, &Sec->SectionData[0], CPLocations[i], TM.getTargetData(), Sec->Relocations); @@ -266,6 +293,7 @@ void MachOCodeEmitter::emitJumpTables(MachineJumpTableInfo *MJTI) { MachOWriter::MachOSection *Sec = MOW.getJumpTableSection(); unsigned TextSecIndex = MOW.getTextSection()->Index; + OutputBuffer SecDataOut(Sec->SectionData, is64Bit, isLittleEndian); for (unsigned i = 0, e = JT.size(); i != e; ++i) { // For each jump table, record its offset from the start of the section, @@ -278,7 +306,7 @@ void MachOCodeEmitter::emitJumpTables(MachineJumpTableInfo *MJTI) { MR.setResultPointer((void *)JTLocations[i]); MR.setConstantVal(TextSecIndex); Sec->Relocations.push_back(MR); - TOI->outaddr(Sec->SectionData, 0); + SecDataOut.outaddr(0); } } // FIXME: remove when we have unified size + output buffer @@ -289,15 +317,14 @@ void MachOCodeEmitter::emitJumpTables(MachineJumpTableInfo *MJTI) { // MachOWriter Implementation //===----------------------------------------------------------------------===// -MachOWriter::MachOWriter(std::ostream &o, TargetMachine &tm) : O(o), TM(tm) { +char MachOWriter::ID = 0; +MachOWriter::MachOWriter(std::ostream &o, TargetMachine &tm) + : MachineFunctionPass((intptr_t)&ID), O(o), TM(tm) { is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64; isLittleEndian = TM.getTargetData()->isLittleEndian(); // Create the machine code emitter object for this target. - MCE = new MachOCodeEmitter(*this, tm); - - // Create the target object info object for this target. - TOI = TM.getTargetObjInfo(); + MCE = new MachOCodeEmitter(*this); } MachOWriter::~MachOWriter() { @@ -306,16 +333,16 @@ MachOWriter::~MachOWriter() { void MachOWriter::AddSymbolToSection(MachOSection *Sec, GlobalVariable *GV) { const Type *Ty = GV->getType()->getElementType(); - unsigned Size = TM.getTargetData()->getTypeSize(Ty); + unsigned Size = TM.getTargetData()->getABITypeSize(Ty); unsigned Align = GV->getAlignment(); if (Align == 0) - Align = TM.getTargetData()->getTypeAlignment(Ty); - - MachOSym Sym(GV, Mang->getValueName(GV), Sec->Index, TM); + Align = TM.getTargetData()->getPrefTypeAlignment(Ty); // Reserve space in the .bss section for this symbol while maintaining the // desired section alignment, which must be at least as much as required by // this symbol. + OutputBuffer SecDataOut(Sec->SectionData, is64Bit, isLittleEndian); + if (Align) { uint64_t OrigSize = Sec->size; Align = Log2_32(Align); @@ -326,14 +353,19 @@ void MachOWriter::AddSymbolToSection(MachOSection *Sec, GlobalVariable *GV) { // FIXME: remove when we have unified size + output buffer unsigned AlignedSize = Sec->size - OrigSize; for (unsigned i = 0; i < AlignedSize; ++i) - TOI->outbyte(Sec->SectionData, 0); + SecDataOut.outbyte(0); + } + // Globals without external linkage apparently do not go in the symbol table. + if (GV->getLinkage() != GlobalValue::InternalLinkage) { + MachOSym Sym(GV, Mang->getValueName(GV), Sec->Index, TM); + Sym.n_value = Sec->size; + SymbolTable.push_back(Sym); } + // Record the offset of the symbol, and then allocate space for it. // FIXME: remove when we have unified size + output buffer - Sym.n_value = Sec->size; Sec->size += Size; - SymbolTable.push_back(Sym); - + // Now that we know what section the GlovalVariable is going to be emitted // into, update our mappings. // FIXME: We may also need to update this when outputting non-GlobalVariable @@ -343,12 +375,12 @@ void MachOWriter::AddSymbolToSection(MachOSection *Sec, GlobalVariable *GV) { // Allocate space in the section for the global. for (unsigned i = 0; i < Size; ++i) - TOI->outbyte(Sec->SectionData, 0); + SecDataOut.outbyte(0); } void MachOWriter::EmitGlobal(GlobalVariable *GV) { const Type *Ty = GV->getType()->getElementType(); - unsigned Size = TM.getTargetData()->getTypeSize(Ty); + unsigned Size = TM.getTargetData()->getABITypeSize(Ty); bool NoInit = !GV->hasInitializer(); // If this global has a zero initializer, it is part of the .bss or common @@ -362,12 +394,9 @@ void MachOWriter::EmitGlobal(GlobalVariable *GV) { // For undefined (N_UNDF) external (N_EXT) types, n_value is the size in // bytes of the symbol. ExtOrCommonSym.n_value = Size; - // If the symbol is external, we'll put it on a list of symbols whose - // addition to the symbol table is being pended until we find a reference - if (NoInit) - PendingSyms.push_back(ExtOrCommonSym); - else - SymbolTable.push_back(ExtOrCommonSym); + SymbolTable.push_back(ExtOrCommonSym); + // Remember that we've seen this symbol + GVOffset[GV] = Size; return; } // Otherwise, this symbol is part of the .bss section. @@ -379,7 +408,8 @@ void MachOWriter::EmitGlobal(GlobalVariable *GV) { // Scalar read-only data goes in a literal section if the scalar is 4, 8, or // 16 bytes, or a cstring. Other read only data goes into a regular const // section. Read-write data goes in the data section. - MachOSection *Sec = GV->isConstant() ? getConstSection(Ty) : getDataSection(); + MachOSection *Sec = GV->isConstant() ? getConstSection(GV->getInitializer()) : + getDataSection(); AddSymbolToSection(Sec, GV); InitMem(GV->getInitializer(), &Sec->SectionData[0], GVOffset[GV], TM.getTargetData(), Sec->Relocations); @@ -456,15 +486,17 @@ void MachOWriter::EmitHeaderAndLoadCommands() { // Step #3: write the header to the file // Local alias to shortenify coming code. DataBuffer &FH = Header.HeaderData; - TOI->outword(FH, Header.magic); - TOI->outword(FH, Header.cputype); - TOI->outword(FH, Header.cpusubtype); - TOI->outword(FH, Header.filetype); - TOI->outword(FH, Header.ncmds); - TOI->outword(FH, Header.sizeofcmds); - TOI->outword(FH, Header.flags); + OutputBuffer FHOut(FH, is64Bit, isLittleEndian); + + FHOut.outword(Header.magic); + FHOut.outword(TM.getMachOWriterInfo()->getCPUType()); + FHOut.outword(TM.getMachOWriterInfo()->getCPUSubType()); + FHOut.outword(Header.filetype); + FHOut.outword(Header.ncmds); + FHOut.outword(Header.sizeofcmds); + FHOut.outword(Header.flags); if (is64Bit) - TOI->outword(FH, Header.reserved); + FHOut.outword(Header.reserved); // Step #4: Finish filling in the segment load command and write it out for (std::vector::iterator I = SectionList.begin(), @@ -474,17 +506,17 @@ void MachOWriter::EmitHeaderAndLoadCommands() { SEG.vmsize = SEG.filesize; SEG.fileoff = Header.cmdSize(is64Bit) + Header.sizeofcmds; - TOI->outword(FH, SEG.cmd); - TOI->outword(FH, SEG.cmdsize); - TOI->outstring(FH, SEG.segname, 16); - TOI->outaddr(FH, SEG.vmaddr); - TOI->outaddr(FH, SEG.vmsize); - TOI->outaddr(FH, SEG.fileoff); - TOI->outaddr(FH, SEG.filesize); - TOI->outword(FH, SEG.maxprot); - TOI->outword(FH, SEG.initprot); - TOI->outword(FH, SEG.nsects); - TOI->outword(FH, SEG.flags); + FHOut.outword(SEG.cmd); + FHOut.outword(SEG.cmdsize); + FHOut.outstring(SEG.segname, 16); + FHOut.outaddr(SEG.vmaddr); + FHOut.outaddr(SEG.vmsize); + FHOut.outaddr(SEG.fileoff); + FHOut.outaddr(SEG.filesize); + FHOut.outword(SEG.maxprot); + FHOut.outword(SEG.initprot); + FHOut.outword(SEG.nsects); + FHOut.outword(SEG.flags); // Step #5: Finish filling in the fields of the MachOSections uint64_t currentAddr = 0; @@ -498,7 +530,13 @@ void MachOWriter::EmitHeaderAndLoadCommands() { currentAddr += MOS->size; } - // Step #6: Calculate the number of relocations for each section and write out + // Step #6: Emit the symbol table to temporary buffers, so that we know the + // size of the string table when we write the next load command. This also + // sorts and assigns indices to each of the symbols, which is necessary for + // emitting relocations to externally-defined objects. + BufferSymbolAndStringTable(); + + // Step #7: Calculate the number of relocations for each section and write out // the section commands for each section currentAddr += SEG.fileoff; for (std::vector::iterator I = SectionList.begin(), @@ -511,60 +549,56 @@ void MachOWriter::EmitHeaderAndLoadCommands() { currentAddr += MOS->nreloc * 8; // write the finalized section command to the output buffer - TOI->outstring(FH, MOS->sectname, 16); - TOI->outstring(FH, MOS->segname, 16); - TOI->outaddr(FH, MOS->addr); - TOI->outaddr(FH, MOS->size); - TOI->outword(FH, MOS->offset); - TOI->outword(FH, MOS->align); - TOI->outword(FH, MOS->reloff); - TOI->outword(FH, MOS->nreloc); - TOI->outword(FH, MOS->flags); - TOI->outword(FH, MOS->reserved1); - TOI->outword(FH, MOS->reserved2); + FHOut.outstring(MOS->sectname, 16); + FHOut.outstring(MOS->segname, 16); + FHOut.outaddr(MOS->addr); + FHOut.outaddr(MOS->size); + FHOut.outword(MOS->offset); + FHOut.outword(MOS->align); + FHOut.outword(MOS->reloff); + FHOut.outword(MOS->nreloc); + FHOut.outword(MOS->flags); + FHOut.outword(MOS->reserved1); + FHOut.outword(MOS->reserved2); if (is64Bit) - TOI->outword(FH, MOS->reserved3); + FHOut.outword(MOS->reserved3); } - // Step #7: Emit the symbol table to temporary buffers, so that we know the - // size of the string table when we write the next load command. - BufferSymbolAndStringTable(); - // Step #8: Emit LC_SYMTAB/LC_DYSYMTAB load commands SymTab.symoff = currentAddr; SymTab.nsyms = SymbolTable.size(); SymTab.stroff = SymTab.symoff + SymT.size(); SymTab.strsize = StrT.size(); - TOI->outword(FH, SymTab.cmd); - TOI->outword(FH, SymTab.cmdsize); - TOI->outword(FH, SymTab.symoff); - TOI->outword(FH, SymTab.nsyms); - TOI->outword(FH, SymTab.stroff); - TOI->outword(FH, SymTab.strsize); + FHOut.outword(SymTab.cmd); + FHOut.outword(SymTab.cmdsize); + FHOut.outword(SymTab.symoff); + FHOut.outword(SymTab.nsyms); + FHOut.outword(SymTab.stroff); + FHOut.outword(SymTab.strsize); // FIXME: set DySymTab fields appropriately // We should probably just update these in BufferSymbolAndStringTable since // thats where we're partitioning up the different kinds of symbols. - TOI->outword(FH, DySymTab.cmd); - TOI->outword(FH, DySymTab.cmdsize); - TOI->outword(FH, DySymTab.ilocalsym); - TOI->outword(FH, DySymTab.nlocalsym); - TOI->outword(FH, DySymTab.iextdefsym); - TOI->outword(FH, DySymTab.nextdefsym); - TOI->outword(FH, DySymTab.iundefsym); - TOI->outword(FH, DySymTab.nundefsym); - TOI->outword(FH, DySymTab.tocoff); - TOI->outword(FH, DySymTab.ntoc); - TOI->outword(FH, DySymTab.modtaboff); - TOI->outword(FH, DySymTab.nmodtab); - TOI->outword(FH, DySymTab.extrefsymoff); - TOI->outword(FH, DySymTab.nextrefsyms); - TOI->outword(FH, DySymTab.indirectsymoff); - TOI->outword(FH, DySymTab.nindirectsyms); - TOI->outword(FH, DySymTab.extreloff); - TOI->outword(FH, DySymTab.nextrel); - TOI->outword(FH, DySymTab.locreloff); - TOI->outword(FH, DySymTab.nlocrel); + FHOut.outword(DySymTab.cmd); + FHOut.outword(DySymTab.cmdsize); + FHOut.outword(DySymTab.ilocalsym); + FHOut.outword(DySymTab.nlocalsym); + FHOut.outword(DySymTab.iextdefsym); + FHOut.outword(DySymTab.nextdefsym); + FHOut.outword(DySymTab.iundefsym); + FHOut.outword(DySymTab.nundefsym); + FHOut.outword(DySymTab.tocoff); + FHOut.outword(DySymTab.ntoc); + FHOut.outword(DySymTab.modtaboff); + FHOut.outword(DySymTab.nmodtab); + FHOut.outword(DySymTab.extrefsymoff); + FHOut.outword(DySymTab.nextrefsyms); + FHOut.outword(DySymTab.indirectsymoff); + FHOut.outword(DySymTab.nindirectsyms); + FHOut.outword(DySymTab.extreloff); + FHOut.outword(DySymTab.nextrel); + FHOut.outword(DySymTab.locreloff); + FHOut.outword(DySymTab.nlocrel); O.write((char*)&FH[0], FH.size()); } @@ -604,6 +638,17 @@ void MachOWriter::BufferSymbolAndStringTable() { // 2. defined external symbols (sorted by name) // 3. undefined external symbols (sorted by name) + // Before sorting the symbols, check the PendingGlobals for any undefined + // globals that need to be put in the symbol table. + for (std::vector::iterator I = PendingGlobals.begin(), + E = PendingGlobals.end(); I != E; ++I) { + if (GVOffset[*I] == 0 && GVSection[*I] == 0) { + MachOSym UndfSym(*I, Mang->getValueName(*I), MachOSym::NO_SECT, TM); + SymbolTable.push_back(UndfSym); + GVOffset[*I] = -1; + } + } + // Sort the symbols by name, so that when we partition the symbols by scope // of definition, we won't have to sort by name within each partition. std::sort(SymbolTable.begin(), SymbolTable.end(), MachOSymCmp()); @@ -631,6 +676,7 @@ void MachOWriter::BufferSymbolAndStringTable() { if (PartitionByLocal(*I)) { ++DySymTab.nlocalsym; ++DySymTab.iextdefsym; + ++DySymTab.iundefsym; } else if (PartitionByDefined(*I)) { ++DySymTab.nextdefsym; ++DySymTab.iundefsym; @@ -641,7 +687,8 @@ void MachOWriter::BufferSymbolAndStringTable() { // Write out a leading zero byte when emitting string table, for n_strx == 0 // which means an empty string. - TOI->outbyte(StrT, 0); + OutputBuffer StrTOut(StrT, is64Bit, isLittleEndian); + StrTOut.outbyte(0); // The order of the string table is: // 1. strings for external symbols @@ -654,25 +701,30 @@ void MachOWriter::BufferSymbolAndStringTable() { I->n_strx = 0; } else { I->n_strx = StrT.size(); - TOI->outstring(StrT, I->GVName, I->GVName.length()+1); + StrTOut.outstring(I->GVName, I->GVName.length()+1); } } + OutputBuffer SymTOut(SymT, is64Bit, isLittleEndian); + + unsigned index = 0; for (std::vector::iterator I = SymbolTable.begin(), - E = SymbolTable.end(); I != E; ++I) { + E = SymbolTable.end(); I != E; ++I, ++index) { // Add the section base address to the section offset in the n_value field // to calculate the full address. // FIXME: handle symbols where the n_value field is not the address GlobalValue *GV = const_cast(I->GV); if (GV && GVSection[GV]) I->n_value += GVSection[GV]->addr; + if (GV && (GVOffset[GV] == -1)) + GVOffset[GV] = index; // Emit nlist to buffer - TOI->outword(SymT, I->n_strx); - TOI->outbyte(SymT, I->n_type); - TOI->outbyte(SymT, I->n_sect); - TOI->outhalf(SymT, I->n_desc); - TOI->outaddr(SymT, I->n_value); + SymTOut.outword(I->n_strx); + SymTOut.outbyte(I->n_type); + SymTOut.outbyte(I->n_sect); + SymTOut.outhalf(I->n_desc); + SymTOut.outaddr(I->n_value); } } @@ -685,22 +737,49 @@ void MachOWriter::CalculateRelocations(MachOSection &MOS) { for (unsigned i = 0, e = MOS.Relocations.size(); i != e; ++i) { MachineRelocation &MR = MOS.Relocations[i]; unsigned TargetSection = MR.getConstantVal(); - + unsigned TargetAddr = 0; + unsigned TargetIndex = 0; + + // This is a scattered relocation entry if it points to a global value with + // a non-zero offset. + bool Scattered = false; + bool Extern = false; + // Since we may not have seen the GlobalValue we were interested in yet at // the time we emitted the relocation for it, fix it up now so that it // points to the offset into the correct section. if (MR.isGlobalValue()) { GlobalValue *GV = MR.getGlobalValue(); MachOSection *MOSPtr = GVSection[GV]; - intptr_t offset = GVOffset[GV]; - - assert(MOSPtr && "Trying to relocate unknown global!"); + intptr_t Offset = GVOffset[GV]; - TargetSection = MOSPtr->Index; - MR.setResultPointer((void*)offset); + // If we have never seen the global before, it must be to a symbol + // defined in another module (N_UNDF). + if (!MOSPtr) { + // FIXME: need to append stub suffix + Extern = true; + TargetAddr = 0; + TargetIndex = GVOffset[GV]; + } else { + Scattered = TargetSection != 0; + TargetSection = MOSPtr->Index; + } + MR.setResultPointer((void*)Offset); } - GetTargetRelocation(MR, MOS, *SectionList[TargetSection-1]); + // If the symbol is locally defined, pass in the address of the section and + // the section index to the code which will generate the target relocation. + if (!Extern) { + MachOSection &To = *SectionList[TargetSection - 1]; + TargetAddr = To.addr; + TargetIndex = To.Index; + } + + OutputBuffer RelocOut(MOS.RelocBuffer, is64Bit, isLittleEndian); + OutputBuffer SecOut(MOS.SectionData, is64Bit, isLittleEndian); + + MOS.nreloc += GetTargetRelocation(MR, MOS.Index, TargetAddr, TargetIndex, + RelocOut, SecOut, Scattered, Extern); } } @@ -714,6 +793,8 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset, WorkList.push_back(CPair(C,(intptr_t)Addr + Offset)); + intptr_t ScatteredOffset = 0; + while (!WorkList.empty()) { const Constant *PC = WorkList.back().first; intptr_t PA = WorkList.back().second; @@ -721,8 +802,9 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset, if (isa(PC)) { continue; - } else if (const ConstantPacked *CP = dyn_cast(PC)) { - unsigned ElementSize = TD->getTypeSize(CP->getType()->getElementType()); + } else if (const ConstantVector *CP = dyn_cast(PC)) { + unsigned ElementSize = + TD->getABITypeSize(CP->getType()->getElementType()); for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) WorkList.push_back(CPair(CP->getOperand(i), PA+i*ElementSize)); } else if (const ConstantExpr *CE = dyn_cast(PC)) { @@ -730,7 +812,13 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset, // FIXME: Handle ConstantExpression. See EE::getConstantValue() // switch (CE->getOpcode()) { - case Instruction::GetElementPtr: + case Instruction::GetElementPtr: { + SmallVector Indices(CE->op_begin()+1, CE->op_end()); + ScatteredOffset = TD->getIndexedOffset(CE->getOperand(0)->getType(), + &Indices[0], Indices.size()); + WorkList.push_back(CPair(CE->getOperand(0), PA)); + break; + } case Instruction::Add: default: cerr << "ConstantExpr not handled as global var init: " << *CE << "\n"; @@ -774,7 +862,8 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset, break; } case Type::FloatTyID: { - uint64_t val = FloatToBits(cast(PC)->getValue()); + uint32_t val = cast(PC)->getValueAPF().convertToAPInt(). + getZExtValue(); if (TD->isBigEndian()) val = ByteSwap_32(val); ptr[0] = val; @@ -784,7 +873,8 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset, break; } case Type::DoubleTyID: { - uint64_t val = DoubleToBits(cast(PC)->getValue()); + uint64_t val = cast(PC)->getValueAPF().convertToAPInt(). + getZExtValue(); if (TD->isBigEndian()) val = ByteSwap_64(val); ptr[0] = val; @@ -798,14 +888,16 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset, break; } case Type::PointerTyID: - if (isa(C)) + if (isa(PC)) memset(ptr, 0, TD->getPointerSize()); - else if (const GlobalValue* GV = dyn_cast(C)) + else if (const GlobalValue* GV = dyn_cast(PC)) { // FIXME: what about function stubs? MRs.push_back(MachineRelocation::getGV(PA-(intptr_t)Addr, MachineRelocation::VANILLA, - const_cast(GV))); - else + const_cast(GV), + ScatteredOffset)); + ScatteredOffset = 0; + } else assert(0 && "Unknown constant pointer type!"); break; default: @@ -813,16 +905,18 @@ void MachOWriter::InitMem(const Constant *C, void *Addr, intptr_t Offset, abort(); } } else if (isa(PC)) { - memset((void*)PA, 0, (size_t)TD->getTypeSize(PC->getType())); + memset((void*)PA, 0, (size_t)TD->getABITypeSize(PC->getType())); } else if (const ConstantArray *CPA = dyn_cast(PC)) { - unsigned ElementSize = TD->getTypeSize(CPA->getType()->getElementType()); + unsigned ElementSize = + TD->getABITypeSize(CPA->getType()->getElementType()); for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i) WorkList.push_back(CPair(CPA->getOperand(i), PA+i*ElementSize)); } else if (const ConstantStruct *CPS = dyn_cast(PC)) { const StructLayout *SL = TD->getStructLayout(cast(CPS->getType())); for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i) - WorkList.push_back(CPair(CPS->getOperand(i), PA+SL->MemberOffsets[i])); + WorkList.push_back(CPair(CPS->getOperand(i), + PA+SL->getElementOffset(i))); } else { cerr << "Bad Type: " << *PC->getType() << "\n"; assert(0 && "Unknown constant type to initialize memory with!"); @@ -846,10 +940,10 @@ MachOSym::MachOSym(const GlobalValue *gv, std::string name, uint8_t sect, assert(!isa(gv) && "Unexpected linkage type for Function!"); case GlobalValue::ExternalLinkage: GVName = TAI->getGlobalPrefix() + name; - n_type |= N_EXT; + n_type |= GV->hasHiddenVisibility() ? N_PEXT : N_EXT; break; case GlobalValue::InternalLinkage: - GVName = TAI->getPrivateGlobalPrefix() + name; + GVName = TAI->getGlobalPrefix() + name; break; } }