MLIR  21.0.0git
VariantValue.cpp
Go to the documentation of this file.
1 //===--- Variantvalue.cpp -------------------------------------------------===//
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 //
10 //===----------------------------------------------------------------------===//
11 
13 
14 namespace mlir::query::matcher {
15 
16 VariantMatcher::Payload::~Payload() = default;
17 
18 class VariantMatcher::SinglePayload : public VariantMatcher::Payload {
19 public:
20  explicit SinglePayload(DynMatcher matcher) : matcher(std::move(matcher)) {}
21 
22  std::optional<DynMatcher> getDynMatcher() const override { return matcher; }
23 
24  std::string getTypeAsString() const override { return "Matcher"; }
25 
26 private:
27  DynMatcher matcher;
28 };
29 
30 class VariantMatcher::VariadicOpPayload : public VariantMatcher::Payload {
31 public:
33  std::vector<VariantMatcher> args)
34  : varOp(varOp), args(std::move(args)) {}
35 
36  std::optional<DynMatcher> getDynMatcher() const override {
37  std::vector<DynMatcher> dynMatchers;
38  for (auto variantMatcher : args) {
39  std::optional<DynMatcher> dynMatcher = variantMatcher.getDynMatcher();
40  if (dynMatcher)
41  dynMatchers.push_back(dynMatcher.value());
42  }
43  auto result = DynMatcher::constructVariadic(varOp, dynMatchers);
44  return *result;
45  }
46 
47  std::string getTypeAsString() const override {
48  std::string inner;
49  llvm::interleave(
50  args, [&](auto const &arg) { inner += arg.getTypeAsString(); },
51  [&] { inner += " & "; });
52  return inner;
53  }
54 
55 private:
56  const DynMatcher::VariadicOperator varOp;
57  const std::vector<VariantMatcher> args;
58 };
59 
61 
63  return VariantMatcher(std::make_shared<SinglePayload>(std::move(matcher)));
64 }
65 
69  return VariantMatcher(
70  std::make_shared<VariadicOpPayload>(varOp, std::move(args)));
71 }
72 
73 std::optional<DynMatcher> VariantMatcher::MatcherOps::constructVariadicOperator(
75  ArrayRef<VariantMatcher> innerMatchers) const {
76  std::vector<DynMatcher> dynMatchers;
77  for (const auto &innerMatcher : innerMatchers) {
78  if (!innerMatcher.value)
79  return std::nullopt;
80  std::optional<DynMatcher> inner = innerMatcher.value->getDynMatcher();
81  if (!inner)
82  return std::nullopt;
83  dynMatchers.push_back(*inner);
84  }
85  return *DynMatcher::constructVariadic(varOp, dynMatchers);
86 }
87 
88 std::optional<DynMatcher> VariantMatcher::getDynMatcher() const {
89  return value ? value->getDynMatcher() : std::nullopt;
90 }
91 
92 void VariantMatcher::reset() { value.reset(); }
93 
94 std::string VariantMatcher::getTypeAsString() const { return "<Nothing>"; }
95 
97  : type(ValueType::Nothing) {
98  *this = other;
99 }
100 
101 VariantValue::VariantValue(const llvm::StringRef string)
102  : type(ValueType::String) {
103  value.String = new llvm::StringRef(string);
104 }
105 
107  : type(ValueType::Matcher) {
108  value.Matcher = new VariantMatcher(matcher);
109 }
110 
111 VariantValue::VariantValue(int64_t signedValue) : type(ValueType::Signed) {
112  value.Signed = signedValue;
113 }
114 
115 VariantValue::VariantValue(bool setBoolean) : type(ValueType::Boolean) {
116  value.Boolean = setBoolean;
117 }
118 
120 
122  if (this == &other)
123  return *this;
124  reset();
125  switch (other.type) {
126  case ValueType::String:
127  setString(other.getString());
128  break;
129  case ValueType::Matcher:
130  setMatcher(other.getMatcher());
131  break;
132  case ValueType::Signed:
133  setSigned(other.getSigned());
134  break;
135  case ValueType::Boolean:
136  setBoolean(other.getBoolean());
137  break;
138  case ValueType::Nothing:
139  type = ValueType::Nothing;
140  break;
141  }
142  return *this;
143 }
144 
145 void VariantValue::reset() {
146  switch (type) {
147  case ValueType::String:
148  delete value.String;
149  break;
150  case ValueType::Matcher:
151  delete value.Matcher;
152  break;
153  // Cases that do nothing.
154  case ValueType::Signed:
155  case ValueType::Boolean:
156  case ValueType::Nothing:
157  break;
158  }
159  type = ValueType::Nothing;
160 }
161 
162 // Signed
163 bool VariantValue::isSigned() const { return type == ValueType::Signed; }
164 
165 int64_t VariantValue::getSigned() const { return value.Signed; }
166 
167 void VariantValue::setSigned(int64_t newValue) {
168  type = ValueType::Signed;
169  value.Signed = newValue;
170 }
171 
172 // Boolean
173 bool VariantValue::isBoolean() const { return type == ValueType::Boolean; }
174 
175 bool VariantValue::getBoolean() const { return value.Boolean; }
176 
177 void VariantValue::setBoolean(bool newValue) {
178  type = ValueType::Boolean;
179  value.Boolean = newValue;
180 }
181 
182 bool VariantValue::isString() const { return type == ValueType::String; }
183 
184 const llvm::StringRef &VariantValue::getString() const {
185  assert(isString());
186  return *value.String;
187 }
188 
189 void VariantValue::setString(const llvm::StringRef &newValue) {
190  reset();
191  type = ValueType::String;
192  value.String = new llvm::StringRef(newValue);
193 }
194 
195 bool VariantValue::isMatcher() const { return type == ValueType::Matcher; }
196 
198  assert(isMatcher());
199  return *value.Matcher;
200 }
201 
203  reset();
204  type = ValueType::Matcher;
205  value.Matcher = new VariantMatcher(newValue);
206 }
207 
208 std::string VariantValue::getTypeAsString() const {
209  switch (type) {
210  case ValueType::String:
211  return "String";
212  case ValueType::Matcher:
213  return "Matcher";
214  case ValueType::Signed:
215  return "Signed";
216  case ValueType::Boolean:
217  return "Boolean";
218  case ValueType::Nothing:
219  return "Nothing";
220  }
221  llvm_unreachable("Invalid Type");
222 }
223 
224 } // namespace mlir::query::matcher
static std::unique_ptr< DynMatcher > constructVariadic(VariadicOperator Op, std::vector< DynMatcher > innerMatchers)
std::optional< DynMatcher > getDynMatcher() const override
VariadicOpPayload(DynMatcher::VariadicOperator varOp, std::vector< VariantMatcher > args)
std::optional< DynMatcher > getDynMatcher() const override
static VariantMatcher SingleMatcher(DynMatcher matcher)
std::optional< DynMatcher > getDynMatcher() const
static VariantMatcher VariadicOperatorMatcher(DynMatcher::VariadicOperator varOp, ArrayRef< VariantMatcher > args)
VariantValue & operator=(const VariantValue &other)
const VariantMatcher & getMatcher() const
void setMatcher(const VariantMatcher &matcher)
const llvm::StringRef & getString() const
void setSigned(int64_t signedValue)
void setString(const llvm::StringRef &string)
void setBoolean(bool booleanValue)
Computes the backward-slice of all transitive defs reachable from rootOp, if innerMatcher matches.
Definition: ErrorBuilder.h:20
@ String
A string value.