[ARM,MVE] Integer-type nitpicks in MVE intrinsics.

[simon_tatham]

Summary

A few integer types in the ACLE definitions of MVE intrinsics are
given as 'int' or 'unsigned' instead of <stdint.h> fixed-size types
like uint32_t. Usually these are the ones where the size isn't that
important, such as immediate offsets in loads (which have a range
limited by the instruction encoding) or the carry flag in vadcq which
can only be 0 or 1 anyway.

With this change, <arm_mve.h> follows that exact type naming, so that
the function prototypes look identical to the ones in ACLE, instead of
replacing int and unsigned with int32_t and uint32_t.

[dmgreen]

clang/utils/TableGen/MveEmitter.cpp

551

Can you explain this, is it related to something else?

[simon_tatham]

Removed the asValue system, which (as you'd guessed) ought to have
been part of D69791.

[dmgreen]

LGTM then.

clang/include/clang/Basic/arm_mve.td

 def urshrl: Intrinsic<u64, (args u64:$value, imm_1to32:$shift),
                       (seq (u32 (lshr $value, (u64 32))):$hi,
                            (u32 $value):$lo,
                            (IRInt<"urshrl"> $lo, $hi, $shift):$pair,
                            (or (shl (u64 (xval $pair, 1)), (u64 32)),
                                (u64 (xval $pair, 0))))>;
 
 let params = T.Int32 in {
-def vadcq: Intrinsic<Vector, (args Vector:$a, Vector:$b, Ptr<u32>:$carry),
+def vadcq: Intrinsic<Vector, (args Vector:$a, Vector:$b, Ptr<uint>:$carry),
     (seq (IRInt<"vadc", [Vector]> $a, $b, (shl (load $carry), 29)):$pair,
          (store (and 1, (lshr (xval $pair, 1), 29)), $carry),
          (xval $pair, 0))>;
-def vadciq: Intrinsic<Vector, (args Vector:$a, Vector:$b, Ptr<u32>:$carry),
+def vadciq: Intrinsic<Vector, (args Vector:$a, Vector:$b, Ptr<uint>:$carry),
     (seq (IRInt<"vadc", [Vector]> $a, $b, 0):$pair,
          (store (and 1, (lshr (xval $pair, 1), 29)), $carry),
          (xval $pair, 0))>;
 def vadcq_m: Intrinsic<Vector, (args Vector:$inactive, Vector:$a, Vector:$b,
-                                     Ptr<u32>:$carry, Predicate:$pred),
+                                     Ptr<uint>:$carry, Predicate:$pred),
     (seq (IRInt<"vadc_predicated", [Vector, Predicate]> $inactive, $a, $b,
              (shl (load $carry), 29), $pred):$pair,
          (store (and 1, (lshr (xval $pair, 1), 29)), $carry),
          (xval $pair, 0))>;
 def vadciq_m: Intrinsic<Vector, (args Vector:$inactive, Vector:$a, Vector:$b,
-                                      Ptr<u32>:$carry, Predicate:$pred),
+                                      Ptr<uint>:$carry, Predicate:$pred),
     (seq (IRInt<"vadc_predicated", [Vector, Predicate]> $inactive, $a, $b,
              0, $pred):$pair,
          (store (and 1, (lshr (xval $pair, 1), 29)), $carry),
          (xval $pair, 0))>;
 }

clang/include/clang/Basic/arm_mve_defs.td

 // of _s32 / _f16 / _u8 suffix.
 def Void : Type;
 
 // Primitive types: base class, and an instance for the set of scalar integer
 // and floating types that MVE uses.
 class PrimitiveType<string kind_, int size_>: Type {
   string kind = kind_;
   int size = size_;
+  string nameOverride = "";
 }
+
 // The type records defined by these foreaches have names like s32, f16, u8.
 foreach size = [8, 16, 32, 64] in
   foreach kind = ["u", "s"] in
     def kind # size: PrimitiveType<kind, size>;
 foreach size = [16, 32] in
   foreach kind = ["f"] in
     def kind # size: PrimitiveType<kind, size>;
 
+// Sometimes we need to refer to a type by a different name in C, when
+// ACLE defines a function parameter to be something like 'unsigned'
+// rather than uint32_t.
+def uint: PrimitiveType<"u", 32> { let nameOverride = "unsigned"; }
+def sint: PrimitiveType<"s", 32> { let nameOverride = "int"; }
+
 // VecOf<t> expects t to be a scalar, and gives a 128-bit vector of whatever it
 // is.
 class VecOf<Type t>: ComplexType<(CTO_Vec t)>;
 
 // PredOf expects t to be a scalar, and expands to a predicate vector which
 // (logically speaking) has the same number of lanes as VecOf<t> would.
 class PredOf<Type t>: ComplexType<(CTO_Pred t)>;
 

 def imm_1248 : Immediate<u32, IB_ConstRange<1, 8>> {
   let extra = "Power2";
 }
 
 // imm_mem7bit<n> is a valid immediate offset for a load/store intrinsic whose
 // memory access size is n bytes (e.g. 1 for vldrb_[whatever], 2 for vldrh,
 // ...). The set of valid immediates for these is {0*n, 1*n, ..., 127*n}.
 class imm_mem7bit<int membytes>
