| 1 | //===- Builders.cpp - Helpers for constructing MLIR Classes ---------------===// |
| 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 "mlir/IR/Builders.h" |
| 10 | #include "mlir/IR/AffineExpr.h" |
| 11 | #include "mlir/IR/AffineMap.h" |
| 12 | #include "mlir/IR/BuiltinTypes.h" |
| 13 | #include "mlir/IR/Dialect.h" |
| 14 | #include "mlir/IR/IRMapping.h" |
| 15 | #include "mlir/IR/Matchers.h" |
| 16 | #include "llvm/ADT/SmallVectorExtras.h" |
| 17 | #include "llvm/Support/DebugLog.h" |
| 18 | |
| 19 | using namespace mlir; |
| 20 | |
| 21 | //===----------------------------------------------------------------------===// |
| 22 | // Locations. |
| 23 | //===----------------------------------------------------------------------===// |
| 24 | |
| 25 | Location Builder::getUnknownLoc() { return UnknownLoc::get(context); } |
| 26 | |
| 27 | Location Builder::getFusedLoc(ArrayRef<Location> locs, Attribute metadata) { |
| 28 | return FusedLoc::get(locs, metadata, context); |
| 29 | } |
| 30 | |
| 31 | //===----------------------------------------------------------------------===// |
| 32 | // Types. |
| 33 | //===----------------------------------------------------------------------===// |
| 34 | |
| 35 | FloatType Builder::getF8E8M0Type() { return Float8E8M0FNUType::get(ctx: context); } |
| 36 | |
| 37 | FloatType Builder::getF8E5M3FNUType() { |
| 38 | return Float8E5M3FNUType::get(ctx: context); |
| 39 | } |
| 40 | |
| 41 | FloatType Builder::getF8E4M3FNType() { return Float8E4M3FNType::get(ctx: context); } |
| 42 | |
| 43 | FloatType Builder::getF8E5M2Type() { return Float8E5M2Type::get(ctx: context); } |
| 44 | |
| 45 | FloatType Builder::getBF16Type() { return BFloat16Type::get(context); } |
| 46 | |
| 47 | FloatType Builder::getF16Type() { return Float16Type::get(context); } |
| 48 | |
| 49 | FloatType Builder::getTF32Type() { return FloatTF32Type::get(context); } |
| 50 | |
| 51 | FloatType Builder::getF32Type() { return Float32Type::get(context); } |
| 52 | |
| 53 | FloatType Builder::getF64Type() { return Float64Type::get(context); } |
| 54 | |
| 55 | FloatType Builder::getF80Type() { return Float80Type::get(context); } |
| 56 | |
| 57 | FloatType Builder::getF128Type() { return Float128Type::get(context); } |
| 58 | |
| 59 | IndexType Builder::getIndexType() { return IndexType::get(context); } |
| 60 | |
| 61 | IntegerType Builder::getI1Type() { return IntegerType::get(context, width: 1); } |
| 62 | |
| 63 | IntegerType Builder::getI2Type() { return IntegerType::get(context, width: 2); } |
| 64 | |
| 65 | IntegerType Builder::getI4Type() { return IntegerType::get(context, width: 4); } |
| 66 | |
| 67 | IntegerType Builder::getI8Type() { return IntegerType::get(context, width: 8); } |
| 68 | |
| 69 | IntegerType Builder::getI16Type() { return IntegerType::get(context, width: 16); } |
| 70 | |
| 71 | IntegerType Builder::getI32Type() { return IntegerType::get(context, width: 32); } |
| 72 | |
| 73 | IntegerType Builder::getI64Type() { return IntegerType::get(context, width: 64); } |
| 74 | |
| 75 | IntegerType Builder::getIntegerType(unsigned width) { |
| 76 | return IntegerType::get(context, width); |
| 77 | } |
| 78 | |
| 79 | IntegerType Builder::getIntegerType(unsigned width, bool isSigned) { |
| 80 | return IntegerType::get( |
| 81 | context, width, signedness: isSigned ? IntegerType::Signed : IntegerType::Unsigned); |
| 82 | } |
| 83 | |
| 84 | FunctionType Builder::getFunctionType(TypeRange inputs, TypeRange results) { |
| 85 | return FunctionType::get(context, inputs, results); |
| 86 | } |
| 87 | |
| 88 | GraphType Builder::getGraphType(TypeRange inputs, TypeRange results) { |
| 89 | return GraphType::get(context, inputs, results); |
| 90 | } |
| 91 | |
| 92 | TupleType Builder::getTupleType(TypeRange elementTypes) { |
| 93 | return TupleType::get(context, elementTypes); |
| 94 | } |
| 95 | |
| 96 | NoneType Builder::getNoneType() { return NoneType::get(context); } |
| 97 | |
| 98 | //===----------------------------------------------------------------------===// |
| 99 | // Attributes. |
| 100 | //===----------------------------------------------------------------------===// |
| 101 | |
| 102 | NamedAttribute Builder::getNamedAttr(StringRef name, Attribute val) { |
| 103 | return NamedAttribute(name, val); |
| 104 | } |
| 105 | |
| 106 | UnitAttr Builder::getUnitAttr() { return UnitAttr::get(context); } |
| 107 | |
| 108 | BoolAttr Builder::getBoolAttr(bool value) { |
| 109 | return BoolAttr::get(context, value); |
| 110 | } |
| 111 | |
| 112 | DictionaryAttr Builder::getDictionaryAttr(ArrayRef<NamedAttribute> value) { |
| 113 | return DictionaryAttr::get(context, value); |
| 114 | } |
| 115 | |
| 116 | IntegerAttr Builder::getIndexAttr(int64_t value) { |
| 117 | return IntegerAttr::get(type: getIndexType(), value: APInt(64, value)); |
| 118 | } |
| 119 | |
| 120 | IntegerAttr Builder::getI64IntegerAttr(int64_t value) { |
| 121 | return IntegerAttr::get(type: getIntegerType(width: 64), value: APInt(64, value)); |
| 122 | } |
| 123 | |
| 124 | DenseIntElementsAttr Builder::getBoolVectorAttr(ArrayRef<bool> values) { |
| 125 | return DenseIntElementsAttr::get( |
| 126 | type: VectorType::get(shape: static_cast<int64_t>(values.size()), elementType: getI1Type()), |
| 127 | arg&: values); |
| 128 | } |
| 129 | |
| 130 | DenseIntElementsAttr Builder::getI32VectorAttr(ArrayRef<int32_t> values) { |
| 131 | return DenseIntElementsAttr::get( |
| 132 | type: VectorType::get(shape: static_cast<int64_t>(values.size()), elementType: getIntegerType(width: 32)), |
| 133 | arg&: values); |
| 134 | } |
| 135 | |
| 136 | DenseIntElementsAttr Builder::getI64VectorAttr(ArrayRef<int64_t> values) { |
| 137 | return DenseIntElementsAttr::get( |
| 138 | type: VectorType::get(shape: static_cast<int64_t>(values.size()), elementType: getIntegerType(width: 64)), |
| 139 | arg&: values); |
| 140 | } |
| 141 | |
| 142 | DenseIntElementsAttr Builder::getIndexVectorAttr(ArrayRef<int64_t> values) { |
| 143 | return DenseIntElementsAttr::get( |
| 144 | type: VectorType::get(shape: static_cast<int64_t>(values.size()), elementType: getIndexType()), |
| 145 | arg&: values); |
| 146 | } |
| 147 | |
| 148 | DenseFPElementsAttr Builder::getF32VectorAttr(ArrayRef<float> values) { |
| 149 | return DenseFPElementsAttr::get( |
| 150 | type: VectorType::get(shape: static_cast<float>(values.size()), elementType: getF32Type()), arg&: values); |
| 151 | } |
| 152 | |
| 153 | DenseFPElementsAttr Builder::getF64VectorAttr(ArrayRef<double> values) { |
| 154 | return DenseFPElementsAttr::get( |
| 155 | type: VectorType::get(shape: static_cast<double>(values.size()), elementType: getF64Type()), |
| 156 | arg&: values); |
| 157 | } |
| 158 | |
| 159 | DenseBoolArrayAttr Builder::getDenseBoolArrayAttr(ArrayRef<bool> values) { |
| 160 | return DenseBoolArrayAttr::get(context, content: values); |
| 161 | } |
| 162 | |
| 163 | DenseI8ArrayAttr Builder::getDenseI8ArrayAttr(ArrayRef<int8_t> values) { |
| 164 | return DenseI8ArrayAttr::get(context, content: values); |
| 165 | } |
| 166 | |
| 167 | DenseI16ArrayAttr Builder::getDenseI16ArrayAttr(ArrayRef<int16_t> values) { |
| 168 | return DenseI16ArrayAttr::get(context, content: values); |
| 169 | } |
| 170 | |
| 171 | DenseI32ArrayAttr Builder::getDenseI32ArrayAttr(ArrayRef<int32_t> values) { |
| 172 | return DenseI32ArrayAttr::get(context, content: values); |
| 173 | } |
| 174 | |
| 175 | DenseI64ArrayAttr Builder::getDenseI64ArrayAttr(ArrayRef<int64_t> values) { |
| 176 | return DenseI64ArrayAttr::get(context, content: values); |
| 177 | } |
| 178 | |
| 179 | DenseF32ArrayAttr Builder::getDenseF32ArrayAttr(ArrayRef<float> values) { |
| 180 | return DenseF32ArrayAttr::get(context, content: values); |
| 181 | } |
| 182 | |
| 183 | DenseF64ArrayAttr Builder::getDenseF64ArrayAttr(ArrayRef<double> values) { |
| 184 | return DenseF64ArrayAttr::get(context, content: values); |
| 185 | } |
| 186 | |
| 187 | DenseIntElementsAttr Builder::getI32TensorAttr(ArrayRef<int32_t> values) { |
| 188 | return DenseIntElementsAttr::get( |
| 189 | type: RankedTensorType::get(shape: static_cast<int64_t>(values.size()), |
| 190 | elementType: getIntegerType(width: 32)), |
| 191 | arg&: values); |
| 192 | } |
| 193 | |
| 194 | DenseIntElementsAttr Builder::getI64TensorAttr(ArrayRef<int64_t> values) { |
| 195 | return DenseIntElementsAttr::get( |
| 196 | type: RankedTensorType::get(shape: static_cast<int64_t>(values.size()), |
| 197 | elementType: getIntegerType(width: 64)), |
| 198 | arg&: values); |
| 199 | } |
| 200 | |
| 201 | DenseIntElementsAttr Builder::getIndexTensorAttr(ArrayRef<int64_t> values) { |
| 202 | return DenseIntElementsAttr::get( |
| 203 | type: RankedTensorType::get(shape: static_cast<int64_t>(values.size()), |
| 204 | elementType: getIndexType()), |
| 205 | arg&: values); |
| 206 | } |
| 207 | |
| 208 | IntegerAttr Builder::getI32IntegerAttr(int32_t value) { |
| 209 | // The APInt always uses isSigned=true here because we accept the value |
| 210 | // as int32_t. |
| 211 | return IntegerAttr::get(type: getIntegerType(width: 32), |
| 212 | value: APInt(32, value, /*isSigned=*/true)); |
| 213 | } |
| 214 | |
| 215 | IntegerAttr Builder::getSI32IntegerAttr(int32_t value) { |
| 216 | return IntegerAttr::get(type: getIntegerType(width: 32, /*isSigned=*/true), |
| 217 | value: APInt(32, value, /*isSigned=*/true)); |
| 218 | } |
| 219 | |
| 220 | IntegerAttr Builder::getUI32IntegerAttr(uint32_t value) { |
| 221 | return IntegerAttr::get(type: getIntegerType(width: 32, /*isSigned=*/false), |
| 222 | value: APInt(32, (uint64_t)value, /*isSigned=*/false)); |
| 223 | } |
| 224 | |
| 225 | IntegerAttr Builder::getI16IntegerAttr(int16_t value) { |
| 226 | return IntegerAttr::get(type: getIntegerType(width: 16), |
| 227 | value: APInt(16, value, /*isSigned=*/true)); |
| 228 | } |
| 229 | |
| 230 | IntegerAttr Builder::getI8IntegerAttr(int8_t value) { |
| 231 | // The APInt always uses isSigned=true here because we accept the value |
| 232 | // as int8_t. |
| 233 | return IntegerAttr::get(type: getIntegerType(width: 8), |
| 234 | value: APInt(8, value, /*isSigned=*/true)); |
| 235 | } |
| 236 | |
| 237 | IntegerAttr Builder::getIntegerAttr(Type type, int64_t value) { |
| 238 | if (type.isIndex()) |
| 239 | return IntegerAttr::get(type, value: APInt(64, value)); |
| 240 | // TODO: Avoid implicit trunc? |
| 241 | // See https://github.com/llvm/llvm-project/issues/112510. |
| 242 | return IntegerAttr::get(type, value: APInt(type.getIntOrFloatBitWidth(), value, |
| 243 | type.isSignedInteger(), |
| 244 | /*implicitTrunc=*/true)); |
| 245 | } |
| 246 | |
| 247 | IntegerAttr Builder::getIntegerAttr(Type type, const APInt &value) { |
| 248 | return IntegerAttr::get(type, value); |
| 249 | } |
| 250 | |
| 251 | FloatAttr Builder::getF64FloatAttr(double value) { |
| 252 | return FloatAttr::get(type: getF64Type(), value: APFloat(value)); |
| 253 | } |
| 254 | |
| 255 | FloatAttr Builder::getF32FloatAttr(float value) { |
| 256 | return FloatAttr::get(type: getF32Type(), value: APFloat(value)); |
| 257 | } |
| 258 | |
| 259 | FloatAttr Builder::getF16FloatAttr(float value) { |
| 260 | return FloatAttr::get(type: getF16Type(), value); |
| 261 | } |
| 262 | |
| 263 | FloatAttr Builder::getFloatAttr(Type type, double value) { |
| 264 | return FloatAttr::get(type, value); |
| 265 | } |
| 266 | |
| 267 | FloatAttr Builder::getFloatAttr(Type type, const APFloat &value) { |
| 268 | return FloatAttr::get(type, value); |
| 269 | } |
| 270 | |
| 271 | StringAttr Builder::getStringAttr(const Twine &bytes) { |
| 272 | return StringAttr::get(context, bytes); |
| 273 | } |
| 274 | |
| 275 | ArrayAttr Builder::getArrayAttr(ArrayRef<Attribute> value) { |
| 276 | return ArrayAttr::get(context, value); |
| 277 | } |
| 278 | |
| 279 | ArrayAttr Builder::getBoolArrayAttr(ArrayRef<bool> values) { |
| 280 | auto attrs = llvm::map_to_vector<8>( |
| 281 | C&: values, F: [this](bool v) -> Attribute { return getBoolAttr(value: v); }); |
| 282 | return getArrayAttr(value: attrs); |
| 283 | } |
| 284 | |
| 285 | ArrayAttr Builder::getI32ArrayAttr(ArrayRef<int32_t> values) { |
| 286 | auto attrs = llvm::map_to_vector<8>( |
| 287 | C&: values, F: [this](int32_t v) -> Attribute { return getI32IntegerAttr(value: v); }); |
| 288 | return getArrayAttr(value: attrs); |
| 289 | } |
| 290 | ArrayAttr Builder::getI64ArrayAttr(ArrayRef<int64_t> values) { |
| 291 | auto attrs = llvm::map_to_vector<8>( |
| 292 | C&: values, F: [this](int64_t v) -> Attribute { return getI64IntegerAttr(value: v); }); |
| 293 | return getArrayAttr(value: attrs); |
| 294 | } |
| 295 | |
| 296 | ArrayAttr Builder::getIndexArrayAttr(ArrayRef<int64_t> values) { |
| 297 | auto attrs = llvm::map_to_vector<8>(C&: values, F: [this](int64_t v) -> Attribute { |
| 298 | return getIntegerAttr(type: IndexType::get(context: getContext()), value: v); |
| 299 | }); |
| 300 | return getArrayAttr(value: attrs); |
| 301 | } |
| 302 | |
| 303 | ArrayAttr Builder::getF32ArrayAttr(ArrayRef<float> values) { |
| 304 | auto attrs = llvm::map_to_vector<8>( |
| 305 | C&: values, F: [this](float v) -> Attribute { return getF32FloatAttr(value: v); }); |
| 306 | return getArrayAttr(value: attrs); |
| 307 | } |
| 308 | |
| 309 | ArrayAttr Builder::getF64ArrayAttr(ArrayRef<double> values) { |
| 310 | auto attrs = llvm::map_to_vector<8>( |
| 311 | C&: values, F: [this](double v) -> Attribute { return getF64FloatAttr(value: v); }); |
| 312 | return getArrayAttr(value: attrs); |
| 313 | } |
| 314 | |
| 315 | ArrayAttr Builder::getStrArrayAttr(ArrayRef<StringRef> values) { |
| 316 | auto attrs = llvm::map_to_vector<8>( |
| 317 | C&: values, F: [this](StringRef v) -> Attribute { return getStringAttr(bytes: v); }); |
| 318 | return getArrayAttr(value: attrs); |
| 319 | } |
| 320 | |
| 321 | ArrayAttr Builder::getTypeArrayAttr(TypeRange values) { |
| 322 | auto attrs = llvm::map_to_vector<8>( |
| 323 | C&: values, F: [](Type v) -> Attribute { return TypeAttr::get(type: v); }); |
| 324 | return getArrayAttr(value: attrs); |
| 325 | } |
| 326 | |
| 327 | ArrayAttr Builder::getAffineMapArrayAttr(ArrayRef<AffineMap> values) { |
| 328 | auto attrs = llvm::map_to_vector<8>( |
| 329 | C&: values, F: [](AffineMap v) -> Attribute { return AffineMapAttr::get(value: v); }); |
| 330 | return getArrayAttr(value: attrs); |
| 331 | } |
| 332 | |
| 333 | TypedAttr Builder::getZeroAttr(Type type) { |
| 334 | if (llvm::isa<FloatType>(Val: type)) |
| 335 | return getFloatAttr(type, value: 0.0); |
| 336 | if (llvm::isa<IndexType>(Val: type)) |
| 337 | return getIndexAttr(value: 0); |
| 338 | if (llvm::dyn_cast<IntegerType>(Val&: type)) |
| 339 | return getIntegerAttr(type, |
| 340 | value: APInt(llvm::cast<IntegerType>(Val&: type).getWidth(), 0)); |
| 341 | if (llvm::isa<RankedTensorType, VectorType>(Val: type)) { |
| 342 | auto vtType = llvm::cast<ShapedType>(Val&: type); |
| 343 | auto element = getZeroAttr(type: vtType.getElementType()); |
| 344 | if (!element || !isa<DenseElementType>(Val: vtType.getElementType())) |
| 345 | return {}; |
| 346 | return DenseElementsAttr::get(type: vtType, values: element); |
| 347 | } |
| 348 | return {}; |
| 349 | } |
| 350 | |
| 351 | TypedAttr Builder::getOneAttr(Type type) { |
| 352 | if (llvm::isa<FloatType>(Val: type)) |
| 353 | return getFloatAttr(type, value: 1.0); |
| 354 | if (llvm::isa<IndexType>(Val: type)) |
| 355 | return getIndexAttr(value: 1); |
| 356 | if (llvm::dyn_cast<IntegerType>(Val&: type)) |
| 357 | return getIntegerAttr(type, |
| 358 | value: APInt(llvm::cast<IntegerType>(Val&: type).getWidth(), 1)); |
| 359 | if (llvm::isa<RankedTensorType, VectorType>(Val: type)) { |
| 360 | auto vtType = llvm::cast<ShapedType>(Val&: type); |
| 361 | auto element = getOneAttr(type: vtType.getElementType()); |
| 362 | if (!element || !isa<DenseElementType>(Val: vtType.getElementType())) |
| 363 | return {}; |
| 364 | return DenseElementsAttr::get(type: vtType, values: element); |
| 365 | } |
| 366 | return {}; |
| 367 | } |
| 368 | |
| 369 | //===----------------------------------------------------------------------===// |
| 370 | // Affine Expressions, Affine Maps, and Integer Sets. |
| 371 | //===----------------------------------------------------------------------===// |
| 372 | |
| 373 | AffineExpr Builder::getAffineDimExpr(unsigned position) { |
| 374 | return mlir::getAffineDimExpr(position, context); |
| 375 | } |
| 376 | |
| 377 | AffineExpr Builder::getAffineSymbolExpr(unsigned position) { |
| 378 | return mlir::getAffineSymbolExpr(position, context); |
| 379 | } |
| 380 | |
| 381 | AffineExpr Builder::getAffineConstantExpr(int64_t constant) { |
| 382 | return mlir::getAffineConstantExpr(constant, context); |
| 383 | } |
| 384 | |
| 385 | AffineMap Builder::getEmptyAffineMap() { return AffineMap::get(context); } |
| 386 | |
| 387 | AffineMap Builder::getConstantAffineMap(int64_t val) { |
| 388 | return AffineMap::get(/*dimCount=*/0, /*symbolCount=*/0, |
| 389 | result: getAffineConstantExpr(constant: val)); |
| 390 | } |
| 391 | |
| 392 | AffineMap Builder::getDimIdentityMap() { |
| 393 | return AffineMap::get(/*dimCount=*/1, /*symbolCount=*/0, result: getAffineDimExpr(position: 0)); |
| 394 | } |
| 395 | |
| 396 | AffineMap Builder::getMultiDimIdentityMap(unsigned rank) { |
| 397 | SmallVector<AffineExpr, 4> dimExprs; |
| 398 | dimExprs.reserve(N: rank); |
| 399 | for (unsigned i = 0; i < rank; ++i) |
| 400 | dimExprs.push_back(Elt: getAffineDimExpr(position: i)); |
| 401 | return AffineMap::get(/*dimCount=*/rank, /*symbolCount=*/0, results: dimExprs, |
| 402 | context); |
| 403 | } |
| 404 | |
| 405 | AffineMap Builder::getSymbolIdentityMap() { |
| 406 | return AffineMap::get(/*dimCount=*/0, /*symbolCount=*/1, |
| 407 | result: getAffineSymbolExpr(position: 0)); |
| 408 | } |
| 409 | |
| 410 | AffineMap Builder::getSingleDimShiftAffineMap(int64_t shift) { |
| 411 | // expr = d0 + shift. |
| 412 | auto expr = getAffineDimExpr(position: 0) + shift; |
| 413 | return AffineMap::get(/*dimCount=*/1, /*symbolCount=*/0, result: expr); |
| 414 | } |
| 415 | |
| 416 | AffineMap Builder::getShiftedAffineMap(AffineMap map, int64_t shift) { |
| 417 | SmallVector<AffineExpr, 4> shiftedResults; |
| 418 | shiftedResults.reserve(N: map.getNumResults()); |
| 419 | for (auto resultExpr : map.getResults()) |
| 420 | shiftedResults.push_back(Elt: resultExpr + shift); |
| 421 | return AffineMap::get(dimCount: map.getNumDims(), symbolCount: map.getNumSymbols(), results: shiftedResults, |
| 422 | context); |
| 423 | } |
| 424 | |
| 425 | //===----------------------------------------------------------------------===// |
| 426 | // OpBuilder |
| 427 | //===----------------------------------------------------------------------===// |
| 428 | |
| 429 | /// Insert the given operation at the current insertion point and return it. |
| 430 | Operation *OpBuilder::insert(Operation *op) { |
| 431 | if (block) { |
| 432 | block->getOperations().insert(where: insertPoint, New: op); |
| 433 | if (listener) |
| 434 | listener->notifyOperationInserted(op, /*previous=*/{}); |
| 435 | } |
| 436 | return op; |
| 437 | } |
| 438 | |
| 439 | Block *OpBuilder::createBlock(Region *parent, Region::iterator insertPt, |
| 440 | TypeRange argTypes, ArrayRef<Location> locs) { |
| 441 | assert(parent && "expected valid parent region" ); |
| 442 | assert(argTypes.size() == locs.size() && "argument location mismatch" ); |
| 443 | if (insertPt == Region::iterator()) |
| 444 | insertPt = parent->end(); |
| 445 | |
| 446 | Block *b = new Block(); |
| 447 | b->addArguments(types: argTypes, locs); |
| 448 | parent->getBlocks().insert(where: insertPt, New: b); |
| 449 | setInsertionPointToEnd(b); |
| 450 | |
| 451 | if (listener) |
| 452 | listener->notifyBlockInserted(block: b, /*previous=*/nullptr, /*previousIt=*/{}); |
| 453 | return b; |
| 454 | } |
| 455 | |
| 456 | /// Add new block with 'argTypes' arguments and set the insertion point to the |
| 457 | /// end of it. The block is placed before 'insertBefore'. |
| 458 | Block *OpBuilder::createBlock(Block *insertBefore, TypeRange argTypes, |
| 459 | ArrayRef<Location> locs) { |
| 460 | assert(insertBefore && "expected valid insertion block" ); |
| 461 | return createBlock(parent: insertBefore->getParent(), insertPt: Region::iterator(insertBefore), |
| 462 | argTypes, locs); |
| 463 | } |
| 464 | |
| 465 | /// Create an operation given the fields represented as an OperationState. |
| 466 | Operation *OpBuilder::create(const OperationState &state) { |
| 467 | return insert(op: Operation::create(state)); |
| 468 | } |
| 469 | |
| 470 | /// Creates an operation with the given fields. |
| 471 | Operation *OpBuilder::create(Location loc, StringAttr opName, |
| 472 | ValueRange operands, TypeRange types, |
| 473 | ArrayRef<NamedAttribute> attributes, |
| 474 | BlockRange successors, |
| 475 | MutableArrayRef<std::unique_ptr<Region>> regions) { |
| 476 | OperationState state(loc, opName, operands, types, attributes, successors, |
| 477 | regions); |
| 478 | return create(state); |
| 479 | } |
| 480 | |
| 481 | LogicalResult |
| 482 | OpBuilder::tryFold(Operation *op, SmallVectorImpl<Value> &results, |
| 483 | SmallVectorImpl<Operation *> *materializedConstants) { |
| 484 | assert(results.empty() && "expected empty results" ); |
| 485 | ResultRange opResults = op->getResults(); |
| 486 | |
| 487 | results.reserve(N: opResults.size()); |
| 488 | auto cleanupFailure = [&] { |
| 489 | results.clear(); |
| 490 | return failure(); |
| 491 | }; |
| 492 | |
| 493 | // If this operation is already a constant, there is nothing to do. |
| 494 | if (matchPattern(op, pattern: m_Constant())) |
| 495 | return cleanupFailure(); |
| 496 | |
| 497 | // Try to fold the operation. |
| 498 | SmallVector<OpFoldResult, 4> foldResults; |
| 499 | LDBG() << "Trying to fold: " |
| 500 | << OpWithFlags(op, OpPrintingFlags().skipRegions()); |
| 501 | if (failed(Result: op->fold(results&: foldResults))) |
| 502 | return cleanupFailure(); |
| 503 | |
| 504 | // Bound the number of in-place fold iterations. Legitimate chains are very |
| 505 | // short (e.g. foldCommutative swaps once, then the op folds to a value). |
| 506 | // Without a bound, circular SSA uses in graph regions can cause an infinite |
| 507 | // loop (e.g. addi(x, 0) where x is the op's own result). |
| 508 | constexpr int kMaxInPlaceFolds = 64; |
| 509 | int count = 0; |
| 510 | do { |
| 511 | LDBG() << "Folded in place #" << count |
| 512 | << " times: " << OpWithFlags(op, OpPrintingFlags().skipRegions()); |
| 513 | if (++count >= kMaxInPlaceFolds) { |
| 514 | LDBG() << "Aborting after " << kMaxInPlaceFolds |
| 515 | << " in-place fold iterations: " |
| 516 | << OpWithFlags(op, OpPrintingFlags().skipRegions()); |
| 517 | return cleanupFailure(); |
| 518 | } |
| 519 | } while (foldResults.empty() && succeeded(Result: op->fold(results&: foldResults))); |
| 520 | |
| 521 | // An in-place fold does not require generation of any constants. |
| 522 | if (foldResults.empty()) |
| 523 | return success(); |
| 524 | |
| 525 | // A temporary builder used for creating constants during folding. |
| 526 | OpBuilder cstBuilder(context); |
| 527 | SmallVector<Operation *, 1> generatedConstants; |
| 528 | |
| 529 | // Populate the results with the folded results. |
| 530 | Dialect *dialect = op->getDialect(); |
| 531 | for (auto [foldResult, expectedType] : |
| 532 | llvm::zip_equal(t&: foldResults, u: opResults.getTypes())) { |
| 533 | |
| 534 | // Normal values get pushed back directly. |
| 535 | if (auto value = llvm::dyn_cast_if_present<Value>(Val&: foldResult)) { |
| 536 | results.push_back(Elt: value); |
| 537 | continue; |
| 538 | } |
| 539 | |
| 540 | // Otherwise, try to materialize a constant operation. |
| 541 | if (!dialect) |
| 542 | return cleanupFailure(); |
| 543 | |
| 544 | // Ask the dialect to materialize a constant operation for this value. |
| 545 | Attribute attr = cast<Attribute>(Val&: foldResult); |
| 546 | auto *constOp = dialect->materializeConstant(builder&: cstBuilder, value: attr, type: expectedType, |
| 547 | loc: op->getLoc()); |
| 548 | if (!constOp) { |
| 549 | // Erase any generated constants. |
| 550 | for (Operation *cst : generatedConstants) |
| 551 | cst->erase(); |
| 552 | return cleanupFailure(); |
| 553 | } |
| 554 | assert(matchPattern(constOp, m_Constant())); |
| 555 | |
| 556 | generatedConstants.push_back(Elt: constOp); |
| 557 | results.push_back(Elt: constOp->getResult(idx: 0)); |
| 558 | } |
| 559 | |
| 560 | // If we were successful, insert any generated constants. |
| 561 | for (Operation *cst : generatedConstants) |
| 562 | insert(op: cst); |
| 563 | |
| 564 | // Return materialized constant operations. |
| 565 | if (materializedConstants) |
| 566 | *materializedConstants = std::move(generatedConstants); |
| 567 | |
| 568 | return success(); |
| 569 | } |
| 570 | |
| 571 | /// Helper function that sends block insertion notifications for every block |
| 572 | /// that is directly nested in the given op. |
| 573 | static void notifyBlockInsertions(Operation *op, |
| 574 | OpBuilder::Listener *listener) { |
| 575 | for (Region &r : op->getRegions()) |
| 576 | for (Block &b : r.getBlocks()) |
| 577 | listener->notifyBlockInserted(block: &b, /*previous=*/nullptr, |
| 578 | /*previousIt=*/{}); |
| 579 | } |
| 580 | |
| 581 | Operation *OpBuilder::clone(Operation &op, IRMapping &mapper) { |
| 582 | Operation *newOp = op.clone(mapper); |
| 583 | newOp = insert(op: newOp); |
| 584 | |
| 585 | // The `insert` call above handles the notification for inserting `newOp` |
| 586 | // itself. But if `newOp` has any regions, we need to notify the listener |
| 587 | // about any ops that got inserted inside those regions as part of cloning. |
| 588 | if (listener) { |
| 589 | // The `insert` call above notifies about op insertion, but not about block |
| 590 | // insertion. |
| 591 | notifyBlockInsertions(op: newOp, listener); |
| 592 | auto walkFn = [&](Operation *walkedOp) { |
| 593 | listener->notifyOperationInserted(op: walkedOp, /*previous=*/{}); |
| 594 | notifyBlockInsertions(op: walkedOp, listener); |
| 595 | }; |
| 596 | for (Region ®ion : newOp->getRegions()) |
| 597 | region.walk<WalkOrder::PreOrder>(callback&: walkFn); |
| 598 | } |
| 599 | |
| 600 | return newOp; |
| 601 | } |
| 602 | |
| 603 | Operation *OpBuilder::clone(Operation &op) { |
| 604 | IRMapping mapper; |
| 605 | return clone(op, mapper); |
| 606 | } |
| 607 | |
| 608 | void OpBuilder::cloneRegionBefore(Region ®ion, Region &parent, |
| 609 | Region::iterator before, IRMapping &mapping) { |
| 610 | region.cloneInto(dest: &parent, destPos: before, mapper&: mapping); |
| 611 | |
| 612 | // Fast path: If no listener is attached, there is no more work to do. |
| 613 | if (!listener) |
| 614 | return; |
| 615 | |
| 616 | // Notify about op/block insertion. |
| 617 | for (auto it = mapping.lookup(from: ®ion.front())->getIterator(); it != before; |
| 618 | ++it) { |
| 619 | listener->notifyBlockInserted(block: &*it, /*previous=*/nullptr, |
| 620 | /*previousIt=*/{}); |
| 621 | it->walk<WalkOrder::PreOrder>(callback: [&](Operation *walkedOp) { |
| 622 | listener->notifyOperationInserted(op: walkedOp, /*previous=*/{}); |
| 623 | notifyBlockInsertions(op: walkedOp, listener); |
| 624 | }); |
| 625 | } |
| 626 | } |
| 627 | |
| 628 | void OpBuilder::cloneRegionBefore(Region ®ion, Region &parent, |
| 629 | Region::iterator before) { |
| 630 | IRMapping mapping; |
| 631 | cloneRegionBefore(region, parent, before, mapping); |
| 632 | } |
| 633 | |
| 634 | void OpBuilder::cloneRegionBefore(Region ®ion, Block *before) { |
| 635 | cloneRegionBefore(region, parent&: *before->getParent(), before: before->getIterator()); |
| 636 | } |
| 637 | |