[RISCV] Resolve a few bugs in RISCVVIntrinsicUtils.cpp

[4vtomat]

Summary

This patch does a few things:

1. Add a new type called Undefined to ScalarTypeKind.
2. Make RVVType::applyModifier early return when encounter invalid ScalarType, otherwise it could be modified to "non-invalid" type in the following code.
3. When FixedLMULType::SmallerThan is applied, the lmul should be "<" than specified one, so lmuls which are ">=" should be marked as invalid.

[kito-cheng]

Does it possible to add a precommit test case to show that we accept unexpected combination of the type?

[eopXD]

clang/lib/Sema/SemaRISCVVectorLookup.cpp

136

Could we just reuse Invalid?

[4vtomat]

Add a test case for invalid example.

[4vtomat]

clang/lib/Sema/SemaRISCVVectorLookup.cpp

136

We can't reuse Invalid, since ScalarType in RVVType class is default to Invalid, we are not able to determine whether it's really invalid or not during applyModifier function, so that's the reason why I added Undefined to differentiate between default and really invalid.

[kito-cheng]

LGTM

clang/lib/Sema/SemaRISCVVectorLookup.cpp

136

I has some question before too :P thanks for explanation!

clang/include/clang/Support/RISCVVIntrinsicUtils.h

 //===--- RISCVVIntrinsicUtils.h - RISC-V Vector Intrinsic Utils -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
enum ScalarTypeKind : uint8_t {
   Ptrdiff_t,
   UnsignedLong,
   SignedLong,
   Boolean,
   SignedInteger,
   UnsignedInteger,
   Float,
   Invalid,
+  Undefined,
 };
 
 // Exponential LMUL
 struct LMULType {
   int Log2LMUL;
   LMULType(int Log2LMUL);
   // Return the C/C++ string representation of LMUL
   std::string str() const;
   std::optional<unsigned> getScale(unsigned ElementBitwidth) const;
   void MulLog2LMUL(int Log2LMUL);
 };
 
 class RVVType;
 using RVVTypePtr = RVVType *;
 using RVVTypes = std::vector<RVVTypePtr>;
 class RVVTypeCache;
 
 // This class is compact representation of a valid and invalid RVVType.
 class RVVType {
   friend class RVVTypeCache;
 
   BasicType BT;
-  ScalarTypeKind ScalarType = Invalid;
+  ScalarTypeKind ScalarType = Undefined;
   LMULType LMUL;
   bool IsPointer = false;
   // IsConstant indices are "int", but have the constant expression.
   bool IsImmediate = false;
   // Const qualifier for pointer to const object or object of const type.
   bool IsConstant = false;
   unsigned ElementBitwidth = 0;
   VScaleVal Scale = 0;

clang/lib/Sema/SemaRISCVVectorLookup.cpp

 //==- SemaRISCVVectorLookup.cpp - Name Lookup for RISC-V Vector Intrinsic -==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
case ScalarTypeKind::Float:
     case 16:
       QT = Context.Float16Ty;
       break;
     default:
       llvm_unreachable("Unsupported floating point width.");
     }
     break;
   case Invalid:
+  case Undefined:
     llvm_unreachable("Unhandled type.");
   }
   if (Type->isVector()) {
     if (Type->isTuple())
       QT = Context.getScalableVectorType(QT, *Type->getScale(), Type->getNF());
     else
       QT = Context.getScalableVectorType(QT, *Type->getScale());
   }

clang/lib/Support/RISCVVIntrinsicUtils.cpp

 //===- RISCVVIntrinsicUtils.cpp - RISC-V Vector Intrinsic Utils -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
case VectorTypeModifier::Tuple8: {
     NF = 2 + static_cast<uint8_t>(Transformer.VTM) -
          static_cast<uint8_t>(VectorTypeModifier::Tuple2);
     break;
   }
   case VectorTypeModifier::NoModifier:
     break;
   }
 
+  // Early return if the current type modifier is already invalid.
+  if (ScalarType == Invalid)
+    return;
+
   for (unsigned TypeModifierMaskShift = 0;
        TypeModifierMaskShift <= static_cast<unsigned>(TypeModifier::MaxOffset);
        ++TypeModifierMaskShift) {
     unsigned TypeModifierMask = 1 << TypeModifierMaskShift;
     if ((static_cast<unsigned>(Transformer.TM) & TypeModifierMask) !=
         TypeModifierMask)
       continue;
     switch (static_cast<TypeModifier>(TypeModifierMask)) {
void RVVType::applyFixedSEW(unsigned NewSEW) {
   // Update new SEW
   ElementBitwidth = NewSEW;
   Scale = LMUL.getScale(ElementBitwidth);
 }
 
 void RVVType::applyFixedLog2LMUL(int Log2LMUL, enum FixedLMULType Type) {
   switch (Type) {
   case FixedLMULType::LargerThan:
-    if (Log2LMUL < LMUL.Log2LMUL) {
+    if (Log2LMUL <= LMUL.Log2LMUL) {
       ScalarType = ScalarTypeKind::Invalid;
       return;
     }
     break;
   case FixedLMULType::SmallerThan:
-    if (Log2LMUL > LMUL.Log2LMUL) {
+    if (Log2LMUL >= LMUL.Log2LMUL) {
       ScalarType = ScalarTypeKind::Invalid;
       return;
     }
     break;
   }
 
   // Update new LMUL
   LMUL = LMULType(Log2LMUL);