[RISCV][NFC] Remove `*=` operator for LMULType

[eopXD]

Summary

LMULType always manipulate on Log2LMUL, let all manipulations go
through LMULType::MulLog2LMUL.

[khchen]

LGTM, thanks.

clang/include/clang/Support/RISCVVIntrinsicUtils.h

 // Exponential LMUL
 struct LMULType {
   int Log2LMUL;
   LMULType(int Log2LMUL);
   // Return the C/C++ string representation of LMUL
   std::string str() const;
   llvm::Optional<unsigned> getScale(unsigned ElementBitwidth) const;
   void MulLog2LMUL(int Log2LMUL);
-  LMULType &operator*=(uint32_t RHS);
 };
 
 class RVVType;
 using RVVTypePtr = RVVType *;
 using RVVTypes = std::vector<RVVTypePtr>;
 
 // This class is compact representation of a valid and invalid RVVType.
 class RVVType {

clang/lib/Support/RISCVVIntrinsicUtils.cpp

VScaleVal LMULType::getScale(unsigned ElementBitwidth) const {
   // Illegal vscale result would be less than 1
   if (Log2ScaleResult < 0)
     return llvm::None;
   return 1 << Log2ScaleResult;
 }
 
 void LMULType::MulLog2LMUL(int log2LMUL) { Log2LMUL += log2LMUL; }
 
-LMULType &LMULType::operator*=(uint32_t RHS) {
-  assert(isPowerOf2_32(RHS));
-  this->Log2LMUL = this->Log2LMUL + Log2_32(RHS);
-  return *this;
-}
-
 RVVType::RVVType(BasicType BT, int Log2LMUL,
                  const PrototypeDescriptor &prototype)
     : BT(BT), LMUL(LMULType(Log2LMUL)) {
   applyBasicType();
   applyModifier(prototype);
   Valid = verifyType();
   if (Valid) {
     initBuiltinStr();
void RVVType::applyModifier(const PrototypeDescriptor &Transformer) {
   case BaseTypeModifier::Invalid:
     ScalarType = ScalarTypeKind::Invalid;
     return;
   }
 
   switch (static_cast<VectorTypeModifier>(Transformer.VTM)) {
   case VectorTypeModifier::Widening2XVector:
     ElementBitwidth *= 2;
-    LMUL *= 2;
+    LMUL.MulLog2LMUL(1);
     Scale = LMUL.getScale(ElementBitwidth);
     break;
   case VectorTypeModifier::Widening4XVector:
     ElementBitwidth *= 4;
-    LMUL *= 4;
+    LMUL.MulLog2LMUL(2);
     Scale = LMUL.getScale(ElementBitwidth);
     break;
   case VectorTypeModifier::Widening8XVector:
     ElementBitwidth *= 8;
-    LMUL *= 8;
+    LMUL.MulLog2LMUL(3);
     Scale = LMUL.getScale(ElementBitwidth);
     break;
   case VectorTypeModifier::MaskVector:
     ScalarType = ScalarTypeKind::Boolean;
     Scale = LMUL.getScale(ElementBitwidth);
     ElementBitwidth = 1;
     break;
   case VectorTypeModifier::Log2EEW3: