Debian Codegraph @

llvm-project/llvm/unittests/tools/llvm-exegesis/X86/SnippetGeneratorTest.cpp

raw
1 //===-- SnippetGeneratorTest.cpp --------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "../Common/AssemblerUtils.h"
10 #include "LlvmState.h"
11 #include "MCInstrDescView.h"
12 #include "ParallelSnippetGenerator.h"
13 #include "RegisterAliasing.h"
14 #include "SerialSnippetGenerator.h"
15 #include "TestBase.h"
16 #include "X86InstrInfo.h"
17 #include "llvm/ADT/SetOperations.h"
18
19 #include <unordered_set>
20
21 namespace llvm {
22 namespace exegesis {
23
24 void InitializeX86ExegesisTarget();
25
26 namespace {
27
28 using testing::AnyOf;
29 using testing::ElementsAre;
30 using testing::Ge;
31 using testing::Gt;
32 using testing::HasSubstr;
33 using testing::IsEmpty;
34 using testing::Not;
35 using testing::SizeIs;
36 using testing::UnorderedElementsAre;
37
38 MATCHER(IsInvalid, "") { return !arg.isValid(); }
39 MATCHER(IsReg, "") { return arg.isReg(); }
40
41 template <typename SnippetGeneratorT>
42 class X86SnippetGeneratorTest : public X86TestBase {
43 protected:
44 X86SnippetGeneratorTest() : Generator(State, SnippetGenerator::Options()),
45 InstrInfo(State.getInstrInfo()) {}
46
47 std::vector<CodeTemplate> checkAndGetCodeTemplates(unsigned Opcode) {
48 randomGenerator().seed(0); // Initialize seed.
49 const Instruction &Instr = State.getIC().getInstr(Opcode);
50 auto CodeTemplateOrError = Generator.generateCodeTemplates(
51 &Instr, State.getRATC().emptyRegisters());
52 EXPECT_FALSE(CodeTemplateOrError.takeError()); // Valid configuration.
53 return std::move(CodeTemplateOrError.get());
54 }
55
56 SnippetGeneratorT Generator;
57 const MCInstrInfo &InstrInfo;
58 };
59
60 using X86SerialSnippetGeneratorTest = X86SnippetGeneratorTest<SerialSnippetGenerator>;
61
62 using X86ParallelSnippetGeneratorTest =
63 X86SnippetGeneratorTest<ParallelSnippetGenerator>;
64
65 TEST_F(X86SerialSnippetGeneratorTest, ImplicitSelfDependencyThroughImplicitReg) {
66 // - ADC16i16
67 // - Op0 Explicit Use Immediate
68 // - Op1 Implicit Def Reg(AX)
69 // - Op2 Implicit Def Reg(EFLAGS)
70 // - Op3 Implicit Use Reg(AX)
71 // - Op4 Implicit Use Reg(EFLAGS)
72 // - Var0 [Op0]
73 // - hasAliasingImplicitRegisters (execution is always serial)
74 // - hasAliasingRegisters
75 const unsigned Opcode = X86::ADC16i16;
76 EXPECT_THAT(InstrInfo.get(Opcode).implicit_defs()[0], X86::AX);
77 EXPECT_THAT(InstrInfo.get(Opcode).implicit_defs()[1], X86::EFLAGS);
78 EXPECT_THAT(InstrInfo.get(Opcode).implicit_uses()[0], X86::AX);
79 EXPECT_THAT(InstrInfo.get(Opcode).implicit_uses()[1], X86::EFLAGS);
80 const auto CodeTemplates = checkAndGetCodeTemplates(Opcode);
81 ASSERT_THAT(CodeTemplates, SizeIs(1));
82 const auto &CT = CodeTemplates[0];
83 EXPECT_THAT(CT.Execution, ExecutionMode::ALWAYS_SERIAL_IMPLICIT_REGS_ALIAS);
84 ASSERT_THAT(CT.Instructions, SizeIs(1));
85 const InstructionTemplate &IT = CT.Instructions[0];
86 EXPECT_THAT(IT.getOpcode(), Opcode);
87 ASSERT_THAT(IT.getVariableValues(), SizeIs(1)); // Imm.
88 EXPECT_THAT(IT.getVariableValues()[0], IsInvalid()) << "Immediate is not set";
89 }
90
91 TEST_F(X86SerialSnippetGeneratorTest, ImplicitSelfDependencyThroughTiedRegs) {
92 // - ADD16ri
93 // - Op0 Explicit Def RegClass(GR16)
94 // - Op1 Explicit Use RegClass(GR16) TiedToOp0
95 // - Op2 Explicit Use Immediate
96 // - Op3 Implicit Def Reg(EFLAGS)
97 // - Var0 [Op0,Op1]
98 // - Var1 [Op2]
99 // - hasTiedRegisters (execution is always serial)
100 // - hasAliasingRegisters
101 const unsigned Opcode = X86::ADD16ri;
102 EXPECT_THAT(InstrInfo.get(Opcode).implicit_defs()[0], X86::EFLAGS);
103 const auto CodeTemplates = checkAndGetCodeTemplates(Opcode);
104 ASSERT_THAT(CodeTemplates, SizeIs(1));
105 const auto &CT = CodeTemplates[0];
106 EXPECT_THAT(CT.Execution, ExecutionMode::ALWAYS_SERIAL_TIED_REGS_ALIAS);
107 ASSERT_THAT(CT.Instructions, SizeIs(1));
108 const InstructionTemplate &IT = CT.Instructions[0];
109 EXPECT_THAT(IT.getOpcode(), Opcode);
110 ASSERT_THAT(IT.getVariableValues(), SizeIs(2));
111 EXPECT_THAT(IT.getVariableValues()[0], IsInvalid()) << "Operand 1 is not set";
112 EXPECT_THAT(IT.getVariableValues()[1], IsInvalid()) << "Operand 2 is not set";
113 }
114
115 TEST_F(X86SerialSnippetGeneratorTest, ImplicitSelfDependencyThroughExplicitRegs) {
116 // - VXORPSrr
117 // - Op0 Explicit Def RegClass(VR128)
118 // - Op1 Explicit Use RegClass(VR128)
119 // - Op2 Explicit Use RegClass(VR128)
120 // - Var0 [Op0]
121 // - Var1 [Op1]
122 // - Var2 [Op2]
123 // - hasAliasingRegisters
124 const unsigned Opcode = X86::VXORPSrr;
125 const auto CodeTemplates = checkAndGetCodeTemplates(Opcode);
126 ASSERT_THAT(CodeTemplates, SizeIs(1));
127 const auto &CT = CodeTemplates[0];
128 EXPECT_THAT(CT.Execution, ExecutionMode::SERIAL_VIA_EXPLICIT_REGS);
129 ASSERT_THAT(CT.Instructions, SizeIs(1));
130 const InstructionTemplate &IT = CT.Instructions[0];
131 EXPECT_THAT(IT.getOpcode(), Opcode);
132 ASSERT_THAT(IT.getVariableValues(), SizeIs(3));
133 EXPECT_THAT(IT.getVariableValues(),
134 AnyOf(ElementsAre(IsReg(), IsInvalid(), IsReg()),
135 ElementsAre(IsReg(), IsReg(), IsInvalid())))
136 << "Op0 is either set to Op1 or to Op2";
137 }
138
139 TEST_F(X86SerialSnippetGeneratorTest,
140 ImplicitSelfDependencyThroughExplicitRegsForbidAll) {
141 // - VXORPSrr
142 // - Op0 Explicit Def RegClass(VR128)
143 // - Op1 Explicit Use RegClass(VR128)
144 // - Op2 Explicit Use RegClass(VR128)
145 // - Var0 [Op0]
146 // - Var1 [Op1]
147 // - Var2 [Op2]
148 // - hasAliasingRegisters
149 const unsigned Opcode = X86::VXORPSrr;
150 randomGenerator().seed(0); // Initialize seed.
151 const Instruction &Instr = State.getIC().getInstr(Opcode);
152 auto AllRegisters = State.getRATC().emptyRegisters();
153 AllRegisters.flip();
154 auto Error =
155 Generator.generateCodeTemplates(&Instr, AllRegisters).takeError();
156 EXPECT_TRUE((bool)Error);
157 consumeError(std::move(Error));
158 }
159
160 TEST_F(X86SerialSnippetGeneratorTest,
161 ImplicitSelfDependencyThroughExplicitRegsForbidAlmostAll) {
162 // - VXORPSrr
163 // - Op0 Explicit Def RegClass(VR128)
164 // - Op1 Explicit Use RegClass(VR128)
165 // - Op2 Explicit Use RegClass(VR128)
166 // - Var0 [Op0]
167 // - Var1 [Op1]
168 // - Var2 [Op2]
169 // - hasAliasingRegisters
170 const unsigned Opcode = X86::VXORPSrr;
171 randomGenerator().seed(0); // Initialize seed.
172 const Instruction &Instr = State.getIC().getInstr(Opcode);
173 auto ForbiddenRegisters = State.getRATC().emptyRegisters();
174 ForbiddenRegisters.flip();
175 ForbiddenRegisters.reset(X86::XMM0);
176 auto Error = Generator.generateCodeTemplates(&Instr, ForbiddenRegisters);
177 EXPECT_FALSE((bool)Error.takeError());
178 auto CodeTemplates = std::move(Error.get());
179 ASSERT_THAT(CodeTemplates, SizeIs(Gt(0U))) << "Templates are available";
180 for (const auto &CT : CodeTemplates) {
181 EXPECT_THAT(CT.Execution, ExecutionMode::SERIAL_VIA_EXPLICIT_REGS);
182 ASSERT_THAT(CT.Instructions, SizeIs(1));
183 const InstructionTemplate &IT = CT.Instructions[0];
184 EXPECT_THAT(IT.getOpcode(), Opcode);
185 ASSERT_THAT(IT.getVariableValues(), SizeIs(3));
186 for (const auto &Var : IT.getVariableValues()) {
187 if (Var.isReg())
188 EXPECT_FALSE(ForbiddenRegisters[Var.getReg()]);
189 }
190 }
191 }
192
193 TEST_F(X86SerialSnippetGeneratorTest, DependencyThroughOtherOpcode) {
194 // - CMP64rr
195 // - Op0 Explicit Use RegClass(GR64)
196 // - Op1 Explicit Use RegClass(GR64)
197 // - Op2 Implicit Def Reg(EFLAGS)
198 // - Var0 [Op0]
199 // - Var1 [Op1]
200 const unsigned Opcode = X86::CMP64rr;
201 const auto CodeTemplates = checkAndGetCodeTemplates(Opcode);
202 ASSERT_THAT(CodeTemplates, SizeIs(Gt(1U))) << "Many templates are available";
203 for (const auto &CT : CodeTemplates) {
204 EXPECT_THAT(CT.Execution, ExecutionMode::SERIAL_VIA_NON_MEMORY_INSTR);
205 ASSERT_THAT(CT.Instructions, SizeIs(2));
206 const InstructionTemplate &IT = CT.Instructions[0];
207 EXPECT_THAT(IT.getOpcode(), Opcode);
208 ASSERT_THAT(IT.getVariableValues(), SizeIs(2));
209 EXPECT_THAT(IT.getVariableValues(),
210 AnyOf(ElementsAre(IsReg(), IsInvalid()),
211 ElementsAre(IsInvalid(), IsReg())));
212 EXPECT_THAT(CT.Instructions[1].getOpcode(), Not(Opcode));
213 // TODO: check that the two instructions alias each other.
214 }
215 }
216
217 TEST_F(X86SerialSnippetGeneratorTest, LAHF) {
218 // - LAHF
219 // - Op0 Implicit Def Reg(AH)
220 // - Op1 Implicit Use Reg(EFLAGS)
221 const unsigned Opcode = X86::LAHF;
222 const auto CodeTemplates = checkAndGetCodeTemplates(Opcode);
223 ASSERT_THAT(CodeTemplates, SizeIs(Gt(1U))) << "Many templates are available";
224 for (const auto &CT : CodeTemplates) {
225 EXPECT_THAT(CT.Execution, ExecutionMode::SERIAL_VIA_NON_MEMORY_INSTR);
226 ASSERT_THAT(CT.Instructions, SizeIs(2));
227 const InstructionTemplate &IT = CT.Instructions[0];
228 EXPECT_THAT(IT.getOpcode(), Opcode);
229 ASSERT_THAT(IT.getVariableValues(), SizeIs(0));
230 }
231 }
232
233 TEST_F(X86SerialSnippetGeneratorTest, VCVTUSI642SDZrrb_Int) {
234 // - VCVTUSI642SDZrrb_Int
235 // - Op0 Explicit Def RegClass(VR128X)
236 // - Op1 Explicit Use RegClass(VR128X)
237 // - Op2 Explicit Use STATIC_ROUNDING
238 // - Op2 Explicit Use RegClass(GR64)
239 // - Op4 Implicit Use Reg(MXSCR)
240 const unsigned Opcode = X86::VCVTUSI642SDZrrb_Int;
241 const Instruction &Instr = State.getIC().getInstr(Opcode);
242 std::vector<BenchmarkCode> Configs;
243 auto Error = Generator.generateConfigurations(
244 &Instr, Configs, State.getRATC().emptyRegisters());
245 ASSERT_FALSE(Error);
246 ASSERT_THAT(Configs, SizeIs(1));
247 const BenchmarkCode &BC = Configs[0];
248 ASSERT_THAT(BC.Key.Instructions, SizeIs(1));
249 ASSERT_TRUE(BC.Key.Instructions[0].getOperand(3).isImm());
250 }
251
252 TEST_F(X86ParallelSnippetGeneratorTest, SerialInstruction) {
253 // - CDQ
254 // - Op0 Implicit Def Reg(EAX)
255 // - Op1 Implicit Def Reg(EDX)
256 // - Op2 Implicit Use Reg(EAX)
257 // - hasAliasingImplicitRegisters (execution is always serial)
258 // - hasAliasingRegisters
259 const unsigned Opcode = X86::CDQ;
260 const auto CodeTemplates = checkAndGetCodeTemplates(Opcode);
261 ASSERT_THAT(CodeTemplates, SizeIs(1));
262 const auto &CT = CodeTemplates[0];
263 EXPECT_THAT(CT.Info, HasSubstr("serial"));
264 EXPECT_THAT(CT.Execution, ExecutionMode::UNKNOWN);
265 ASSERT_THAT(CT.Instructions, SizeIs(1));
266 const InstructionTemplate &IT = CT.Instructions[0];
267 EXPECT_THAT(IT.getOpcode(), Opcode);
268 ASSERT_THAT(IT.getVariableValues(), SizeIs(0));
269 }
270
271 TEST_F(X86ParallelSnippetGeneratorTest, ReadAfterWrite_CMOV32rr) {
272 // CMOV32rr has tied variables, we enumerate the possible values to execute
273 // as many in parallel as possible.
274
275 // - CMOV32rr
276 // - Op0 Explicit Def RegClass(GR32)
277 // - Op1 Explicit Use RegClass(GR32) TiedToOp0
278 // - Op2 Explicit Use RegClass(GR32)
279 // - Op3 Explicit Use Immediate
280 // - Op3 Implicit Use Reg(EFLAGS)
281 // - Var0 [Op0,Op1]
282 // - Var1 [Op2]
283 // - hasTiedRegisters (execution is always serial)
284 // - hasAliasingRegisters
285 const unsigned Opcode = X86::CMOV32rr;
286 const auto CodeTemplates = checkAndGetCodeTemplates(Opcode);
287 ASSERT_THAT(CodeTemplates, SizeIs(2));
288 for (const auto &CT : CodeTemplates) {
289 EXPECT_THAT(CT.Info, HasSubstr("avoiding Read-After-Write issue"));
290 EXPECT_THAT(CT.Execution, ExecutionMode::UNKNOWN);
291 ASSERT_GT(CT.Instructions.size(), 1U);
292 std::unordered_set<unsigned> AllDefRegisters;
293 std::unordered_set<unsigned> AllUseRegisters;
294 for (const auto &IT : CT.Instructions) {
295 ASSERT_THAT(IT.getVariableValues(), SizeIs(3));
296 AllDefRegisters.insert(IT.getVariableValues()[0].getReg());
297 AllUseRegisters.insert(IT.getVariableValues()[1].getReg());
298 }
299 EXPECT_THAT(AllDefRegisters, SizeIs(CT.Instructions.size()))
300 << "Each instruction writes to a different register";
301 EXPECT_THAT(AllUseRegisters, Not(IsEmpty()))
302 << "In total, some other registers are used";
303 auto AllDefAndUseRegs = AllUseRegisters;
304 llvm::set_intersect(AllDefAndUseRegs, AllDefRegisters); // A := A ^ B
305 EXPECT_THAT(AllDefAndUseRegs, IsEmpty())
306 << "No instruction uses any register defined by any of the "
307 "instructions";
308 }
309 }
310
311 TEST_F(X86ParallelSnippetGeneratorTest, ReadAfterWrite_VFMADD132PDr) {
312 // VFMADD132PDr has tied variables, we enumerate the possible values
313 // to execute as many in parallel as possible.
314
315 // - VFMADD132PDr
316 // - Op0 Explicit Def RegClass(XMM)
317 // - Op1 Explicit Use RegClass(XMM) TiedToOp0
318 // - Op2 Explicit Use RegClass(XMM)
319 // - Op3 Explicit Use RegClass(XMM)
320 // - Var0 [Op0,Op1]
321 // - Var1 [Op2]
322 // - Var2 [Op3]
323 // - hasTiedRegisters (execution is always serial)
324 // - hasAliasingRegisters
325 const unsigned Opcode = X86::VFMADD132PDr;
326 const auto CodeTemplates = checkAndGetCodeTemplates(Opcode);
327 ASSERT_THAT(CodeTemplates, SizeIs(3));
328 for (const auto &CT : CodeTemplates) {
329 EXPECT_THAT(CT.Info, HasSubstr("avoiding Read-After-Write issue"));
330 EXPECT_THAT(CT.Execution, ExecutionMode::UNKNOWN);
331 ASSERT_GT(CT.Instructions.size(), 1U);
332 std::unordered_set<unsigned> AllDefRegisters;
333 std::unordered_set<unsigned> AllUseRegisters;
334 for (const auto &IT : CT.Instructions) {
335 ASSERT_THAT(IT.getVariableValues(), SizeIs(3));
336 AllDefRegisters.insert(IT.getVariableValues()[0].getReg());
337 AllUseRegisters.insert(IT.getVariableValues()[1].getReg());
338 AllUseRegisters.insert(IT.getVariableValues()[2].getReg());
339 }
340 EXPECT_THAT(AllDefRegisters, SizeIs(CT.Instructions.size()))
341 << "Each instruction writes to a different register";
342 EXPECT_THAT(AllUseRegisters, Not(IsEmpty()))
343 << "In total, some other registers are used";
344 auto AllDefAndUseRegs = AllUseRegisters;
345 llvm::set_intersect(AllDefAndUseRegs, AllDefRegisters); // A := A ^ B
346 EXPECT_THAT(AllDefAndUseRegs, IsEmpty())
347 << "No instruction uses any register defined by any of the "
348 "instructions";
349 }
350 }
351
352 TEST_F(X86ParallelSnippetGeneratorTest, NoTiedVariables) {
353 // CMOV_GR32 has no tied variables, we make sure def and use are different
354 // from each other.
355
356 // - CMOV_GR32
357 // - Op0 Explicit Def RegClass(GR32)
358 // - Op1 Explicit Use RegClass(GR32)
359 // - Op2 Explicit Use RegClass(GR32)
360 // - Op3 Explicit Use Immediate
361 // - Op4 Implicit Use Reg(EFLAGS)
362 // - Var0 [Op0]
363 // - Var1 [Op1]
364 // - Var2 [Op2]
365 // - Var3 [Op3]
366 // - hasAliasingRegisters
367 const unsigned Opcode = X86::CMOV_GR32;
368 const auto CodeTemplates = checkAndGetCodeTemplates(Opcode);
369 ASSERT_THAT(CodeTemplates, SizeIs(2));
370 for (const auto &CT : CodeTemplates) {
371 EXPECT_THAT(CT.Info, HasSubstr("no tied variables"));
372 EXPECT_THAT(CT.Execution, ExecutionMode::UNKNOWN);
373 ASSERT_THAT(CT.Instructions, SizeIs(1));
374 const InstructionTemplate &IT = CT.Instructions[0];
375 EXPECT_THAT(IT.getOpcode(), Opcode);
376 ASSERT_THAT(IT.getVariableValues(), SizeIs(4));
377 EXPECT_THAT(IT.getVariableValues()[0].getReg(),
378 Not(IT.getVariableValues()[1].getReg()))
379 << "Def is different from first Use";
380 EXPECT_THAT(IT.getVariableValues()[0].getReg(),
381 Not(IT.getVariableValues()[2].getReg()))
382 << "Def is different from second Use";
383 EXPECT_THAT(IT.getVariableValues()[3], IsInvalid());
384 }
385 }
386
387 TEST_F(X86ParallelSnippetGeneratorTest, MemoryUse) {
388 // Mov32rm reads from memory.
389 // - MOV32rm
390 // - Op0 Explicit Def RegClass(GR32)
391 // - Op1 Explicit Use Memory RegClass(GR8)
392 // - Op2 Explicit Use Memory
393 // - Op3 Explicit Use Memory RegClass(GRH8)
394 // - Op4 Explicit Use Memory
395 // - Op5 Explicit Use Memory RegClass(SEGMENT_REG)
396 // - Var0 [Op0]
397 // - Var1 [Op1]
398 // - Var2 [Op2]
399 // - Var3 [Op3]
400 // - Var4 [Op4]
401 // - Var5 [Op5]
402 // - hasMemoryOperands
403 // - hasAliasingRegisters
404 const unsigned Opcode = X86::MOV32rm;
405 const auto CodeTemplates = checkAndGetCodeTemplates(Opcode);
406 ASSERT_THAT(CodeTemplates, SizeIs(1));
407 for (const auto &CT : CodeTemplates) {
408 EXPECT_THAT(CT.Info, HasSubstr("no tied variables"));
409 EXPECT_THAT(CT.Execution, ExecutionMode::UNKNOWN);
410 ASSERT_THAT(CT.Instructions,
411 SizeIs(ParallelSnippetGenerator::kMinNumDifferentAddresses));
412 const InstructionTemplate &IT = CT.Instructions[0];
413 EXPECT_THAT(IT.getOpcode(), Opcode);
414 ASSERT_THAT(IT.getVariableValues(), SizeIs(6));
415 EXPECT_EQ(IT.getVariableValues()[2].getImm(), 1);
416 EXPECT_EQ(IT.getVariableValues()[3].getReg(), 0u);
417 EXPECT_EQ(IT.getVariableValues()[4].getImm(), 0);
418 EXPECT_EQ(IT.getVariableValues()[5].getReg(), 0u);
419 }
420 }
421
422 TEST_F(X86ParallelSnippetGeneratorTest, MOV16ms) {
423 const unsigned Opcode = X86::MOV16ms;
424 const Instruction &Instr = State.getIC().getInstr(Opcode);
425 std::vector<BenchmarkCode> Benchmarks;
426 auto Err = Generator.generateConfigurations(&Instr, Benchmarks,
427 State.getRATC().emptyRegisters());
428 EXPECT_TRUE((bool)Err);
429 EXPECT_THAT(toString(std::move(Err)),
430 testing::HasSubstr("no available registers"));
431 }
432
433 TEST_F(X86ParallelSnippetGeneratorTest,
434 AvoidSerializingThroughImplicitRegisters) {
435 // MULX32rr implicitly uses EDX. We should not select that register to avoid
436 // serialization.
437 const unsigned Opcode = X86::MULX32rr;
438 randomGenerator().seed(0); // Initialize seed.
439 const Instruction &Instr = State.getIC().getInstr(Opcode);
440 // Forbid all registers but RDX/EDX/DX/DH/DL. The only option would be to
441 // choose that register, but that would serialize the instruction, so we
442 // should be returning an error.
443 auto AllRegisters = State.getRATC().emptyRegisters();
444 AllRegisters.flip();
445 AllRegisters.reset(X86::RDX);
446 AllRegisters.reset(X86::EDX);
447 AllRegisters.reset(X86::DX);
448 AllRegisters.reset(X86::DH);
449 AllRegisters.reset(X86::DL);
450 auto Err = Generator.generateCodeTemplates(&Instr, AllRegisters);
451 EXPECT_FALSE((bool)Err);
452 EXPECT_THAT(toString(Err.takeError()),
453 testing::HasSubstr("Failed to produce any snippet"));
454 }
455
456 class X86FakeSnippetGenerator : public SnippetGenerator {
457 public:
458 X86FakeSnippetGenerator(const LLVMState &State, const Options &Opts)
459 : SnippetGenerator(State, Opts) {}
460
461 const Instruction &getInstr(unsigned Opcode) {
462 return State.getIC().getInstr(Opcode);
463 }
464
465 InstructionTemplate getInstructionTemplate(unsigned Opcode) {
466 return {&getInstr(Opcode)};
467 }
468
469 private:
470 Expected<std::vector<CodeTemplate>>
471 generateCodeTemplates(InstructionTemplate, const BitVector &) const override {
472 return make_error<StringError>("not implemented", inconvertibleErrorCode());
473 }
474 };
475
476 using X86FakeSnippetGeneratorTest = X86SnippetGeneratorTest<X86FakeSnippetGenerator>;
477
478 testing::Matcher<const RegisterValue &> IsRegisterValue(unsigned Reg,
479 APInt Value) {
480 return testing::AllOf(testing::Field(&RegisterValue::Register, Reg),
481 testing::Field(&RegisterValue::Value, Value));
482 }
483
484 TEST_F(X86FakeSnippetGeneratorTest, MemoryUse_Movsb) {
485 // MOVSB writes to scratch memory register.
486 // - MOVSB
487 // - Op0 Explicit Use Memory RegClass(GR8)
488 // - Op1 Explicit Use Memory RegClass(GR8)
489 // - Op2 Explicit Use Memory RegClass(SEGMENT_REG)
490 // - Op3 Implicit Def Reg(EDI)
491 // - Op4 Implicit Def Reg(ESI)
492 // - Op5 Implicit Use Reg(EDI)
493 // - Op6 Implicit Use Reg(ESI)
494 // - Op7 Implicit Use Reg(DF)
495 // - Var0 [Op0]
496 // - Var1 [Op1]
497 // - Var2 [Op2]
498 // - hasMemoryOperands
499 // - hasAliasingImplicitRegisters (execution is always serial)
500 // - hasAliasingRegisters
501 const unsigned Opcode = X86::MOVSB;
502 const Instruction &Instr = State.getIC().getInstr(Opcode);
503 std::vector<BenchmarkCode> Benchmarks;
504 auto Error = Generator.generateConfigurations(
505 &Instr, Benchmarks, State.getRATC().emptyRegisters());
506 EXPECT_TRUE((bool)Error);
507 consumeError(std::move(Error));
508 }
509
510 TEST_F(X86FakeSnippetGeneratorTest, ComputeRegisterInitialValuesAdd16ri) {
511 // ADD16ri:
512 // explicit def 0 : reg RegClass=GR16
513 // explicit use 1 : reg RegClass=GR16 | TIED_TO:0
514 // explicit use 2 : imm
515 // implicit def : EFLAGS
516 InstructionTemplate IT = Generator.getInstructionTemplate(X86::ADD16ri);
517 IT.getValueFor(IT.getInstr().Variables[0]) = MCOperand::createReg(X86::AX);
518 std::vector<InstructionTemplate> Snippet;
519 Snippet.push_back(std::move(IT));
520 const auto RIV = Generator.computeRegisterInitialValues(Snippet);
521 EXPECT_THAT(RIV, ElementsAre(IsRegisterValue(X86::AX, APInt())));
522 }
523
524 TEST_F(X86FakeSnippetGeneratorTest, ComputeRegisterInitialValuesAdd64rr) {
525 // ADD64rr:
526 // mov64ri rax, 42
527 // add64rr rax, rax, rbx
528 // -> only rbx needs defining.
529 std::vector<InstructionTemplate> Snippet;
530 {
531 InstructionTemplate Mov = Generator.getInstructionTemplate(X86::MOV64ri);
532 Mov.getValueFor(Mov.getInstr().Variables[0]) =
533 MCOperand::createReg(X86::RAX);
534 Mov.getValueFor(Mov.getInstr().Variables[1]) = MCOperand::createImm(42);
535 Snippet.push_back(std::move(Mov));
536 }
537 {
538 InstructionTemplate Add = Generator.getInstructionTemplate(X86::ADD64rr);
539 Add.getValueFor(Add.getInstr().Variables[0]) =
540 MCOperand::createReg(X86::RAX);
541 Add.getValueFor(Add.getInstr().Variables[1]) =
542 MCOperand::createReg(X86::RBX);
543 Snippet.push_back(std::move(Add));
544 }
545
546 const auto RIV = Generator.computeRegisterInitialValues(Snippet);
547 EXPECT_THAT(RIV, ElementsAre(IsRegisterValue(X86::RBX, APInt())));
548 }
549
550 } // namespace
551 } // namespace exegesis
552 } // namespace llvm