| 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 |