[SveEmitter] NFCI: Describe splat operands like any other modifier

[sdesmalen]

Summary

For scalar operands that need to be splat to a vector,
this patch adds a bool to the SVEType struct so that the
applyModifier function sets the value appropriately.
This makes the implementation/meaning of the modifiers more
transparent.

[SjoerdMeijer]

clang/utils/TableGen/SveEmitter.cpp

68

I was wondering if IsSplat belongs here or somewhere else. It doesn't sound like a type, like the other members do, but more a specific case of a vector? But saying this off the top of my head, haven't looked at the code and the context, but perhaps you can comment on this if this is where it should be or not.

[sdesmalen]

Thanks for having a look @SjoerdMeijer

clang/utils/TableGen/SveEmitter.cpp

68

This is for type modifiers like a which is defined as:

a: scalar of element type (splat to vector type)

which is used in the definition of the _n forms of builtins like:

svuint16_t svadd_n_u16_z(svbool_t pg, svuint16_t op1, uint16_t op2)

Here op2 is uint16_t instead of svuint16_t. This operand is conceptually splat to a SVE vector for the operation (that is what the instruction will do). This is also how we implement it in CGBuiltin, because there is only a LLVM IR intrinsic for the (vector, vector) form. In CodeGen we may map the (vector, vector) form back onto a (vector, imm) instruction if the value fits the immediate.

Because it is part of the modifier, I thought it made sense to add that information to SVEType so that applyModifier can set that property, avoiding the very opaque Proto.find_first_of("ajfrKLR") in hasSplat to determine this. Maybe it isn't strictly part of the type (although you can probably also argue it kind of is), but in any case I thought might make the code a bit more readable because now all such information can live in one place (applyModifier).

clang/utils/TableGen/SveEmitter.cpp

public:
 
   unsigned getArg() const { return Arg; }
   unsigned getKind() const { return Kind; }
   unsigned getElementSizeInBits() const { return ElementSizeInBits; }
 };
 
 class SVEType {
   TypeSpec TS;
+  bool IsSplat;
   bool Float, Signed, Immediate, Void, Constant, Pointer;
   bool DefaultType, IsScalable, Predicate, PredicatePattern, PrefetchOp;
   unsigned Bitwidth, ElementBitwidth, NumVectors;
 
 public:
   SVEType() : SVEType(TypeSpec(), 'v') {}
 
   SVEType(TypeSpec TS, char CharMod)
-      : TS(TS), Float(false), Signed(true), Immediate(false), Void(false),
-        Constant(false), Pointer(false), DefaultType(false), IsScalable(true),
-        Predicate(false), PredicatePattern(false), PrefetchOp(false),
-        Bitwidth(128), ElementBitwidth(~0U), NumVectors(1) {
+      : TS(TS), IsSplat(false), Float(false), Signed(true), Immediate(false),
+        Void(false), Constant(false), Pointer(false), DefaultType(false),
+        IsScalable(true), Predicate(false), PredicatePattern(false),
+        PrefetchOp(false), Bitwidth(128), ElementBitwidth(~0U), NumVectors(1) {
     if (!TS.empty())
       applyTypespec();
     applyModifier(CharMod);
   }
 
   bool isPointer() const { return Pointer; }
   bool isVoidPointer() const { return Pointer && Void; }
   bool isSigned() const { return Signed; }
   bool isImmediate() const { return Immediate; }
   bool isScalar() const { return NumVectors == 0; }
   bool isVector() const { return NumVectors > 0; }
   bool isScalableVector() const { return isVector() && IsScalable; }
   bool isChar() const { return ElementBitwidth == 8; }
   bool isVoid() const { return Void & !Pointer; }
   bool isDefault() const { return DefaultType; }
   bool isFloat() const { return Float; }
   bool isInteger() const { return !Float && !Predicate; }
   bool isScalarPredicate() const { return !Float && ElementBitwidth == 1; }
   bool isPredicateVector() const { return Predicate; }
   bool isPredicatePattern() const { return PredicatePattern; }
   bool isPrefetchOp() const { return PrefetchOp; }
   bool isConstant() const { return Constant; }
+  bool isSplat() const { return IsSplat; }
   unsigned getElementSizeInBits() const { return ElementBitwidth; }
   unsigned getNumVectors() const { return NumVectors; }
 
   unsigned getNumElements() const {
     assert(ElementBitwidth != ~0U);
     return Bitwidth / ElementBitwidth;
   }
   unsigned getSizeInBits() const {
public:
   static bool isOverloadedIntrinsic(StringRef Name) {
     auto BrOpen = Name.find("[");
     auto BrClose = Name.find(']');
     return BrOpen != std::string::npos && BrClose != std::string::npos;
   }
 
   /// Return true if the intrinsic takes a splat operand.
   bool hasSplat() const {
-    // These prototype modifiers are described in arm_sve.td.
-    return Proto.find_first_of("ajfrKLR") != std::string::npos;
+    return llvm::any_of(getTypes(), [](const SVEType &T) { return T.isSplat(); });
   }
 
   /// Return the parameter index of the splat operand.
   unsigned getSplatIdx() const {
-    // These prototype modifiers are described in arm_sve.td.
-    auto Idx = Proto.find_first_of("ajfrKLR");
-    assert(Idx != std::string::npos && Idx > 0 &&
-           "Prototype has no splat operand");
-    return Idx - 1;
+    return std::distance(
+        &Types[1], //Types.begin(),
+        llvm::find_if(getTypes(), [](const SVEType &T) { return T.isSplat(); }));
   }
 
   /// Emits the intrinsic declaration to the ostream.
   void emitIntrinsic(raw_ostream &OS) const;
 
 private:
   std::string getMergeSuffix() const { return MergeSuffix; }
   std::string mangleName(ClassKind LocalCK) const;
case 'o':
     break;
   case 'P':
     Signed = true;
     Float = false;
     Predicate = true;
     Bitwidth = 16;
     ElementBitwidth = 1;
     break;
-  case 's':
   case 'a':
+    IsSplat = true;
+    LLVM_FALLTHROUGH;
+  case 's':
     Bitwidth = ElementBitwidth;
     NumVectors = 0;
     break;
   case 'u':
     Predicate = false;
     Signed = false;
     Float = false;
     break;
case 'n':
     Float = false;
     ElementBitwidth = Bitwidth = 64;
     NumVectors = 0;
     break;
   case 'w':
     ElementBitwidth = 64;
     break;
   case 'j':
+    IsSplat = true;
     ElementBitwidth = Bitwidth = 64;
     NumVectors = 0;
     break;
   case 't':
     Signed = true;
     Float = false;
     ElementBitwidth = 32;
     break;