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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
// SPDX-License-Identifier: GPL-3.0-or-later
#include "CodeGenTarget.h"
#include "rcc/CodeGen/GenericOpcodes.h"
#include "rcc/CodeGen/LowLevelType.h"
#include <algorithm>
#include <cstdint>
#include <optional>
#include <ranges>
#include <string_view>
#include <unordered_set>
#include <utility>
namespace rcc::targetgen {
namespace {
[[nodiscard]] std::optional<std::uint32_t> genericOpcodeValue(std::string_view Symbol) {
#define RCC_CORE_OPCODE(Name) \
if (Symbol == #Name) \
return static_cast<std::uint32_t>(GenericOpcode::Name);
#define RCC_GENERIC_OPCODE(Name) RCC_CORE_OPCODE(Name)
#include "rcc/CodeGen/GenericOpcode.def"
#undef RCC_GENERIC_OPCODE
#undef RCC_CORE_OPCODE
return std::nullopt;
}
[[nodiscard]] const NormalizedInstruction *
findInstructionBySymbol(const NormalizedTargetModel &Model, std::string_view Symbol) {
const auto Position =
std::ranges::find(Model.Instructions, Symbol, &NormalizedInstruction::Symbol);
return Position == Model.Instructions.end() ? nullptr : &*Position;
}
[[nodiscard]] std::optional<std::uint32_t> resolveOpcode(const NormalizedTargetModel &Model,
std::string_view Symbol) {
if (const NormalizedInstruction *Instruction = findInstructionBySymbol(Model, Symbol))
return Instruction->ID;
return genericOpcodeValue(Symbol);
}
[[nodiscard]] bool isRegisterOperand(const NormalizedInstruction &Instruction,
std::uint32_t Index) {
return Index < Instruction.Operands.size() &&
std::ranges::contains(Instruction.Operands[Index].Kinds, "Register");
}
} // namespace
bool CodeGenTarget::normalizeSelectionRules(NormalizedTargetModel &Result) {
std::unordered_set<std::string> Symbols;
for (const SourceSelectionRule &Rule : Input.SelectionRules) {
const auto MatchOpcode = resolveOpcode(Result, Rule.MatchOpcodeSymbol);
const auto ResultOpcode = resolveOpcode(Result, Rule.ResultOpcodeSymbol);
const NormalizedInstruction *MatchInstruction =
findInstructionBySymbol(Result, Rule.MatchOpcodeSymbol);
const NormalizedInstruction *ResultInstruction =
findInstructionBySymbol(Result, Rule.ResultOpcodeSymbol);
if (!isIdentifier(Rule.Symbol) || !Symbols.insert(Rule.Symbol).second || !MatchOpcode ||
!ResultOpcode) {
fail(Rule.Range,
"selection rules require a unique identifier and declared match/result opcodes");
return false;
}
if (MatchInstruction != nullptr && !std::ranges::contains(MatchInstruction->Flags, "Generic")) {
fail(Rule.Range, "selection rule match opcode must be generic");
return false;
}
if (isGenericOpcode(Opcode::fromValue(*ResultOpcode)) ||
(ResultInstruction != nullptr &&
std::ranges::contains(ResultInstruction->Flags, "Generic"))) {
fail(Rule.Range, "selection rule result opcode must not be generic");
return false;
}
if (MatchInstruction != nullptr && ResultInstruction != nullptr &&
ResultInstruction->Operands.size() !=
MatchInstruction->Operands.size() + Rule.AppendedImmediates.size()) {
fail(Rule.Range, "selection rule result opcode has an incompatible operand count");
return false;
}
const auto NormalizeType = [this](const SourceSelectionTypePredicate &Source)
-> std::optional<NormalizedSelectionTypePredicate> {
NormalizedSelectionTypeKind Kind = NormalizedSelectionTypeKind::Any;
if (Source.Kind == "scalar")
Kind = NormalizedSelectionTypeKind::Scalar;
else if (Source.Kind == "pointer")
Kind = NormalizedSelectionTypeKind::Pointer;
else if (Source.Kind != "any") {
fail(Source.Range, "selection type kind must be 'any', 'scalar', or 'pointer'");
return std::nullopt;
}
if (Source.Bits > LowLevelType::MaxBitWidth ||
(Kind != NormalizedSelectionTypeKind::Any && Source.Bits == 0)) {
fail(Source.Range, "selection type bit width is invalid for its kind");
return std::nullopt;
}
return NormalizedSelectionTypePredicate{.Kind = Kind, .Bits = Source.Bits};
};
NormalizedSelectionRule Normalized;
Normalized.Symbol = Rule.Symbol;
Normalized.Priority = Rule.Priority;
Normalized.Specificity = 1;
Normalized.MatchOpcode = *MatchOpcode;
Normalized.ResultOpcode = *ResultOpcode;
Normalized.AppendedImmediates = Rule.AppendedImmediates;
if (Rule.ResultType) {
auto Type = NormalizeType(*Rule.ResultType);
if (!Type)
return false;
if (MatchInstruction != nullptr && !isRegisterOperand(*MatchInstruction, 0)) {
fail(Rule.ResultType->Range,
"selection result type predicate requires register operand zero");
return false;
}
Normalized.ResultType = *Type;
++Normalized.Specificity;
}
std::unordered_set<std::uint32_t> TypeOperands;
for (const SourceSelectionOperandTypePredicate &Predicate : Rule.OperandTypes) {
auto Type = NormalizeType(Predicate.Type);
if (!Type)
return false;
if (!TypeOperands.insert(Predicate.OperandIndex).second ||
(MatchInstruction != nullptr &&
!isRegisterOperand(*MatchInstruction, Predicate.OperandIndex))) {
fail(Predicate.Range,
"selection operand type predicates require distinct register operands");
return false;
}
Normalized.OperandTypes.push_back({.OperandIndex = Predicate.OperandIndex, .Type = *Type});
++Normalized.Specificity;
}
std::unordered_set<std::uint32_t> BankOperands;
for (const SourceSelectionOperandBankPredicate &Predicate : Rule.OperandBanks) {
const auto Bank = BankBySymbol.find(Predicate.BankSymbol);
if (!BankOperands.insert(Predicate.OperandIndex).second || Bank == BankBySymbol.end() ||
(MatchInstruction != nullptr &&
!isRegisterOperand(*MatchInstruction, Predicate.OperandIndex))) {
fail(Predicate.Range,
"selection operand bank predicates require distinct register operands and declared "
"banks");
return false;
}
Normalized.OperandBanks.push_back(
{.OperandIndex = Predicate.OperandIndex, .Bank = Bank->second});
++Normalized.Specificity;
}
std::unordered_set<std::uint32_t> ClassOperands;
for (const SourceSelectionOperandClassPredicate &Predicate : Rule.OperandClasses) {
const auto RegClass = ClassBySymbol.find(Predicate.ClassSymbol);
if (!ClassOperands.insert(Predicate.OperandIndex).second || RegClass == ClassBySymbol.end() ||
(MatchInstruction != nullptr &&
!isRegisterOperand(*MatchInstruction, Predicate.OperandIndex))) {
fail(Predicate.Range,
"selection operand class predicates require distinct register operands and declared "
"classes");
return false;
}
Normalized.OperandClasses.push_back(
{.OperandIndex = Predicate.OperandIndex, .RegClass = RegClass->second});
++Normalized.Specificity;
}
Result.SelectionRules.push_back(std::move(Normalized));
}
std::ranges::sort(Result.SelectionRules,
[](const NormalizedSelectionRule &Left, const NormalizedSelectionRule &Right) {
if (Left.Priority != Right.Priority)
return Left.Priority > Right.Priority;
if (Left.Specificity != Right.Specificity)
return Left.Specificity > Right.Specificity;
return Left.Symbol < Right.Symbol;
});
return true;
}
} // namespace rcc::targetgen
|