-  : Immediate<u32, IB_ConstRange<0, !mul(membytes, 127)>> {
+  : Immediate<sint, IB_ConstRange<0, !mul(membytes, 127)>> {
   let extra = !if(!eq(membytes, 1), ?, "Multiple");
   let extraarg = !cast<string>(membytes);
 }
 
 // -----------------------------------------------------------------------------
 // Specification of ways that the full name of an intrinsic can be mapped to
 // its shorter polymorphic name.
 

clang/utils/TableGen/MveEmitter.cpp

 
 public:
   std::string cName() const override { return cNameBase() + "_t"; }
 };
 
 class ScalarType : public CRegularNamedType {
   ScalarTypeKind Kind;
   unsigned Bits;
+  std::string NameOverride;
 
 public:
   ScalarType(const Record *Record) : CRegularNamedType(TypeKind::Scalar) {
     Kind = StringSwitch<ScalarTypeKind>(Record->getValueAsString("kind"))
                .Case("s", ScalarTypeKind::SignedInt)
                .Case("u", ScalarTypeKind::UnsignedInt)
                .Case("f", ScalarTypeKind::Float);
     Bits = Record->getValueAsInt("size");
+    NameOverride = Record->getValueAsString("nameOverride");
   }
   unsigned sizeInBits() const override { return Bits; }
   ScalarTypeKind kind() const { return Kind; }
   std::string suffix() const { return toLetter(Kind) + utostr(Bits); }
   std::string cNameBase() const override {
     return toCPrefix(Kind) + utostr(Bits);
   }
+  std::string cName() const override {
+    if (NameOverride.empty())
+      return CRegularNamedType::cName();
+    return NameOverride;
+  }
   std::string llvmName() const override {
     if (Kind == ScalarTypeKind::Float) {
       if (Bits == 16)
         return "HalfTy";
       if (Bits == 32)
         return "FloatTy";
       if (Bits == 64)
         return "DoubleTy";
       PrintFatalError("bad size for floating type");
     }
     return "Int" + utostr(Bits) + "Ty";
   }
   std::string acleSuffix() const override {
     return "_" + toLetter(Kind) + utostr(Bits);
   }
   bool isInteger() const { return Kind != ScalarTypeKind::Float; }
   bool requiresFloat() const override { return !isInteger(); }
+  bool hasNonstandardName() const { return !NameOverride.empty(); }
 
   static bool classof(const Type *T) {
     return T->typeKind() == TypeKind::Scalar;
   }
 };
 
 class VectorType : public CRegularNamedType {
   const ScalarType *Element;
public:
   void genCode(raw_ostream &OS, CodeGenParamAllocator &) const override {
     OS << (AddressType ? "EmitPointerWithAlignment" : "EmitScalarExpr")
        << "(E->getArg(" << ArgNum << "))";
   }
   std::string typeName() const override {
     return AddressType ? "Address" : Result::typeName();
   }
 };
 
 // Result subclass for an integer literal appearing in Tablegen. This may need
 // to be turned into an llvm::Result by means of llvm::ConstantInt::get(), or
 // it may be used directly as an integer, depending on which IRBuilder method
 // it's being passed to.
 class IntLiteralResult : public Result {
 public:
   const ScalarType *IntegerType;
   uint32_t IntegerValue;
void MveEmitter::EmitHeader(raw_ostream &OS) {
   // Write typedefs for all the required vector types, and a few scalar
   // types that don't already have the name we want them to have.
 
   parts[0] << "typedef uint16_t mve_pred16_t;\n";
   parts[Float] << "typedef __fp16 float16_t;\n"
                   "typedef float float32_t;\n";
   for (const auto &kv : ScalarTypes) {
     const ScalarType *ST = kv.second.get();
+    if (ST->hasNonstandardName())
+      continue;
     raw_ostream &OS = parts[ST->requiresFloat() ? Float : 0];
     const VectorType *VT = getVectorType(ST);
 
     OS << "typedef __attribute__((neon_vector_type(" << VT->lanes() << "))) "
        << ST->cName() << " " << VT->cName() << ";\n";
 
     // Every vector type also comes with a pair of multi-vector types for
     // the VLD2 and VLD4 instructions.