NumToTensor.mlir

func.func @torch.prim.NumToTensor.Scalar() -> !torch.vtensor<[],f64> {
  %float8.000000e00 = torch.constant.float 8.000000e+00
  %1 = "torch.prim.NumToTensor.Scalar"(%float8.000000e00) : (!torch.float) -> !torch.vtensor<[],f64>
  return %1 : !torch.vtensor<[],f64>
}

Failure to use f64 to create DenseElementsAttr:

float floatValue = static_cast<float>(doubleValue);
DenseElementsAttr constAttr = isInt ? DenseElementsAttr::get(resultType, {intValue}) : DenseElementsAttr::get(resultType, {floatValue});

Bug Output:

torch-mlir-opt -convert-torch-to-tosa /tmp/NumToTensor.mlir --debug
Legalizing operation : 'func.func'(0x56034a6de200) {
  * Fold {
ImplicitTypeIDRegistry::lookupOrInsert(mlir::DialectFoldInterface)
  } -> FAILURE : unable to fold
} -> FAILURE : no matched legalization pattern
//===-------------------------------------------===//

//===-------------------------------------------===//
Legalizing operation : 'torch.constant.float'(0x56034a6eff10) {
  %0 = "torch.constant.float"() {value = 8.000000e+00 : f64} : () -> !torch.float

  * Fold {
  } -> FAILURE : unable to fold
} -> FAILURE : no matched legalization pattern
//===-------------------------------------------===//

//===-------------------------------------------===//
Legalizing operation : 'torch.prim.NumToTensor.Scalar'(0x56034a7339b0) {
  %1 = "torch.prim.NumToTensor.Scalar"(%0) : (!torch.float) -> !torch.vtensor<[],f64>

  * Fold {
  } -> FAILURE : unable to fold

  * Pattern : 'torch.prim.NumToTensor.Scalar -> ()' {
Trying to match "(anonymous namespace)::ConvertAtenOp<mlir::torch::Torch::PrimNumToTensorScalarOp>"
ImplicitTypeIDRegistry::lookupOrInsert(mlir::OpTrait::OneTypedResult<mlir::TensorType>::Impl<Empty>)
ImplicitTypeIDRegistry::lookupOrInsert(mlir::tosa::TosaOp::Trait<Empty>)
    ** Insert  : 'tosa.const'(0x56034a791260)
    ** Replace : 'torch.prim.NumToTensor.Scalar'(0x56034a7339b0)
"(anonymous namespace)::ConvertAtenOp<mlir::torch::Torch::PrimNumToTensorScalarOp>" result 1

    //===-------------------------------------------===//
    Legalizing operation : 'tosa.const'(0x56034a791260) {
      %2 = "tosa.const"() {value = dense<8.000000e+00> : tensor<f64>} : () -> tensor<f64>

    } -> SUCCESS : operation marked legal by the target
    //===-------------------------------------------===//
  } -> SUCCESS : pattern applied successfully
// *** IR Dump After Pattern Application ***
mlir-asm-printer: Verifying operation: func.func
'tosa.const' op result #0 must be tensor of number values, but got 'tensor<f64>'
mlir-asm-printer: 'func.func' failed to verify and will be printed in generic form
"func.func"() ({
  %0 = "torch.constant.float"() {value = 8.000000e+00 : f64} : () -> !torch.float
  %1 = "builtin.unrealized_conversion_cast"(%0) : (!torch.float) -> f64
  %2 = "tosa.const"() {value = dense<8.000000e+00> : tensor<f64>} : () -> tensor<f64>
  %3 = "torch.prim.NumToTensor.Scalar"(%0) : (!torch.float) -> !torch.vtensor<[],f64>
  "func.return"(%3) : (!torch.vtensor<[],f64>) -> ()
}) {function_type = () -> !torch.vtensor<[],f64>, sym_name = "torch.prim.NumToTensor.Scalar"} : () -> ()


} -> SUCCESS
//===-------------------------------------------===//

//===-------------------------------------------===//
Legalizing operation : 'func.return'(0x56034a733b80) {
  "func.return"(%3) : (!torch.vtensor<[],f64>) -> ()

  * Fold {
  } -> FAILURE : unable to fold
} -> FAILURE : no matched legalization pattern
//===-------------------------------------------===//
** Insert  : 'torch_c.from_builtin_tensor'(0x56034a6eeb10)
ImplicitTypeIDRegistry::lookupOrInsert(mlir::detail::PreservedAnalyses::AllAnalysesType)
/tmp/NumToTensor.mlir:3:8: error: 'tosa.const' op result #0 must be tensor of number values, but got 'tensor<f64>'
  %1 = "torch.prim.NumToTensor.Scalar"(%float8.000000e00) : (!torch.float) -> !torch.vtensor<[],f64>
       ^
