[GlobalISel] Remove semantic operand of G_IS_FPCLASS

[sepavloff]

Summary

Instruction G_IS_FPCLASS had an operand that represented floating-point
semantics of its first operand. It allowed types that have the same length,
like bfloat16 and half, to be distinguished. Unfortunately, it is
not sufficient, as other operation still cannot distinguish such types.
Solution of this problem must be more general, so now this operand is removed.

llvm/docs/GlobalISel/GenericOpcode.rst

 ^^^^^^^^^^^^^^^
 
 See :ref:`i_intr_llvm_canonicalize`.
 
 G_IS_FPCLASS
 ^^^^^^^^^^^^
 
 Tests if the first operand, which must be floating-point scalar or vector, has
-floating-point class specified by the second operand. The third operand
-specifies floating-point semantics of the tested value. Returns non-zero (true)
+floating-point class specified by the second operand. Returns non-zero (true)
 or zero (false). It's target specific whether a true value is 1, ~0U, or some
 other non-zero value. If the first operand is a vector, the returned value is a
 vector of the same length.
 
 G_FMINNUM
 ^^^^^^^^^
 
 Perform floating-point minimum on two values.

llvm/include/llvm/Target/GenericOpcodes.td

def G_FCANONICALIZE : GenericInstruction {
   let OutOperandList = (outs type0:$dst);
   let InOperandList = (ins type0:$src);
   let hasSideEffects = false;
 }
 
 // Generic opcode equivalent to the llvm.is_fpclass intrinsic.
 def G_IS_FPCLASS: GenericInstruction {
   let OutOperandList = (outs type0:$dst);
-  let InOperandList = (ins type1:$src, unknown:$test, unknown:$fpsem);
+  let InOperandList = (ins type1:$src, unknown:$test);
   let hasSideEffects = false;
 }
 
 // FMINNUM/FMAXNUM - Perform floating-point minimum or maximum on two
 // values.
 //
 // In the case where a single input is a NaN (either signaling or quiet),
 // the non-NaN input is returned.

llvm/lib/CodeGen/MachineVerifier.cpp

if (!TestMO.isImm()) {
       report("floating-point class set (operand 2) must be an immediate", MI);
       break;
     }
     int64_t Test = TestMO.getImm();
     if (Test < 0 || Test > fcAllFlags) {
       report("Incorrect floating-point class set (operand 2)", MI);
       break;
     }
-    const MachineOperand &SemanticsMO = MI->getOperand(3);
-    if (!SemanticsMO.isImm()) {
-      report("floating-point semantics (operand 3) must be an immediate", MI);
-      break;
-    }
-    int64_t Semantics = SemanticsMO.getImm();
-    if (Semantics < 0 || Semantics > APFloat::S_MaxSemantics) {
-      report("Incorrect floating-point semantics (operand 3)", MI);
-      break;
-    }
     break;
   }
   case TargetOpcode::G_ASSERT_ALIGN: {
     if (MI->getOperand(2).getImm() < 1)
       report("alignment immediate must be >= 1", MI);
     break;
   }
   default:

llvm/test/MachineVerifier/test_g_is_fpclass.mir

 liveins:
 body:             |
   bb.0:
     liveins: $x0, $w0, $q0
     %s32:_(s32) = COPY $w0
     %ptr:_(p0) = COPY $x0
     %vector:_(<4 x s32>) = COPY $q0
 
-    %val1:_(s1) = G_IS_FPCLASS %s32, 1
+    %val1:_(s1) = G_IS_FPCLASS %s32
     ; CHECK: *** Bad machine code: Too few operands ***
-    ; CHECK: 4 operands expected, but 3 given.
+    ; CHECK: 3 operands expected, but 2 given.
 
-    %val2:_(p0) = G_IS_FPCLASS %s32, 3, 2
+    %val2:_(p0) = G_IS_FPCLASS %s32, 3
     ; CHECK: *** Bad machine code: Destination must be a scalar or vector of scalars ***
 
-    %val3:_(s1) = G_IS_FPCLASS %s32, 1, 66
-    ; CHECK: *** Bad machine code: Incorrect floating-point semantics (operand 3) ***
-
-    %val4:_(s1) = G_IS_FPCLASS %s32, 7777, 2
+    %val4:_(s1) = G_IS_FPCLASS %s32, 7777
     ; CHECK: *** Bad machine code: Incorrect floating-point class set (operand 2) ***
 
-    %val5:_(s1) = G_IS_FPCLASS %ptr:_(p0), 3, 2
+    %val5:_(s1) = G_IS_FPCLASS %ptr:_(p0), 3
     ; CHECK: *** Bad machine code: Source must be a scalar or vector of scalars ***
 
-    %var6:_(s1) = G_IS_FPCLASS %vector:_(<4 x s32>), 1, 2
+    %var6:_(s1) = G_IS_FPCLASS %vector:_(<4 x s32>), 1
     ; CHECK: *** Bad machine code: operand types must be all-vector or all-scalar ***
 
-    %var7:_(<2 x s1>) = G_IS_FPCLASS %vector:_(<4 x s32>), 1, 2
+    %var7:_(<2 x s1>) = G_IS_FPCLASS %vector:_(<4 x s32>), 1
     ; CHECK: *** Bad machine code: operand types must preserve number of vector elements ***
 
 ...