[RISCV] Add additional checking to tablgen RISCVVEmitter requested in D95016.

[craig.topper]

Summary

This errors, but doesn't give source location. We'd need to pass
the Record through several layers to get to the location.

[jrtc27]

Any TableGen backend error that's a real message and not an assertion failure with a backtrace is a win in my books :)

clang/utils/TableGen/RISCVVEmitter.cpp

627

Hm, if this is the actual parser then these should also be PrintFatalError (another instance earlier in the function, and one in applyBasicType)?

[craig.topper]

Turn some llvm_unreachables into fatal errors

clang/utils/TableGen/RISCVVEmitter.cpp

 //===- RISCVVEmitter.cpp - Generate riscv_vector.h for use with clang -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This tablegen backend is responsible for emitting riscv_vector.h and
 // riscv_vector_generic.h, which includes a declaration and definition of each
 // intrinsic fucntions specified in https://github.com/riscv/rvv-intrinsic-doc.
 //
 // See also the documentation in include/clang/Basic/riscv_vector.td.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace llvm;
 using BasicType = char;
 using VScaleVal = Optional<unsigned>;
 
 namespace {
 
case 'f':
     ElementBitwidth = 32;
     ScalarType = ScalarTypeKind::Float;
     break;
   case 'd':
     ElementBitwidth = 64;
     ScalarType = ScalarTypeKind::Float;
     break;
   default:
-    llvm_unreachable("Unhandled type code!");
+    PrintFatalError("Unhandled type code!");
   }
   assert(ElementBitwidth != 0 && "Bad element bitwidth!");
 }
 
 void RVVType::applyModifier(StringRef Transformer) {
   if (Transformer.empty())
     return;
   // Handle primitive type transformer
case 't':
     ScalarType = ScalarTypeKind::Ptrdiff_t;
     break;
   case 'c': // uint8_t
     ScalarType = ScalarTypeKind::UnsignedInteger;
     ElementBitwidth = 8;
     Scale = 0;
     break;
   default:
-    llvm_unreachable("Illegal primitive type transformers!");
+    PrintFatalError("Illegal primitive type transformers!");
   }
   Transformer = Transformer.drop_back();
 
   // Compute type transformers
   for (char I : Transformer) {
     switch (I) {
     case 'P':
+      if (IsConstant)
+        PrintFatalError("'P' transformer cannot be used after 'C'");
+      if (IsPointer)
+        PrintFatalError("'P' transformer cannot be used twice");
       IsPointer = true;
       break;
     case 'C':
+      if (IsConstant)
+        PrintFatalError("'C' transformer cannot be used twice");
       IsConstant = true;
       break;
     case 'K':
       IsImmediate = true;
       break;
     case 'U':
       ScalarType = ScalarTypeKind::UnsignedInteger;
       break;
     case 'I':
       ScalarType = ScalarTypeKind::SignedInteger;
       break;
     case 'F':
       ScalarType = ScalarTypeKind::Float;
       break;
     case 'S':
       LMUL = LMULType(0);
-      // Update ElementBitwidth need ot update Scale too.
+      // Update ElementBitwidth need to update Scale too.
       Scale = LMUL.getScale(ElementBitwidth);
       break;
     default:
-      llvm_unreachable("Illegal non-primitive type transformer!");
+      PrintFatalError("Illegal non-primitive type transformer!");
     }
   }
 }
 
 //===----------------------------------------------------------------------===//
 // RVVIntrinsic implementation
 //===----------------------------------------------------------------------===//
 RVVIntrinsic::RVVIntrinsic(StringRef NewName, StringRef Suffix,