mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-11-02 07:11:49 +00:00
1911fd4f85
This pass: 1. Splits TargetMachine into TargetMachine (generic targets, can be implemented any way, like the CBE) and LLVMTargetMachine (subclass of TM that is used by things using libcodegen and other support). 2. Instead of having each target fully populate the passmgr for file or JIT output, move all this to common code, and give targets hooks they can implement. 3. Commonalize the target population stuff between file emission and JIT emission. 4. All (native code) codegen stuff now happens in a FunctionPassManager, which paves the way for "fast -O0" stuff in the CFE later, and now LLC could lazily stream .bc files from disk to use less memory. 5. There are now many fewer #includes and the targets don't depend on the scalar xforms or libanalysis anymore (but codegen does). 6. Changing common code generator pass ordering stuff no longer requires touching all targets. 7. The JIT now has the option of "-fast" codegen or normal optimized codegen, which is now orthogonal to the fact that JIT'ing is being done. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@30081 91177308-0d34-0410-b5e6-96231b3b80d8
91 lines
3.5 KiB
C++
91 lines
3.5 KiB
C++
//===- Target/TargetJITInfo.h - Target Information for JIT ------*- C++ -*-===//
|
|
//
|
|
// 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 exposes an abstract interface used by the Just-In-Time code
|
|
// generator to perform target-specific activities, such as emitting stubs. If
|
|
// a TargetMachine supports JIT code generation, it should provide one of these
|
|
// objects through the getJITInfo() method.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_TARGET_TARGETJITINFO_H
|
|
#define LLVM_TARGET_TARGETJITINFO_H
|
|
|
|
#include <cassert>
|
|
#include <vector>
|
|
|
|
namespace llvm {
|
|
class Function;
|
|
class FunctionPassManager;
|
|
class MachineBasicBlock;
|
|
class MachineCodeEmitter;
|
|
class MachineRelocation;
|
|
|
|
/// TargetJITInfo - Target specific information required by the Just-In-Time
|
|
/// code generator.
|
|
class TargetJITInfo {
|
|
public:
|
|
virtual ~TargetJITInfo() {}
|
|
|
|
/// 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) = 0;
|
|
|
|
/// emitFunctionStub - Use the specified MachineCodeEmitter object to emit a
|
|
/// small native function that simply calls the function at the specified
|
|
/// address. Return the address of the resultant function.
|
|
virtual void *emitFunctionStub(void *Fn, MachineCodeEmitter &MCE) {
|
|
assert(0 && "This target doesn't implement emitFunctionStub!");
|
|
return 0;
|
|
}
|
|
|
|
/// LazyResolverFn - This typedef is used to represent the function that
|
|
/// unresolved call points should invoke. This is a target specific
|
|
/// function that knows how to walk the stack and find out which stub the
|
|
/// call is coming from.
|
|
typedef void (*LazyResolverFn)();
|
|
|
|
/// JITCompilerFn - This typedef is used to represent the JIT function that
|
|
/// lazily compiles the function corresponding to a stub. The JIT keeps
|
|
/// track of the mapping between stubs and LLVM Functions, the target
|
|
/// provides the ability to figure out the address of a stub that is called
|
|
/// by the LazyResolverFn.
|
|
typedef void* (*JITCompilerFn)(void *);
|
|
|
|
/// getLazyResolverFunction - This method is used to initialize the JIT,
|
|
/// giving the target the function that should be used to compile a
|
|
/// function, and giving the JIT the target function used to do the lazy
|
|
/// resolving.
|
|
virtual LazyResolverFn getLazyResolverFunction(JITCompilerFn) {
|
|
assert(0 && "Not implemented for this target!");
|
|
return 0;
|
|
}
|
|
|
|
/// 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) {
|
|
assert(NumRelocs == 0 && "This target does not have relocations!");
|
|
}
|
|
|
|
/// needsGOT - Allows a target to specify that it would like the
|
|
// JIT to manage a GOT for it.
|
|
bool needsGOT() const { return useGOT; }
|
|
|
|
protected:
|
|
bool useGOT;
|
|
};
|
|
} // End llvm namespace
|
|
|
|
#endif
|