lib/CodeGen/MachOCodeEmitter.cpp

   1 //===-- MachOEmitter.cpp - Target-independent Mach-O Emitter code --------===//
   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 #include "MachOCodeEmitter.h"
  11 #include "llvm/Constants.h"
  12 #include "llvm/DerivedTypes.h"
  13 #include "llvm/Function.h"
  14 #include "llvm/CodeGen/MachineConstantPool.h"
  15 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  16 #include "llvm/Target/TargetAsmInfo.h"
  17 #include "llvm/Support/Mangler.h"
  18 #include "llvm/Support/OutputBuffer.h"
  19 #include <vector>
  20
  21 //===----------------------------------------------------------------------===//
  22 //                       MachOCodeEmitter Implementation
  23 //===----------------------------------------------------------------------===//
  24
  25 namespace llvm {
  26
  27 /// startFunction - This callback is invoked when a new machine function is
  28 /// about to be emitted.
  29
  30 void MachOCodeEmitter::startFunction(MachineFunction &MF) {
  31   const TargetData *TD = TM.getTargetData();
  32   const Function *F = MF.getFunction();
  33
  34   // Align the output buffer to the appropriate alignment, power of 2.
  35   unsigned FnAlign = F->getAlignment();
  36   unsigned TDAlign = TD->getPrefTypeAlignment(F->getType());
  37   unsigned Align = Log2_32(std::max(FnAlign, TDAlign));
  38   assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
  39
  40   // Get the Mach-O Section that this function belongs in.
  41   MachOSection *MOS = MOW.getTextSection();
  42
  43   // Upgrade the section alignment if required.
  44   if (MOS->align < Align) MOS->align = Align;
  45
  46   MOS->emitAlignment(Align);
  47
  48   // Create symbol for function entry
  49   const GlobalValue *FuncV = MF.getFunction();
  50   MachOSym FnSym(FuncV, MOW.Mang->getValueName(FuncV), MOS->Index, TAI);
  51   FnSym.n_value = getCurrentPCOffset();
  52
  53   // add it to the symtab.
  54   MOW.SymbolTable.push_back(FnSym);
  55 }
  56
  57 /// finishFunction - This callback is invoked after the function is completely
  58 /// finished.
  59
  60 bool MachOCodeEmitter::finishFunction(MachineFunction &MF) {
  61
  62   // Get the Mach-O Section that this function belongs in.
  63   MachOSection *MOS = MOW.getTextSection();
  64
  65   // Emit constant pool to appropriate section(s)
  66   emitConstantPool(MF.getConstantPool());
  67
  68   // Emit jump tables to appropriate section
  69   emitJumpTables(MF.getJumpTableInfo());
  70
  71   // If we have emitted any relocations to function-specific objects such as
  72   // basic blocks, constant pools entries, or jump tables, record their
  73   // addresses now so that we can rewrite them with the correct addresses
  74   // later.
  75   for (unsigned i = 0, e = Relocations.size(); i != e; ++i) {
  76     MachineRelocation &MR = Relocations[i];
  77     intptr_t Addr;
  78
  79     if (MR.isBasicBlock()) {
  80       Addr = getMachineBasicBlockAddress(MR.getBasicBlock());
  81       MR.setConstantVal(MOS->Index);
  82       MR.setResultPointer((void*)Addr);
  83     } else if (MR.isJumpTableIndex()) {
  84       Addr = getJumpTableEntryAddress(MR.getJumpTableIndex());
  85       MR.setConstantVal(MOW.getJumpTableSection()->Index);
  86       MR.setResultPointer((void*)Addr);
  87     } else if (MR.isConstantPoolIndex()) {
  88       Addr = getConstantPoolEntryAddress(MR.getConstantPoolIndex());
  89       MR.setConstantVal(CPSections[MR.getConstantPoolIndex()]);
  90       MR.setResultPointer((void*)Addr);
  91     } else if (MR.isGlobalValue()) {
  92       // FIXME: This should be a set or something that uniques
  93       MOW.PendingGlobals.push_back(MR.getGlobalValue());
  94     } else {
  95       assert(0 && "Unhandled relocation type");
  96     }
  97     MOS->addRelocation(MR);
  98   }
  99   Relocations.clear();
 100
 101   // Clear per-function data structures.
 102   CPLocations.clear();
 103   CPSections.clear();
 104   JTLocations.clear();
 105   MBBLocations.clear();
 106
 107   return false;
 108 }
 109
 110 /// emitConstantPool - For each constant pool entry, figure out which section
 111 /// the constant should live in, allocate space for it, and emit it to the
 112 /// Section data buffer.
 113 void MachOCodeEmitter::emitConstantPool(MachineConstantPool *MCP) {
 114   const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants();
 115   if (CP.empty()) return;
 116
 117   // FIXME: handle PIC codegen
 118   assert(TM.getRelocationModel() != Reloc::PIC_ &&
 119          "PIC codegen not yet handled for mach-o jump tables!");
 120
 121   // Although there is no strict necessity that I am aware of, we will do what
 122   // gcc for OS X does and put each constant pool entry in a section of constant
 123   // objects of a certain size.  That means that float constants go in the
 124   // literal4 section, and double objects go in literal8, etc.
 125   //
 126   // FIXME: revisit this decision if we ever do the "stick everything into one
 127   // "giant object for PIC" optimization.
 128   for (unsigned i = 0, e = CP.size(); i != e; ++i) {
 129     const Type *Ty = CP[i].getType();
 130     unsigned Size = TM.getTargetData()->getTypeAllocSize(Ty);
 131
 132     MachOSection *Sec = MOW.getConstSection(CP[i].Val.ConstVal);
 133     OutputBuffer SecDataOut(Sec->getData(), is64Bit, isLittleEndian);
 134
 135     CPLocations.push_back(Sec->size());
 136     CPSections.push_back(Sec->Index);
 137
 138     // Allocate space in the section for the global.
 139     // FIXME: need alignment?
 140     // FIXME: share between here and AddSymbolToSection?
 141     for (unsigned j = 0; j < Size; ++j)
 142       SecDataOut.outbyte(0);
 143
 144     MachOWriter::InitMem(CP[i].Val.ConstVal, CPLocations[i], TM.getTargetData(), Sec);
 145   }
 146 }
 147
 148 /// emitJumpTables - Emit all the jump tables for a given jump table info
 149 /// record to the appropriate section.
 150 void MachOCodeEmitter::emitJumpTables(MachineJumpTableInfo *MJTI) {
 151   const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 152   if (JT.empty()) return;
 153
 154   // FIXME: handle PIC codegen
 155   assert(TM.getRelocationModel() != Reloc::PIC_ &&
 156          "PIC codegen not yet handled for mach-o jump tables!");
 157
 158   MachOSection *Sec = MOW.getJumpTableSection();
 159   unsigned TextSecIndex = MOW.getTextSection()->Index;
 160   OutputBuffer SecDataOut(Sec->getData(), is64Bit, isLittleEndian);
 161
 162   for (unsigned i = 0, e = JT.size(); i != e; ++i) {
 163     // For each jump table, record its offset from the start of the section,
 164     // reserve space for the relocations to the MBBs, and add the relocations.
 165     const std::vector<MachineBasicBlock*> &MBBs = JT[i].MBBs;
 166     JTLocations.push_back(Sec->size());
 167     for (unsigned mi = 0, me = MBBs.size(); mi != me; ++mi) {
 168       MachineRelocation MR(MOW.GetJTRelocation(Sec->size(), MBBs[mi]));
 169       MR.setResultPointer((void *)JTLocations[i]);
 170       MR.setConstantVal(TextSecIndex);
 171       Sec->addRelocation(MR);
 172       SecDataOut.outaddr(0);
 173     }
 174   }
 175 }
 176
 177 } // end namespace llvm
 178