6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-13 04:30:23 +00:00
Code Issues Projects Releases Wiki Activity

[MCJIT] Nuke MachineRelocation and MachineCodeEmitter. Now that the old JIT is

Browse Source 
gone they're no longer needed.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@218320 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Lang Hames 2014-09-23 18:08:47 +00:00
parent 04b11eb4ec
commit 3025b00b7f
8 changed files with 0 additions and 902 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

334
include/llvm/CodeGen/MachineCodeEmitter.h
View File

@ -1,334 +0,0 @@
//===-- llvm/CodeGen/MachineCodeEmitter.h - Code emission -------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines an abstract interface that is used by the machine code
// emission framework to output the code. This allows machine code emission to
// be separated from concerns such as resolution of call targets, and where the
// machine code will be written (memory or disk, f.e.).
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_MACHINECODEEMITTER_H
#define LLVM_CODEGEN_MACHINECODEEMITTER_H
#include "llvm/IR/DebugLoc.h"
#include "llvm/Support/DataTypes.h"
#include <string>
namespace llvm {
class MachineBasicBlock;
class MachineConstantPool;
class MachineJumpTableInfo;
class MachineFunction;
class MachineModuleInfo;
class MachineRelocation;
class Value;
class GlobalValue;
class Function;
class MCSymbol;
/// MachineCodeEmitter - This class defines two sorts of methods: those for
/// emitting the actual bytes of machine code, and those for emitting auxiliary
/// structures, such as jump tables, relocations, etc.
///
/// Emission of machine code is complicated by the fact that we don't (in
/// general) know the size of the machine code that we're about to emit before
/// we emit it. As such, we preallocate a certain amount of memory, and set the
/// BufferBegin/BufferEnd pointers to the start and end of the buffer. As we
/// emit machine instructions, we advance the CurBufferPtr to indicate the
/// location of the next byte to emit. In the case of a buffer overflow (we
/// need to emit more machine code than we have allocated space for), the
/// CurBufferPtr will saturate to BufferEnd and ignore stores. Once the entire
/// function has been emitted, the overflow condition is checked, and if it has
/// occurred, more memory is allocated, and we reemit the code into it.
///
class MachineCodeEmitter {
virtual void anchor();
protected:
/// BufferBegin/BufferEnd - Pointers to the start and end of the memory
/// allocated for this code buffer.
uint8_t *BufferBegin, *BufferEnd;
/// CurBufferPtr - Pointer to the next byte of memory to fill when emitting
/// code. This is guaranteed to be in the range [BufferBegin,BufferEnd]. If
/// this pointer is at BufferEnd, it will never move due to code emission, and
/// all code emission requests will be ignored (this is the buffer overflow
/// condition).
uint8_t *CurBufferPtr;
public:
virtual ~MachineCodeEmitter() {}
/// 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;
/// emitByte - This callback is invoked when a byte needs to be written to the
/// output stream.
///
void emitByte(uint8_t B) {
if (CurBufferPtr != BufferEnd)
*CurBufferPtr++ = B;
}
/// emitWordLE - This callback is invoked when a 32-bit word needs to be
/// written to the output stream in little-endian format.
///
void emitWordLE(uint32_t W) {
if (4 <= BufferEnd-CurBufferPtr) {
emitWordLEInto(CurBufferPtr, W);
} else {
CurBufferPtr = BufferEnd;
}
}
/// emitWordLEInto - This callback is invoked when a 32-bit word needs to be
/// written to an arbitrary buffer in little-endian format. Buf must have at
/// least 4 bytes of available space.
///
static void emitWordLEInto(uint8_t *&Buf, uint32_t W) {
*Buf++ = (uint8_t)(W >> 0);
*Buf++ = (uint8_t)(W >> 8);
*Buf++ = (uint8_t)(W >> 16);
*Buf++ = (uint8_t)(W >> 24);
}
/// emitWordBE - This callback is invoked when a 32-bit word needs to be
/// written to the output stream in big-endian format.
///
void emitWordBE(uint32_t W) {
if (4 <= BufferEnd-CurBufferPtr) {
*CurBufferPtr++ = (uint8_t)(W >> 24);
*CurBufferPtr++ = (uint8_t)(W >> 16);
*CurBufferPtr++ = (uint8_t)(W >> 8);
*CurBufferPtr++ = (uint8_t)(W >> 0);
} else {
CurBufferPtr = BufferEnd;
}
}
/// emitDWordLE - This callback is invoked when a 64-bit word needs to be
/// written to the output stream in little-endian format.
///
void emitDWordLE(uint64_t W) {
if (8 <= BufferEnd-CurBufferPtr) {
*CurBufferPtr++ = (uint8_t)(W >> 0);
*CurBufferPtr++ = (uint8_t)(W >> 8);
*CurBufferPtr++ = (uint8_t)(W >> 16);
*CurBufferPtr++ = (uint8_t)(W >> 24);
*CurBufferPtr++ = (uint8_t)(W >> 32);
*CurBufferPtr++ = (uint8_t)(W >> 40);
*CurBufferPtr++ = (uint8_t)(W >> 48);
*CurBufferPtr++ = (uint8_t)(W >> 56);
} else {
CurBufferPtr = BufferEnd;
}
}
/// emitDWordBE - This callback is invoked when a 64-bit word needs to be
/// written to the output stream in big-endian format.
///
void emitDWordBE(uint64_t W) {
if (8 <= BufferEnd-CurBufferPtr) {
*CurBufferPtr++ = (uint8_t)(W >> 56);
*CurBufferPtr++ = (uint8_t)(W >> 48);
*CurBufferPtr++ = (uint8_t)(W >> 40);
*CurBufferPtr++ = (uint8_t)(W >> 32);
*CurBufferPtr++ = (uint8_t)(W >> 24);
*CurBufferPtr++ = (uint8_t)(W >> 16);
*CurBufferPtr++ = (uint8_t)(W >> 8);
*CurBufferPtr++ = (uint8_t)(W >> 0);
} else {
CurBufferPtr = BufferEnd;
}
}
/// emitAlignment - Move the CurBufferPtr pointer up to the specified
/// alignment (saturated to BufferEnd of course).
void emitAlignment(unsigned Alignment) {
if (Alignment == 0) Alignment = 1;
if(Alignment <= (uintptr_t)(BufferEnd-CurBufferPtr)) {
// Move the current buffer ptr up to the specified alignment.
CurBufferPtr =
(uint8_t*)(((uintptr_t)CurBufferPtr+Alignment-1) &
~(uintptr_t)(Alignment-1));
} else {
CurBufferPtr = BufferEnd;
}
}
/// emitULEB128Bytes - This callback is invoked when a ULEB128 needs to be
/// written to the output stream.
void emitULEB128Bytes(uint64_t Value) {
do {
uint8_t 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(uint64_t Value) {
uint64_t Sign = Value >> (8 * sizeof(Value) - 1);
bool IsMore;
do {
uint8_t 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<unsigned>(String.size());
i < N; ++i) {
uint8_t C = String[i];
emitByte(C);
}
emitByte(0);
}
/// emitInt32 - Emit a int32 directive.
void emitInt32(int32_t Value) {
if (4 <= BufferEnd-CurBufferPtr) {
*((uint32_t*)CurBufferPtr) = Value;
CurBufferPtr += 4;
} else {
CurBufferPtr = BufferEnd;
}
}
/// emitInt64 - Emit a int64 directive.
void emitInt64(uint64_t Value) {
if (8 <= BufferEnd-CurBufferPtr) {
*((uint64_t*)CurBufferPtr) = Value;
CurBufferPtr += 8;
} else {
CurBufferPtr = BufferEnd;
}
}
/// emitInt32At - Emit the Int32 Value in Addr.
void emitInt32At(uintptr_t *Addr, uintptr_t Value) {
if (Addr >= (uintptr_t*)BufferBegin && Addr < (uintptr_t*)BufferEnd)
(*(uint32_t*)Addr) = (uint32_t)Value;
}
/// emitInt64At - Emit the Int64 Value in Addr.
void emitInt64At(uintptr_t *Addr, uintptr_t Value) {
if (Addr >= (uintptr_t*)BufferBegin && Addr < (uintptr_t*)BufferEnd)
(*(uint64_t*)Addr) = (uint64_t)Value;
}
/// processDebugLoc - Records debug location information about a
/// MachineInstruction. This is called before emitting any bytes associated
/// with the instruction. Even if successive instructions have the same debug
/// location, this method will be called for each one.
virtual void processDebugLoc(DebugLoc DL, bool BeforePrintintInsn) {}
/// emitLabel - Emits a label
virtual void emitLabel(MCSymbol *Label) = 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.
virtual void *allocateSpace(uintptr_t Size, unsigned Alignment) {
emitAlignment(Alignment);
void *Result;
// Check for buffer overflow.
if (Size >= (uintptr_t)(BufferEnd-CurBufferPtr)) {
CurBufferPtr = BufferEnd;
Result = nullptr;
} else {
// Allocate the space.
Result = CurBufferPtr;
CurBufferPtr += Size;
}
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.
///
virtual uintptr_t getCurrentPCValue() const {
return (uintptr_t)CurBufferPtr;
}
/// getCurrentPCOffset - Return the offset from the start of the emitted
/// buffer that we are currently writing to.
virtual uintptr_t getCurrentPCOffset() const {
return CurBufferPtr-BufferBegin;
}
/// 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.
virtual bool earlyResolveAddresses() const = 0;
/// addRelocation - Whenever a relocatable address is needed, it should be
/// 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 uintptr_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 uintptr_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 uintptr_t getMachineBasicBlockAddress(MachineBasicBlock *MBB) const= 0;
/// getLabelAddress - Return the address of the specified Label, only usable
/// after the LabelID has been emitted.
///
virtual uintptr_t getLabelAddress(MCSymbol *Label) const = 0;
/// Specifies the MachineModuleInfo object. This is used for exception handling
/// purposes.
virtual void setModuleInfo(MachineModuleInfo* Info) = 0;
};
} // End llvm namespace
#endif

342
include/llvm/CodeGen/MachineRelocation.h
View File

@ -1,342 +0,0 @@
//===-- llvm/CodeGen/MachineRelocation.h - Target Relocation ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the MachineRelocation class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_MACHINERELOCATION_H
#define LLVM_CODEGEN_MACHINERELOCATION_H
#include "llvm/Support/DataTypes.h"
#include <cassert>
namespace llvm {
class GlobalValue;
class MachineBasicBlock;
/// MachineRelocation - This represents a target-specific relocation value,
/// produced by the code emitter. This relocation is resolved after the has
/// been emitted, either to an object file or to memory, when the target of the
/// relocation can be resolved.
///
/// A relocation is made up of the following logical portions:
/// 1. An offset in the machine code buffer, the location to modify.
/// 2. A target specific relocation type (a number from 0 to 63).
/// 3. A symbol being referenced, either as a GlobalValue* or as a string.
/// 4. An optional constant value to be added to the reference.
/// 5. A bit, CanRewrite, which indicates to the JIT that a function stub is
/// not needed for the relocation.
/// 6. An index into the GOT, if the target uses a GOT
///
class MachineRelocation {
enum AddressType {
isResult, // Relocation has be transformed into its result pointer.
isGV, // The Target.GV field is valid.
isIndirectSym, // Relocation of an indirect symbol.
isBB, // Relocation of BB address.
isExtSym, // The Target.ExtSym field is valid.
isConstPool, // Relocation of constant pool address.
isJumpTable, // Relocation of jump table address.
isGOTIndex // The Target.GOTIndex field is valid.
};
/// Offset - This is the offset from the start of the code buffer of the
/// relocation to perform.
uintptr_t Offset;
/// ConstantVal - A field that may be used by the target relocation type.
intptr_t ConstantVal;
union {
void *Result; // If this has been resolved to a resolved pointer
GlobalValue *GV; // If this is a pointer to a GV or an indirect ref.
MachineBasicBlock *MBB; // If this is a pointer to an LLVM BB
const char *ExtSym; // If this is a pointer to a named symbol
unsigned Index; // Constant pool / jump table index
unsigned GOTIndex; // Index in the GOT of this symbol/global
} Target;
unsigned TargetReloType : 6; // The target relocation ID
AddressType AddrType : 4; // The field of Target to use
bool MayNeedFarStub : 1; // True if this relocation may require a far-stub
bool GOTRelative : 1; // Should this relocation be relative to the GOT?
bool TargetResolve : 1; // True if target should resolve the address
public:
// Relocation types used in a generic implementation. Currently, relocation
// entries for all things use the generic VANILLA type until they are refined
// into target relocation types.
enum RelocationType {
VANILLA
};
/// MachineRelocation::getGV - Return a relocation entry for a GlobalValue.
///
static MachineRelocation getGV(uintptr_t offset, unsigned RelocationType,
GlobalValue *GV, intptr_t cst = 0,
bool MayNeedFarStub = 0,
bool GOTrelative = 0) {
assert((RelocationType & ~63) == 0 && "Relocation type too large!");
MachineRelocation Result;
Result.Offset = offset;
Result.ConstantVal = cst;
Result.TargetReloType = RelocationType;
Result.AddrType = isGV;
Result.MayNeedFarStub = MayNeedFarStub;
Result.GOTRelative = GOTrelative;
Result.TargetResolve = false;
Result.Target.GV = GV;
return Result;
}
/// MachineRelocation::getIndirectSymbol - Return a relocation entry for an
/// indirect symbol.
static MachineRelocation getIndirectSymbol(uintptr_t offset,
unsigned RelocationType,
GlobalValue *GV, intptr_t cst = 0,
bool MayNeedFarStub = 0,
bool GOTrelative = 0) {
assert((RelocationType & ~63) == 0 && "Relocation type too large!");
MachineRelocation Result;
Result.Offset = offset;
Result.ConstantVal = cst;
Result.TargetReloType = RelocationType;
Result.AddrType = isIndirectSym;
Result.MayNeedFarStub = MayNeedFarStub;
Result.GOTRelative = GOTrelative;
Result.TargetResolve = false;
Result.Target.GV = GV;
return Result;
}
/// MachineRelocation::getBB - Return a relocation entry for a BB.
///
static MachineRelocation getBB(uintptr_t offset,unsigned RelocationType,
MachineBasicBlock *MBB, intptr_t cst = 0) {
assert((RelocationType & ~63) == 0 && "Relocation type too large!");
MachineRelocation Result;
Result.Offset = offset;
Result.ConstantVal = cst;
Result.TargetReloType = RelocationType;
Result.AddrType = isBB;
Result.MayNeedFarStub = false;
Result.GOTRelative = false;
Result.TargetResolve = false;
Result.Target.MBB = MBB;
return Result;
}
/// MachineRelocation::getExtSym - Return a relocation entry for an external
/// symbol, like "free".
///
static MachineRelocation getExtSym(uintptr_t offset, unsigned RelocationType,
const char *ES, intptr_t cst = 0,
bool GOTrelative = 0,
bool NeedStub = true) {
assert((RelocationType & ~63) == 0 && "Relocation type too large!");
MachineRelocation Result;
Result.Offset = offset;
Result.ConstantVal = cst;
Result.TargetReloType = RelocationType;
Result.AddrType = isExtSym;
Result.MayNeedFarStub = NeedStub;
Result.GOTRelative = GOTrelative;
Result.TargetResolve = false;
Result.Target.ExtSym = ES;
return Result;
}
/// MachineRelocation::getConstPool - Return a relocation entry for a constant
/// pool entry.
///
static MachineRelocation getConstPool(uintptr_t offset,unsigned RelocationType,
unsigned CPI, intptr_t cst = 0,
bool letTargetResolve = false) {
assert((RelocationType & ~63) == 0 && "Relocation type too large!");
MachineRelocation Result;
Result.Offset = offset;
Result.ConstantVal = cst;
Result.TargetReloType = RelocationType;
Result.AddrType = isConstPool;
Result.MayNeedFarStub = false;
Result.GOTRelative = false;
Result.TargetResolve = letTargetResolve;
Result.Target.Index = CPI;
return Result;
}
/// MachineRelocation::getJumpTable - Return a relocation entry for a jump
/// table entry.
///
static MachineRelocation getJumpTable(uintptr_t offset,unsigned RelocationType,
unsigned JTI, intptr_t cst = 0,
bool letTargetResolve = false) {
assert((RelocationType & ~63) == 0 && "Relocation type too large!");
MachineRelocation Result;
Result.Offset = offset;
Result.ConstantVal = cst;
Result.TargetReloType = RelocationType;
Result.AddrType = isJumpTable;
Result.MayNeedFarStub = false;
Result.GOTRelative = false;
Result.TargetResolve = letTargetResolve;
Result.Target.Index = JTI;
return Result;
}
/// getMachineCodeOffset - Return the offset into the code buffer that the
/// relocation should be performed.
intptr_t getMachineCodeOffset() const {
return Offset;
}
/// getRelocationType - Return the target-specific relocation ID for this
/// relocation.
unsigned getRelocationType() const {
return TargetReloType;
}
/// getConstantVal - Get the constant value associated with this relocation.
/// This is often an offset from the symbol.
///
intptr_t getConstantVal() const {
return ConstantVal;
}
/// setConstantVal - Set the constant value associated with this relocation.
/// This is often an offset from the symbol.
///
void setConstantVal(intptr_t val) {
ConstantVal = val;
}
/// isGlobalValue - Return true if this relocation is a GlobalValue, as
/// opposed to a constant string.
bool isGlobalValue() const {
return AddrType == isGV;
}
/// isIndirectSymbol - Return true if this relocation is the address an
/// indirect symbol
bool isIndirectSymbol() const {
return AddrType == isIndirectSym;
}
/// isBasicBlock - Return true if this relocation is a basic block reference.
///
bool isBasicBlock() const {
return AddrType == isBB;
}
/// isExternalSymbol - Return true if this is a constant string.
///
bool isExternalSymbol() const {
return AddrType == isExtSym;
}
/// isConstantPoolIndex - Return true if this is a constant pool reference.
///
bool isConstantPoolIndex() const {
return AddrType == isConstPool;
}
/// isJumpTableIndex - Return true if this is a jump table reference.
///
bool isJumpTableIndex() const {
return AddrType == isJumpTable;
}
/// isGOTRelative - Return true the target wants the index into the GOT of
/// the symbol rather than the address of the symbol.
bool isGOTRelative() const {
return GOTRelative;
}
/// mayNeedFarStub - This function returns true if the JIT for this target may
/// need either a stub function or an indirect global-variable load to handle
/// the relocated GlobalValue reference. For example, the x86-64 call
/// instruction can only call functions within +/-2GB of the call site.
/// Anything farther away needs a longer mov+call sequence, which can't just
/// be written on top of the existing call.
bool mayNeedFarStub() const {
return MayNeedFarStub;
}
/// letTargetResolve - Return true if the target JITInfo is usually
/// responsible for resolving the address of this relocation.
bool letTargetResolve() const {
return TargetResolve;
}
/// getGlobalValue - If this is a global value reference, return the
/// referenced global.
GlobalValue *getGlobalValue() const {
assert((isGlobalValue() || isIndirectSymbol()) &&
"This is not a global value reference!");
return Target.GV;
}
MachineBasicBlock *getBasicBlock() const {
assert(isBasicBlock() && "This is not a basic block reference!");
return Target.MBB;
}
/// getString - If this is a string value, return the string reference.
///
const char *getExternalSymbol() const {
assert(isExternalSymbol() && "This is not an external symbol reference!");
return Target.ExtSym;
}
/// getConstantPoolIndex - If this is a const pool reference, return
/// the index into the constant pool.
unsigned getConstantPoolIndex() const {
assert(isConstantPoolIndex() && "This is not a constant pool reference!");
return Target.Index;
}
/// getJumpTableIndex - If this is a jump table reference, return
/// the index into the jump table.
unsigned getJumpTableIndex() const {
assert(isJumpTableIndex() && "This is not a jump table reference!");
return Target.Index;
}
/// getResultPointer - Once this has been resolved to point to an actual
/// address, this returns the pointer.
void *getResultPointer() const {
assert(AddrType == isResult && "Result pointer isn't set yet!");
return Target.Result;
}
/// setResultPointer - Set the result to the specified pointer value.
///
void setResultPointer(void *Ptr) {
Target.Result = Ptr;
AddrType = isResult;
}
/// setGOTIndex - Set the GOT index to a specific value.
void setGOTIndex(unsigned idx) {
AddrType = isGOTIndex;
Target.GOTIndex = idx;
}
/// getGOTIndex - Once this has been resolved to an entry in the GOT,
/// this returns that index. The index is from the lowest address entry
/// in the GOT.
unsigned getGOTIndex() const {
assert(AddrType == isGOTIndex);
return Target.GOTIndex;
}
};
}
#endif

1
lib/CodeGen/CMakeLists.txt
View File

@ -47,7 +47,6 @@ add_llvm_library(LLVMCodeGen
MachineBlockPlacement.cpp
MachineBranchProbabilityInfo.cpp
MachineCSE.cpp
MachineCodeEmitter.cpp
MachineCombiner.cpp
MachineCopyPropagation.cpp
MachineDominators.cpp

14
lib/CodeGen/MachineCodeEmitter.cpp
View File

@ -1,14 +0,0 @@
//===-- llvm/CodeGen/MachineCodeEmitter.cpp - Code emission -----*- 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/MachineCodeEmitter.h"
using namespace llvm;
void MachineCodeEmitter::anchor() { }

62
lib/Target/ARM/ARMRelocations.h
View File

@ -1,62 +0,0 @@
//===-- ARMRelocations.h - ARM Code Relocations -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the ARM target-specific relocation types.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIB_TARGET_ARM_ARMRELOCATIONS_H
#define LLVM_LIB_TARGET_ARM_ARMRELOCATIONS_H
#include "llvm/CodeGen/MachineRelocation.h"
namespace llvm {
namespace ARM {
enum RelocationType {
// reloc_arm_absolute - Absolute relocation, just add the relocated value
// to the value already in memory.
reloc_arm_absolute,
// reloc_arm_relative - PC relative relocation, add the relocated value to
// the value already in memory, after we adjust it for where the PC is.
reloc_arm_relative,
// reloc_arm_cp_entry - PC relative relocation for constpool_entry's whose
// addresses are kept locally in a map.
reloc_arm_cp_entry,
// reloc_arm_vfp_cp_entry - Same as reloc_arm_cp_entry except the offset
// should be divided by 4.
reloc_arm_vfp_cp_entry,
// reloc_arm_machine_cp_entry - Relocation of a ARM machine constantpool
// entry.
reloc_arm_machine_cp_entry,
// reloc_arm_jt_base - PC relative relocation for jump tables whose
// addresses are kept locally in a map.
reloc_arm_jt_base,
// reloc_arm_pic_jt - PIC jump table entry relocation: dest bb - jt base.
reloc_arm_pic_jt,
// reloc_arm_branch - Branch address relocation.
reloc_arm_branch,
// reloc_arm_movt - MOVT immediate relocation.
reloc_arm_movt,
// reloc_arm_movw - MOVW immediate relocation.
reloc_arm_movw
};
}
}
#endif

41
lib/Target/Mips/MipsRelocations.h
View File

@ -1,41 +0,0 @@
//===-- MipsRelocations.h - Mips Code Relocations ---------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the Mips target-specific relocation types
// (for relocation-model=static).
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIB_TARGET_MIPS_MIPSRELOCATIONS_H
#define LLVM_LIB_TARGET_MIPS_MIPSRELOCATIONS_H
#include "llvm/CodeGen/MachineRelocation.h"
namespace llvm {
namespace Mips{
enum RelocationType {
// reloc_mips_pc16 - pc relative relocation for branches. The lower 18
// bits of the difference between the branch target and the branch
// instruction, shifted right by 2.
reloc_mips_pc16 = 1,
// reloc_mips_hi - upper 16 bits of the address (modified by +1 if the
// lower 16 bits of the address is negative).
reloc_mips_hi = 2,
// reloc_mips_lo - lower 16 bits of the address.
reloc_mips_lo = 3,
// reloc_mips_26 - lower 28 bits of the address, shifted right by 2.
reloc_mips_26 = 4
};
}
}
#endif /* MIPSRELOCATIONS_H_ */

56
lib/Target/Sparc/SparcRelocations.h
View File

@ -1,56 +0,0 @@
//===-- SparcRelocations.h - Sparc Code Relocations -------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the Sparc target-specific relocation types
// (for relocation-model=static).
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIB_TARGET_SPARC_SPARCRELOCATIONS_H
#define LLVM_LIB_TARGET_SPARC_SPARCRELOCATIONS_H
#include "llvm/CodeGen/MachineRelocation.h"
namespace llvm {
namespace SP {
enum RelocationType {
// reloc_sparc_hi - upper 22 bits
reloc_sparc_hi = 1,
// reloc_sparc_lo - lower 10 bits
reloc_sparc_lo = 2,
// reloc_sparc_pc30 - pc rel. 30 bits for call
reloc_sparc_pc30 = 3,
// reloc_sparc_pc22 - pc rel. 22 bits for branch
reloc_sparc_pc22 = 4,
// reloc_sparc_pc22 - pc rel. 19 bits for branch with icc/xcc
reloc_sparc_pc19 = 5,
// reloc_sparc_h44 - 43-22 bits
reloc_sparc_h44 = 6,
// reloc_sparc_m44 - 21-12 bits
reloc_sparc_m44 = 7,
// reloc_sparc_l44 - lower 12 bits
reloc_sparc_l44 = 8,
// reloc_sparc_hh - 63-42 bits
reloc_sparc_hh = 9,
// reloc_sparc_hm - 41-32 bits
reloc_sparc_hm = 10
};
}
}
#endif

52
lib/Target/X86/X86Relocations.h
View File

@ -1,52 +0,0 @@
//===-- X86Relocations.h - X86 Code Relocations -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the X86 target-specific relocation types.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIB_TARGET_X86_X86RELOCATIONS_H
#define LLVM_LIB_TARGET_X86_X86RELOCATIONS_H
#include "llvm/CodeGen/MachineRelocation.h"
namespace llvm {
namespace X86 {
/// RelocationType - An enum for the x86 relocation codes. Note that
/// the terminology here doesn't follow x86 convention - word means
/// 32-bit and dword means 64-bit. The relocations will be treated
/// by JIT or ObjectCode emitters, this is transparent to the x86 code
/// emitter but JIT and ObjectCode will treat them differently
enum RelocationType {
/// reloc_pcrel_word - PC relative relocation, add the relocated value to
/// the value already in memory, after we adjust it for where the PC is.
reloc_pcrel_word = 0,
/// reloc_picrel_word - PIC base relative relocation, add the relocated
/// value to the value already in memory, after we adjust it for where the
/// PIC base is.
reloc_picrel_word = 1,
/// reloc_absolute_word - absolute relocation, just add the relocated
/// value to the value already in memory.
reloc_absolute_word = 2,
/// reloc_absolute_word_sext - absolute relocation, just add the relocated
/// value to the value already in memory. In object files, it represents a
/// value which must be sign-extended when resolving the relocation.
reloc_absolute_word_sext = 3,
/// reloc_absolute_dword - absolute relocation, just add the relocated
/// value to the value already in memory.
reloc_absolute_dword = 4
};
}
}
#endif