blob: dcc66b2a089fc47facb530cf76308633327b8399 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
//===- JITEventListener.h - Exposes events from JIT compilation -*- 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 JITEventListener interface, which lets users get
// callbacks when significant events happen during the JIT compilation process.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_EXECUTION_ENGINE_JIT_EVENTLISTENER_H
#define LLVM_EXECUTION_ENGINE_JIT_EVENTLISTENER_H
#include "llvm/System/DataTypes.h"
#include "llvm/Support/DebugLoc.h"
#include <vector>
namespace llvm {
class Function;
class MachineFunction;
/// Empty for now, but this object will contain all details about the
/// generated machine code that a Listener might care about.
struct JITEvent_EmittedFunctionDetails {
const MachineFunction *MF;
struct LineStart {
// The address at which the current line changes.
uintptr_t Address;
// The new location information. These can be translated to
// DebugLocTuples using MF->getDebugLocTuple().
DebugLoc Loc;
};
// This holds line boundary information sorted by address.
std::vector<LineStart> LineStarts;
};
/// JITEventListener - This interface is used by the JIT to notify clients about
/// significant events during compilation. For example, we could have
/// implementations for profilers and debuggers that need to know where
/// functions have been emitted.
///
/// Each method defaults to doing nothing, so you only need to override the ones
/// you care about.
class JITEventListener {
public:
JITEventListener() {}
virtual ~JITEventListener(); // Defined in JIT.cpp.
typedef JITEvent_EmittedFunctionDetails EmittedFunctionDetails;
/// NotifyFunctionEmitted - Called after a function has been successfully
/// emitted to memory. The function still has its MachineFunction attached,
/// if you should happen to need that.
virtual void NotifyFunctionEmitted(const Function &F,
void *Code, size_t Size,
const EmittedFunctionDetails &Details) {}
/// 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 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.
JITEventListener *createOProfileJITEventListener();
} // end namespace llvm.
#endif
|
