forked from OSchip/llvm-project
parent
5661ea68e7
commit
765655535a
|
@ -0,0 +1,171 @@
|
|||
//===-- llvm/CodeGen/ObjectCodeEmitter.h - Object Code Emitter -*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// Generalized Object Code Emitter, works with ObjectModule and BinaryObject.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_CODEGEN_OBJECTCODEEMITTER_H
|
||||
#define LLVM_CODEGEN_OBJECTCODEEMITTER_H
|
||||
|
||||
#include "llvm/CodeGen/MachineCodeEmitter.h"
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class BinaryObject;
|
||||
class MachineBasicBlock;
|
||||
class MachineCodeEmitter;
|
||||
class MachineFunction;
|
||||
class MachineConstantPool;
|
||||
class MachineJumpTableInfo;
|
||||
class MachineModuleInfo;
|
||||
|
||||
class ObjectCodeEmitter : public MachineCodeEmitter {
|
||||
protected:
|
||||
|
||||
/// Binary Object (Section or Segment) we are emitting to.
|
||||
BinaryObject *BO;
|
||||
|
||||
/// MBBLocations - This vector is a mapping from MBB ID's to their address.
|
||||
/// It is filled in by the StartMachineBasicBlock callback and queried by
|
||||
/// the getMachineBasicBlockAddress callback.
|
||||
std::vector<uintptr_t> MBBLocations;
|
||||
|
||||
/// LabelLocations - This vector is a mapping from Label ID's to their
|
||||
/// address.
|
||||
std::vector<uintptr_t> LabelLocations;
|
||||
|
||||
/// CPLocations - This is a map of constant pool indices to offsets from the
|
||||
/// start of the section for that constant pool index.
|
||||
std::vector<uintptr_t> CPLocations;
|
||||
|
||||
/// CPSections - This is a map of constant pool indices to the Section
|
||||
/// containing the constant pool entry for that index.
|
||||
std::vector<uintptr_t> CPSections;
|
||||
|
||||
/// JTLocations - This is a map of jump table indices to offsets from the
|
||||
/// start of the section for that jump table index.
|
||||
std::vector<uintptr_t> JTLocations;
|
||||
|
||||
public:
|
||||
ObjectCodeEmitter();
|
||||
ObjectCodeEmitter(BinaryObject *bo);
|
||||
virtual ~ObjectCodeEmitter();
|
||||
|
||||
/// setBinaryObject - set the BinaryObject we are writting to
|
||||
void setBinaryObject(BinaryObject *bo);
|
||||
|
||||
/// emitByte - This callback is invoked when a byte needs to be
|
||||
/// written to the data stream, without buffer overflow testing.
|
||||
void emitByte(uint8_t B);
|
||||
|
||||
/// emitWordLE - This callback is invoked when a 32-bit word needs to be
|
||||
/// written to the data stream in little-endian format.
|
||||
void emitWordLE(uint32_t W);
|
||||
|
||||
/// emitWordBE - This callback is invoked when a 32-bit word needs to be
|
||||
/// written to the data stream in big-endian format.
|
||||
void emitWordBE(uint32_t W);
|
||||
|
||||
/// emitDWordLE - This callback is invoked when a 64-bit word needs to be
|
||||
/// written to the data stream in little-endian format.
|
||||
void emitDWordLE(uint64_t W);
|
||||
|
||||
/// emitDWordBE - This callback is invoked when a 64-bit word needs to be
|
||||
/// written to the data stream in big-endian format.
|
||||
void emitDWordBE(uint64_t W);
|
||||
|
||||
/// emitAlignment - Move the CurBufferPtr pointer up the the specified
|
||||
/// alignment (saturated to BufferEnd of course).
|
||||
void emitAlignment(unsigned Alignment = 0, uint8_t fill = 0);
|
||||
|
||||
/// emitULEB128Bytes - This callback is invoked when a ULEB128 needs to be
|
||||
/// written to the data stream.
|
||||
void emitULEB128Bytes(uint64_t Value);
|
||||
|
||||
/// emitSLEB128Bytes - This callback is invoked when a SLEB128 needs to be
|
||||
/// written to the data stream.
|
||||
void emitSLEB128Bytes(uint64_t Value);
|
||||
|
||||
/// emitString - This callback is invoked when a String needs to be
|
||||
/// written to the data stream.
|
||||
void emitString(const std::string &String);
|
||||
|
||||
/// getCurrentPCValue - This returns the address that the next emitted byte
|
||||
/// will be output to.
|
||||
uintptr_t getCurrentPCValue() const;
|
||||
|
||||
/// getCurrentPCOffset - Return the offset from the start of the emitted
|
||||
/// buffer that we are currently writing to.
|
||||
uintptr_t getCurrentPCOffset() const;
|
||||
|
||||
/// addRelocation - Whenever a relocatable address is needed, it should be
|
||||
/// noted with this interface.
|
||||
void addRelocation(const MachineRelocation& relocation);
|
||||
|
||||
/// startFunction - This callback is invoked when the specified function is
|
||||
/// about to be code generated. This initializes the BufferBegin/End/Ptr
|
||||
/// fields.
|
||||
virtual void startFunction(MachineFunction &F) = 0;
|
||||
|
||||
/// finishFunction - This callback is invoked when the specified function has
|
||||
/// finished code generation. If a buffer overflow has occurred, this method
|
||||
/// returns true (the callee is required to try again), otherwise it returns
|
||||
/// false.
|
||||
virtual bool finishFunction(MachineFunction &F) = 0;
|
||||
|
||||
/// StartMachineBasicBlock - This should be called by the target when a new
|
||||
/// basic block is about to be emitted. This way the MCE knows where the
|
||||
/// start of the block is, and can implement getMachineBasicBlockAddress.
|
||||
virtual void StartMachineBasicBlock(MachineBasicBlock *MBB);
|
||||
|
||||
/// getMachineBasicBlockAddress - Return the address of the specified
|
||||
/// MachineBasicBlock, only usable after the label for the MBB has been
|
||||
/// emitted.
|
||||
virtual uintptr_t getMachineBasicBlockAddress(MachineBasicBlock *MBB) const;
|
||||
|
||||
/// emitLabel - Emits a label
|
||||
virtual void emitLabel(uint64_t LabelID) = 0;
|
||||
|
||||
/// getLabelAddress - Return the address of the specified LabelID, only usable
|
||||
/// after the LabelID has been emitted.
|
||||
virtual uintptr_t getLabelAddress(uint64_t LabelID) const = 0;
|
||||
|
||||
/// emitJumpTables - Emit all the jump tables for a given jump table info
|
||||
/// record to the appropriate section.
|
||||
virtual void emitJumpTables(MachineJumpTableInfo *MJTI) = 0;
|
||||
|
||||
/// getJumpTableEntryAddress - Return the address of the jump table with index
|
||||
/// 'Index' in the function that last called initJumpTableInfo.
|
||||
virtual uintptr_t getJumpTableEntryAddress(unsigned Index) const;
|
||||
|
||||
/// 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.
|
||||
virtual void emitConstantPool(MachineConstantPool *MCP) = 0;
|
||||
|
||||
/// getConstantPoolEntryAddress - Return the address of the 'Index' entry in
|
||||
/// the constant pool that was last emitted with the emitConstantPool method.
|
||||
virtual uintptr_t getConstantPoolEntryAddress(unsigned Index) const;
|
||||
|
||||
/// getConstantPoolEntrySection - Return the section of the 'Index' entry in
|
||||
/// the constant pool that was last emitted with the emitConstantPool method.
|
||||
virtual uintptr_t getConstantPoolEntrySection(unsigned Index) const;
|
||||
|
||||
/// Specifies the MachineModuleInfo object. This is used for exception handling
|
||||
/// purposes.
|
||||
virtual void setModuleInfo(MachineModuleInfo* Info) = 0;
|
||||
// to be implemented or depreciated with MachineModuleInfo
|
||||
|
||||
}; // end class ObjectCodeEmitter
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,142 @@
|
|||
//===-- llvm/CodeGen/ObjectCodeEmitter.cpp -------------------- -*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/CodeGen/BinaryObject.h"
|
||||
#include "llvm/CodeGen/MachineBasicBlock.h"
|
||||
#include "llvm/CodeGen/MachineRelocation.h"
|
||||
#include "llvm/CodeGen/ObjectCodeEmitter.h"
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// ObjectCodeEmitter Implementation
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
namespace llvm {
|
||||
|
||||
ObjectCodeEmitter::ObjectCodeEmitter() : BO(0) {}
|
||||
ObjectCodeEmitter::ObjectCodeEmitter(BinaryObject *bo) : BO(bo) {}
|
||||
ObjectCodeEmitter::~ObjectCodeEmitter() {}
|
||||
|
||||
/// setBinaryObject - set the BinaryObject we are writting to
|
||||
void ObjectCodeEmitter::setBinaryObject(BinaryObject *bo) { BO = bo; }
|
||||
|
||||
/// emitByte - This callback is invoked when a byte needs to be
|
||||
/// written to the data stream, without buffer overflow testing.
|
||||
void ObjectCodeEmitter::emitByte(uint8_t B) {
|
||||
BO->emitByte(B);
|
||||
}
|
||||
|
||||
/// emitWordLE - This callback is invoked when a 32-bit word needs to be
|
||||
/// written to the data stream in little-endian format.
|
||||
void ObjectCodeEmitter::emitWordLE(uint32_t W) {
|
||||
BO->emitWordLE(W);
|
||||
}
|
||||
|
||||
/// emitWordBE - This callback is invoked when a 32-bit word needs to be
|
||||
/// written to the data stream in big-endian format.
|
||||
void ObjectCodeEmitter::emitWordBE(uint32_t W) {
|
||||
BO->emitWordBE(W);
|
||||
}
|
||||
|
||||
/// emitDWordLE - This callback is invoked when a 64-bit word needs to be
|
||||
/// written to the data stream in little-endian format.
|
||||
void ObjectCodeEmitter::emitDWordLE(uint64_t W) {
|
||||
BO->emitDWordLE(W);
|
||||
}
|
||||
|
||||
/// emitDWordBE - This callback is invoked when a 64-bit word needs to be
|
||||
/// written to the data stream in big-endian format.
|
||||
void ObjectCodeEmitter::emitDWordBE(uint64_t W) {
|
||||
BO->emitDWordBE(W);
|
||||
}
|
||||
|
||||
/// emitAlignment - Move the CurBufferPtr pointer up the the specified
|
||||
/// alignment (saturated to BufferEnd of course).
|
||||
void ObjectCodeEmitter::emitAlignment(unsigned Alignment /* 0 */,
|
||||
uint8_t fill /* 0 */) {
|
||||
BO->emitAlignment(Alignment, fill);
|
||||
}
|
||||
|
||||
/// emitULEB128Bytes - This callback is invoked when a ULEB128 needs to be
|
||||
/// written to the data stream.
|
||||
void ObjectCodeEmitter::emitULEB128Bytes(uint64_t Value) {
|
||||
BO->emitULEB128Bytes(Value);
|
||||
}
|
||||
|
||||
/// emitSLEB128Bytes - This callback is invoked when a SLEB128 needs to be
|
||||
/// written to the data stream.
|
||||
void ObjectCodeEmitter::emitSLEB128Bytes(uint64_t Value) {
|
||||
BO->emitSLEB128Bytes(Value);
|
||||
}
|
||||
|
||||
/// emitString - This callback is invoked when a String needs to be
|
||||
/// written to the data stream.
|
||||
void ObjectCodeEmitter::emitString(const std::string &String) {
|
||||
BO->emitString(String);
|
||||
}
|
||||
|
||||
/// getCurrentPCValue - This returns the address that the next emitted byte
|
||||
/// will be output to.
|
||||
uintptr_t ObjectCodeEmitter::getCurrentPCValue() const {
|
||||
return BO->getCurrentPCOffset();
|
||||
}
|
||||
|
||||
/// getCurrentPCOffset - Return the offset from the start of the emitted
|
||||
/// buffer that we are currently writing to.
|
||||
uintptr_t ObjectCodeEmitter::getCurrentPCOffset() const {
|
||||
return BO->getCurrentPCOffset();
|
||||
}
|
||||
|
||||
/// addRelocation - Whenever a relocatable address is needed, it should be
|
||||
/// noted with this interface.
|
||||
void ObjectCodeEmitter::addRelocation(const MachineRelocation& relocation) {
|
||||
BO->addRelocation(relocation);
|
||||
}
|
||||
|
||||
/// StartMachineBasicBlock - This should be called by the target when a new
|
||||
/// basic block is about to be emitted. This way the MCE knows where the
|
||||
/// start of the block is, and can implement getMachineBasicBlockAddress.
|
||||
void ObjectCodeEmitter::StartMachineBasicBlock(MachineBasicBlock *MBB) {
|
||||
if (MBBLocations.size() <= (unsigned)MBB->getNumber())
|
||||
MBBLocations.resize((MBB->getNumber()+1)*2);
|
||||
MBBLocations[MBB->getNumber()] = getCurrentPCOffset();
|
||||
}
|
||||
|
||||
/// getMachineBasicBlockAddress - Return the address of the specified
|
||||
/// MachineBasicBlock, only usable after the label for the MBB has been
|
||||
/// emitted.
|
||||
uintptr_t
|
||||
ObjectCodeEmitter::getMachineBasicBlockAddress(MachineBasicBlock *MBB) const {
|
||||
assert(MBBLocations.size() > (unsigned)MBB->getNumber() &&
|
||||
MBBLocations[MBB->getNumber()] && "MBB not emitted!");
|
||||
return MBBLocations[MBB->getNumber()];
|
||||
}
|
||||
|
||||
/// getJumpTableEntryAddress - Return the address of the jump table with index
|
||||
/// 'Index' in the function that last called initJumpTableInfo.
|
||||
uintptr_t ObjectCodeEmitter::getJumpTableEntryAddress(unsigned Index) const {
|
||||
assert(JTLocations.size() > Index && "JT not emitted!");
|
||||
return JTLocations[Index];
|
||||
}
|
||||
|
||||
/// getConstantPoolEntryAddress - Return the address of the 'Index' entry in
|
||||
/// the constant pool that was last emitted with the emitConstantPool method.
|
||||
uintptr_t ObjectCodeEmitter::getConstantPoolEntryAddress(unsigned Index) const {
|
||||
assert(CPLocations.size() > Index && "CP not emitted!");
|
||||
return CPLocations[Index];
|
||||
}
|
||||
|
||||
/// getConstantPoolEntrySection - Return the section of the 'Index' entry in
|
||||
/// the constant pool that was last emitted with the emitConstantPool method.
|
||||
uintptr_t ObjectCodeEmitter::getConstantPoolEntrySection(unsigned Index) const {
|
||||
assert(CPSections.size() > Index && "CP not emitted!");
|
||||
return CPSections[Index];
|
||||
}
|
||||
|
||||
} // end namespace llvm
|
||||
|
Loading…
Reference in New Issue