/tmp/NumToTensor.mlir:3:8: note: see current operation: %1 = "tosa.const"() {value = dense<8.000000e+00> : tensor<f64>} : () -> tensor<f64>

With tosa::cast f32 to f64:

  auto outElemTy = resultType.getElementType();
  if (outElemTy.isa<mlir::IntegerType>() || outElemTy.isF32()) {
    DenseElementsAttr constAttr = isInt ? DenseElementsAttr::get(resultType, {intValue}) : DenseElementsAttr::get(resultType, {floatValue});
    rewriter.replaceOpWithNewOp<tosa::ConstOp>(op, resultType, constAttr);
  } else if (outElemTy.isF64()) {
    auto resultF32 =
        tosa::getConstTensor<float>(rewriter, op, floatValue, {}).value();
    rewriter.replaceOpWithNewOp<tosa::CastOp>(op, resultType, resultF32);
  }

Bug Output:

// *** IR Dump After Pattern Application ***
mlir-asm-printer: Verifying operation: func.func
ImplicitTypeIDRegistry::lookupOrInsert(mlir::InferShapedTypeOpInterface::Trait<Empty>)
'tosa.cast' op result #0 must be tensor of number values, but got 'tensor<f64>'
mlir-asm-printer: 'func.func' failed to verify and will be printed in generic form
"func.func"() ({
  %0 = "torch.constant.float"() {value = 8.000000e+00 : f64} : () -> !torch.float
  %1 = "builtin.unrealized_conversion_cast"(%0) : (!torch.float) -> f64
  %2 = "tosa.const"() {value = dense<8.000000e+00> : tensor<f32>} : () -> tensor<f32>
  %3 = "tosa.cast"(%2) : (tensor<f32>) -> tensor<f64>
  %4 = "torch.prim.NumToTensor.Scalar"(%0) : (!torch.float) -> !torch.vtensor<[],f64>
  "func.return"(%4) : (!torch.vtensor<[],f64>) -> ()
}) {function_type = () -> !torch.vtensor<[],f64>, sym_name = "torch.prim.NumToTensor.Scalar"} : () -> ()


} -> SUCCESS
//===-------------------------------------------===//

//===-------------------------------------------===//
Legalizing operation : 'func.return'(0x55a53fab0c30) {
  "func.return"(%4) : (!torch.vtensor<[],f64>) -> ()

  * Fold {
  } -> FAILURE : unable to fold
} -> FAILURE : no matched legalization pattern
//===-------------------------------------------===//
** Insert  : 'torch_c.from_builtin_tensor'(0x55a53fb17c60)
ImplicitTypeIDRegistry::lookupOrInsert(mlir::detail::PreservedAnalyses::AllAnalysesType)
/tmp/NumToTensor.mlir:3:8: error: 'tosa.cast' op result #0 must be tensor of number values, but got 'tensor<f64>'
  %1 = "torch.prim.NumToTensor.Scalar"(%float8.000000e00) : (!torch.float) -> !torch.vtensor<[],f64>
       ^
/tmp/NumToTensor.mlir:3:8: note: see current operation: %2 = "tosa.cast"(%1) : (tensor<f32>) -> tensor<f64>

For comparison with F64: F32 successfuly

func.func @torch.prim.NumToTensor.Scalar() -> !torch.vtensor<[],f32> {
  %float8.000000e00 = torch.constant.float 8.000000e+00
  %1 = "torch.prim.NumToTensor.Scalar"(%float8.000000e00) : (!torch.float) -> !torch.vtensor<[],f32>
  return %1 : !torch.vtensor<[],f32>
}

--->

module {
  func.func @torch.prim.NumToTensor.Scalar() -> !torch.vtensor<[],f32> {
    %float8.000000e00 = torch.constant.float 8.000000e+00
    %0 = "tosa.const"() {value = dense<8.000000e+00> : tensor<f32>} : () -> tensor<f32>
    %1 = torch_c.from_builtin_tensor %0 : tensor<f32> -> !torch.vtensor<[],f32>
    return %1 : !torch.vtensor<[],f32>
  }
}