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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
//===-- CodeTemplate.cpp ----------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "CodeTemplate.h"
namespace llvm {
namespace exegesis {
CodeTemplate::CodeTemplate(CodeTemplate &&) = default;
CodeTemplate &CodeTemplate::operator=(CodeTemplate &&) = default;
InstructionTemplate::InstructionTemplate(const Instruction *Instr)
: Instr(Instr), VariableValues(Instr->Variables.size()) {}
InstructionTemplate::InstructionTemplate(InstructionTemplate &&) = default;
InstructionTemplate &InstructionTemplate::
operator=(InstructionTemplate &&) = default;
InstructionTemplate::InstructionTemplate(const InstructionTemplate &) = default;
InstructionTemplate &InstructionTemplate::
operator=(const InstructionTemplate &) = default;
unsigned InstructionTemplate::getOpcode() const {
return Instr->Description.getOpcode();
}
MCOperand &InstructionTemplate::getValueFor(const Variable &Var) {
return VariableValues[Var.getIndex()];
}
const MCOperand &InstructionTemplate::getValueFor(const Variable &Var) const {
return VariableValues[Var.getIndex()];
}
MCOperand &InstructionTemplate::getValueFor(const Operand &Op) {
return getValueFor(Instr->Variables[Op.getVariableIndex()]);
}
const MCOperand &InstructionTemplate::getValueFor(const Operand &Op) const {
return getValueFor(Instr->Variables[Op.getVariableIndex()]);
}
bool InstructionTemplate::hasImmediateVariables() const {
return any_of(Instr->Variables, [this](const Variable &Var) {
return Instr->getPrimaryOperand(Var).isImmediate();
});
}
MCInst InstructionTemplate::build() const {
MCInst Result;
Result.setOpcode(Instr->Description.Opcode);
for (const auto &Op : Instr->Operands)
if (Op.isExplicit())
Result.addOperand(getValueFor(Op));
return Result;
}
bool isEnumValue(ExecutionMode Execution) {
return isPowerOf2_32(static_cast<uint32_t>(Execution));
}
StringRef getName(ExecutionMode Bit) {
assert(isEnumValue(Bit) && "Bit must be a power of two");
switch (Bit) {
case ExecutionMode::UNKNOWN:
return "UNKNOWN";
case ExecutionMode::ALWAYS_SERIAL_IMPLICIT_REGS_ALIAS:
return "ALWAYS_SERIAL_IMPLICIT_REGS_ALIAS";
case ExecutionMode::ALWAYS_SERIAL_TIED_REGS_ALIAS:
return "ALWAYS_SERIAL_TIED_REGS_ALIAS";
case ExecutionMode::SERIAL_VIA_MEMORY_INSTR:
return "SERIAL_VIA_MEMORY_INSTR";
case ExecutionMode::SERIAL_VIA_EXPLICIT_REGS:
return "SERIAL_VIA_EXPLICIT_REGS";
case ExecutionMode::SERIAL_VIA_NON_MEMORY_INSTR:
return "SERIAL_VIA_NON_MEMORY_INSTR";
case ExecutionMode::ALWAYS_PARALLEL_MISSING_USE_OR_DEF:
return "ALWAYS_PARALLEL_MISSING_USE_OR_DEF";
case ExecutionMode::PARALLEL_VIA_EXPLICIT_REGS:
return "PARALLEL_VIA_EXPLICIT_REGS";
}
llvm_unreachable("Missing enum case");
}
ArrayRef<ExecutionMode> getAllExecutionBits() {
static const ExecutionMode kAllExecutionModeBits[] = {
ExecutionMode::ALWAYS_SERIAL_IMPLICIT_REGS_ALIAS,
ExecutionMode::ALWAYS_SERIAL_TIED_REGS_ALIAS,
ExecutionMode::SERIAL_VIA_MEMORY_INSTR,
ExecutionMode::SERIAL_VIA_EXPLICIT_REGS,
ExecutionMode::SERIAL_VIA_NON_MEMORY_INSTR,
ExecutionMode::ALWAYS_PARALLEL_MISSING_USE_OR_DEF,
ExecutionMode::PARALLEL_VIA_EXPLICIT_REGS,
};
return makeArrayRef(kAllExecutionModeBits);
}
SmallVector<ExecutionMode, 4> getExecutionModeBits(ExecutionMode Execution) {
SmallVector<ExecutionMode, 4> Result;
for (const auto Bit : getAllExecutionBits())
if ((Execution & Bit) == Bit)
Result.push_back(Bit);
return Result;
}
} // namespace exegesis
} // namespace llvm
|
