[llvm-commits] [llvm] r74814 - in /llvm/trunk: include/llvm/CodeGen/ObjectCodeEmitter.h lib/CodeGen/ObjectCodeEmitter.cpp
Aaron Gray
aaronngray.lists at googlemail.com
Mon Jul 6 07:03:14 PDT 2009
Ah, 'uintptr_t getCurrentPCOffset() const' is 'virtual' in
MachineCodeEmitter :)
Sorry,
Aaron
> Author: bruno
> Date: Mon Jul 6 00:16:40 2009
> New Revision: 74814
>
> URL: http://llvm.org/viewvc/llvm-project?rev=74814&view=rev
> Log:
> Just forgot to include the two new files
>
> Added:
> llvm/trunk/include/llvm/CodeGen/ObjectCodeEmitter.h
> llvm/trunk/lib/CodeGen/ObjectCodeEmitter.cpp
>
> Added: llvm/trunk/include/llvm/CodeGen/ObjectCodeEmitter.h
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/ObjectCodeEmitter.h?rev=74814&view=auto
>
> ==============================================================================
> --- llvm/trunk/include/llvm/CodeGen/ObjectCodeEmitter.h (added)
> +++ llvm/trunk/include/llvm/CodeGen/ObjectCodeEmitter.h Mon Jul 6
> 00:16:40 2009
> @@ -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
> +
>
> Added: llvm/trunk/lib/CodeGen/ObjectCodeEmitter.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/ObjectCodeEmitter.cpp?rev=74814&view=auto
>
> ==============================================================================
> --- llvm/trunk/lib/CodeGen/ObjectCodeEmitter.cpp (added)
> +++ llvm/trunk/lib/CodeGen/ObjectCodeEmitter.cpp Mon Jul 6 00:16:40 2009
> @@ -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
> +
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list