6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-10-10 16:24:04 +00:00
Code Issues Projects Releases Wiki Activity

Cleanup MachO writer and code emitter. Fix 80 cols problems, remove extra spaces, shrink down includes and move some methods out-of-line

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@74817 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bruno Cardoso Lopes 2009-07-06 06:40:51 +00:00
parent 8ae058a815
commit 752e928e6b
5 changed files with 205 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
lib/CodeGen/MachO.h
View File

@ -14,18 +14,15 @@
#ifndef MACHO_H #ifndef MACHO_H
#define MACHO_H #define MACHO_H
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/CodeGen/MachineRelocation.h"
#include "llvm/CodeGen/BinaryObject.h" #include "llvm/CodeGen/BinaryObject.h"
#include "llvm/Target/TargetAsmInfo.h"
#include <string> #include <string>
#include <vector> #include <vector>
namespace llvm { namespace llvm {
typedef std::vector<unsigned char> DataBuffer; class GlobalValue;
class TargetAsmInfo;
/// MachOSym - This struct contains information about each symbol that is /// MachOSym - This struct contains information about each symbol that is
/// added to logical symbol table for the module. This is eventually /// added to logical symbol table for the module. This is eventually
/// turned into a real symbol table in the file. /// turned into a real symbol table in the file.
@ -111,7 +108,7 @@ struct MachOHeader {
/// HeaderData - The actual data for the header which we are building /// HeaderData - The actual data for the header which we are building
/// up for emission to the file. /// up for emission to the file.
DataBuffer HeaderData; std::vector<unsigned char> HeaderData;
// Constants for the filetype field // Constants for the filetype field
// see <mach-o/loader.h> for additional info on the various types // see <mach-o/loader.h> for additional info on the various types
@ -181,8 +178,8 @@ struct MachOHeader {
}; };
MachOHeader() : magic(0), filetype(0), ncmds(0), sizeofcmds(0), flags(0), MachOHeader() : magic(0), filetype(0), ncmds(0), sizeofcmds(0), flags(0),
reserved(0) { } reserved(0) {}
/// cmdSize - This routine returns the size of the MachOSection as written /// cmdSize - This routine returns the size of the MachOSection as written
/// to disk, depending on whether the destination is a 64 bit Mach-O file. /// to disk, depending on whether the destination is a 64 bit Mach-O file.
unsigned cmdSize(bool is64Bit) const { unsigned cmdSize(bool is64Bit) const {
@ -204,7 +201,7 @@ struct MachOHeader {
} }
}; // end struct MachOHeader }; // end struct MachOHeader
/// MachOSegment - This struct contains the necessary information to /// MachOSegment - This struct contains the necessary information to
/// emit the load commands for each section in the file. /// emit the load commands for each section in the file.
struct MachOSegment { struct MachOSegment {
@ -246,13 +243,13 @@ struct MachOSegment {
SEG_VM_PROT_EXECUTE = VM_PROT_EXECUTE, SEG_VM_PROT_EXECUTE = VM_PROT_EXECUTE,
SEG_VM_PROT_ALL = VM_PROT_ALL SEG_VM_PROT_ALL = VM_PROT_ALL
}; };
// Constants for the cmd field // Constants for the cmd field
// see <mach-o/loader.h> // see <mach-o/loader.h>
enum { LC_SEGMENT = 0x01, // segment of this file to be mapped enum { LC_SEGMENT = 0x01, // segment of this file to be mapped
LC_SEGMENT_64 = 0x19 // 64-bit segment of this file to be mapped LC_SEGMENT_64 = 0x19 // 64-bit segment of this file to be mapped
}; };
/// cmdSize - This routine returns the size of the MachOSection as written /// cmdSize - This routine returns the size of the MachOSection as written
/// to disk, depending on whether the destination is a 64 bit Mach-O file. /// to disk, depending on whether the destination is a 64 bit Mach-O file.
unsigned cmdSize(bool is64Bit) const { unsigned cmdSize(bool is64Bit) const {
@ -285,15 +282,15 @@ struct MachOSection : public BinaryObject {
uint32_t reserved1; // reserved (for offset or index) uint32_t reserved1; // reserved (for offset or index)
uint32_t reserved2; // reserved (for count or sizeof) uint32_t reserved2; // reserved (for count or sizeof)
uint32_t reserved3; // reserved (64 bit only) uint32_t reserved3; // reserved (64 bit only)
/// A unique number for this section, which will be used to match symbols /// A unique number for this section, which will be used to match symbols
/// to the correct section. /// to the correct section.
uint32_t Index; uint32_t Index;
/// RelocBuffer - A buffer to hold the mach-o relocations before we write /// RelocBuffer - A buffer to hold the mach-o relocations before we write
/// them out at the appropriate location in the file. /// them out at the appropriate location in the file.
DataBuffer RelocBuffer; std::vector<unsigned char> RelocBuffer;
// Constants for the section types (low 8 bits of flags field) // Constants for the section types (low 8 bits of flags field)
// see <mach-o/loader.h> // see <mach-o/loader.h>
enum { S_REGULAR = 0, enum { S_REGULAR = 0,
@ -405,7 +402,7 @@ struct MachODySymTab {
ilocalsym(0), nlocalsym(0), iextdefsym(0), nextdefsym(0), ilocalsym(0), nlocalsym(0), iextdefsym(0), nextdefsym(0),
iundefsym(0), nundefsym(0), tocoff(0), ntoc(0), modtaboff(0), iundefsym(0), nundefsym(0), tocoff(0), ntoc(0), modtaboff(0),
nmodtab(0), extrefsymoff(0), nextrefsyms(0), indirectsymoff(0), nmodtab(0), extrefsymoff(0), nextrefsyms(0), indirectsymoff(0),
nindirectsyms(0), extreloff(0), nextrel(0), locreloff(0), nlocrel(0) { } nindirectsyms(0), extreloff(0), nextrel(0), locreloff(0), nlocrel(0) {}
}; // end struct MachODySymTab }; // end struct MachODySymTab

17
lib/CodeGen/MachOCodeEmitter.cpp
View File

@ -7,13 +7,18 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MachO.h"
#include "MachOWriter.h"
#include "MachOCodeEmitter.h" #include "MachOCodeEmitter.h"
#include "llvm/Constants.h" #include "llvm/Constants.h"
#include "llvm/DerivedTypes.h" #include "llvm/DerivedTypes.h"
#include "llvm/Function.h" #include "llvm/Function.h"
#include "llvm/CodeGen/MachineConstantPool.h" #include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/CodeGen/MachineJumpTableInfo.h" #include "llvm/CodeGen/MachineJumpTableInfo.h"
#include "llvm/CodeGen/MachineRelocation.h"
#include "llvm/Target/TargetAsmInfo.h" #include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Support/Mangler.h" #include "llvm/Support/Mangler.h"
#include "llvm/Support/OutputBuffer.h" #include "llvm/Support/OutputBuffer.h"
#include <vector> #include <vector>
@ -23,7 +28,14 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
namespace llvm { namespace llvm {
MachOCodeEmitter::MachOCodeEmitter(MachOWriter &mow, MachOSection &mos) :
ObjectCodeEmitter(&mos), MOW(mow), TM(MOW.TM) {
is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64;
isLittleEndian = TM.getTargetData()->isLittleEndian();
TAI = TM.getTargetAsmInfo();
}
/// startFunction - This callback is invoked when a new machine function is /// startFunction - This callback is invoked when a new machine function is
/// about to be emitted. /// about to be emitted.
@ -141,7 +153,8 @@ void MachOCodeEmitter::emitConstantPool(MachineConstantPool *MCP) {
for (unsigned j = 0; j < Size; ++j) for (unsigned j = 0; j < Size; ++j)
SecDataOut.outbyte(0); SecDataOut.outbyte(0);
MachOWriter::InitMem(CP[i].Val.ConstVal, CPLocations[i], TM.getTargetData(), Sec); MachOWriter::InitMem(CP[i].Val.ConstVal, CPLocations[i],
TM.getTargetData(), Sec);
} }
} }

14
lib/CodeGen/MachOCodeEmitter.h
View File

@ -10,10 +10,13 @@
#ifndef MACHOCODEEMITTER_H #ifndef MACHOCODEEMITTER_H
#define MACHOCODEEMITTER_H #define MACHOCODEEMITTER_H
#include "MachOWriter.h" #include "llvm/CodeGen/ObjectCodeEmitter.h"
#include <map>
namespace llvm { namespace llvm {
class MachOWriter;
/// MachOCodeEmitter - This class is used by the MachOWriter to emit the code /// MachOCodeEmitter - This class is used by the MachOWriter to emit the code
/// for functions to the Mach-O file. /// for functions to the Mach-O file.
@ -36,12 +39,7 @@ class MachOCodeEmitter : public ObjectCodeEmitter {
std::map<uint64_t, uintptr_t> Labels; std::map<uint64_t, uintptr_t> Labels;
public: public:
MachOCodeEmitter(MachOWriter &mow, MachOSection &mos) : MachOCodeEmitter(MachOWriter &mow, MachOSection &mos);
ObjectCodeEmitter(&mos), MOW(mow), TM(MOW.TM) {
is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64;
isLittleEndian = TM.getTargetData()->isLittleEndian();
TAI = TM.getTargetAsmInfo();
}
virtual void startFunction(MachineFunction &MF); virtual void startFunction(MachineFunction &MF);
virtual bool finishFunction(MachineFunction &MF); virtual bool finishFunction(MachineFunction &MF);
@ -49,7 +47,7 @@ public:
virtual void addRelocation(const MachineRelocation &MR) { virtual void addRelocation(const MachineRelocation &MR) {
Relocations.push_back(MR); Relocations.push_back(MR);
} }
void emitConstantPool(MachineConstantPool *MCP); void emitConstantPool(MachineConstantPool *MCP);
void emitJumpTables(MachineJumpTableInfo *MJTI); void emitJumpTables(MachineJumpTableInfo *MJTI);

180
lib/CodeGen/MachOWriter.cpp
View File

@ -22,25 +22,20 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MachO.h"
#include "MachOWriter.h" #include "MachOWriter.h"
#include "MachOCodeEmitter.h" #include "MachOCodeEmitter.h"
#include "llvm/Constants.h" #include "llvm/Constants.h"
#include "llvm/DerivedTypes.h" #include "llvm/DerivedTypes.h"
#include "llvm/Module.h" #include "llvm/Module.h"
#include "llvm/PassManager.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/Target/TargetAsmInfo.h" #include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetJITInfo.h" #include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetMachOWriterInfo.h"
#include "llvm/Support/Mangler.h" #include "llvm/Support/Mangler.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/OutputBuffer.h" #include "llvm/Support/OutputBuffer.h"
#include "llvm/Support/Streams.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cstring>
namespace llvm { namespace llvm {
@ -60,16 +55,14 @@ ObjectCodeEmitter *AddMachOWriter(PassManagerBase &PM,
char MachOWriter::ID = 0; char MachOWriter::ID = 0;
MachOWriter::MachOWriter(raw_ostream &o, TargetMachine &tm) MachOWriter::MachOWriter(raw_ostream &o, TargetMachine &tm)
: MachineFunctionPass(&ID), O(o), TM(tm) : MachineFunctionPass(&ID), O(o), TM(tm) {
{
is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64; is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64;
isLittleEndian = TM.getTargetData()->isLittleEndian(); isLittleEndian = TM.getTargetData()->isLittleEndian();
TAI = TM.getTargetAsmInfo(); TAI = TM.getTargetAsmInfo();
// Create the machine code emitter object for this target. // Create the machine code emitter object for this target.
MachOCE = new MachOCodeEmitter(*this, *getTextSection(true)); MachOCE = new MachOCodeEmitter(*this, *getTextSection(true));
} }
@ -98,13 +91,13 @@ bool MachOWriter::runOnMachineFunction(MachineFunction &MF) {
/// the Mach-O file to 'O'. /// the Mach-O file to 'O'.
bool MachOWriter::doFinalization(Module &M) { bool MachOWriter::doFinalization(Module &M) {
// FIXME: we don't handle debug info yet, we should probably do that. // FIXME: we don't handle debug info yet, we should probably do that.
// Okay, the.text section has been completed, build the .data, .bss, and // Okay, the.text section has been completed, build the .data, .bss, and
// "common" sections next. // "common" sections next.
for (Module::global_iterator I = M.global_begin(), E = M.global_end(); for (Module::global_iterator I = M.global_begin(), E = M.global_end();
I != E; ++I) I != E; ++I)
EmitGlobal(I); EmitGlobal(I);
// Emit the header and load commands. // Emit the header and load commands.
EmitHeaderAndLoadCommands(); EmitHeaderAndLoadCommands();
@ -126,6 +119,89 @@ bool MachOWriter::doFinalization(Module &M) {
return false; return false;
} }
// getConstSection - Get constant section for Constant 'C'
MachOSection *MachOWriter::getConstSection(Constant *C) {
const ConstantArray *CVA = dyn_cast<ConstantArray>(C);
if (CVA && CVA->isCString())
return getSection("__TEXT", "__cstring",
MachOSection::S_CSTRING_LITERALS);
const Type *Ty = C->getType();
if (Ty->isPrimitiveType() || Ty->isInteger()) {
unsigned Size = TM.getTargetData()->getTypeAllocSize(Ty);
switch(Size) {
default: break; // Fall through to __TEXT,__const
case 4:
return getSection("__TEXT", "__literal4",
MachOSection::S_4BYTE_LITERALS);
case 8:
return getSection("__TEXT", "__literal8",
MachOSection::S_8BYTE_LITERALS);
case 16:
return getSection("__TEXT", "__literal16",
MachOSection::S_16BYTE_LITERALS);
}
}
return getSection("__TEXT", "__const");
}
// getJumpTableSection - Select the Jump Table section
MachOSection *MachOWriter::getJumpTableSection() {
if (TM.getRelocationModel() == Reloc::PIC_)
return getTextSection(false);
else
return getSection("__TEXT", "__const");
}
// getSection - Return the section with the specified name, creating a new
// section if one does not already exist.
MachOSection *MachOWriter::getSection(const std::string &seg,
const std::string &sect,
unsigned Flags /* = 0 */ ) {
MachOSection *MOS = SectionLookup[seg+sect];
if (MOS) return MOS;
MOS = new MachOSection(seg, sect);
SectionList.push_back(MOS);
MOS->Index = SectionList.size();
MOS->flags = MachOSection::S_REGULAR | Flags;
SectionLookup[seg+sect] = MOS;
return MOS;
}
// getTextSection - Return text section with different flags for code/data
MachOSection *MachOWriter::getTextSection(bool isCode /* = true */ ) {
if (isCode)
return getSection("__TEXT", "__text",
MachOSection::S_ATTR_PURE_INSTRUCTIONS |
MachOSection::S_ATTR_SOME_INSTRUCTIONS);
else
return getSection("__TEXT", "__text");
}
MachOSection *MachOWriter::getBSSSection() {
return getSection("__DATA", "__bss", MachOSection::S_ZEROFILL);
}
// GetJTRelocation - Get a relocation a new BB relocation based
// on target information.
MachineRelocation MachOWriter::GetJTRelocation(unsigned Offset,
MachineBasicBlock *MBB) const {
return TM.getMachOWriterInfo()->GetJTRelocation(Offset, MBB);
}
// GetTargetRelocation - Returns the number of relocations.
unsigned MachOWriter::GetTargetRelocation(MachineRelocation &MR,
unsigned FromIdx, unsigned ToAddr,
unsigned ToIndex, OutputBuffer &RelocOut,
OutputBuffer &SecOut, bool Scattered,
bool Extern) {
return TM.getMachOWriterInfo()->GetTargetRelocation(MR, FromIdx, ToAddr,
ToIndex, RelocOut,
SecOut, Scattered,
Extern);
}
void MachOWriter::AddSymbolToSection(MachOSection *Sec, GlobalVariable *GV) { void MachOWriter::AddSymbolToSection(MachOSection *Sec, GlobalVariable *GV) {
const Type *Ty = GV->getType()->getElementType(); const Type *Ty = GV->getType()->getElementType();
unsigned Size = TM.getTargetData()->getTypeAllocSize(Ty); unsigned Size = TM.getTargetData()->getTypeAllocSize(Ty);
@ -151,15 +227,15 @@ void MachOWriter::AddSymbolToSection(MachOSection *Sec, GlobalVariable *GV) {
// Record the offset of the symbol, and then allocate space for it. // Record the offset of the symbol, and then allocate space for it.
// FIXME: remove when we have unified size + output buffer // FIXME: remove when we have unified size + output buffer
// Now that we know what section the GlovalVariable is going to be emitted // Now that we know what section the GlovalVariable is going to be emitted
// into, update our mappings. // into, update our mappings.
// FIXME: We may also need to update this when outputting non-GlobalVariable // FIXME: We may also need to update this when outputting non-GlobalVariable
// GlobalValues such as functions. // GlobalValues such as functions.
GVSection[GV] = Sec; GVSection[GV] = Sec;
GVOffset[GV] = Sec->size(); GVOffset[GV] = Sec->size();
// Allocate space in the section for the global. // Allocate space in the section for the global.
for (unsigned i = 0; i < Size; ++i) for (unsigned i = 0; i < Size; ++i)
SecDataOut.outbyte(0); SecDataOut.outbyte(0);
@ -169,7 +245,7 @@ void MachOWriter::EmitGlobal(GlobalVariable *GV) {
const Type *Ty = GV->getType()->getElementType(); const Type *Ty = GV->getType()->getElementType();
unsigned Size = TM.getTargetData()->getTypeAllocSize(Ty); unsigned Size = TM.getTargetData()->getTypeAllocSize(Ty);
bool NoInit = !GV->hasInitializer(); bool NoInit = !GV->hasInitializer();
// If this global has a zero initializer, it is part of the .bss or common // If this global has a zero initializer, it is part of the .bss or common
// section. // section.
if (NoInit || GV->getInitializer()->isNullValue()) { if (NoInit || GV->getInitializer()->isNullValue()) {
@ -178,7 +254,8 @@ void MachOWriter::EmitGlobal(GlobalVariable *GV) {
// merged with other symbols. // merged with other symbols.
if (NoInit || GV->hasLinkOnceLinkage() || GV->hasWeakLinkage() || if (NoInit || GV->hasLinkOnceLinkage() || GV->hasWeakLinkage() ||
GV->hasCommonLinkage()) { GV->hasCommonLinkage()) {
MachOSym ExtOrCommonSym(GV, Mang->getValueName(GV), MachOSym::NO_SECT, TAI); MachOSym ExtOrCommonSym(GV, Mang->getValueName(GV),
MachOSym::NO_SECT, TAI);
// For undefined (N_UNDF) external (N_EXT) types, n_value is the size in // For undefined (N_UNDF) external (N_EXT) types, n_value is the size in
// bytes of the symbol. // bytes of the symbol.
ExtOrCommonSym.n_value = Size; ExtOrCommonSym.n_value = Size;
@ -192,11 +269,11 @@ void MachOWriter::EmitGlobal(GlobalVariable *GV) {
AddSymbolToSection(BSS, GV); AddSymbolToSection(BSS, GV);
return; return;
} }
// Scalar read-only data goes in a literal section if the scalar is 4, 8, or // 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 // 16 bytes, or a cstring. Other read only data goes into a regular const
// section. Read-write data goes in the data section. // section. Read-write data goes in the data section.
MachOSection *Sec = GV->isConstant() ? getConstSection(GV->getInitializer()) : MachOSection *Sec = GV->isConstant() ? getConstSection(GV->getInitializer()) :
getDataSection(); getDataSection();
AddSymbolToSection(Sec, GV); AddSymbolToSection(Sec, GV);
InitMem(GV->getInitializer(), GVOffset[GV], TM.getTargetData(), Sec); InitMem(GV->getInitializer(), GVOffset[GV], TM.getTargetData(), Sec);
@ -210,22 +287,22 @@ void MachOWriter::EmitHeaderAndLoadCommands() {
MachOSegment SEG("", is64Bit); MachOSegment SEG("", is64Bit);
SEG.nsects = SectionList.size(); SEG.nsects = SectionList.size();
SEG.cmdsize = SEG.cmdSize(is64Bit) + SEG.cmdsize = SEG.cmdSize(is64Bit) +
SEG.nsects * SectionList[0]->cmdSize(is64Bit); SEG.nsects * SectionList[0]->cmdSize(is64Bit);
// Step #1: calculate the number of load commands. We always have at least // Step #1: calculate the number of load commands. We always have at least
// one, for the LC_SEGMENT load command, plus two for the normal // one, for the LC_SEGMENT load command, plus two for the normal
// and dynamic symbol tables, if there are any symbols. // and dynamic symbol tables, if there are any symbols.
Header.ncmds = SymbolTable.empty() ? 1 : 3; Header.ncmds = SymbolTable.empty() ? 1 : 3;
// Step #2: calculate the size of the load commands // Step #2: calculate the size of the load commands
Header.sizeofcmds = SEG.cmdsize; Header.sizeofcmds = SEG.cmdsize;
if (!SymbolTable.empty()) if (!SymbolTable.empty())
Header.sizeofcmds += SymTab.cmdsize + DySymTab.cmdsize; Header.sizeofcmds += SymTab.cmdsize + DySymTab.cmdsize;
// Step #3: write the header to the file // Step #3: write the header to the file
// Local alias to shortenify coming code. // Local alias to shortenify coming code.
DataBuffer &FH = Header.HeaderData; std::vector<unsigned char> &FH = Header.HeaderData;
OutputBuffer FHOut(FH, is64Bit, isLittleEndian); OutputBuffer FHOut(FH, is64Bit, isLittleEndian);
FHOut.outword(Header.magic); FHOut.outword(Header.magic);
@ -237,7 +314,7 @@ void MachOWriter::EmitHeaderAndLoadCommands() {
FHOut.outword(Header.flags); FHOut.outword(Header.flags);
if (is64Bit) if (is64Bit)
FHOut.outword(Header.reserved); FHOut.outword(Header.reserved);
// Step #4: Finish filling in the segment load command and write it out // Step #4: Finish filling in the segment load command and write it out
for (std::vector<MachOSection*>::iterator I = SectionList.begin(), for (std::vector<MachOSection*>::iterator I = SectionList.begin(),
E = SectionList.end(); I != E; ++I) E = SectionList.end(); I != E; ++I)
@ -245,7 +322,7 @@ void MachOWriter::EmitHeaderAndLoadCommands() {
SEG.vmsize = SEG.filesize; SEG.vmsize = SEG.filesize;
SEG.fileoff = Header.cmdSize(is64Bit) + Header.sizeofcmds; SEG.fileoff = Header.cmdSize(is64Bit) + Header.sizeofcmds;
FHOut.outword(SEG.cmd); FHOut.outword(SEG.cmd);
FHOut.outword(SEG.cmdsize); FHOut.outword(SEG.cmdsize);
FHOut.outstring(SEG.segname, 16); FHOut.outstring(SEG.segname, 16);
@ -257,8 +334,8 @@ void MachOWriter::EmitHeaderAndLoadCommands() {
FHOut.outword(SEG.initprot); FHOut.outword(SEG.initprot);
FHOut.outword(SEG.nsects); FHOut.outword(SEG.nsects);
FHOut.outword(SEG.flags); FHOut.outword(SEG.flags);
// Step #5: Finish filling in the fields of the MachOSections // Step #5: Finish filling in the fields of the MachOSections
uint64_t currentAddr = 0; uint64_t currentAddr = 0;
for (std::vector<MachOSection*>::iterator I = SectionList.begin(), for (std::vector<MachOSection*>::iterator I = SectionList.begin(),
E = SectionList.end(); I != E; ++I) { E = SectionList.end(); I != E; ++I) {
@ -268,13 +345,13 @@ void MachOWriter::EmitHeaderAndLoadCommands() {
// FIXME: do we need to do something with alignment here? // FIXME: do we need to do something with alignment here?
currentAddr += MOS->size(); currentAddr += MOS->size();
} }
// Step #6: Emit the symbol table to temporary buffers, so that we know the // 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 // 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 // sorts and assigns indices to each of the symbols, which is necessary for
// emitting relocations to externally-defined objects. // emitting relocations to externally-defined objects.
BufferSymbolAndStringTable(); BufferSymbolAndStringTable();
// Step #7: Calculate the number of relocations for each section and write out // Step #7: Calculate the number of relocations for each section and write out
// the section commands for each section // the section commands for each section
currentAddr += SEG.fileoff; currentAddr += SEG.fileoff;
@ -287,7 +364,7 @@ void MachOWriter::EmitHeaderAndLoadCommands() {
CalculateRelocations(*MOS); CalculateRelocations(*MOS);
MOS->reloff = MOS->nreloc ? currentAddr : 0; MOS->reloff = MOS->nreloc ? currentAddr : 0;
currentAddr += MOS->nreloc * 8; currentAddr += MOS->nreloc * 8;
// write the finalized section command to the output buffer // write the finalized section command to the output buffer
FHOut.outstring(MOS->sectname, 16); FHOut.outstring(MOS->sectname, 16);
FHOut.outstring(MOS->segname, 16); FHOut.outstring(MOS->segname, 16);
@ -303,7 +380,7 @@ void MachOWriter::EmitHeaderAndLoadCommands() {
if (is64Bit) if (is64Bit)
FHOut.outword(MOS->reserved3); FHOut.outword(MOS->reserved3);
} }
// Step #8: Emit LC_SYMTAB/LC_DYSYMTAB load commands // Step #8: Emit LC_SYMTAB/LC_DYSYMTAB load commands
SymTab.symoff = currentAddr; SymTab.symoff = currentAddr;
SymTab.nsyms = SymbolTable.size(); SymTab.nsyms = SymbolTable.size();
@ -339,7 +416,7 @@ void MachOWriter::EmitHeaderAndLoadCommands() {
FHOut.outword(DySymTab.nextrel); FHOut.outword(DySymTab.nextrel);
FHOut.outword(DySymTab.locreloff); FHOut.outword(DySymTab.locreloff);
FHOut.outword(DySymTab.nlocrel); FHOut.outword(DySymTab.nlocrel);
O.write((char*)&FH[0], FH.size()); O.write((char*)&FH[0], FH.size());
} }
@ -370,7 +447,7 @@ void MachOWriter::BufferSymbolAndStringTable() {
// 1. local symbols // 1. local symbols
// 2. defined external symbols (sorted by name) // 2. defined external symbols (sorted by name)
// 3. undefined external symbols (sorted by name) // 3. undefined external symbols (sorted by name)
// Before sorting the symbols, check the PendingGlobals for any undefined // Before sorting the symbols, check the PendingGlobals for any undefined
// globals that need to be put in the symbol table. // globals that need to be put in the symbol table.
for (std::vector<GlobalValue*>::iterator I = PendingGlobals.begin(), for (std::vector<GlobalValue*>::iterator I = PendingGlobals.begin(),
@ -386,10 +463,11 @@ void MachOWriter::BufferSymbolAndStringTable() {
// of definition, we won't have to sort by name within each partition. // of definition, we won't have to sort by name within each partition.
std::sort(SymbolTable.begin(), SymbolTable.end(), MachOSym::SymCmp()); std::sort(SymbolTable.begin(), SymbolTable.end(), MachOSym::SymCmp());
// Parition the symbol table entries so that all local symbols come before // Parition the symbol table entries so that all local symbols come before
// all symbols with external linkage. { 1 | 2 3 } // all symbols with external linkage. { 1 | 2 3 }
std::partition(SymbolTable.begin(), SymbolTable.end(), MachOSym::PartitionByLocal); std::partition(SymbolTable.begin(), SymbolTable.end(),
MachOSym::PartitionByLocal);
// Advance iterator to beginning of external symbols and partition so that // Advance iterator to beginning of external symbols and partition so that
// all external symbols defined in this module come before all external // all external symbols defined in this module come before all external
// symbols defined elsewhere. { 1 | 2 | 3 } // symbols defined elsewhere. { 1 | 2 | 3 }
@ -401,7 +479,7 @@ void MachOWriter::BufferSymbolAndStringTable() {
} }
} }
// Calculate the starting index for each of the local, extern defined, and // Calculate the starting index for each of the local, extern defined, and
// undefined symbols, as well as the number of each to put in the LC_DYSYMTAB // undefined symbols, as well as the number of each to put in the LC_DYSYMTAB
// load command. // load command.
for (std::vector<MachOSym>::iterator I = SymbolTable.begin(), for (std::vector<MachOSym>::iterator I = SymbolTable.begin(),
@ -417,7 +495,7 @@ void MachOWriter::BufferSymbolAndStringTable() {
++DySymTab.nundefsym; ++DySymTab.nundefsym;
} }
} }
// Write out a leading zero byte when emitting string table, for n_strx == 0 // Write out a leading zero byte when emitting string table, for n_strx == 0
// which means an empty string. // which means an empty string.
OutputBuffer StrTOut(StrT, is64Bit, isLittleEndian); OutputBuffer StrTOut(StrT, is64Bit, isLittleEndian);
@ -451,7 +529,7 @@ void MachOWriter::BufferSymbolAndStringTable() {
I->n_value += GVSection[GV]->addr; I->n_value += GVSection[GV]->addr;
if (GV && (GVOffset[GV] == -1)) if (GV && (GVOffset[GV] == -1))
GVOffset[GV] = index; GVOffset[GV] = index;
// Emit nlist to buffer // Emit nlist to buffer
SymTOut.outword(I->n_strx); SymTOut.outword(I->n_strx);
SymTOut.outbyte(I->n_type); SymTOut.outbyte(I->n_type);
@ -486,7 +564,7 @@ void MachOWriter::CalculateRelocations(MachOSection &MOS) {
GlobalValue *GV = MR.getGlobalValue(); GlobalValue *GV = MR.getGlobalValue();
MachOSection *MOSPtr = GVSection[GV]; MachOSection *MOSPtr = GVSection[GV];
intptr_t Offset = GVOffset[GV]; intptr_t Offset = GVOffset[GV];
// If we have never seen the global before, it must be to a symbol // If we have never seen the global before, it must be to a symbol
// defined in another module (N_UNDF). // defined in another module (N_UNDF).
if (!MOSPtr) { if (!MOSPtr) {
@ -500,7 +578,7 @@ void MachOWriter::CalculateRelocations(MachOSection &MOS) {
} }
MR.setResultPointer((void*)Offset); MR.setResultPointer((void*)Offset);
} }
// If the symbol is locally defined, pass in the address of the section and // 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. // the section index to the code which will generate the target relocation.
if (!Extern) { if (!Extern) {
@ -519,21 +597,21 @@ void MachOWriter::CalculateRelocations(MachOSection &MOS) {
// InitMem - Write the value of a Constant to the specified memory location, // InitMem - Write the value of a Constant to the specified memory location,
// converting it into bytes and relocations. // converting it into bytes and relocations.
void MachOWriter::InitMem(const Constant *C, uintptr_t Offset, void MachOWriter::InitMem(const Constant *C, uintptr_t Offset,
const TargetData *TD, MachOSection* mos) { const TargetData *TD, MachOSection* mos) {
typedef std::pair<const Constant*, intptr_t> CPair; typedef std::pair<const Constant*, intptr_t> CPair;
std::vector<CPair> WorkList; std::vector<CPair> WorkList;
uint8_t *Addr = &mos->getData()[0]; uint8_t *Addr = &mos->getData()[0];
WorkList.push_back(CPair(C,(intptr_t)Addr + Offset)); WorkList.push_back(CPair(C,(intptr_t)Addr + Offset));
intptr_t ScatteredOffset = 0; intptr_t ScatteredOffset = 0;
while (!WorkList.empty()) { while (!WorkList.empty()) {
const Constant *PC = WorkList.back().first; const Constant *PC = WorkList.back().first;
intptr_t PA = WorkList.back().second; intptr_t PA = WorkList.back().second;
WorkList.pop_back(); WorkList.pop_back();
if (isa<UndefValue>(PC)) { if (isa<UndefValue>(PC)) {
continue; continue;
} else if (const ConstantVector *CP = dyn_cast<ConstantVector>(PC)) { } else if (const ConstantVector *CP = dyn_cast<ConstantVector>(PC)) {
@ -626,7 +704,7 @@ void MachOWriter::InitMem(const Constant *C, uintptr_t Offset,
memset(ptr, 0, TD->getPointerSize()); memset(ptr, 0, TD->getPointerSize());
else if (const GlobalValue* GV = dyn_cast<GlobalValue>(PC)) { else if (const GlobalValue* GV = dyn_cast<GlobalValue>(PC)) {
// FIXME: what about function stubs? // FIXME: what about function stubs?
mos->addRelocation(MachineRelocation::getGV(PA-(intptr_t)Addr, mos->addRelocation(MachineRelocation::getGV(PA-(intptr_t)Addr,
MachineRelocation::VANILLA, MachineRelocation::VANILLA,
const_cast<GlobalValue*>(GV), const_cast<GlobalValue*>(GV),
ScatteredOffset)); ScatteredOffset));

149
lib/CodeGen/MachOWriter.h
View File

@ -14,29 +14,27 @@
#ifndef MACHOWRITER_H #ifndef MACHOWRITER_H
#define MACHOWRITER_H #define MACHOWRITER_H
#include "MachO.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/CodeGen/MachineFunctionPass.h" #include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/ObjectCodeEmitter.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetMachOWriterInfo.h"
#include <vector> #include <vector>
#include <map> #include <map>
namespace llvm { namespace llvm {
class Constant;
class GlobalVariable; class GlobalVariable;
class Mangler; class Mangler;
class MachineRelocation; class MachineRelocation;
class ObjectCodeEmitter;
class MachOCodeEmitter; class MachOCodeEmitter;
class MachODySymTab;
class MachOHeader;
class MachOSection;
class MachOSym;
class TargetData; class TargetData;
class TargetMachine; class TargetMachine;
class TargetAsmInfo;
class ObjectCodeEmitter;
class OutputBuffer; class OutputBuffer;
class raw_ostream; class raw_ostream;
/// MachOWriter - This class implements the common target-independent code for /// MachOWriter - This class implements the common target-independent code for
/// writing Mach-O files. Targets should derive a class from this to /// writing Mach-O files. Targets should derive a class from this to
/// parameterize the output format. /// parameterize the output format.
@ -69,36 +67,30 @@ namespace llvm {
/// Mang - The object used to perform name mangling for this module. /// Mang - The object used to perform name mangling for this module.
/// ///
Mangler *Mang; Mangler *Mang;
/// MachOCE - The MachineCodeEmitter object that we are exposing to emit machine
/// code for functions to the .o file.
/// MachOCE - The MachineCodeEmitter object that we are exposing to emit
/// machine code for functions to the .o file.
MachOCodeEmitter *MachOCE; MachOCodeEmitter *MachOCE;
/// is64Bit/isLittleEndian - This information is inferred from the target /// is64Bit/isLittleEndian - This information is inferred from the target
/// machine directly, indicating what header values and flags to set. /// machine directly, indicating what header values and flags to set.
bool is64Bit, isLittleEndian; bool is64Bit, isLittleEndian;
// Target Asm Info // Target Asm Info
const TargetAsmInfo *TAI; const TargetAsmInfo *TAI;
/// Header - An instance of MachOHeader that we will update while we build /// Header - An instance of MachOHeader that we will update while we build
/// the file, and then emit during finalization. /// the file, and then emit during finalization.
MachOHeader Header; MachOHeader Header;
/// doInitialization - Emit the file header and all of the global variables /// doInitialization - Emit the file header and all of the global variables
/// for the module to the Mach-O file. /// for the module to the Mach-O file.
bool doInitialization(Module &M); bool doInitialization(Module &M);
bool runOnMachineFunction(MachineFunction &MF); bool runOnMachineFunction(MachineFunction &MF);
/// doFinalization - Now that the module has been completely processed, emit /// doFinalization - Now that the module has been completely processed, emit
/// the Mach-O file to 'O'. /// the Mach-O file to 'O'.
bool doFinalization(Module &M); bool doFinalization(Module &M);
private: private:
@ -106,85 +98,37 @@ namespace llvm {
/// SectionList - This is the list of sections that we have emitted to the /// SectionList - This is the list of sections that we have emitted to the
/// file. Once the file has been completely built, the segment load command /// file. Once the file has been completely built, the segment load command
/// SectionCommands are constructed from this info. /// SectionCommands are constructed from this info.
std::vector<MachOSection*> SectionList; std::vector<MachOSection*> SectionList;
/// SectionLookup - This is a mapping from section name to SectionList entry /// SectionLookup - This is a mapping from section name to SectionList entry
std::map<std::string, MachOSection*> SectionLookup; std::map<std::string, MachOSection*> SectionLookup;
/// GVSection - This is a mapping from a GlobalValue to a MachOSection, /// GVSection - This is a mapping from a GlobalValue to a MachOSection,
/// to aid in emitting relocations. /// to aid in emitting relocations.
std::map<GlobalValue*, MachOSection*> GVSection; std::map<GlobalValue*, MachOSection*> GVSection;
/// GVOffset - This is a mapping from a GlobalValue to an offset from the /// GVOffset - This is a mapping from a GlobalValue to an offset from the
/// start of the section in which the GV resides, to aid in emitting /// start of the section in which the GV resides, to aid in emitting
/// relocations. /// relocations.
std::map<GlobalValue*, intptr_t> GVOffset; std::map<GlobalValue*, intptr_t> GVOffset;
/// getSection - Return the section with the specified name, creating a new /// getSection - Return the section with the specified name, creating a new
/// section if one does not already exist. /// section if one does not already exist.
MachOSection *getSection(const std::string &seg, const std::string &sect, MachOSection *getSection(const std::string &seg, const std::string &sect,
unsigned Flags = 0) { unsigned Flags = 0);
MachOSection *MOS = SectionLookup[seg+sect];
if (MOS) return MOS; /// getTextSection - Return text section with different flags for code/data
MachOSection *getTextSection(bool isCode = true);
MOS = new MachOSection(seg, sect);
SectionList.push_back(MOS);
MOS->Index = SectionList.size();
MOS->flags = MachOSection::S_REGULAR | Flags;
SectionLookup[seg+sect] = MOS;
return MOS;
}
MachOSection *getTextSection(bool isCode = true) {
if (isCode)
return getSection("__TEXT", "__text",
MachOSection::S_ATTR_PURE_INSTRUCTIONS |
MachOSection::S_ATTR_SOME_INSTRUCTIONS);
else
return getSection("__TEXT", "__text");
}
MachOSection *getBSSSection() {
return getSection("__DATA", "__bss", MachOSection::S_ZEROFILL);
}
MachOSection *getDataSection() { MachOSection *getDataSection() {
return getSection("__DATA", "__data"); return getSection("__DATA", "__data");
} }
MachOSection *getConstSection(Constant *C) {
const ConstantArray *CVA = dyn_cast<ConstantArray>(C); MachOSection *getBSSSection();
if (CVA && CVA->isCString()) MachOSection *getConstSection(Constant *C);
return getSection("__TEXT", "__cstring", MachOSection *getJumpTableSection();
MachOSection::S_CSTRING_LITERALS);
/// MachOSymTab - This struct contains information about the offsets and
const Type *Ty = C->getType();
if (Ty->isPrimitiveType() || Ty->isInteger()) {
unsigned Size = TM.getTargetData()->getTypeAllocSize(Ty);
switch(Size) {
default: break; // Fall through to __TEXT,__const
case 4:
return getSection("__TEXT", "__literal4",
MachOSection::S_4BYTE_LITERALS);
case 8:
return getSection("__TEXT", "__literal8",
MachOSection::S_8BYTE_LITERALS);
case 16:
return getSection("__TEXT", "__literal16",
MachOSection::S_16BYTE_LITERALS);
}
}
return getSection("__TEXT", "__const");
}
MachOSection *getJumpTableSection() {
if (TM.getRelocationModel() == Reloc::PIC_)
return getTextSection(false);
else
return getSection("__TEXT", "__const");
}
/// MachOSymTab - This struct contains information about the offsets and
/// size of symbol table information. /// size of symbol table information.
/// segment. /// segment.
struct MachOSymTab { struct MachOSymTab {
@ -199,44 +143,42 @@ namespace llvm {
// see <mach-o/loader.h> // see <mach-o/loader.h>
enum { LC_SYMTAB = 0x02 // link-edit stab symbol table info enum { LC_SYMTAB = 0x02 // link-edit stab symbol table info
}; };
MachOSymTab() : cmd(LC_SYMTAB), cmdsize(6 * sizeof(uint32_t)), symoff(0), MachOSymTab() : cmd(LC_SYMTAB), cmdsize(6 * sizeof(uint32_t)), symoff(0),
nsyms(0), stroff(0), strsize(0) { } nsyms(0), stroff(0), strsize(0) { }
}; };
/// SymTab - The "stab" style symbol table information /// SymTab - The "stab" style symbol table information
MachOSymTab SymTab; MachOSymTab SymTab;
/// DySymTab - symbol table info for the dynamic link editor /// DySymTab - symbol table info for the dynamic link editor
MachODySymTab DySymTab; MachODySymTab DySymTab;
protected: protected:
/// SymbolTable - This is the list of symbols we have emitted to the file. /// SymbolTable - This is the list of symbols we have emitted to the file.
/// This actually gets rearranged before emission to the file (to put the /// This actually gets rearranged before emission to the file (to put the
/// local symbols first in the list). /// local symbols first in the list).
std::vector<MachOSym> SymbolTable; std::vector<MachOSym> SymbolTable;
/// SymT - A buffer to hold the symbol table before we write it out at the /// SymT - A buffer to hold the symbol table before we write it out at the
/// appropriate location in the file. /// appropriate location in the file.
DataBuffer SymT; std::vector<unsigned char> SymT;
/// StrT - A buffer to hold the string table before we write it out at the /// StrT - A buffer to hold the string table before we write it out at the
/// appropriate location in the file. /// appropriate location in the file.
DataBuffer StrT; std::vector<unsigned char> StrT;
/// PendingSyms - This is a list of externally defined symbols that we have /// PendingSyms - This is a list of externally defined symbols that we have
/// been asked to emit, but have not seen a reference to. When a reference /// been asked to emit, but have not seen a reference to. When a reference
/// is seen, the symbol will move from this list to the SymbolTable. /// is seen, the symbol will move from this list to the SymbolTable.
std::vector<GlobalValue*> PendingGlobals; std::vector<GlobalValue*> PendingGlobals;
/// DynamicSymbolTable - This is just a vector of indices into /// DynamicSymbolTable - This is just a vector of indices into
/// SymbolTable to aid in emitting the DYSYMTAB load command. /// SymbolTable to aid in emitting the DYSYMTAB load command.
std::vector<unsigned> DynamicSymbolTable; std::vector<unsigned> DynamicSymbolTable;
static void InitMem(const Constant *C, static void InitMem(const Constant *C, uintptr_t Offset,
uintptr_t Offset, const TargetData *TD, MachOSection* mos);
const TargetData *TD,
MachOSection* mos);
private: private:
void AddSymbolToSection(MachOSection *MOS, GlobalVariable *GV); void AddSymbolToSection(MachOSection *MOS, GlobalVariable *GV);
@ -247,25 +189,16 @@ namespace llvm {
void BufferSymbolAndStringTable(); void BufferSymbolAndStringTable();
void CalculateRelocations(MachOSection &MOS); void CalculateRelocations(MachOSection &MOS);
// GetJTRelocation - Get a relocation a new BB relocation based
// on target information.
MachineRelocation GetJTRelocation(unsigned Offset, MachineRelocation GetJTRelocation(unsigned Offset,
MachineBasicBlock *MBB) const { MachineBasicBlock *MBB) const;
return TM.getMachOWriterInfo()->GetJTRelocation(Offset, MBB);
}
/// GetTargetRelocation - Returns the number of relocations. /// GetTargetRelocation - Returns the number of relocations.
unsigned GetTargetRelocation(MachineRelocation &MR, unsigned GetTargetRelocation(MachineRelocation &MR, unsigned FromIdx,
unsigned FromIdx, unsigned ToAddr, unsigned ToIndex,
unsigned ToAddr, OutputBuffer &RelocOut, OutputBuffer &SecOut,
unsigned ToIndex, bool Scattered, bool Extern);
OutputBuffer &RelocOut,
OutputBuffer &SecOut,
bool Scattered,
bool Extern) {
return TM.getMachOWriterInfo()->GetTargetRelocation(MR, FromIdx, ToAddr,
ToIndex, RelocOut,
SecOut, Scattered,
Extern);
}
}; };
} }