mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-23 02:29:18 +00:00
Tidy up. Whitespace and 80-columns.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@128583 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
31d244ead5
commit
f5b23368d2
@ -118,11 +118,11 @@ protected:
|
||||
/// The list of Modules that we are JIT'ing from. We use a SmallVector to
|
||||
/// optimize for the case where there is only one module.
|
||||
SmallVector<Module*, 1> Modules;
|
||||
|
||||
|
||||
void setTargetData(const TargetData *td) {
|
||||
TD = td;
|
||||
}
|
||||
|
||||
|
||||
/// getMemoryforGV - Allocate memory for a global variable.
|
||||
virtual char *getMemoryForGV(const GlobalVariable *GV);
|
||||
|
||||
@ -156,7 +156,7 @@ protected:
|
||||
/// pointer is invoked to create it. If this returns null, the JIT will
|
||||
/// abort.
|
||||
void *(*LazyFunctionCreator)(const std::string &);
|
||||
|
||||
|
||||
/// ExceptionTableRegister - If Exception Handling is set, the JIT will
|
||||
/// register dwarf tables with this function.
|
||||
typedef void (*EERegisterFn)(void*);
|
||||
@ -216,7 +216,7 @@ public:
|
||||
virtual void addModule(Module *M) {
|
||||
Modules.push_back(M);
|
||||
}
|
||||
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
const TargetData *getTargetData() const { return TD; }
|
||||
@ -229,7 +229,7 @@ public:
|
||||
/// defines FnName. This is very slow operation and shouldn't be used for
|
||||
/// general code.
|
||||
Function *FindFunctionNamed(const char *FnName);
|
||||
|
||||
|
||||
/// runFunction - Execute the specified function with the specified arguments,
|
||||
/// and return the result.
|
||||
virtual GenericValue runFunction(Function *F,
|
||||
@ -246,8 +246,8 @@ public:
|
||||
///
|
||||
/// \param isDtors - Run the destructors instead of constructors.
|
||||
void runStaticConstructorsDestructors(Module *module, bool isDtors);
|
||||
|
||||
|
||||
|
||||
|
||||
/// runFunctionAsMain - This is a helper function which wraps runFunction to
|
||||
/// handle the common task of starting up main with the specified argc, argv,
|
||||
/// and envp parameters.
|
||||
@ -262,21 +262,21 @@ public:
|
||||
/// existing data in memory. Mappings are automatically removed when their
|
||||
/// GlobalValue is destroyed.
|
||||
void addGlobalMapping(const GlobalValue *GV, void *Addr);
|
||||
|
||||
|
||||
/// clearAllGlobalMappings - Clear all global mappings and start over again,
|
||||
/// for use in dynamic compilation scenarios to move globals.
|
||||
void clearAllGlobalMappings();
|
||||
|
||||
|
||||
/// clearGlobalMappingsFromModule - Clear all global mappings that came from a
|
||||
/// particular module, because it has been removed from the JIT.
|
||||
void clearGlobalMappingsFromModule(Module *M);
|
||||
|
||||
|
||||
/// updateGlobalMapping - Replace an existing mapping for GV with a new
|
||||
/// address. This updates both maps as required. If "Addr" is null, the
|
||||
/// entry for the global is removed from the mappings. This returns the old
|
||||
/// value of the pointer, or null if it was not in the map.
|
||||
void *updateGlobalMapping(const GlobalValue *GV, void *Addr);
|
||||
|
||||
|
||||
/// getPointerToGlobalIfAvailable - This returns the address of the specified
|
||||
/// global value if it is has already been codegen'd, otherwise it returns
|
||||
/// null.
|
||||
@ -297,7 +297,7 @@ public:
|
||||
/// different ways. Return the representation for a blockaddress of the
|
||||
/// specified block.
|
||||
virtual void *getPointerToBasicBlock(BasicBlock *BB) = 0;
|
||||
|
||||
|
||||
/// getPointerToFunctionOrStub - If the specified function has been
|
||||
/// code-gen'd, return a pointer to the function. If not, compile it, or use
|
||||
/// a stub to implement lazy compilation if available. See
|
||||
@ -401,7 +401,7 @@ public:
|
||||
void InstallLazyFunctionCreator(void* (*P)(const std::string &)) {
|
||||
LazyFunctionCreator = P;
|
||||
}
|
||||
|
||||
|
||||
/// InstallExceptionTableRegister - The JIT will use the given function
|
||||
/// to register the exception tables it generates.
|
||||
void InstallExceptionTableRegister(EERegisterFn F) {
|
||||
@ -410,7 +410,7 @@ public:
|
||||
void InstallExceptionTableDeregister(EERegisterFn F) {
|
||||
ExceptionTableDeregister = F;
|
||||
}
|
||||
|
||||
|
||||
/// RegisterTable - Registers the given pointer as an exception table. It
|
||||
/// uses the ExceptionTableRegister function.
|
||||
void RegisterTable(const Function *fn, void* res) {
|
||||
@ -420,10 +420,12 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
/// DeregisterTable - Deregisters the exception frame previously registered for the given function.
|
||||
/// DeregisterTable - Deregisters the exception frame previously registered
|
||||
/// for the given function.
|
||||
void DeregisterTable(const Function *Fn) {
|
||||
if (ExceptionTableDeregister) {
|
||||
DenseMap<const Function*, void*>::iterator frame = AllExceptionTables.find(Fn);
|
||||
DenseMap<const Function*, void*>::iterator frame =
|
||||
AllExceptionTables.find(Fn);
|
||||
if(frame != AllExceptionTables.end()) {
|
||||
ExceptionTableDeregister(frame->second);
|
||||
AllExceptionTables.erase(frame);
|
||||
@ -443,7 +445,7 @@ protected:
|
||||
void EmitGlobalVariable(const GlobalVariable *GV);
|
||||
|
||||
GenericValue getConstantValue(const Constant *C);
|
||||
void LoadValueFromMemory(GenericValue &Result, GenericValue *Ptr,
|
||||
void LoadValueFromMemory(GenericValue &Result, GenericValue *Ptr,
|
||||
const Type *Ty);
|
||||
};
|
||||
|
||||
|
@ -29,11 +29,11 @@ protected:
|
||||
public:
|
||||
JITMemoryManager() : HasGOT(false) {}
|
||||
virtual ~JITMemoryManager();
|
||||
|
||||
|
||||
/// CreateDefaultMemManager - This is used to create the default
|
||||
/// JIT Memory Manager if the client does not provide one to the JIT.
|
||||
static JITMemoryManager *CreateDefaultMemManager();
|
||||
|
||||
|
||||
/// setMemoryWritable - When code generation is in progress,
|
||||
/// the code pages may need permissions changed.
|
||||
virtual void setMemoryWritable() = 0;
|
||||
@ -55,16 +55,16 @@ public:
|
||||
/// method is invoked to allocate it. This method is required to set HasGOT
|
||||
/// to true.
|
||||
virtual void AllocateGOT() = 0;
|
||||
|
||||
|
||||
/// isManagingGOT - Return true if the AllocateGOT method is called.
|
||||
bool isManagingGOT() const {
|
||||
return HasGOT;
|
||||
}
|
||||
|
||||
|
||||
/// getGOTBase - If this is managing a Global Offset Table, this method should
|
||||
/// return a pointer to its base.
|
||||
virtual uint8_t *getGOTBase() const = 0;
|
||||
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Main Allocation Functions
|
||||
//===--------------------------------------------------------------------===//
|
||||
@ -91,11 +91,11 @@ public:
|
||||
/// startFunctionBody.
|
||||
virtual uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize,
|
||||
unsigned Alignment) = 0;
|
||||
|
||||
|
||||
/// endFunctionBody - This method is called when the JIT is done codegen'ing
|
||||
/// the specified function. At this point we know the size of the JIT
|
||||
/// compiled function. This passes in FunctionStart (which was returned by
|
||||
/// the startFunctionBody method) and FunctionEnd which is a pointer to the
|
||||
/// the startFunctionBody method) and FunctionEnd which is a pointer to the
|
||||
/// actual end of the function. This method should mark the space allocated
|
||||
/// and remember where it is in case the client wants to deallocate it.
|
||||
virtual void endFunctionBody(const Function *F, uint8_t *FunctionStart,
|
||||
@ -113,12 +113,12 @@ public:
|
||||
/// been deallocated yet. This is never called when the JIT is currently
|
||||
/// emitting a function.
|
||||
virtual void deallocateFunctionBody(void *Body) = 0;
|
||||
|
||||
|
||||
/// startExceptionTable - When we finished JITing the function, if exception
|
||||
/// handling is set, we emit the exception table.
|
||||
virtual uint8_t* startExceptionTable(const Function* F,
|
||||
uintptr_t &ActualSize) = 0;
|
||||
|
||||
|
||||
/// endExceptionTable - This method is called when the JIT is done emitting
|
||||
/// the exception table.
|
||||
virtual void endExceptionTable(const Function *F, uint8_t *TableStart,
|
||||
|
Loading…
Reference in New Issue
Block a user