lib/CodeGen/MachOWriter.h

   1 //=== MachOWriter.h - Target-independent Mach-O writer support --*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the MachOWriter class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef MACHOWRITER_H
  15 #define MACHOWRITER_H
  16
  17 #include "llvm/CodeGen/MachineFunctionPass.h"
  18 #include <vector>
  19 #include <map>
  20
  21 namespace llvm {
  22   class Constant;
  23   class GlobalVariable;
  24   class Mangler;
  25   class MachineBasicBlock;
  26   class MachineRelocation;
  27   class MachOCodeEmitter;
  28   struct MachODySymTab;
  29   struct MachOHeader;
  30   struct MachOSection;
  31   struct MachOSym;
  32   class TargetData;
  33   class TargetMachine;
  34   class MCAsmInfo;
  35   class ObjectCodeEmitter;
  36   class OutputBuffer;
  37   class raw_ostream;
  38
  39   /// MachOWriter - This class implements the common target-independent code for
  40   /// writing Mach-O files.  Targets should derive a class from this to
  41   /// parameterize the output format.
  42   ///
  43   class MachOWriter : public MachineFunctionPass {
  44     friend class MachOCodeEmitter;
  45   public:
  46     static char ID;
  47
  48     ObjectCodeEmitter *getObjectCodeEmitter() {
  49       return reinterpret_cast<ObjectCodeEmitter*>(MachOCE);
  50     }
  51
  52     MachOWriter(raw_ostream &O, TargetMachine &TM);
  53     virtual ~MachOWriter();
  54
  55     virtual const char *getPassName() const {
  56       return "Mach-O Writer";
  57     }
  58
  59   protected:
  60     /// Output stream to send the resultant object file to.
  61     ///
  62     raw_ostream &O;
  63
  64     /// Target machine description.
  65     ///
  66     TargetMachine &TM;
  67
  68     /// Mang - The object used to perform name mangling for this module.
  69     ///
  70     Mangler *Mang;
  71
  72     /// MachOCE - The MachineCodeEmitter object that we are exposing to emit
  73     /// machine code for functions to the .o file.
  74     MachOCodeEmitter *MachOCE;
  75
  76     /// is64Bit/isLittleEndian - This information is inferred from the target
  77     /// machine directly, indicating what header values and flags to set.
  78     bool is64Bit, isLittleEndian;
  79
  80     // Target Asm Info
  81     const MCAsmInfo *MAI;
  82
  83     /// Header - An instance of MachOHeader that we will update while we build
  84     /// the file, and then emit during finalization.
  85     MachOHeader Header;
  86
  87     /// doInitialization - Emit the file header and all of the global variables
  88     /// for the module to the Mach-O file.
  89     bool doInitialization(Module &M);
  90
  91     bool runOnMachineFunction(MachineFunction &MF);
  92
  93     /// doFinalization - Now that the module has been completely processed, emit
  94     /// the Mach-O file to 'O'.
  95     bool doFinalization(Module &M);
  96
  97   private:
  98
  99     /// SectionList - This is the list of sections that we have emitted to the
 100     /// file.  Once the file has been completely built, the segment load command
 101     /// SectionCommands are constructed from this info.
 102     std::vector<MachOSection*> SectionList;
 103
 104     /// SectionLookup - This is a mapping from section name to SectionList entry
 105     std::map<std::string, MachOSection*> SectionLookup;
 106
 107     /// GVSection - This is a mapping from a GlobalValue to a MachOSection,
 108     /// to aid in emitting relocations.
 109     std::map<GlobalValue*, MachOSection*> GVSection;
 110
 111     /// GVOffset - This is a mapping from a GlobalValue to an offset from the
 112     /// start of the section in which the GV resides, to aid in emitting
 113     /// relocations.
 114     std::map<GlobalValue*, intptr_t> GVOffset;
 115
 116     /// getSection - Return the section with the specified name, creating a new
 117     /// section if one does not already exist.
 118     MachOSection *getSection(const std::string &seg, const std::string &sect,
 119                              unsigned Flags = 0);
 120
 121     /// getTextSection - Return text section with different flags for code/data
 122     MachOSection *getTextSection(bool isCode = true);
 123
 124     MachOSection *getDataSection() {
 125       return getSection("__DATA", "__data");
 126     }
 127
 128     MachOSection *getBSSSection();
 129     MachOSection *getConstSection(Constant *C);
 130     MachOSection *getJumpTableSection();
 131
 132     /// MachOSymTab - This struct contains information about the offsets and
 133     /// size of symbol table information.
 134     /// segment.
 135     struct MachOSymTab {
 136       uint32_t cmd;     // LC_SYMTAB
 137       uint32_t cmdsize; // sizeof( MachOSymTab )
 138       uint32_t symoff;  // symbol table offset
 139       uint32_t nsyms;   // number of symbol table entries
 140       uint32_t stroff;  // string table offset
 141       uint32_t strsize; // string table size in bytes
 142
 143       // Constants for the cmd field
 144       // see <mach-o/loader.h>
 145       enum { LC_SYMTAB = 0x02  // link-edit stab symbol table info
 146       };
 147
 148       MachOSymTab() : cmd(LC_SYMTAB), cmdsize(6 * sizeof(uint32_t)), symoff(0),
 149         nsyms(0), stroff(0), strsize(0) { }
 150     };
 151
 152     /// SymTab - The "stab" style symbol table information
 153     MachOSymTab SymTab;
 154     /// DySymTab - symbol table info for the dynamic link editor
 155     MachODySymTab DySymTab;
 156
 157   protected:
 158
 159     /// SymbolTable - This is the list of symbols we have emitted to the file.
 160     /// This actually gets rearranged before emission to the file (to put the
 161     /// local symbols first in the list).
 162     std::vector<MachOSym> SymbolTable;
 163
 164     /// SymT - A buffer to hold the symbol table before we write it out at the
 165     /// appropriate location in the file.
 166     std::vector<unsigned char> SymT;
 167
 168     /// StrT - A buffer to hold the string table before we write it out at the
 169     /// appropriate location in the file.
 170     std::vector<unsigned char> StrT;
 171
 172     /// PendingSyms - This is a list of externally defined symbols that we have
 173     /// been asked to emit, but have not seen a reference to.  When a reference
 174     /// is seen, the symbol will move from this list to the SymbolTable.
 175     std::vector<GlobalValue*> PendingGlobals;
 176
 177     /// DynamicSymbolTable - This is just a vector of indices into
 178     /// SymbolTable to aid in emitting the DYSYMTAB load command.
 179     std::vector<unsigned> DynamicSymbolTable;
 180
 181     static void InitMem(const Constant *C, uintptr_t Offset,
 182                         const TargetData *TD, MachOSection* mos);
 183
 184   private:
 185     void AddSymbolToSection(MachOSection *MOS, GlobalVariable *GV);
 186     void EmitGlobal(GlobalVariable *GV);
 187     void EmitHeaderAndLoadCommands();
 188     void EmitSections();
 189     void EmitRelocations();
 190     void BufferSymbolAndStringTable();
 191     void CalculateRelocations(MachOSection &MOS);
 192
 193     // GetJTRelocation - Get a relocation a new BB relocation based
 194     // on target information.
 195     MachineRelocation GetJTRelocation(unsigned Offset,
 196                                       MachineBasicBlock *MBB) const;
 197
 198     /// GetTargetRelocation - Returns the number of relocations.
 199     unsigned GetTargetRelocation(MachineRelocation &MR, unsigned FromIdx,
 200                                  unsigned ToAddr, unsigned ToIndex,
 201                                  OutputBuffer &RelocOut, OutputBuffer &SecOut,
 202                                  bool Scattered, bool Extern);
 203   };
 204 }
 205
 206 #endif