X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineCodeEmitter.h;h=86684d7b9e4f4d788be976909e276ac7ebbf9b96;hb=5eca075b74d62c621b160aa216b4cd50829a2cc7;hp=f05375fc5f4905eafcc3c05966fb03a46cbc408b;hpb=af1563fb62ed76f4818ac172ab1c6cf15fa35a82;p=oota-llvm.git diff --git a/include/llvm/CodeGen/MachineCodeEmitter.h b/include/llvm/CodeGen/MachineCodeEmitter.h index f05375fc5f4..86684d7b9e4 100644 --- a/include/llvm/CodeGen/MachineCodeEmitter.h +++ b/include/llvm/CodeGen/MachineCodeEmitter.h @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -18,7 +18,6 @@ #define LLVM_CODEGEN_MACHINECODEEMITTER_H #include "llvm/Support/DataTypes.h" -#include namespace llvm { @@ -26,6 +25,7 @@ class MachineBasicBlock; class MachineConstantPool; class MachineJumpTableInfo; class MachineFunction; +class MachineModuleInfo; class MachineRelocation; class Value; class GlobalValue; @@ -58,6 +58,7 @@ protected: /// all code emission requests will be ignored (this is the buffer overflow /// condition). unsigned char *CurBufferPtr; + public: virtual ~MachineCodeEmitter() {} @@ -74,25 +75,19 @@ public: /// virtual bool finishFunction(MachineFunction &F) = 0; - /// emitJumpTableInfo - This callback is invoked to output the jump tables - /// for the function. In addition to a pointer to the MachineJumpTableInfo, - /// this function also takes a map of MBB IDs to addresses, so that the final - /// addresses of the MBBs can be written to the jump tables. - virtual void emitJumpTableInfo(MachineJumpTableInfo *MJTI, - std::vector &MBBM) = 0; - /// startFunctionStub - This callback is invoked when the JIT needs the /// address of a function that has not been code generated yet. The StubSize /// specifies the total size required by the stub. Stubs are not allowed to /// have constant pools, the can only use the other emitByte*/emitWord* /// methods. /// - virtual void startFunctionStub(unsigned StubSize) = 0; + virtual void startFunctionStub(const GlobalValue* F, unsigned StubSize, + unsigned Alignment = 1) = 0; /// finishFunctionStub - This callback is invoked to terminate a function /// stub. /// - virtual void *finishFunctionStub(const Function *F) = 0; + virtual void *finishFunctionStub(const GlobalValue* F) = 0; /// emitByte - This callback is invoked when a byte needs to be written to the /// output stream. @@ -130,14 +125,90 @@ public: } } + /// emitAlignment - Move the CurBufferPtr pointer up the the specified + /// alignment (saturated to BufferEnd of course). + void emitAlignment(unsigned Alignment) { + if (Alignment == 0) Alignment = 1; + // Move the current buffer ptr up to the specified alignment. + CurBufferPtr = + (unsigned char*)(((intptr_t)CurBufferPtr+Alignment-1) & + ~(intptr_t)(Alignment-1)); + if (CurBufferPtr > BufferEnd) + CurBufferPtr = BufferEnd; + } + + + /// emitULEB128Bytes - This callback is invoked when a ULEB128 needs to be + /// written to the output stream. + void emitULEB128Bytes(unsigned Value) { + do { + unsigned char Byte = Value & 0x7f; + Value >>= 7; + if (Value) Byte |= 0x80; + emitByte(Byte); + } while (Value); + } + + /// emitSLEB128Bytes - This callback is invoked when a SLEB128 needs to be + /// written to the output stream. + void emitSLEB128Bytes(int Value) { + int Sign = Value >> (8 * sizeof(Value) - 1); + bool IsMore; + + do { + unsigned char Byte = Value & 0x7f; + Value >>= 7; + IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0; + if (IsMore) Byte |= 0x80; + emitByte(Byte); + } while (IsMore); + } + + /// emitString - This callback is invoked when a String needs to be + /// written to the output stream. + void emitString(const std::string &String) { + for (unsigned i = 0, N = static_cast(String.size()); + i < N; ++i) { + unsigned char C = String[i]; + emitByte(C); + } + emitByte(0); + } + + /// emitInt32 - Emit a int32 directive. + void emitInt32(int Value) { + if (CurBufferPtr+4 <= BufferEnd) { + *((uint32_t*)CurBufferPtr) = Value; + CurBufferPtr += 4; + } else { + CurBufferPtr = BufferEnd; + } + } + + /// emitInt64 - Emit a int64 directive. + void emitInt64(uint64_t Value) { + if (CurBufferPtr+8 <= BufferEnd) { + *((uint64_t*)CurBufferPtr) = Value; + CurBufferPtr += 8; + } else { + CurBufferPtr = BufferEnd; + } + } + + /// emitAt - Emit Value in Addr + void emitAt(uintptr_t *Addr, uintptr_t Value) { + if (Addr >= (uintptr_t*)BufferBegin && Addr < (uintptr_t*)BufferEnd) + (*Addr) = Value; + } + + /// emitLabel - Emits a label + virtual void emitLabel(uint64_t LabelID) = 0; + /// allocateSpace - Allocate a block of space in the current output buffer, /// returning null (and setting conditions to indicate buffer overflow) on /// failure. Alignment is the alignment in bytes of the buffer desired. void *allocateSpace(intptr_t Size, unsigned Alignment) { - if (Alignment == 0) Alignment = 1; - // Move the current buffer ptr up to the specified alignment. - CurBufferPtr = - (unsigned char*)(((intptr_t)CurBufferPtr+Alignment-1) & ~(Alignment-1)); + emitAlignment(Alignment); void *Result = CurBufferPtr; // Allocate the space. @@ -150,7 +221,11 @@ public: } return Result; } - + + /// 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) = 0; /// getCurrentPCValue - This returns the address that the next emitted byte /// will be output to. @@ -169,15 +244,33 @@ public: /// noted with this interface. virtual void addRelocation(const MachineRelocation &MR) = 0; + + /// FIXME: These should all be handled with relocations! + /// getConstantPoolEntryAddress - Return the address of the 'Index' entry in /// the constant pool that was last emitted with the emitConstantPool method. /// - virtual uint64_t getConstantPoolEntryAddress(unsigned Index) = 0; + virtual intptr_t getConstantPoolEntryAddress(unsigned Index) const = 0; /// getJumpTableEntryAddress - Return the address of the jump table with index /// 'Index' in the function that last called initJumpTableInfo. /// - virtual uint64_t getJumpTableEntryAddress(unsigned Index) = 0; + virtual intptr_t getJumpTableEntryAddress(unsigned Index) const = 0; + + /// getMachineBasicBlockAddress - Return the address of the specified + /// MachineBasicBlock, only usable after the label for the MBB has been + /// emitted. + /// + virtual intptr_t getMachineBasicBlockAddress(MachineBasicBlock *MBB) const= 0; + + /// getLabelAddress - Return the address of the specified LabelID, only usable + /// after the LabelID has been emitted. + /// + virtual intptr_t getLabelAddress(uint64_t LabelID) const = 0; + + /// Specifies the MachineModuleInfo object. This is used for exception handling + /// purposes. + virtual void setModuleInfo(MachineModuleInfo* Info) = 0; }; } // End llvm namespace