llvm-6502/include/llvm/CodeGen/ObjectCodeEmitter.h
Dan Gohman f3b11aa6a7 Fix several comments which had previously been "the the" where a
different word was intended.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@95795 91177308-0d34-0410-b5e6-96231b3b80d8
2010-02-10 20:04:19 +00:00

179 lines
7.0 KiB
C++

//===-- 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 to 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);
/// earlyResolveAddresses - True if the code emitter can use symbol addresses
/// during code emission time. The JIT is capable of doing this because it
/// creates jump tables or constant pools in memory on the fly while the
/// object code emitters rely on a linker to have real addresses and should
/// use relocations instead.
bool earlyResolveAddresses() const { return false; }
/// 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