[X86][GlobalISel] Support fp80 for G_FPTRUNC and G_FPEXT (#141611)

Introduce `G_FPEXTLOAD` and `G_FPTRUNCSTORE` for extending load and
truncating store of a floating point value.

* Introduce `IfFPExtend` and `IfFPTrunc` into `GINodeEquiv` to dispatch
SDAG patterns to the newly introduced opcodes similarly to `G_SEXTLOAD`
and `G_ZEXTLOAD`.
* Added narrowing and widening for the opcodes. However they aren't used
anywhere.
* Supported lowering of `G_FPEXTLOAD` and `G_FPTRUNCSTORE` for X86 by
using X87.
* Added `lowerFPExtAndTruncMem` as default lowering for `G_FPTRUNC` and
`G_FPEXT` using memory.
* Dropped autogenerated line from `legalizer-info-validation.mir` as
scripts can't update them anymore.
* Updated `match-table-cxx.td` with regexps. This is not the first PR
that updates the whole test after opcode introduction.

Author: e-kud

llvm/docs/GlobalISel/GenericOpcode.rst

@@ -930,6 +930,21 @@ Unlike in SelectionDAG, atomic loads are expressed with the same
 opcodes as regular loads. G_LOAD, G_SEXTLOAD and G_ZEXTLOAD may all
 have atomic memory operands.
 
+G_FPEXTLOAD
+^^^^^^^^^^^
+
+Generic floating-point extending load. Expects a MachineMemOperand in addition
+to explicit operands. Loads a floating-point value from memory and extends it
+to a larger floating-point type.
+
+The memory size must be smaller than the result type. For example, loading an
+f32 value from memory and extending it to f64, or loading an f16 value and
+extending it to f32.
+
+.. code-block:: none
+
+  %1:_(s64) = G_FPEXTLOAD %0:_(p0) :: (load (s32))
+
 G_INDEXED_LOAD
 ^^^^^^^^^^^^^^
 
@@ -956,6 +971,21 @@ the high bits are implicitly truncated. If this is a vector store, the
 high elements are discarded (i.e. this does not function as a per-lane
 vector, truncating store)
 
+G_FPTRUNCSTORE
+^^^^^^^^^^^^^^
+
+Generic floating-point truncating store. Expects a MachineMemOperand in
+addition to explicit operands. Truncates a floating-point value to a smaller
+floating-point type and stores it to memory.
+
+The memory size must be smaller than the source value type. For example,
+truncating an f64 value to f32 and storing it, or truncating an f32 value
+to f16 and storing it.
+
+.. code-block:: none
+
+  G_FPTRUNCSTORE %0:_(s64), %1:_(p0) :: (store (s32))
+
 G_INDEXED_STORE
 ^^^^^^^^^^^^^^^
 

llvm/include/llvm/CodeGen/GlobalISel/GenericMachineInstrs.h

@@ -80,7 +80,7 @@ class GMemOperation : public GenericMachineInstr {
 };
 
 /// Represents any type of generic load or store.
-/// G_LOAD, G_STORE, G_ZEXTLOAD, G_SEXTLOAD.
+/// G_LOAD, G_STORE, G_ZEXTLOAD, G_SEXTLOAD, G_FPEXTLOAD, G_FPTRUNCSTORE.
 class GLoadStore : public GMemOperation {
 public:
   /// Get the source register of the pointer value.
@@ -92,6 +92,8 @@ class GLoadStore : public GMemOperation {
     case TargetOpcode::G_STORE:
     case TargetOpcode::G_ZEXTLOAD:
     case TargetOpcode::G_SEXTLOAD:
+    case TargetOpcode::G_FPEXTLOAD:
+    case TargetOpcode::G_FPTRUNCSTORE:
       return true;
     default:
       return false;
@@ -197,6 +199,7 @@ class GAnyLoad : public GLoadStore {
     case TargetOpcode::G_LOAD:
     case TargetOpcode::G_ZEXTLOAD:
     case TargetOpcode::G_SEXTLOAD:
+    case TargetOpcode::G_FPEXTLOAD:
       return true;
     default:
       return false;
@@ -212,12 +215,13 @@ class GLoad : public GAnyLoad {
   }
 };
 
-/// Represents either a G_SEXTLOAD or G_ZEXTLOAD.
+/// Represents either a G_SEXTLOAD, G_ZEXTLOAD, or G_FPEXTLOAD.
 class GExtLoad : public GAnyLoad {
 public:
   static bool classof(const MachineInstr *MI) {
     return MI->getOpcode() == TargetOpcode::G_SEXTLOAD ||
-           MI->getOpcode() == TargetOpcode::G_ZEXTLOAD;
+           MI->getOpcode() == TargetOpcode::G_ZEXTLOAD ||
+           MI->getOpcode() == TargetOpcode::G_FPEXTLOAD;
   }
 };
 
@@ -237,17 +241,47 @@ class GZExtLoad : public GExtLoad {
   }
 };
 
-/// Represents a G_STORE.
-class GStore : public GLoadStore {
+/// Represents a G_FPEXTLOAD.
+class GFPExtLoad : public GAnyLoad {
+public:
+  static bool classof(const MachineInstr *MI) {
+    return MI->getOpcode() == TargetOpcode::G_FPEXTLOAD;
+  }
+};
+
+/// Represents any generic store, including truncating variants.
+class GAnyStore : public GLoadStore {
 public:
   /// Get the stored value register.
   Register getValueReg() const { return getOperand(0).getReg(); }
 
+  static bool classof(const MachineInstr *MI) {
+    switch (MI->getOpcode()) {
+    case TargetOpcode::G_STORE:
+    case TargetOpcode::G_FPTRUNCSTORE:
+      return true;
+    default:
+      return false;
+    }
+  }
+};
+
+/// Represents a G_STORE.
+class GStore : public GAnyStore {
+public:
   static bool classof(const MachineInstr *MI) {
     return MI->getOpcode() == TargetOpcode::G_STORE;
   }
 };
 
+/// Represents a G_FPTRUNCSTORE.
+class GFPTruncStore : public GAnyStore {
+public:
+  static bool classof(const MachineInstr *MI) {
+    return MI->getOpcode() == TargetOpcode::G_FPTRUNCSTORE;
+  }
+};
+
 /// Represents a G_UNMERGE_VALUES.
 class GUnmerge : public GenericMachineInstr {
 public:

llvm/include/llvm/CodeGen/GlobalISel/LegalizerHelper.h

@@ -523,6 +523,7 @@ class LegalizerHelper {
   LLVM_ABI LegalizeResult lowerFPTOSI(MachineInstr &MI);
   LLVM_ABI LegalizeResult lowerFPTOINT_SAT(MachineInstr &MI);
 
+  LLVM_ABI LegalizeResult lowerFPExtAndTruncMem(MachineInstr &MI);
   LLVM_ABI LegalizeResult lowerFPTRUNC_F64_TO_F16(MachineInstr &MI);
   LLVM_ABI LegalizeResult lowerFPTRUNC_F32_TO_BF16(MachineInstr &MI);
   LLVM_ABI LegalizeResult lowerFPTRUNC(MachineInstr &MI);

llvm/include/llvm/CodeGen/GlobalISel/LegalizerInfo.h

@@ -685,6 +685,15 @@ class LegalizeRuleSet {
                     LegalityPredicates::typePairAndMemDescInSet(
                         typeIdx(0), typeIdx(1), /*MMOIdx*/ 0, TypesAndMemDesc));
   }
+  LegalizeRuleSet &legalForTypesWithMemDesc(
+      bool Pred, std::initializer_list<LegalityPredicates::TypePairAndMemDesc>
+                     TypesAndMemDesc) {
+    if (!Pred)
+      return *this;
+    return actionIf(LegalizeAction::Legal,
+                    LegalityPredicates::typePairAndMemDescInSet(
+                        typeIdx(0), typeIdx(1), /*MMOIdx=*/0, TypesAndMemDesc));
+  }
   /// The instruction is legal when type indexes 0 and 1 are both in the given
   /// list. That is, the type pair is in the cartesian product of the list.
   LegalizeRuleSet &legalForCartesianProduct(std::initializer_list<LLT> Types) {

llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h

@@ -1083,6 +1083,19 @@ class LLVM_ABI MachineIRBuilder {
   MachineInstrBuilder buildStore(const SrcOp &Val, const SrcOp &Addr,
                                  MachineMemOperand &MMO);
 
+  /// Build and insert `<opcode> Val, Addr, MMO`.
+  ///
+  /// Stores the value \p Val to \p Addr.
+  ///
+  /// \pre setBasicBlock or setMI must have been called.
+  /// \pre \p Val must be a generic virtual register.
+  /// \pre \p Addr must be a generic virtual register with pointer type.
+  ///
+  /// \return a MachineInstrBuilder for the newly created instruction.
+  MachineInstrBuilder buildStoreInstr(unsigned Opcode, const SrcOp &Val,
+                                      const SrcOp &Addr,
+                                      MachineMemOperand &MMO);
+
   /// Build and insert a G_STORE instruction, while constructing the
   /// MachineMemOperand.
   MachineInstrBuilder

llvm/include/llvm/Support/TargetOpcodes.def

@@ -409,6 +409,9 @@ HANDLE_TARGET_OPCODE(G_SEXTLOAD)
 /// Generic zeroext load
 HANDLE_TARGET_OPCODE(G_ZEXTLOAD)
 
+/// Generic floating-point extending load
+HANDLE_TARGET_OPCODE(G_FPEXTLOAD)
+
 /// Generic indexed load (including anyext load)
 HANDLE_TARGET_OPCODE(G_INDEXED_LOAD)
 
@@ -421,6 +424,9 @@ HANDLE_TARGET_OPCODE(G_INDEXED_ZEXTLOAD)
 /// Generic store.
 HANDLE_TARGET_OPCODE(G_STORE)
 
+/// Generic floating-point truncating store
+HANDLE_TARGET_OPCODE(G_FPTRUNCSTORE)
+
 /// Generic indexed store.
 HANDLE_TARGET_OPCODE(G_INDEXED_STORE)
 

llvm/include/llvm/Target/GenericOpcodes.td

@@ -1361,6 +1361,15 @@ def G_ZEXTLOAD : GenericInstruction {
   let mayLoad = true;
 }
 
+// Generic floating-point extending load. Expects a MachineMemOperand in
+// addition to explicit operands.
+def G_FPEXTLOAD : GenericInstruction {
+  let OutOperandList = (outs type0:$dst);
+  let InOperandList = (ins ptype1:$addr);
+  let hasSideEffects = false;
+  let mayLoad = true;
+}
+
 // Generic indexed load. Combines a GEP with a load. $newaddr is set to $base + $offset.
 // If $am is 0 (post-indexed), then the value is loaded from $base; if $am is 1 (pre-indexed)
 //  then the value is loaded from $newaddr.
@@ -1397,6 +1406,15 @@ def G_STORE : GenericInstruction {
   let GISelMatchGenericTypes = 1;
 }
 
+// Generic floating-point truncating store. Expects a MachineMemOperand in
+// addition to explicit operands.
+def G_FPTRUNCSTORE : GenericInstruction {
+  let OutOperandList = (outs);
+  let InOperandList = (ins type0:$src, ptype1:$addr);
+  let hasSideEffects = false;
+  let mayStore = true;
+}
+
 // Combines a store with a GEP. See description of G_INDEXED_LOAD for indexing behaviour.
 def G_INDEXED_STORE : GenericInstruction {
   let OutOperandList = (outs ptype0:$newaddr);

llvm/include/llvm/Target/GlobalISel/SelectionDAGCompat.td

@@ -35,6 +35,11 @@ class GINodeEquiv<Instruction i, SDNode node> {
   // depending on the predicates on the node.
   Instruction IfSignExtend = ?;
   Instruction IfZeroExtend = ?;
+  // In contrast to SelectionDAG we would like not to overload an anyext load
+  // for floating point truncation and extending stores and loads. Instead we
+  // assign separate opcodes for it.
+  Instruction IfFPExtend = ?;
+  Instruction IfFPTrunc = ?;
 
   // SelectionDAG has one setcc for all compares. This differentiates
   // for G_ICMP and G_FCMP.
@@ -236,6 +241,7 @@ def : GINodeEquiv<G_LOAD, ld> {
   let CheckMMOIsNonAtomic = true;
   let IfSignExtend = G_SEXTLOAD;
   let IfZeroExtend = G_ZEXTLOAD;
+  let IfFPExtend = G_FPEXTLOAD;
 }
 
 def : GINodeEquiv<G_ICMP, setcc> {
@@ -249,7 +255,11 @@ def : GINodeEquiv<G_ICMP, setcc> {
 // G_STORE handles both atomic and non-atomic stores where as SelectionDAG had
 // separate nodes for them. This GINodeEquiv maps the non-atomic stores to
 // G_STORE with a non-atomic MachineMemOperand.
-def : GINodeEquiv<G_STORE, st> { let CheckMMOIsNonAtomic = true; }
+def : GINodeEquiv<G_STORE, st> {
+  let CheckMMOIsNonAtomic = true;
+  let IfFPTrunc = G_FPTRUNCSTORE;
+}
+
 def : GINodeEquiv<G_STORE, atomic_store> {
   let CheckMMOIsNonAtomic = false;
   let CheckMMOIsAtomic = true;