1 //===-- MachOEmitter.cpp - Target-independent Mach-O Emitter code --------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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"
20 //===----------------------------------------------------------------------===//
21 // MachOCodeEmitter Implementation
22 //===----------------------------------------------------------------------===//
26 /// startFunction - This callback is invoked when a new machine function is
27 /// about to be emitted.
29 void MachOCodeEmitter::startFunction(MachineFunction &MF) {
30 const TargetData *TD = TM.getTargetData();
31 const Function *F = MF.getFunction();
33 // Align the output buffer to the appropriate alignment, power of 2.
34 unsigned FnAlign = F->getAlignment();
35 unsigned TDAlign = TD->getPrefTypeAlignment(F->getType());
36 unsigned Align = Log2_32(std::max(FnAlign, TDAlign));
37 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
39 // Get the Mach-O Section that this function belongs in.
40 MachOSection *MOS = MOW.getTextSection();
42 // FIXME: better memory management
43 MOS->SectionData.reserve(4096);
44 BufferBegin = &MOS->SectionData[0];
45 BufferEnd = BufferBegin + MOS->SectionData.capacity();
47 // Upgrade the section alignment if required.
48 if (MOS->align < Align) MOS->align = Align;
50 // Round the size up to the correct alignment for starting the new function.
51 if ((MOS->size & ((1 << Align) - 1)) != 0) {
52 MOS->size += (1 << Align);
53 MOS->size &= ~((1 << Align) - 1);
56 // FIXME: Using MOS->size directly here instead of calculating it from the
57 // output buffer size (impossible because the code emitter deals only in raw
58 // bytes) forces us to manually synchronize size and write padding zero bytes
59 // to the output buffer for all non-text sections. For text sections, we do
60 // not synchonize the output buffer, and we just blow up if anyone tries to
61 // write non-code to it. An assert should probably be added to
62 // AddSymbolToSection to prevent calling it on the text section.
63 CurBufferPtr = BufferBegin + MOS->size;
66 /// finishFunction - This callback is invoked after the function is completely
69 bool MachOCodeEmitter::finishFunction(MachineFunction &MF) {
71 // Get the Mach-O Section that this function belongs in.
72 MachOSection *MOS = MOW.getTextSection();
74 // Get a symbol for the function to add to the symbol table
75 // FIXME: it seems like we should call something like AddSymbolToSection
76 // in startFunction rather than changing the section size and symbol n_value
78 const GlobalValue *FuncV = MF.getFunction();
79 MachOSym FnSym(FuncV, MOW.Mang->getValueName(FuncV), MOS->Index, TAI);
80 FnSym.n_value = MOS->size;
81 MOS->size = CurBufferPtr - BufferBegin;
83 // Emit constant pool to appropriate section(s)
84 emitConstantPool(MF.getConstantPool());
86 // Emit jump tables to appropriate section
87 emitJumpTables(MF.getJumpTableInfo());
89 // If we have emitted any relocations to function-specific objects such as
90 // basic blocks, constant pools entries, or jump tables, record their
91 // addresses now so that we can rewrite them with the correct addresses
93 for (unsigned i = 0, e = Relocations.size(); i != e; ++i) {
94 MachineRelocation &MR = Relocations[i];
97 if (MR.isBasicBlock()) {
98 Addr = getMachineBasicBlockAddress(MR.getBasicBlock());
99 MR.setConstantVal(MOS->Index);
100 MR.setResultPointer((void*)Addr);
101 } else if (MR.isJumpTableIndex()) {
102 Addr = getJumpTableEntryAddress(MR.getJumpTableIndex());
103 MR.setConstantVal(MOW.getJumpTableSection()->Index);
104 MR.setResultPointer((void*)Addr);
105 } else if (MR.isConstantPoolIndex()) {
106 Addr = getConstantPoolEntryAddress(MR.getConstantPoolIndex());
107 MR.setConstantVal(CPSections[MR.getConstantPoolIndex()]);
108 MR.setResultPointer((void*)Addr);
109 } else if (MR.isGlobalValue()) {
110 // FIXME: This should be a set or something that uniques
111 MOW.PendingGlobals.push_back(MR.getGlobalValue());
113 assert(0 && "Unhandled relocation type");
115 MOS->Relocations.push_back(MR);
119 // Finally, add it to the symtab.
120 MOW.SymbolTable.push_back(FnSym);
122 // Clear per-function data structures.
126 MBBLocations.clear();
131 /// emitConstantPool - For each constant pool entry, figure out which section
132 /// the constant should live in, allocate space for it, and emit it to the
133 /// Section data buffer.
134 void MachOCodeEmitter::emitConstantPool(MachineConstantPool *MCP) {
135 const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants();
136 if (CP.empty()) return;
138 // FIXME: handle PIC codegen
139 assert(TM.getRelocationModel() != Reloc::PIC_ &&
140 "PIC codegen not yet handled for mach-o jump tables!");
142 // Although there is no strict necessity that I am aware of, we will do what
143 // gcc for OS X does and put each constant pool entry in a section of constant
144 // objects of a certain size. That means that float constants go in the
145 // literal4 section, and double objects go in literal8, etc.
147 // FIXME: revisit this decision if we ever do the "stick everything into one
148 // "giant object for PIC" optimization.
149 for (unsigned i = 0, e = CP.size(); i != e; ++i) {
150 const Type *Ty = CP[i].getType();
151 unsigned Size = TM.getTargetData()->getTypeAllocSize(Ty);
153 MachOSection *Sec = MOW.getConstSection(CP[i].Val.ConstVal);
154 OutputBuffer SecDataOut(Sec->SectionData, is64Bit, isLittleEndian);
156 CPLocations.push_back(Sec->SectionData.size());
157 CPSections.push_back(Sec->Index);
159 // FIXME: remove when we have unified size + output buffer
162 // Allocate space in the section for the global.
163 // FIXME: need alignment?
164 // FIXME: share between here and AddSymbolToSection?
165 for (unsigned j = 0; j < Size; ++j)
166 SecDataOut.outbyte(0);
168 MOW.InitMem(CP[i].Val.ConstVal, &Sec->SectionData[0], CPLocations[i],
169 TM.getTargetData(), Sec->Relocations);
173 /// emitJumpTables - Emit all the jump tables for a given jump table info
174 /// record to the appropriate section.
176 void MachOCodeEmitter::emitJumpTables(MachineJumpTableInfo *MJTI) {
177 const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
178 if (JT.empty()) return;
180 // FIXME: handle PIC codegen
181 assert(TM.getRelocationModel() != Reloc::PIC_ &&
182 "PIC codegen not yet handled for mach-o jump tables!");
184 MachOSection *Sec = MOW.getJumpTableSection();
185 unsigned TextSecIndex = MOW.getTextSection()->Index;
186 OutputBuffer SecDataOut(Sec->SectionData, is64Bit, isLittleEndian);
188 for (unsigned i = 0, e = JT.size(); i != e; ++i) {
189 // For each jump table, record its offset from the start of the section,
190 // reserve space for the relocations to the MBBs, and add the relocations.
191 const std::vector<MachineBasicBlock*> &MBBs = JT[i].MBBs;
192 JTLocations.push_back(Sec->SectionData.size());
193 for (unsigned mi = 0, me = MBBs.size(); mi != me; ++mi) {
194 MachineRelocation MR(MOW.GetJTRelocation(Sec->SectionData.size(),
196 MR.setResultPointer((void *)JTLocations[i]);
197 MR.setConstantVal(TextSecIndex);
198 Sec->Relocations.push_back(MR);
199 SecDataOut.outaddr(0);
202 // FIXME: remove when we have unified size + output buffer
203 Sec->size = Sec->SectionData.size();
206 } // end namespace llvm