mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-02-19 06:31:18 +00:00
bc6d876adf
Since the ARM constant pool handling supercedes the standard LLVM constant pool entirely, the JIT emitter does not allocate space for the constants, nor initialize the memory. The constant pool is considered part of the instruction stream. Likewise, when resolving relocations into the constant pool, a hook into the target back end is used to resolve from the constant ID# to the address where the constant is stored. For now, the support in the ARM emitter is limited to 32-bit integer. Future patches will expand this to the full range of constants necessary. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@58338 91177308-0d34-0410-b5e6-96231b3b80d8
75 lines
2.9 KiB
C++
75 lines
2.9 KiB
C++
//===- ARMJITInfo.h - ARM implementation of the JIT interface --*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains the declaration of the ARMJITInfo class.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef ARMJITINFO_H
|
|
#define ARMJITINFO_H
|
|
|
|
#include "llvm/Target/TargetJITInfo.h"
|
|
#include <map>
|
|
|
|
namespace llvm {
|
|
class ARMTargetMachine;
|
|
|
|
class ARMJITInfo : public TargetJITInfo {
|
|
ARMTargetMachine &TM;
|
|
std::map<unsigned, intptr_t> CPIDtoAddressMap;
|
|
public:
|
|
explicit ARMJITInfo(ARMTargetMachine &tm) : TM(tm) { useGOT = false; }
|
|
|
|
/// replaceMachineCodeForFunction - Make it so that calling the function
|
|
/// whose machine code is at OLD turns into a call to NEW, perhaps by
|
|
/// overwriting OLD with a branch to NEW. This is used for self-modifying
|
|
/// code.
|
|
///
|
|
virtual void replaceMachineCodeForFunction(void *Old, void *New);
|
|
|
|
/// emitFunctionStub - Use the specified MachineCodeEmitter object to emit a
|
|
/// small native function that simply calls the function at the specified
|
|
/// address.
|
|
virtual void *emitFunctionStub(const Function* F, void *Fn,
|
|
MachineCodeEmitter &MCE);
|
|
|
|
/// getLazyResolverFunction - Expose the lazy resolver to the JIT.
|
|
virtual LazyResolverFn getLazyResolverFunction(JITCompilerFn);
|
|
|
|
/// relocate - Before the JIT can run a block of code that has been emitted,
|
|
/// it must rewrite the code to contain the actual addresses of any
|
|
/// referenced global symbols.
|
|
virtual void relocate(void *Function, MachineRelocation *MR,
|
|
unsigned NumRelocs, unsigned char* GOTBase);
|
|
|
|
/// hasCustomConstantPool - Allows a target to specify that constant
|
|
/// pool address resolution is handled by the target.
|
|
virtual bool hasCustomConstantPool() const { return true; }
|
|
|
|
/// getCustomConstantPoolEntryAddress - The ARM target puts all constant
|
|
/// pool entries into constant islands. Resolve the constant pool index
|
|
/// into the address where the constant is stored.
|
|
virtual intptr_t getCustomConstantPoolEntryAddress(unsigned CPID) const
|
|
{
|
|
std::map<unsigned, intptr_t>::const_iterator elem;
|
|
elem = CPIDtoAddressMap.find(CPID);
|
|
assert (elem != CPIDtoAddressMap.end());
|
|
return elem->second;
|
|
}
|
|
|
|
/// mapCPIDtoAddress - Map a Constant Pool Index (CPID) to the address
|
|
/// where its associated value is stored. When relocations are processed,
|
|
/// this value will be used to resolve references to the constant.
|
|
void mapCPIDtoAddress(unsigned CPID, intptr_t address)
|
|
{ CPIDtoAddressMap[CPID] = address; }
|
|
};
|
|
}
|
|
|
|
#endif
|