mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-30 05:29:47 +00:00
one new .cpp file, in preparation for merging in the Direct Object Emission changes we're working on. No functional changes. Fixed coding style issues on the original patch. Patch by Aaron Gray git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@72754 91177308-0d34-0410-b5e6-96231b3b80d8
208 lines
7.9 KiB
C++
208 lines
7.9 KiB
C++
//===-- MachOEmitter.cpp - Target-independent Mach-O Emitter code --------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "MachOCodeEmitter.h"
|
|
#include "llvm/Constants.h"
|
|
#include "llvm/DerivedTypes.h"
|
|
#include "llvm/Function.h"
|
|
#include "llvm/CodeGen/MachineConstantPool.h"
|
|
#include "llvm/CodeGen/MachineJumpTableInfo.h"
|
|
#include "llvm/Target/TargetAsmInfo.h"
|
|
#include "llvm/Support/Mangler.h"
|
|
#include "llvm/Support/OutputBuffer.h"
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// MachOCodeEmitter Implementation
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace llvm {
|
|
|
|
/// startFunction - This callback is invoked when a new machine function is
|
|
/// about to be emitted.
|
|
|
|
void MachOCodeEmitter::startFunction(MachineFunction &MF) {
|
|
const TargetData *TD = TM.getTargetData();
|
|
const Function *F = MF.getFunction();
|
|
|
|
// Align the output buffer to the appropriate alignment, power of 2.
|
|
unsigned FnAlign = F->getAlignment();
|
|
unsigned TDAlign = TD->getPrefTypeAlignment(F->getType());
|
|
unsigned Align = Log2_32(std::max(FnAlign, TDAlign));
|
|
assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
|
|
|
|
// Get the Mach-O Section that this function belongs in.
|
|
MachOSection *MOS = MOW.getTextSection();
|
|
|
|
// FIXME: better memory management
|
|
MOS->SectionData.reserve(4096);
|
|
BufferBegin = &MOS->SectionData[0];
|
|
BufferEnd = BufferBegin + MOS->SectionData.capacity();
|
|
|
|
// Upgrade the section alignment if required.
|
|
if (MOS->align < Align) MOS->align = Align;
|
|
|
|
// Round the size up to the correct alignment for starting the new function.
|
|
if ((MOS->size & ((1 << Align) - 1)) != 0) {
|
|
MOS->size += (1 << Align);
|
|
MOS->size &= ~((1 << Align) - 1);
|
|
}
|
|
|
|
// FIXME: Using MOS->size directly here instead of calculating it from the
|
|
// output buffer size (impossible because the code emitter deals only in raw
|
|
// bytes) forces us to manually synchronize size and write padding zero bytes
|
|
// to the output buffer for all non-text sections. For text sections, we do
|
|
// not synchonize the output buffer, and we just blow up if anyone tries to
|
|
// write non-code to it. An assert should probably be added to
|
|
// AddSymbolToSection to prevent calling it on the text section.
|
|
CurBufferPtr = BufferBegin + MOS->size;
|
|
}
|
|
|
|
/// finishFunction - This callback is invoked after the function is completely
|
|
/// finished.
|
|
|
|
bool MachOCodeEmitter::finishFunction(MachineFunction &MF) {
|
|
|
|
// Get the Mach-O Section that this function belongs in.
|
|
MachOSection *MOS = MOW.getTextSection();
|
|
|
|
// Get a symbol for the function to add to the symbol table
|
|
// FIXME: it seems like we should call something like AddSymbolToSection
|
|
// in startFunction rather than changing the section size and symbol n_value
|
|
// here.
|
|
const GlobalValue *FuncV = MF.getFunction();
|
|
MachOSym FnSym(FuncV, MOW.Mang->getValueName(FuncV), MOS->Index, TAI);
|
|
FnSym.n_value = MOS->size;
|
|
MOS->size = CurBufferPtr - BufferBegin;
|
|
|
|
// Emit constant pool to appropriate section(s)
|
|
emitConstantPool(MF.getConstantPool());
|
|
|
|
// Emit jump tables to appropriate section
|
|
emitJumpTables(MF.getJumpTableInfo());
|
|
|
|
// If we have emitted any relocations to function-specific objects such as
|
|
// basic blocks, constant pools entries, or jump tables, record their
|
|
// addresses now so that we can rewrite them with the correct addresses
|
|
// later.
|
|
for (unsigned i = 0, e = Relocations.size(); i != e; ++i) {
|
|
MachineRelocation &MR = Relocations[i];
|
|
intptr_t Addr;
|
|
|
|
if (MR.isBasicBlock()) {
|
|
Addr = getMachineBasicBlockAddress(MR.getBasicBlock());
|
|
MR.setConstantVal(MOS->Index);
|
|
MR.setResultPointer((void*)Addr);
|
|
} else if (MR.isJumpTableIndex()) {
|
|
Addr = getJumpTableEntryAddress(MR.getJumpTableIndex());
|
|
MR.setConstantVal(MOW.getJumpTableSection()->Index);
|
|
MR.setResultPointer((void*)Addr);
|
|
} else if (MR.isConstantPoolIndex()) {
|
|
Addr = getConstantPoolEntryAddress(MR.getConstantPoolIndex());
|
|
MR.setConstantVal(CPSections[MR.getConstantPoolIndex()]);
|
|
MR.setResultPointer((void*)Addr);
|
|
} else if (MR.isGlobalValue()) {
|
|
// FIXME: This should be a set or something that uniques
|
|
MOW.PendingGlobals.push_back(MR.getGlobalValue());
|
|
} else {
|
|
assert(0 && "Unhandled relocation type");
|
|
}
|
|
MOS->Relocations.push_back(MR);
|
|
}
|
|
Relocations.clear();
|
|
|
|
// Finally, add it to the symtab.
|
|
MOW.SymbolTable.push_back(FnSym);
|
|
|
|
// Clear per-function data structures.
|
|
CPLocations.clear();
|
|
CPSections.clear();
|
|
JTLocations.clear();
|
|
MBBLocations.clear();
|
|
|
|
return false;
|
|
}
|
|
|
|
/// emitConstantPool - For each constant pool entry, figure out which section
|
|
/// the constant should live in, allocate space for it, and emit it to the
|
|
/// Section data buffer.
|
|
void MachOCodeEmitter::emitConstantPool(MachineConstantPool *MCP) {
|
|
const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants();
|
|
if (CP.empty()) return;
|
|
|
|
// FIXME: handle PIC codegen
|
|
assert(TM.getRelocationModel() != Reloc::PIC_ &&
|
|
"PIC codegen not yet handled for mach-o jump tables!");
|
|
|
|
// Although there is no strict necessity that I am aware of, we will do what
|
|
// gcc for OS X does and put each constant pool entry in a section of constant
|
|
// objects of a certain size. That means that float constants go in the
|
|
// literal4 section, and double objects go in literal8, etc.
|
|
//
|
|
// FIXME: revisit this decision if we ever do the "stick everything into one
|
|
// "giant object for PIC" optimization.
|
|
for (unsigned i = 0, e = CP.size(); i != e; ++i) {
|
|
const Type *Ty = CP[i].getType();
|
|
unsigned Size = TM.getTargetData()->getTypeAllocSize(Ty);
|
|
|
|
MachOSection *Sec = MOW.getConstSection(CP[i].Val.ConstVal);
|
|
OutputBuffer SecDataOut(Sec->SectionData, is64Bit, isLittleEndian);
|
|
|
|
CPLocations.push_back(Sec->SectionData.size());
|
|
CPSections.push_back(Sec->Index);
|
|
|
|
// FIXME: remove when we have unified size + output buffer
|
|
Sec->size += Size;
|
|
|
|
// Allocate space in the section for the global.
|
|
// FIXME: need alignment?
|
|
// FIXME: share between here and AddSymbolToSection?
|
|
for (unsigned j = 0; j < Size; ++j)
|
|
SecDataOut.outbyte(0);
|
|
|
|
MOW.InitMem(CP[i].Val.ConstVal, &Sec->SectionData[0], CPLocations[i],
|
|
TM.getTargetData(), Sec->Relocations);
|
|
}
|
|
}
|
|
|
|
/// emitJumpTables - Emit all the jump tables for a given jump table info
|
|
/// record to the appropriate section.
|
|
|
|
void MachOCodeEmitter::emitJumpTables(MachineJumpTableInfo *MJTI) {
|
|
const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
|
|
if (JT.empty()) return;
|
|
|
|
// FIXME: handle PIC codegen
|
|
assert(TM.getRelocationModel() != Reloc::PIC_ &&
|
|
"PIC codegen not yet handled for mach-o jump tables!");
|
|
|
|
MachOSection *Sec = MOW.getJumpTableSection();
|
|
unsigned TextSecIndex = MOW.getTextSection()->Index;
|
|
OutputBuffer SecDataOut(Sec->SectionData, is64Bit, isLittleEndian);
|
|
|
|
for (unsigned i = 0, e = JT.size(); i != e; ++i) {
|
|
// For each jump table, record its offset from the start of the section,
|
|
// reserve space for the relocations to the MBBs, and add the relocations.
|
|
const std::vector<MachineBasicBlock*> &MBBs = JT[i].MBBs;
|
|
JTLocations.push_back(Sec->SectionData.size());
|
|
for (unsigned mi = 0, me = MBBs.size(); mi != me; ++mi) {
|
|
MachineRelocation MR(MOW.GetJTRelocation(Sec->SectionData.size(),
|
|
MBBs[mi]));
|
|
MR.setResultPointer((void *)JTLocations[i]);
|
|
MR.setConstantVal(TextSecIndex);
|
|
Sec->Relocations.push_back(MR);
|
|
SecDataOut.outaddr(0);
|
|
}
|
|
}
|
|
// FIXME: remove when we have unified size + output buffer
|
|
Sec->size = Sec->SectionData.size();
|
|
}
|
|
|
|
} // end namespace llvm
|
|
|