[mlir][Standard] Add unsigned integers to UIToFPOp and FPToUIOp cast-compatibility checks

[NatashaKnk]

Summary

Added support for unsigned int in addition to the already-existing signless int

[rriddle]

Standard operations are explicitly signless by design, i.e. they purposefully don't support signed/unsigned integers.

https://mlir.llvm.org/docs/Rationale/Rationale/#integer-signedness-semantics

[NatashaKnk]

I might be misunderstanding the situation, but if the Ops are signless why does SIToFOp exist? If we handle the explicitly signed case, why not the explicitly unsigned one?

[mehdi_amini]

I might be misunderstanding the situation, but if the Ops are signless why does SIToFOp exist?

When you design operations like this on Integer, you need to decide if you encode the sign in the type or in the operation name. For example you can have:

%uquotient = div %ua, %ub : uint32
%squotient = div %sa, %sb : sint32

where you decide to encode the sign in the type itself. In this case you only need one div operation. The alternative is to have a "signless" type for integer and encode the difference in the operation:

%squotient = sdiv %sa, %sb : int32
%uquotient = udiv %ua, %ub : int32

This last solution is what is preferred in the standard dialect. This is consistent with the existence of SIToFOp and UIToFOp: the sign aspect is carried by the operation and not by the type.

[NatashaKnk]

Oh, I completely missed that SItoFOp also checks for it to be signless, not signed. This makes sense. Thank you!

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

 //===----------------------------------------------------------------------===//
 // FPToUIOp
 //===----------------------------------------------------------------------===//
 
 bool FPToUIOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (inputs.size() != 1 || outputs.size() != 1)
     return false;
   Type a = inputs.front(), b = outputs.front();
-  if (a.isa<FloatType>() && b.isSignlessInteger())
+  if (a.isa<FloatType>() && (b.isSignlessInteger() || a.isUnsignedInteger()))
     return true;
   return areVectorCastSimpleCompatible(a, b, areCastCompatible);
 }
 
 //===----------------------------------------------------------------------===//
 // FPTruncOp
 //===----------------------------------------------------------------------===//
 

 // UIToFPOp
 //===----------------------------------------------------------------------===//
 
 // uitofp is applicable from integer types to float types.
 bool UIToFPOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (inputs.size() != 1 || outputs.size() != 1)
     return false;
   Type a = inputs.front(), b = outputs.front();
-  if (a.isSignlessInteger() && b.isa<FloatType>())
+  if ((a.isSignlessInteger() || a.isUnsignedInteger()) && b.isa<FloatType>())
     return true;
   return areVectorCastSimpleCompatible(a, b, areCastCompatible);
 }
 
 //===----------------------------------------------------------------------===//
 // SubTensorOp
 //===----------------------------------------------------------------------===//