Bump LLVM to 881ff4e (#539)

Author: stephenneuendorffer

CMakeLists.txt

@@ -13,6 +13,10 @@ if(POLICY CMP0077)
   cmake_policy(SET CMP0077 NEW)
 endif()
 
+if(POLICY CMP0116)
+  cmake_policy(SET CMP0116 OLD)
+endif()
+
 #-------------------------------------------------------------------------------
 # Project setup and globals
 #-------------------------------------------------------------------------------

external/llvm-project

@@ -14,6 +14,7 @@
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
+#include "mlir/Dialect/Tensor/Utils/Utils.h"
 #include "mlir/Dialect/Traits.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Transforms/DialectConversion.h"
@@ -275,14 +276,14 @@ static Value getPaddedTensor(Operation *op, OpBuilder &b, Value &input,
                              SmallVectorImpl<int64_t> &highPaddingInts,
                              Value pad) {
   Location loc = op->getLoc();
-  Type rankedTensorType = linalg::PadTensorOp::inferResultType(
+  Type rankedTensorType = tensor::PadOp::inferResultType(
       input.getType().cast<RankedTensorType>(), lowPaddingInts,
       highPaddingInts);
   SmallVector<OpFoldResult> lowPaddings =
       getAsOpFoldResult(b, loc, lowPaddingInts);
   SmallVector<OpFoldResult> highPaddings =
       getAsOpFoldResult(b, loc, highPaddingInts);
-  Value paddedInput = linalg::PadTensorOp::createPadScalarOp(
+  Value paddedInput = tensor::createPadScalarOp(
       rankedTensorType, input, pad, /*low=*/lowPaddings, /*high=*/highPaddings,
       /*packing=*/false, loc, b);
   return paddedInput;

lib/Conversion/TorchToLinalg/TorchToLinalg.cpp

@@ -1059,7 +1059,7 @@ class ConvertAtenMatmulBaseOp : public OpConversionPattern<AtenOpT> {
       // Step: generate the common dim/shape information
       for (uint32_t dim = 0; dim < maxInputRank - 2; dim++) {
         bool isDynamicDim =
-            lhsBroadcastedTy.isDynamic(lhsBroadcastedShape[dim]);
+            ShapedType::isDynamic(lhsBroadcastedShape[dim]);
         if (isDynamicDim ||
             lhsBroadcastedShape[dim] == rhsBroadcastedShape[dim]) {
           commonValue *= lhsBroadcastedShape[dim];
@@ -1071,7 +1071,7 @@ class ConvertAtenMatmulBaseOp : public OpConversionPattern<AtenOpT> {
       bool hasDynamicDims = false;
       for (uint32_t dim = 0; dim < maxInputRank - 2; dim++) {
         bool isDynamicDim =
-            lhsBroadcastedTy.isDynamic(lhsBroadcastedShape[dim]);
+            ShapedType::isDynamic(lhsBroadcastedShape[dim]);
         hasDynamicDims |= isDynamicDim;
         if (!isDynamicDim &&
             lhsBroadcastedShape[dim] != rhsBroadcastedShape[dim]) {
@@ -1156,7 +1156,7 @@ class ConvertAtenMatmulBaseOp : public OpConversionPattern<AtenOpT> {
       hasDynamicDims = false;
       for (uint32_t dim = 0; dim < maxInputRank - 2; dim++) {
         bool isDynamicDim =
-            rhsBroadcastedTy.isDynamic(rhsBroadcastedShape[dim]);
+            ShapedType::isDynamic(rhsBroadcastedShape[dim]);
         hasDynamicDims |= isDynamicDim;
         if (!isDynamicDim &&
             rhsBroadcastedShape[dim] != lhsBroadcastedShape[dim]) {

lib/Conversion/TorchToTosa/TorchToTosa.cpp

@@ -63,28 +63,6 @@ void TorchDialect::initialize() {
   addInterfaces<TorchInlinerInterface>();
 }
 
-//===----------------------------------------------------------------------===//
-// Type-related Dialect methods.
-//===----------------------------------------------------------------------===//
-
-Type TorchDialect::parseType(DialectAsmParser &parser) const {
-  StringRef keyword;
-  if (parser.parseKeyword(&keyword))
-    return Type();
-  Type type;
-  if (generatedTypeParser(parser, keyword, type).hasValue())
-    return type;
-
-  parser.emitError(parser.getNameLoc(), "invalid 'torch' type: `")
-      << keyword << "'";
-  return Type();
-}
-
-void TorchDialect::printType(Type type, DialectAsmPrinter &printer) const {
-  if (failed(generatedTypePrinter(type, printer)))
-    llvm_unreachable("unknown 'torch' type");
-}
-
 //===----------------------------------------------------------------------===//
 // Dialect-level verifiers.
 //===----------------------------------------------------------------------===//

lib/Dialect/Torch/IR/TorchDialect.cpp

@@ -321,9 +321,9 @@ static ParseResult parsePrimIfOp(OpAsmParser &parser, OperationState &result) {
 
 static void print(OpAsmPrinter &p, PrimIfOp op) {
   p << " " << op.condition();
-  p << " -> (" << op.getResultTypes() << ")";
+  p << " -> (" << op.getResultTypes() << ") ";
   p.printRegion(op.thenRegion(), /*printEntryBlockArgs=*/false);
-  p << " else";
+  p << " else ";
   p.printRegion(op.elseRegion(), /*printEntryBlockArgs=*/false);
 
   p.printOptionalAttrDict(op->getAttrs());

lib/Dialect/Torch/IR/TorchOps.cpp

@@ -38,7 +38,7 @@ class AdjustCallingConventionForFunc : public OpConversionPattern<FuncOp> {
   matchAndRewrite(FuncOp func, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     MLIRContext *context = func.getContext();
-    auto typeBoundIdent = Identifier::get("torch.type_bound", context);
+    auto typeBoundIdent = StringAttr::get(context, "torch.type_bound");
     TypeConverter::SignatureConversion conversion(func.getNumArguments());
 
     // The TypeConverter hooks for type conversion are "context free", so we

lib/Dialect/Torch/Transforms/AdjustCallingConventions.cpp

@@ -164,7 +164,7 @@ struct FuncBackendTypeConversionPass
     typeConverter.addConversion([](Type type) { return type; });
     TorchConversion::setupBackendTypeConversion(target, typeConverter);
 
-    populateFuncOpTypeConversionPattern(patterns, typeConverter);
+    populateFunctionOpInterfaceTypeConversionPattern<FuncOp>(patterns, typeConverter);
     target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) {
       return typeConverter.isSignatureLegal(op.getType()) &&
              typeConverter.isLegal(&op.getBody());

lib/Dialect/TorchConversion/Transforms/BackendTypeConversion.cpp

@@ -173,7 +173,7 @@ MlirValue IValueImporter::importModule(torch::jit::Module currentModule) {
       torchMlirTorchNnModuleTypeGet(context, toMlirStringRef(moduleTypeName)),
       mlirRegionCreate());
   MlirRegion nnModuleRegion = mlirOperationGetRegion(nnModule, 0);
-  mlirRegionAppendOwnedBlock(nnModuleRegion, mlirBlockCreate(0, nullptr));
+  mlirRegionAppendOwnedBlock(nnModuleRegion, mlirBlockCreate(0, nullptr, nullptr));
   MlirBlock nnModuleBody = mlirRegionGetFirstBlock(nnModuleRegion);
   auto inserter = caffe2::MakeGuard([&]() {
     mlirBlockInsertOwnedOperationBefore(
@@ -441,7 +441,7 @@ void IValueImporter::importClassType(c10::ClassType *classType) {
           mlirStringAttrGet(
               context, toMlirStringRef(classType->name()->qualifiedName()))));
   MlirRegion region = mlirOperationGetRegion(op, 0);
-  mlirRegionAppendOwnedBlock(region, mlirBlockCreate(0, nullptr));
+  mlirRegionAppendOwnedBlock(region, mlirBlockCreate(0, nullptr, nullptr));
   MlirBlock classTypeBody = mlirRegionGetFirstBlock(region);
 
   ClassAnnotation &classAnnotation =

python/torch_mlir/dialects/torch/importer/jit_ir/csrc/ivalue_importer.cpp

@@ -303,7 +303,8 @@ MlirBlock NodeImporter::createBlockFor(Block *jitBlock) {
   MlirLocation loc = getMlirLocationFromNode(context, paramNode);
   std::vector<MlirType> blockArgTypes =
       getMlirTypesFromValues(loc, paramNode->outputs());
-  MlirBlock block = mlirBlockCreate(blockArgTypes.size(), blockArgTypes.data());
+  std::vector<MlirLocation> blockArgLocs(blockArgTypes.size(), loc);
+  MlirBlock block = mlirBlockCreate(blockArgTypes.size(), blockArgTypes.data(), blockArgLocs.data());
   for (int i = 0, e = mlirBlockGetNumArguments(block); i < e; i++) {
     Value *jitValue = paramNode->outputs()[i];
     MlirValue value = mlirBlockGetArgument(block, i);