llvm: update tag to 061e0189

CMakeLists.txt

@@ -23,7 +23,7 @@ endif()
 
 project(torch-mlir LANGUAGES CXX C)
 set(CMAKE_C_STANDARD 11)
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 
 macro(torch_mlir_add_llvm_external_project name identifier location)
   message(STATUS "Adding LLVM external project ${name} (${identifier}) -> ${location}")

include/torch-mlir/Dialect/Torch/IR/TorchTypes.h

@@ -54,12 +54,12 @@ class BaseTensorType : public Type {
   Type getOptionalDtype() const;
 
   /// Return true if this type has a list of sizes.
-  bool hasSizes() const { return getOptionalSizes().hasValue(); }
+  bool hasSizes() const { return getOptionalSizes().has_value(); }
 
   /// Get the list of sizes. Requires `hasSizes()`.
   ArrayRef<int64_t> getSizes() const {
     assert(hasSizes() && "must have sizes");
-    return getOptionalSizes().getValue();
+    return getOptionalSizes().value();
   }
 
   /// Return true if all sizes of this tensor are known.

include/torch-mlir/Dialect/Torch/IR/TorchTypes.td

@@ -49,8 +49,8 @@ class OptionalArrayRefParameter<string arrayOf, string desc = ""> :
     AttrOrTypeParameter<
       "::llvm::Optional<::llvm::ArrayRef<" # arrayOf # ">>", desc> {
   let allocator = [{
-    if ($_self.hasValue()) {
-      $_dst.getValue() = $_allocator.copyInto($_self.getValue());
+    if ($_self.has_value()) {
+      $_dst.value() = $_allocator.copyInto($_self.value());
     }
   }];
 }

lib/CAPI/TorchTypes.cpp

@@ -213,7 +213,8 @@ MlirType torchMlirTorchNonValueTensorTypeGetWithLeastStaticInformation(
 }
 
 MlirType torchMlirTorchNonValueTensorTypeGetFromAttribute(MlirAttribute attr) {
-  auto attrTensorType = unwrap(attr).getType().cast<RankedTensorType>();
+  auto attrTensorType =
+      unwrap(attr).cast<TypedAttr>().getType().cast<RankedTensorType>();
   return wrap(Torch::NonValueTensorType::get(attrTensorType.getContext(),
                                              attrTensorType.getShape(),
                                              attrTensorType.getElementType()));

lib/Conversion/TorchToLinalg/DataMovement.cpp

@@ -342,7 +342,7 @@ class ConvertAtenViewOp : public OpConversionPattern<AtenViewOp> {
           continue;
         }
 
-        if (inferredDimension.hasValue()) {
+        if (inferredDimension.has_value()) {
           return rewriter.notifyMatchFailure(
               op, "at most one element in size list is allowed to be -1");
         }
@@ -363,7 +363,7 @@ class ConvertAtenViewOp : public OpConversionPattern<AtenViewOp> {
     // then we don't need to analyze the static information of the input
     // shape since the reassociation of dimensions only requires rank
     // information.
-    if (inferredDimension.hasValue() && outputShape.size() > 1) {
+    if (inferredDimension.has_value() && outputShape.size() > 1) {
       if (llvm::count(outputShape, kUnknownSize) != 1 ||
           llvm::count(inputShape, kUnknownSize) != 0) {
         return rewriter.notifyMatchFailure(
@@ -585,14 +585,14 @@ class ConvertAtenViewOp : public OpConversionPattern<AtenViewOp> {
       collapsedInput = rewriter
                            .create<tensor::ExpandShapeOp>(
                                loc, adjustedResultType,
-                               expandedInput.hasValue() ? expandedInput.value()
-                                                        : castedInput,
+                               expandedInput.has_value() ? expandedInput.value()
+                                                         : castedInput,
                                outputAssociations)
                            .result();
     }
 
-    Value result = collapsedInput.hasValue() ? collapsedInput.value()
-                                             : expandedInput.value();
+    Value result = collapsedInput.has_value() ? collapsedInput.value()
+                                              : expandedInput.value();
     rewriter.replaceOpWithNewOp<tensor::CastOp>(op, resultType, result);
     return success();
   }

lib/Conversion/TorchToMhlo/Basic.cpp

@@ -119,7 +119,7 @@ class ConvertAtenConstPatternOp : public OpConversionPattern<AtenOpT> {
 
     SmallVector<int32_t> values(size, fillVal);
     auto constOp =
-        mhlo::getConstTensor<int32_t>(rewriter, op, values, shape).getValue();
+        mhlo::getConstTensor<int32_t>(rewriter, op, values, shape).value();
 
     rewriter.replaceOpWithNewOp<mhlo::ConvertOp>(op, outType, constOp);
     return success();
@@ -884,7 +884,7 @@ LogicalResult ConvertAtenOp<AtenNativeLayerNormOp>::matchAndRewrite(
       op->getLoc(), mhloBatchNormOutTy, input,
       mhlo::getConstTensor(rewriter, op, llvm::makeArrayRef(inputFlattenShape),
                            {static_cast<int64_t>(inputFlattenShape.size())})
-          .getValue());
+          .value());
 
   // Generate "scale" and "offset" Value for mhlo.BatchNormTrainingOp.
   SmallVector<APFloat> zeroConstVec(
@@ -920,19 +920,19 @@ LogicalResult ConvertAtenOp<AtenNativeLayerNormOp>::matchAndRewrite(
       op->getLoc(), outputTy, batchNormTrainingResult.getResult(0),
       mhlo::getConstTensor(rewriter, op, outputTy.getShape(),
                            {static_cast<int64_t>(outputTy.getShape().size())})
-          .getValue());
+          .value());
   auto mean = rewriter.create<mhlo::DynamicReshapeOp>(
       op->getLoc(), outputMeanOrVarTy, batchNormTrainingResult.getResult(1),
       mhlo::getConstTensor(
           rewriter, op, outputMeanOrVarTy.getShape(),
           {static_cast<int64_t>(outputMeanOrVarTy.getShape().size())})
-          .getValue());
+          .value());
   auto var = rewriter.create<mhlo::DynamicReshapeOp>(
       op->getLoc(), outputMeanOrVarTy, batchNormTrainingResult.getResult(2),
       mhlo::getConstTensor(
           rewriter, op, outputMeanOrVarTy.getShape(),
           {static_cast<int64_t>(outputMeanOrVarTy.getShape().size())})
-          .getValue());
+          .value());
 
   // Apply affine transform: output x weight + bias [element-wise]
   auto bcastedWeight = mhlo::promoteAndBroadcast(rewriter, weight, outputTy);

lib/Conversion/TorchToMhlo/Pooling.cpp

@@ -314,8 +314,7 @@ LogicalResult ConvertAtenPoolingOp<AtenMaxPool2dWithIndicesOp>::matchAndRewrite(
               initIndexTensor, inputShapeTensor)
           .getResult();
 
-  Value initIdx =
-      mhlo::getConstTensor<int64_t>(rewriter, op, {0}, {}).getValue();
+  Value initIdx = mhlo::getConstTensor<int64_t>(rewriter, op, {0}, {}).value();
 
   auto reduceWindowOp = rewriter.create<mhlo::ReduceWindowOp>(
       op->getLoc(), mlir::TypeRange{outValTy, outIdxTy},
@@ -491,7 +490,7 @@ LogicalResult ConvertAtenPoolingOp<AtenAvgPool2dOp>::matchAndRewrite(
   if (countIncludePad) {
     Value divisor = mhlo::getConstTensor<int64_t>(
                         rewriter, op, {kernelSize[0] * kernelSize[1]}, {})
-                        .getValue();
+                        .value();
     divisor = mhlo::promoteType(rewriter, divisor, outTy);
     DenseIntElementsAttr bcastDimensions;
     rewriter.replaceOpWithNewOp<mlir::chlo::BroadcastDivOp>(
@@ -501,7 +500,7 @@ LogicalResult ConvertAtenPoolingOp<AtenAvgPool2dOp>::matchAndRewrite(
 
   // Use another mhlo.ReduceWindowOp to get the divisor
   Value windowSizeConst =
-      mhlo::getConstTensor<float>(rewriter, op, {1.0}, {}).getValue();
+      mhlo::getConstTensor<float>(rewriter, op, {1.0}, {}).value();
   windowSizeConst = mhlo::promoteType(rewriter, windowSizeConst, outTy);
   auto inputShapeVec = *mhlo::getDimSizesOfTensor(rewriter, op, input);
   auto inputShapeTensor = rewriter.create<mlir::tensor::FromElementsOp>(

lib/Conversion/TorchToMhlo/Reduction.cpp

@@ -87,7 +87,7 @@ getMaxInDim(ConversionPatternRewriter &rewriter, Operation *op, Value &input,
   if (!initValue) return llvm::None;
 
   Value initIndex =
-      mhlo::getConstTensor<int64_t>(rewriter, op, {0}, {}).getValue();
+      mhlo::getConstTensor<int64_t>(rewriter, op, {0}, {}).value();
 
   DenseIntElementsAttr dimensions = DenseIntElementsAttr::get(
       RankedTensorType::get({}, rewriter.getI64Type()), dim);
@@ -224,7 +224,7 @@ LogicalResult ConvertAtenReductionOp<AtenArgmaxOp>::matchAndRewrite(
   }
   auto inputShapeVec = *inputShapeInfo;
   auto mhloReduceResults =
-      getMaxInDim(rewriter, op, input, inputShapeVec, dim).getValue();
+      getMaxInDim(rewriter, op, input, inputShapeVec, dim).value();
 
   if (keepDim) {
     auto outShapeVec = inputShapeVec;
@@ -301,7 +301,7 @@ LogicalResult ConvertAtenReductionOp<AtenMaxDimOp>::matchAndRewrite(
   }
   auto inputShapeVec = *inputShapeInfo;
   auto mhloReduceResults =
-      getMaxInDim(rewriter, op, input, inputShapeVec, dim).getValue();
+      getMaxInDim(rewriter, op, input, inputShapeVec, dim).value();
 
   if (keepDim) {
     auto outShapeVec = inputShapeVec;

lib/Conversion/TorchToStd/TorchToStd.cpp

@@ -178,16 +178,15 @@ class ConvertTorchTensorLiteralOp
           }));
       return success();
     }
-    if (auto elements = op.valueAttr().dyn_cast<OpaqueElementsAttr>()) {
+    if (auto elements = op.valueAttr().dyn_cast<SparseElementsAttr>()) {
       if (auto type = elements.getType().dyn_cast<RankedTensorType>()) {
         if (auto intType = type.getElementType().dyn_cast<IntegerType>()) {
           Type builtinTensorElemTy =
               IntegerType::get(context, intType.getIntOrFloatBitWidth());
           auto shapedType =
               RankedTensorType::get(type.getShape(), builtinTensorElemTy);
           rewriter.replaceOpWithNewOp<arith::ConstantOp>(
-              op, OpaqueElementsAttr::get(elements.getDialect(), shapedType,
-                                          elements.getValue()));
+              op, DenseElementsAttr::get(shapedType, elements.getValues()));
           return success();
         }
       }