JITEventListenerTest.cpp revision a44defeb2208376ca3113ffdddc391570ba865b8 
1//===- JITEventListenerTest.cpp - Unit tests for JITEventListeners --------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "llvm/ExecutionEngine/JITEventListener.h"
11
12#include "llvm/LLVMContext.h"
13#include "llvm/Instructions.h"
14#include "llvm/Module.h"
15#include "llvm/ADT/OwningPtr.h"
16#include "llvm/CodeGen/MachineCodeInfo.h"
17#include "llvm/ExecutionEngine/JIT.h"
18#include "llvm/Support/TypeBuilder.h"
19#include "llvm/Target/TargetSelect.h"
20#include "gtest/gtest.h"
21#include <vector>
22
23using namespace llvm;
24
25int dummy;
26
27namespace {
28
29struct FunctionEmittedEvent {
30  // Indices are local to the RecordingJITEventListener, since the
31  // JITEventListener interface makes no guarantees about the order of
32  // calls between Listeners.
33  unsigned Index;
34  const Function *F;
35  void *Code;
36  size_t Size;
37  JITEvent_EmittedFunctionDetails Details;
38};
39struct FunctionFreedEvent {
40  unsigned Index;
41  void *Code;
42};
43
44struct RecordingJITEventListener : public JITEventListener {
45  std::vector<FunctionEmittedEvent> EmittedEvents;
46  std::vector<FunctionFreedEvent> FreedEvents;
47
48  unsigned NextIndex;
49
50  RecordingJITEventListener() : NextIndex(0) {}
51
52  virtual void NotifyFunctionEmitted(const Function &F,
53                                     void *Code, size_t Size,
54                                     const EmittedFunctionDetails &Details) {
55    FunctionEmittedEvent Event = {NextIndex++, &F, Code, Size, Details};
56    EmittedEvents.push_back(Event);
57  }
58
59  virtual void NotifyFreeingMachineCode(void *OldPtr) {
60    FunctionFreedEvent Event = {NextIndex++, OldPtr};
61    FreedEvents.push_back(Event);
62  }
63};
64
65class JITEventListenerTest : public testing::Test {
66 protected:
67  JITEventListenerTest()
68      : M(new Module("module", getGlobalContext())),
69        EE(EngineBuilder(M)
70           .setEngineKind(EngineKind::JIT)
71           .create()) {
72  }
73
74  Module *M;
75  const OwningPtr<ExecutionEngine> EE;
76};
77
78Function *buildFunction(Module *M) {
79  Function *Result = Function::Create(
80      TypeBuilder<int32_t(int32_t), false>::get(getGlobalContext()),
81      GlobalValue::ExternalLinkage, "id", M);
82  Value *Arg = Result->arg_begin();
83  BasicBlock *BB = BasicBlock::Create(M->getContext(), "entry", Result);
84  ReturnInst::Create(M->getContext(), Arg, BB);
85  return Result;
86}
87
88// Tests that a single JITEventListener follows JIT events accurately.
89TEST_F(JITEventListenerTest, Simple) {
90  RecordingJITEventListener Listener;
91  EE->RegisterJITEventListener(&Listener);
92  Function *F1 = buildFunction(M);
93  Function *F2 = buildFunction(M);
94
95  void *F1_addr = EE->getPointerToFunction(F1);
96  void *F2_addr = EE->getPointerToFunction(F2);
97  EE->getPointerToFunction(F1);  // Should do nothing.
98  EE->freeMachineCodeForFunction(F1);
99  EE->freeMachineCodeForFunction(F2);
100
101  ASSERT_EQ(2U, Listener.EmittedEvents.size());
102  ASSERT_EQ(2U, Listener.FreedEvents.size());
103
104  EXPECT_EQ(0U, Listener.EmittedEvents[0].Index);
105  EXPECT_EQ(F1, Listener.EmittedEvents[0].F);
106  EXPECT_EQ(F1_addr, Listener.EmittedEvents[0].Code);
107  EXPECT_LT(0U, Listener.EmittedEvents[0].Size)
108      << "We don't know how big the function will be, but it had better"
109      << " contain some bytes.";
110
111  EXPECT_EQ(1U, Listener.EmittedEvents[1].Index);
112  EXPECT_EQ(F2, Listener.EmittedEvents[1].F);
113  EXPECT_EQ(F2_addr, Listener.EmittedEvents[1].Code);
114  EXPECT_LT(0U, Listener.EmittedEvents[1].Size)
115      << "We don't know how big the function will be, but it had better"
116      << " contain some bytes.";
117
118  EXPECT_EQ(2U, Listener.FreedEvents[0].Index);
119  EXPECT_EQ(F1_addr, Listener.FreedEvents[0].Code);
120
121  EXPECT_EQ(3U, Listener.FreedEvents[1].Index);
122  EXPECT_EQ(F2_addr, Listener.FreedEvents[1].Code);
123
124  F1->eraseFromParent();
125  F2->eraseFromParent();
126}
127
128// Tests that a single JITEventListener follows JIT events accurately.
129TEST_F(JITEventListenerTest, MultipleListenersDontInterfere) {
130  RecordingJITEventListener Listener1;
131  RecordingJITEventListener Listener2;
132  RecordingJITEventListener Listener3;
133  Function *F1 = buildFunction(M);
134  Function *F2 = buildFunction(M);
135
136  EE->RegisterJITEventListener(&Listener1);
137  EE->RegisterJITEventListener(&Listener2);
138  void *F1_addr = EE->getPointerToFunction(F1);
139  EE->RegisterJITEventListener(&Listener3);
140  EE->UnregisterJITEventListener(&Listener1);
141  void *F2_addr = EE->getPointerToFunction(F2);
142  EE->UnregisterJITEventListener(&Listener2);
143  EE->UnregisterJITEventListener(&Listener3);
144  EE->freeMachineCodeForFunction(F1);
145  EE->RegisterJITEventListener(&Listener2);
146  EE->RegisterJITEventListener(&Listener3);
147  EE->RegisterJITEventListener(&Listener1);
148  EE->freeMachineCodeForFunction(F2);
149  EE->UnregisterJITEventListener(&Listener1);
150  EE->UnregisterJITEventListener(&Listener2);
151  EE->UnregisterJITEventListener(&Listener3);
152
153  // Listener 1.
154  ASSERT_EQ(1U, Listener1.EmittedEvents.size());
155  ASSERT_EQ(1U, Listener1.FreedEvents.size());
156
157  EXPECT_EQ(0U, Listener1.EmittedEvents[0].Index);
158  EXPECT_EQ(F1, Listener1.EmittedEvents[0].F);
159  EXPECT_EQ(F1_addr, Listener1.EmittedEvents[0].Code);
160  EXPECT_LT(0U, Listener1.EmittedEvents[0].Size)
161      << "We don't know how big the function will be, but it had better"
162      << " contain some bytes.";
163
164  EXPECT_EQ(1U, Listener1.FreedEvents[0].Index);
165  EXPECT_EQ(F2_addr, Listener1.FreedEvents[0].Code);
166
167  // Listener 2.
168  ASSERT_EQ(2U, Listener2.EmittedEvents.size());
169  ASSERT_EQ(1U, Listener2.FreedEvents.size());
170
171  EXPECT_EQ(0U, Listener2.EmittedEvents[0].Index);
172  EXPECT_EQ(F1, Listener2.EmittedEvents[0].F);
173  EXPECT_EQ(F1_addr, Listener2.EmittedEvents[0].Code);
174  EXPECT_LT(0U, Listener2.EmittedEvents[0].Size)
175      << "We don't know how big the function will be, but it had better"
176      << " contain some bytes.";
177
178  EXPECT_EQ(1U, Listener2.EmittedEvents[1].Index);
179  EXPECT_EQ(F2, Listener2.EmittedEvents[1].F);
180  EXPECT_EQ(F2_addr, Listener2.EmittedEvents[1].Code);
181  EXPECT_LT(0U, Listener2.EmittedEvents[1].Size)
182      << "We don't know how big the function will be, but it had better"
183      << " contain some bytes.";
184
185  EXPECT_EQ(2U, Listener2.FreedEvents[0].Index);
186  EXPECT_EQ(F2_addr, Listener2.FreedEvents[0].Code);
187
188  // Listener 3.
189  ASSERT_EQ(1U, Listener3.EmittedEvents.size());
190  ASSERT_EQ(1U, Listener3.FreedEvents.size());
191
192  EXPECT_EQ(0U, Listener3.EmittedEvents[0].Index);
193  EXPECT_EQ(F2, Listener3.EmittedEvents[0].F);
194  EXPECT_EQ(F2_addr, Listener3.EmittedEvents[0].Code);
195  EXPECT_LT(0U, Listener3.EmittedEvents[0].Size)
196      << "We don't know how big the function will be, but it had better"
197      << " contain some bytes.";
198
199  EXPECT_EQ(1U, Listener3.FreedEvents[0].Index);
200  EXPECT_EQ(F2_addr, Listener3.FreedEvents[0].Code);
201
202  F1->eraseFromParent();
203  F2->eraseFromParent();
204}
205
206TEST_F(JITEventListenerTest, MatchesMachineCodeInfo) {
207  RecordingJITEventListener Listener;
208  MachineCodeInfo MCI;
209  Function *F = buildFunction(M);
210
211  EE->RegisterJITEventListener(&Listener);
212  EE->runJITOnFunction(F, &MCI);
213  void *F_addr = EE->getPointerToFunction(F);
214  EE->freeMachineCodeForFunction(F);
215
216  ASSERT_EQ(1U, Listener.EmittedEvents.size());
217  ASSERT_EQ(1U, Listener.FreedEvents.size());
218
219  EXPECT_EQ(0U, Listener.EmittedEvents[0].Index);
220  EXPECT_EQ(F, Listener.EmittedEvents[0].F);
221  EXPECT_EQ(F_addr, Listener.EmittedEvents[0].Code);
222  EXPECT_EQ(MCI.address(), Listener.EmittedEvents[0].Code);
223  EXPECT_EQ(MCI.size(), Listener.EmittedEvents[0].Size);
224
225  EXPECT_EQ(1U, Listener.FreedEvents[0].Index);
226  EXPECT_EQ(F_addr, Listener.FreedEvents[0].Code);
227}
228
229class JITEnvironment : public testing::Environment {
230  virtual void SetUp() {
231    // Required to create a JIT.
232    InitializeNativeTarget();
233  }
234};
235testing::Environment* const jit_env =
236  testing::AddGlobalTestEnvironment(new JITEnvironment);
237
238}  // anonymous namespace
239