6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-12 13:38:21 +00:00
Code Issues Projects Releases Wiki Activity

Automatically do the equivalent of freeMachineCodeForFunction(F) when F is

Browse Source 
being destroyed. This allows users to run global optimizations like globaldce
even after some functions have been jitted.

This patch also removes the Function* parameter to
JITEventListener::NotifyFreeingMachineCode() since it can cause that to be
called when the Function is partially destroyed. This change will be even more
helpful later when I think we'll want to allow machine code to actually outlive
its Function.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@85182 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jeffrey Yasskin
2009-10-27 00:03:05 +00:00
parent f2becca90b
commit 7a9034c4db
8 changed files with 209 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
include/llvm/ExecutionEngine/ExecutionEngine.h
View File

@ -263,9 +263,8 @@ public:
/// getPointerToFunction - The different EE's represent function bodies in
/// different ways. They should each implement this to say what a function
/// pointer should look like. When F is destroyed, the ExecutionEngine will
/// remove its global mapping but will not yet free its machine code. Call
/// freeMachineCodeForFunction(F) explicitly to do that. Note that global
/// optimizations can destroy Functions without notifying the ExecutionEngine.
/// remove its global mapping and free any machine code. Be sure no threads
/// are running inside F when that happens.
///
virtual void *getPointerToFunction(Function *F) = 0;

7
include/llvm/ExecutionEngine/JITEventListener.h
View File

@ -63,8 +63,11 @@ public:
/// NotifyFreeingMachineCode - This is called inside of
/// freeMachineCodeForFunction(), after the global mapping is removed, but
/// before the machine code is returned to the allocator. OldPtr is the
/// address of the machine code.
virtual void NotifyFreeingMachineCode(const Function &F, void *OldPtr) {}
/// address of the machine code and will be the same as the Code parameter to
/// a previous NotifyFunctionEmitted call. The Function passed to
/// NotifyFunctionEmitted may have been destroyed by the time of the matching
/// NotifyFreeingMachineCode call.
virtual void NotifyFreeingMachineCode(void *OldPtr) {}
};
// This returns NULL if support isn't available.