[MLIR][IRDL] Support for concrete attribute values in IRDL

[mikeurbach]

I am trying to use IRDL to define an op like a constant op that takes some attribute and returns some result, like a constant op in many dialects. I've followed the example IRDL in the tests, and have something this:

module {                                                                                                                                                                                                                                             
  irdl.dialect @cmath {                                                                                                                                                                                                                              
    irdl.type @complex                                                                                                                                                                                                                               
    irdl.operation @const {                                                                                                                                                                                                                          
      %0 = irdl.parametric @complex<>                                                                                                                                                                                                                
      %1 = irdl.is i64                                                                                                                                                                                                                               
      irdl.attributes {"value" = %1}                                                                                                                                                                                                                 
      irdl.operands()                                                                                                                                                                                                                                
      irdl.results(%0)                                                                                                                                                                                                                               
    }                                                                                                                                                                                                                                                
}

I am trying to build a cmath.const op, passing a concrete attribute for the value:

%0 = "cmath.const"() {value = 1 : i64} : () -> !cmath.complex

This fails to verify with:

error: expected 'i64' but got '1 : i64'

The tests here seem to reflect this as well, in the examples, only a TypeAttr is passed, not an IntegerAttr of the corresponding type:

llvm-project/mlir/test/Dialect/IRDL/testd.mlir

Line 253 in f2794cc

"testd.attrs"() {attr1 = i32, attr2 = i64} : () -> ()

I want my op to express that it requires a TypedAttribute of some type, like i64, not that the attribute is a TypeAttr of type i64. Is this possible? In other words, I want to be able to pass concrete attribute values and have the types of those attributes checked against the IRDL op definition.

I reviewed the discussion on the original patch, and it seems like this was what was originally implemented but then this was changed. Is there any plan to support this? Or am I using the existing tooling wrong?

cc @math-fehr @unterumarmung

[mikeurbach]

I'll note that in my example, I can change %1 to irdl.any and then I can pass the concrete attribute I want and it won't be checked.

So I guess what I'm looking for here is a new kind of constraint that we'd need to add to IRDL. Something like a %constraint = irdl.typed_attr %foo, where %foo is a constraint like %foo = irdl.is i64. Using a irdl.typed_attr constraint would only be legal in irdl.attributes and the constraint verifier would check that the concrete attribute is a TypedAttribute of a type that matches the %foo constraint. Does this make sense? If so, I can take a crack at an implementation when I have time.

[unterumarmung]

Sorry for the long answer!

Now the is op check that the concrete attribute is a TypedAttribute of a type that matches with a constraint. I guess, we need an op that checks if the concrete attribute has a value which type satisfies the given constraint.

Something like:

module {                                                                                                                                                                                                                                             
  irdl.dialect @cmath {                                                                                                                                                                                                                              
    irdl.type @complex                                                                                                                                                                                                                               
    irdl.operation @const {                                                                                                                                                                                                                          
      %0 = irdl.parametric @complex<>                                                                                                                                                                                                                
      %1 = irdl.attribute_of_type i64                                                                                                                                                                                                    
      irdl.attributes {"value" = %1}                                                                                                                                                                                                                 
      irdl.operands()                                                                                                                                                                                                                                
      irdl.results(%0)                                                                                                                                                                                                                               
    }                                                                                                                                                                                                                                                
}

%0 = cmath.const 42  // OK
%1 = cmath.const i64 // error: expected value of type `i64`, not `i64`

What you described with irdl.typed_attr is basically the current behavior of is op for the attributes and I guess it should stay the same.

I may be wrong, I've not touch MLIR and IRDL for a while now..

[mikeurbach]

Thanks for weighing in. I think we are saying the same thing--we need a constraint that checks the type of the attribute's value, not that the attribute is a specific TypeAttr. Today, irdl.is checks that the attribute is a specific TypeAttr.

I think we are both sketching the same thing in different ways. When I proposed irdl.typed_attr, I was imagining the actual expected type could be the TypeAttr supplied to the existing irdl.is operation. In your irdl.attribute_of_type, the TypeAttr is supplied directly to the irdl.attribute_of_type op. Either way would work for me here, but I was thinking having the new constraint op take an operand would help it compose with other IRDL constraints. For example, if you wanted to use irdl.any instead of a single TypeAttr.

[math-fehr]

Extremely sorry for the delay, I was quite busy the last few weeks, so this passed under my radar!

I completely agree with @mikeurbach design, and this is something we should add in IRDL yes, as there are no other ways to make this work currently.
If you don't have time for this anymore, I can also give it a go!

[mikeurbach]

Thanks @math-fehr. This isn't urgent for me, so I'm happy to try my hand next time I get a chance. And if you're interested in working on it I'm also happy to review a PR.