diff options
Diffstat (limited to 'lib/MC')
| -rw-r--r-- | lib/MC/MCAssembler.cpp | 228 | ||||
| -rw-r--r-- | lib/MC/MCMachOStreamer.cpp | 170 |
2 files changed, 398 insertions, 0 deletions
diff --git a/lib/MC/MCAssembler.cpp b/lib/MC/MCAssembler.cpp new file mode 100644 index 0000000..7a1e935 --- /dev/null +++ b/lib/MC/MCAssembler.cpp @@ -0,0 +1,228 @@ +//===- lib/MC/MCAssembler.cpp - Assembler Backend Implementation ----------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/MC/MCAssembler.h" +#include "llvm/MC/MCSectionMachO.h" +#include "llvm/Support/DataTypes.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/Target/TargetMachOWriterInfo.h" + +using namespace llvm; + +namespace { + +class MachObjectWriter { + // See <mach-o/loader.h>. + enum { + Header_Magic32 = 0xFEEDFACE, + Header_Magic64 = 0xFEEDFACF + }; + + static const unsigned Header32Size = 28; + static const unsigned Header64Size = 32; + static const unsigned SegmentLoadCommand32Size = 56; + static const unsigned Section32Size = 68; + + enum HeaderFileType { + HFT_Object = 0x1 + }; + + enum LoadCommandType { + LCT_Segment = 0x1 + }; + + raw_ostream &OS; + bool IsLSB; + +public: + MachObjectWriter(raw_ostream &_OS, bool _IsLSB = true) + : OS(_OS), IsLSB(_IsLSB) { + } + + /// @name Helper Methods + /// @{ + + void Write32(uint32_t Value) { + if (IsLSB) { + OS << char(Value >> 0); + OS << char(Value >> 8); + OS << char(Value >> 16); + OS << char(Value >> 24); + } else { + OS << char(Value >> 24); + OS << char(Value >> 16); + OS << char(Value >> 8); + OS << char(Value >> 0); + } + } + + void WriteZeros(unsigned N) { + const char Zeros[16] = { 0 }; + + for (unsigned i = 0, e = N / 16; i != e; ++i) + OS << StringRef(Zeros, 16); + + OS << StringRef(Zeros, N % 16); + } + + void WriteString(const StringRef &Str, unsigned ZeroFillSize = 0) { + OS << Str; + if (ZeroFillSize) + WriteZeros(ZeroFillSize - Str.size()); + } + + /// @} + + static unsigned getPrologSize32(unsigned NumSections) { + return Header32Size + SegmentLoadCommand32Size + + NumSections * Section32Size; + } + + void WriteHeader32(unsigned NumSections) { + // struct mach_header (28 bytes) + + uint64_t Start = OS.tell(); + (void) Start; + + Write32(Header_Magic32); + + // FIXME: Support cputype. + Write32(TargetMachOWriterInfo::HDR_CPU_TYPE_I386); + + // FIXME: Support cpusubtype. + Write32(TargetMachOWriterInfo::HDR_CPU_SUBTYPE_I386_ALL); + + Write32(HFT_Object); + + // Object files have a single load command, the segment. + Write32(1); + Write32(SegmentLoadCommand32Size + NumSections * Section32Size); + Write32(0); // Flags + + assert(OS.tell() - Start == Header32Size); + } + + void WriteLoadCommandHeader(uint32_t Cmd, uint32_t CmdSize) { + assert((CmdSize & 0x3) == 0 && "Invalid size!"); + + Write32(Cmd); + Write32(CmdSize); + } + + void WriteSegmentLoadCommand32(unsigned NumSections) { + // struct segment_command (56 bytes) + + uint64_t Start = OS.tell(); + (void) Start; + + Write32(LCT_Segment); + Write32(SegmentLoadCommand32Size + NumSections * Section32Size); + + WriteString("", 16); + Write32(0); // vmaddr + Write32(0); // vmsize + Write32(Header32Size + SegmentLoadCommand32Size + + NumSections * Section32Size); // file offset + Write32(0); // file size + Write32(0x7); // maxprot + Write32(0x7); // initprot + Write32(NumSections); + Write32(0); // flags + + assert(OS.tell() - Start == SegmentLoadCommand32Size); + } + + void WriteSection32(const MCSectionData &SD) { + // struct section (68 bytes) + + uint64_t Start = OS.tell(); + (void) Start; + + // FIXME: cast<> support! + const MCSectionMachO &Section = + static_cast<const MCSectionMachO&>(SD.getSection()); + WriteString(Section.getSectionName(), 16); + WriteString(Section.getSegmentName(), 16); + Write32(0); // address + Write32(SD.getFileSize()); // size + Write32(SD.getFileOffset()); + + assert(isPowerOf2_32(SD.getAlignment()) && "Invalid alignment!"); + Write32(Log2_32(SD.getAlignment())); + Write32(0); // file offset of relocation entries + Write32(0); // number of relocation entrions + Write32(Section.getTypeAndAttributes()); + Write32(0); // reserved1 + Write32(Section.getStubSize()); // reserved2 + + assert(OS.tell() - Start == Section32Size); + } +}; + +} + +/* *** */ + +MCFragment::MCFragment(MCSectionData *SD) +{ + if (SD) + SD->getFragmentList().push_back(this); +} + +/* *** */ + +MCSectionData::MCSectionData() : Section(*(MCSection*)0) {} + +MCSectionData::MCSectionData(const MCSection &_Section, MCAssembler *A) + : Section(_Section), + Alignment(1), + FileOffset(0), + FileSize(0) +{ + if (A) + A->getSectionList().push_back(this); +} + +void MCSectionData::WriteFileData(raw_ostream &OS) const { + +} + +/* *** */ + +MCAssembler::MCAssembler(raw_ostream &_OS) : OS(_OS) {} + +MCAssembler::~MCAssembler() { +} + +void MCAssembler::Finish() { + unsigned NumSections = Sections.size(); + + // Compute the file offsets so we can write in a single pass. + uint64_t Offset = MachObjectWriter::getPrologSize32(NumSections); + for (iterator it = begin(), ie = end(); it != ie; ++it) { + it->setFileOffset(Offset); + Offset += it->getFileSize(); + } + + MachObjectWriter MOW(OS); + + // Write the prolog, starting with the header and load command... + MOW.WriteHeader32(NumSections); + MOW.WriteSegmentLoadCommand32(NumSections); + + // ... and then the section headers. + for (iterator it = begin(), ie = end(); it != ie; ++it) + MOW.WriteSection32(*it); + + // Finally, write the section data. + for (iterator it = begin(), ie = end(); it != ie; ++it) + it->WriteFileData(OS); + + OS.flush(); +} diff --git a/lib/MC/MCMachOStreamer.cpp b/lib/MC/MCMachOStreamer.cpp new file mode 100644 index 0000000..f34fcd9 --- /dev/null +++ b/lib/MC/MCMachOStreamer.cpp @@ -0,0 +1,170 @@ +//===- lib/MC/MCMachOStreamer.cpp - Mach-O Object Output ------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/MC/MCStreamer.h" + +#include "llvm/ADT/DenseMap.h" +#include "llvm/MC/MCAssembler.h" +#include "llvm/MC/MCContext.h" +#include "llvm/MC/MCSection.h" +#include "llvm/MC/MCSymbol.h" +#include "llvm/MC/MCValue.h" +#include "llvm/Support/ErrorHandling.h" +using namespace llvm; + +namespace { + +class MCMachOStreamer : public MCStreamer { + MCAssembler Assembler; + + MCSectionData *CurSectionData; + + DenseMap<const MCSection*, MCSectionData*> SectionMap; + +public: + MCMachOStreamer(MCContext &Context, raw_ostream &_OS) + : MCStreamer(Context), Assembler(_OS), CurSectionData(0) {} + ~MCMachOStreamer() {} + + /// @name MCStreamer Interface + /// @{ + + virtual void SwitchSection(const MCSection *Section); + + virtual void EmitLabel(MCSymbol *Symbol); + + virtual void EmitAssemblerFlag(AssemblerFlag Flag); + + virtual void EmitAssignment(MCSymbol *Symbol, const MCValue &Value, + bool MakeAbsolute = false); + + virtual void EmitSymbolAttribute(MCSymbol *Symbol, SymbolAttr Attribute); + + virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue); + + virtual void EmitLocalSymbol(MCSymbol *Symbol, const MCValue &Value); + + virtual void EmitCommonSymbol(MCSymbol *Symbol, unsigned Size, + unsigned Pow2Alignment, bool IsLocal); + + virtual void EmitZerofill(MCSection *Section, MCSymbol *Symbol = NULL, + unsigned Size = 0, unsigned Pow2Alignment = 0); + + virtual void EmitBytes(const StringRef &Data); + + virtual void EmitValue(const MCValue &Value, unsigned Size); + + virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, + unsigned ValueSize = 1, + unsigned MaxBytesToEmit = 0); + + virtual void EmitValueToOffset(const MCValue &Offset, + unsigned char Value = 0); + + virtual void EmitInstruction(const MCInst &Inst); + + virtual void Finish(); + + /// @} +}; + +} // end anonymous namespace. + +void MCMachOStreamer::SwitchSection(const MCSection *Section) { + assert(Section && "Cannot switch to a null section!"); + + if (Section != CurSection) { + CurSection = Section; + MCSectionData *&Entry = SectionMap[Section]; + + if (!Entry) + Entry = new MCSectionData(*Section, &Assembler); + + CurSectionData = Entry; + } +} + +void MCMachOStreamer::EmitLabel(MCSymbol *Symbol) { + assert(Symbol->getSection() == 0 && "Cannot emit a symbol twice!"); + assert(CurSection && "Cannot emit before setting section!"); + assert(!getContext().GetSymbolValue(Symbol) && + "Cannot emit symbol which was directly assigned to!"); + + llvm_unreachable("FIXME: Not yet implemented!"); + + Symbol->setSection(CurSection); + Symbol->setExternal(false); +} + +void MCMachOStreamer::EmitAssemblerFlag(AssemblerFlag Flag) { + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::EmitAssignment(MCSymbol *Symbol, + const MCValue &Value, + bool MakeAbsolute) { + assert(!Symbol->getSection() && "Cannot assign to a label!"); + + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::EmitSymbolAttribute(MCSymbol *Symbol, + SymbolAttr Attribute) { + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) { + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::EmitLocalSymbol(MCSymbol *Symbol, const MCValue &Value) { + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::EmitCommonSymbol(MCSymbol *Symbol, unsigned Size, + unsigned Pow2Alignment, + bool IsLocal) { + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol, + unsigned Size, unsigned Pow2Alignment) { + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::EmitBytes(const StringRef &Data) { + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::EmitValue(const MCValue &Value, unsigned Size) { + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::EmitValueToAlignment(unsigned ByteAlignment, + int64_t Value, unsigned ValueSize, + unsigned MaxBytesToEmit) { + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::EmitValueToOffset(const MCValue &Offset, + unsigned char Value) { + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::EmitInstruction(const MCInst &Inst) { + llvm_unreachable("FIXME: Not yet implemented!"); +} + +void MCMachOStreamer::Finish() { + Assembler.Finish(); +} + +MCStreamer *llvm::createMachOStreamer(MCContext &Context, raw_ostream &OS) { + return new MCMachOStreamer(Context, OS); +} |