[RISCV] Add the zvl extension according to the v1.0 spec

[eopXD]

Summary

zvl is the new standard vector extension that specifies the minimum vector length of the vector extension.
The zvl extension is related to the zve extension and other updates that are added in v1.0.

According to https://github.com/riscv-non-isa/riscv-c-api-doc/pull/21,
Clang defines macro __riscv_v_min_vlen for zvl and it can be used for applications that uses the vector extension.
LLVM checks whether the option riscv-v-vector-bits-min (if specified) matches the zvl* extension specified.

[eopXD]

Update code, bug fixes to this patch.

[eopXD]

llvm/lib/Target/RISCV/RISCV.td

197

Don't need the AssemblerPredicate here because this sub-extension is used to restrict vlen, which is treated as a constant in the assembly.

llvm/lib/Target/RISCV/RISCVSubtarget.h

137

I don't think this function will be called. However other sub-extensions will have this function so I still created it.

[kito-cheng]

llvm/lib/Support/RISCVISAInfo.cpp

72

Although the table in vector spec only list zvl32b~zvl1024b, but there is note say Longer vector length extensions should follow the same pattern.[1], so I would suggest let enumerate to 65536, the unbound of VLEN[2],

[1] https://github.com/riscv/riscv-v-spec/blob/master/v-spec.adoc#181-zvl-minimum-vector-length-standard-extensions
[2] https://github.com/riscv/riscv-v-spec/blob/master/v-spec.adoc#2-implementation-defined-constant-parameters

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

134

I guess this should be more than an assertion? but I am not sure does it make sense to emit error or warning here? or just silently return ZvlLen if RVVVectorBitsMin is less than ZvlLen.

[kito-cheng]

llvm/lib/Support/RISCVISAInfo.cpp

72

Oh, typo, unbound should be upper bound :p

[eopXD]

Address comments.

• enumerate zvl up to 65536
• fix grammitcal error in assertion error message

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

134

I think the compiler should not return ZvlLen silently if the specified RVVVectorBitsMin is less. As zvl hard restricts the minimum vlen, the user should be aware (notified) of that. I think the assertion error here can guide the user to either increase their RVVVectorBitsMin in the argument or compile under another architecture specification.

[craig.topper]

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

112

The max should be greater than ZvlLen right?

127

Some of the callers of this will break if it returns a value less than 64. We need to limit ELEN to 32 if VLEN is 32. And we can't use LMUL=1/8 with i8 vectors, or LMUL=1/4 with i16 vector, or LMUL=1/2 with i32 vector.

134

assertions are compiled out of release builds. The code after the assertions was trying to do something sane for release builds.

[craig.topper]

I think we need to visit some larger aspects of our vector implementation. Here are some thoughts.

-Most uses of Subtarget.hasStdExtV() don't really mean what the spec calls the standard V extension. They just means that we have vector instructions. Could be V, could be one of the Zve32* or Zve64* extensions.
-V extension passed to -march should imply at least Zvl128b.
-V extension passed to -march should enable F and D.
-Does Zvl32b passed to march enable vector instructions? Or do we still need Zve32* or Zve64* or V?
-If Zvl32b is in effect the i64 and f64 RVV intrinsics need to be disabled.

[kito-cheng]

Those rule are unclear to me too, I created an issue on vector spec, I guess we need writing few special rule for those extensions...

https://github.com/riscv/riscv-v-spec/issues/723

In D108694#2966553, @craig.topper wrote:

I think we need to visit some larger aspects of our vector implementation. Here are some thoughts.

-Most uses of Subtarget.hasStdExtV() don't really mean what the spec calls the standard V extension. They just means that we have vector instructions. Could be V, could be one of the Zve32* or Zve64* extensions.
-V extension passed to -march should imply at least Zvl128b.
-V extension passed to -march should enable F and D.
-Does Zvl32b passed to march enable vector instructions? Or do we still need Zve32* or Zve64* or V?
-If Zvl32b is in effect the i64 and f64 RVV intrinsics need to be disabled.

[HsiangKai]

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

127

We have an implicit assumption that VLEN >= 64 from our VLA types. I suggest use 64 as the lower bound and add a FIXME here for VLEN is 32.

134

Should it be RVVVectorBitsMin < ZvlLen?

I suggest to return 0 and print a warning message for users.

[HsiangKai]

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

112

Should it be less than or equal to ZvlLen? I would suggest to return 0 when RVVVectorBitsMax > ZvlLen.
The value also needs to >= 64.

[craig.topper]

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

134

This isn't a good place to print warnings. It would just be a random message printed to stderr without going through any of clang's diagnostic infrastructure.

[HsiangKai]

In D108694#2966553, @craig.topper wrote:

I think we need to visit some larger aspects of our vector implementation. Here are some thoughts.

-Most uses of Subtarget.hasStdExtV() don't really mean what the spec calls the standard V extension. They just means that we have vector instructions. Could be V, could be one of the Zve32* or Zve64* extensions.
-V extension passed to -march should imply at least Zvl128b.
-V extension passed to -march should enable F and D.
-Does Zvl32b passed to march enable vector instructions? Or do we still need Zve32* or Zve64* or V?
-If Zvl32b is in effect the i64 and f64 RVV intrinsics need to be disabled.

We need to apply the constraints of Zve* to intrinsics/pseudo instructions. I am not sure what is the behavior if users specify V and Zve* at the same time? I think Zve* is more complicated. We could prepare another patch for it.

Could we support Zvl32b? We already have an implicit constraint of vlen >= 64 from our VLA types, right?

[eopXD]

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

134

I think moving the check to initializeSubtargetDependencies and use report_fatal_error will be a more appropriate approach?

[craig.topper]

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

134

I think that causes clang to generate a crash report and telling the user to file a bug.

Forgot to mention, all this code is also being modified by D107290

[eopXD]

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

134

I see, then my proposal is invalid.

I am not yet that familiar with the code base. I see RISCVFrameLowering.cpp using LLVMContext::diagnose, but RISCVSubtarget here doesn't seem to have access to LLVMContext.

May you recommend a pointer to some diagnose function I can use to tell the user this is an invalid setting between RVVVectorBitsMin(from riscv-v-vector-bits-min) and ZvlLen (from -march=zvl*b)?

[frasercrmck]

I also don't think we're ready/able to support Zvl32b for the reasons stated above. I think the smoothest path forward would be, as @HsiangKai suggests, to only support VLEN>=64 and revisit 32. Supporting 32 is (I think) a much larger thing owing to our codegen assumptions on VLEN and ELEN. And, as @craig.topper said, there are a few little things that would probably be best prepared before this patch, replacing some of the calls to hasStdExtV at least (hasVVectors, for codegen purposes?). It sounds like we're unsure on some of the finer details about how the extensions interact.

[craig.topper]

In D108694#2971960, @frasercrmck wrote:

I also don't think we're ready/able to support Zvl32b for the reasons stated above. I think the smoothest path forward would be, as @HsiangKai suggests, to only support VLEN>=64 and revisit 32. Supporting 32 is (I think) a much larger thing owing to our codegen assumptions on VLEN and ELEN. And, as @craig.topper said, there are a few little things that would probably be best prepared before this patch, replacing some of the calls to hasStdExtV at least (hasVVectors, for codegen purposes?). It sounds like we're unsure on some of the finer details about how the extensions interact.

I think our mapping from lmul/sew to <vscale x Y x iZ> types also break with VLEN=32. I haven't been able to figure out a single mapping that works for VLEN=32 and VLEN=64 and supports i64 vectors. To support VLEN=32 we need to reduce RVVBitsPerBlock to 32, but then you can't fit an i64 element into it.

[eopXD]

Address comments and add macro in clang.

[eopXD]

Rebase.

[eopXD]

Rebase.

[eopXD]

Fix clang-format.

[eopXD]

Update code.

[eopXD]

Add implication: v imply d and f

[eopXD]

Address comments:

• remove duplicate checkDependency()
• stay consistent in my patch of using auto for StringRef

[eopXD]

Update.

[eopXD]

Change:

• Address commments on restrictions in RISCVSubtarget.cpp
• Fix clang-format fail
• Fix test case fail

[eopXD]

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

134

I see code under RISCVSubtarget::initializeSubtargetDependencies also using report_fatal_error:

[eopXD]

Update code.

[eopXD]

Update code.

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

112

@HsiangKai I think you mis-typed the equation? It should be RVVVectorBitsMax < ZvlLen ;)

[eopXD]

Fix test case.

[eopXD]

Rebase to newest main.

[eopXD]

Rebase.

[eopXD]

Rebase.

[eopXD]

Rebase now since the preceeding patches are accepted.
This patch is ready for review.

[craig.topper]

llvm/lib/Support/RISCVISAInfo.cpp

670

I think I'd like to see this as a static data structure rather than building a StringMap on the fly.

Maybe like

static const char *zvl64bimplied[] = { "zvl32b" };
static const char *zvl128bimplied[] = { "zvl64b" };
...

struct ImpliedEntry = {
  StringLiteral Name;
  ArrayRef<const char*> ImpliedExtensions;
};

static constexpr ImpliedEntry ImpliedTable[] = {
  { "zvl64b", zvl64bimplied },
  { "zvl128b", zvl128implied },
  ...
};

You can then use std::lower_bound to search the ImpliedTable to find the correct row of ImpliedTable. I haven't tested this. Maybe I'll put up a patch on the existing V implications as a proof of concept.

684

I think we should check the return value from consume_back and getAsInteger to make sure we really parsed what we think we parsed. That will prevent surprises if a new extension comes along that also starts with "zvl"

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

127

This needs the same FIXME as above.

[craig.topper]

llvm/lib/Support/RISCVISAInfo.cpp

684

This would match for "zvlsseg" right now wouldn't it?

[eopXD]

llvm/lib/Support/RISCVISAInfo.cpp

684

This would match for "zvlsseg" right now wouldn't it?

Yes, you have a point.

IsZvlExt should be ExtName.consume_front("zvl") && ExtName.consume_back("b").

[eopXD]

Rebase and address comment.

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

134

I am marking this thread as done since there are no further comments.

This patch currently uses report_fatal_error for it. Although as Craig mentioned it may not be ideal.

[frasercrmck]

clang/test/Preprocessor/riscv-target-features.c

230 ↗

(On Diff #394119)

Are we able to test non-default values of __riscv_v_min_vlen here?

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

113

Is this intuitive behaviour? If the user supplies RVVVectorBitsMax and it's less than ZvlLen, should it silently return? Or do we instead see RVVVectorBitsMax as a user-guided limit on top of the architecture? Which means it can be less but not more? I'm not sure.

[eopXD]

Rebase and address comments.

clang/test/Preprocessor/riscv-target-features.c

230 ↗

(On Diff #394119)

Yes we shall, thank you for the reminder.

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

113

Added report_fatal_error here.

[eopXD]

Rebase to latest main.

[craig.topper]

llvm/lib/Support/RISCVISAInfo.cpp

669–670

Need curly braces around the strings too.

685

getAsInteger returns an indication of success or failure. We should check that too. That will protect us in case someone creates an extension like "zvlfoob" in the future.

[eopXD]

Address comments from Craig.

[eopXD]

Ping, thank you.

[achieveartificialintelligence]

llvm/lib/Support/RISCVISAInfo.cpp

670–680

Can we compress the code?

llvm/lib/Target/RISCV/RISCV.td

169–202

Same as here.

[eopXD]

Rebase.

[eopXD]

llvm/lib/Support/RISCVISAInfo.cpp

670–680

Hi,

Thank you for leaving a comment. Do you mean to embed the list of implied extensions into the declaration of ImpliedExts? Like:

static constexpr ImpliedExtsEntry ImpliedExts[] = {
    {{"v"}, {{"zvlsseg", "zvl128b"}}},
   ...

In my opinion I think compressing here may not help because the indirection is intended to have the implications be in more sorted order that is more human readable since ImpliedExts are required to be in lexicographical order.

I am just stating my opinion on my current implementation since I think this is a coding style problem. What do you think?

[eopXD]

ping again, thank you.

[achieveartificialintelligence]

llvm/lib/Target/RISCV/RISCV.td

171–203

I think we can write in this way:

foreach i = { 5-15 } in {
  defvar I = !shl(2, i);
  def FeatureStdExtZvl#I#b
      : SubtargetFeature<"experimental-zvl"#I#"b", "ZvlLen", "ExtZvl::Zvl"#I#"b",
                        "'Zvl' (Minimum Vector Length) "#I,
                        [!cast<SubtargetFeature>("FeatureStdExtZvl"#!srl(I, 1)#"b")]>;
}

[craig.topper]

llvm/lib/Support/RISCVISAInfo.cpp

677

Use StringRef instead of auto here.

678

You can keep this auto though. iterators are ugly.

llvm/lib/Target/RISCV/RISCV.td

204

Is this used?

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

116

Why do we need an explicit Twine construction here?

127

Same here.

[eopXD]

Address comments.
Thanks for reviewing!

llvm/lib/Target/RISCV/RISCV.td

171–203

Thank you for the tip! I previously don't know TableGen can compute values like bit-shift left and do value type casting.

Adapted your code snippet. I modified a bit because Zvl32b don't imply anything.

204

No it is not, deleted.

[craig.topper]

LGTM

[eopXD]

Rebase to latest main.
Resolve test case conflicts due to Zvamo removal.

[eopXD]

Rebase to latest main.
Resolve test case conflicts due to Zfh, Zfhmin version update.

llvm/lib/Support/RISCVISAInfo.cpp

static const RISCVSupportedExtension SupportedExperimentalExtensions[] = {
     {"zbp", RISCVExtensionVersion{0, 93}},
     {"zbr", RISCVExtensionVersion{0, 93}},
     {"zbs", RISCVExtensionVersion{0, 93}},
     {"zbt", RISCVExtensionVersion{0, 93}},
     {"zbproposedc", RISCVExtensionVersion{0, 93}},
 
     {"zvamo", RISCVExtensionVersion{0, 10}},
     {"zvlsseg", RISCVExtensionVersion{0, 10}},
+    {"zvl", RISCVExtensionVersion{0, 10}},
 
     {"zfh", RISCVExtensionVersion{0, 1}},
 };
 
 static bool stripExperimentalPrefix(StringRef &Ext) {
   return Ext.consume_front("experimental-");
 }
 
 void RISCVISAInfo::addExtension(StringRef ExtName, unsigned MajorVersion,
                                 unsigned MinorVersion) {
   RISCVExtensionInfo Ext;
   Ext.ExtName = ExtName.str();
   Ext.MajorVersion = MajorVersion;
case 'b':
       ISAInfo->addExtension("zbp", Major, Minor);
       ISAInfo->addExtension("zbr", Major, Minor);
       ISAInfo->addExtension("zbs", Major, Minor);
       ISAInfo->addExtension("zbt", Major, Minor);
       break;
     case 'v':
       ISAInfo->addExtension("v", Major, Minor);
       ISAInfo->addExtension("zvlsseg", Major, Minor);
+      ISAInfo->addExtension("zvl", Major, Minor);
       break;
     }
     // Consume full extension name and version, including any optional '_'
     // between this extension and the next
     ++I;
     I += ConsumeLength;
     if (*I == '_')
       ++I;
if (!isSupportedExtension(Ext)) {
                                Desc.str().c_str(), Ext.str().c_str());
     }
   }
 
   ISAInfo->updateFLen();
 
   return std::move(ISAInfo);
 }
 
 void RISCVISAInfo::updateFLen() {
   FLen = 0;
   // TODO: Handle q extension.
   if (Exts.count("d"))
     FLen = 64;
   else if (Exts.count("f"))
     FLen = 32;
 }
 
 std::string RISCVISAInfo::toString() const {
   std::string Buffer;
   raw_string_ostream Arch(Buffer);
 
   if (XLen == 32)
     Arch << "rv32";
   else
     Arch << "rv64";
 
   ListSeparator LS("_");
   for (auto &Ext : Exts) {
     StringRef ExtName = Ext.first;
     auto ExtInfo = Ext.second;
     Arch << LS << ExtName;
     Arch << ExtInfo.MajorVersion << "p" << ExtInfo.MinorVersion;
   }
 
   return Arch.str();
 }

llvm/lib/Target/RISCV/RISCV.td

 
 def FeatureNoRVCHints
     : SubtargetFeature<"no-rvc-hints", "EnableRVCHintInstrs", "false",
                        "Disable RVC Hint Instructions.">;
 def HasRVCHints : Predicate<"Subtarget->enableRVCHintInstrs()">,
                   AssemblerPredicate<(all_of(not FeatureNoRVCHints)),
                                       "RVC Hint Instructions">;
 
 def FeatureStdExtV
     : SubtargetFeature<"experimental-v", "HasStdExtV", "true",
                        "'V' (Vector Instructions)">;
 def HasStdExtV : Predicate<"Subtarget->hasStdExtV()">,
                            AssemblerPredicate<(all_of FeatureStdExtV),
                            "'V' (Vector Instructions)">;
 
 def FeatureStdExtZvlsseg
     : SubtargetFeature<"experimental-zvlsseg", "HasStdExtZvlsseg", "true",
                        "'Zvlsseg' (Vector segment load/store instructions)",
                        [FeatureStdExtV]>;
 def HasStdExtZvlsseg : Predicate<"Subtarget->hasStdExtZvlsseg()">,
                                  AssemblerPredicate<(all_of FeatureStdExtZvlsseg),
                                  "'Zvlsseg' (Vector segment load/store instructions)">;
 
 def FeatureExtZvamo
     : SubtargetFeature<"experimental-zvamo", "HasStdExtZvamo", "true",
                        "'Zvamo' (Vector AMO Operations)",
                        [FeatureStdExtV]>;
 def HasStdExtZvamo : Predicate<"Subtarget->hasStdExtZvamo()">,
                                AssemblerPredicate<(all_of FeatureExtZvamo),
                                "'Zvamo' (Vector AMO Operations)">;
 
+foreach i = [32, 64, 128, 256, 512, 1024] in
+    def FeatureExtZvl#i
+        : SubtargetFeature<"experimental-zvl"#i, "ZvlLen", "ExtZvl::Zvl"#i#"b",
+          "'Zvl' (Minimum Vector Length) "#i,
+          [FeatureStdExtV]>;
+def HasStdExtZvl : Predicate<"Subtarget->hasStdExtZvl()">;
+
 def Feature64Bit
     : SubtargetFeature<"64bit", "HasRV64", "true", "Implements RV64">;
 def IsRV64 : Predicate<"Subtarget->is64Bit()">,
                        AssemblerPredicate<(all_of Feature64Bit),
                        "RV64I Base Instruction Set">;
 def IsRV32 : Predicate<"!Subtarget->is64Bit()">,
                        AssemblerPredicate<(all_of (not Feature64Bit)),
                        "RV32I Base Instruction Set">;
 
 defvar RV32 = DefaultMode;
 def RV64           : HwMode<"+64bit">;
 
 def FeatureRV32E
     : SubtargetFeature<"e", "IsRV32E", "true",

llvm/lib/Target/RISCV/RISCVSubtarget.h

 #include "llvm/Target/TargetMachine.h"
 
 #define GET_SUBTARGETINFO_HEADER
 #include "RISCVGenSubtargetInfo.inc"
 
 namespace llvm {
 class StringRef;
 
+namespace {
+enum ExtZvl : unsigned {
+  NotSet = 0,
+  Zvl32b = 32,
+  Zvl64b = 64,
+  Zvl128b = 128,
+  Zvl256b = 256,
+  Zvl512b = 512,
+  Zvl1024b = 1024
+};
+} // End anonymous namespace
+
 class RISCVSubtarget : public RISCVGenSubtargetInfo {
   virtual void anchor();
   bool HasStdExtM = false;
   bool HasStdExtA = false;
   bool HasStdExtF = false;
   bool HasStdExtD = false;
   bool HasStdExtC = false;
   bool HasStdExtB = false;
class RISCVSubtarget : public RISCVGenSubtargetInfo {
   bool HasStdExtZvamo = false;
   bool HasStdExtZfh = false;
   bool HasRV64 = false;
   bool IsRV32E = false;
   bool EnableLinkerRelax = false;
   bool EnableRVCHintInstrs = true;
   bool EnableSaveRestore = false;
   unsigned XLen = 32;
+  ExtZvl ZvlLen = ExtZvl::NotSet;
   MVT XLenVT = MVT::i32;
   uint8_t MaxInterleaveFactor = 2;
   RISCVABI::ABI TargetABI = RISCVABI::ABI_Unknown;
   BitVector UserReservedRegister;
   RISCVFrameLowering FrameLowering;
   RISCVInstrInfo InstrInfo;
   RISCVRegisterInfo RegInfo;
   RISCVTargetLowering TLInfo;
public:
   bool hasStdExtZbm() const { return HasStdExtZbm; }
   bool hasStdExtZbp() const { return HasStdExtZbp; }
   bool hasStdExtZbr() const { return HasStdExtZbr; }
   bool hasStdExtZbs() const { return HasStdExtZbs; }
   bool hasStdExtZbt() const { return HasStdExtZbt; }
   bool hasStdExtZbproposedc() const { return HasStdExtZbproposedc; }
   bool hasStdExtV() const { return HasStdExtV; }
   bool hasStdExtZvlsseg() const { return HasStdExtZvlsseg; }
+  bool hasStdExtZvl() const { return ZvlLen != ExtZvl::NotSet; }
   bool hasStdExtZvamo() const { return HasStdExtZvamo; }
   bool hasStdExtZfh() const { return HasStdExtZfh; }
   bool is64Bit() const { return HasRV64; }
   bool isRV32E() const { return IsRV32E; }
   bool enableLinkerRelax() const { return EnableLinkerRelax; }
   bool enableRVCHintInstrs() const { return EnableRVCHintInstrs; }
   bool enableSaveRestore() const { return EnableSaveRestore; }
   MVT getXLenVT() const { return XLenVT; }

llvm/lib/Target/RISCV/RISCVSubtarget.cpp

 const RegisterBankInfo *RISCVSubtarget::getRegBankInfo() const {
   return RegBankInfo.get();
 }
 
 unsigned RISCVSubtarget::getMaxRVVVectorSizeInBits() const {
   assert(hasStdExtV() && "Tried to get vector length without V support!");
   if (RVVVectorBitsMax == 0)
     return 0;
-  assert(RVVVectorBitsMax >= 128 && RVVVectorBitsMax <= 65536 &&
+  assert(RVVVectorBitsMax >= 32 && RVVVectorBitsMax <= 65536 &&
          isPowerOf2_32(RVVVectorBitsMax) &&
-         "V extension requires vector length to be in the range of 128 to "
+         "V extension requires vector length to be in the range of 32 to "
          "65536 and a power of 2!");
   assert(RVVVectorBitsMax >= RVVVectorBitsMin &&
          "Minimum V extension vector length should not be larger than its "
          "maximum!");
   unsigned Max = std::max(RVVVectorBitsMin, RVVVectorBitsMax);
-  return PowerOf2Floor((Max < 128 || Max > 65536) ? 0 : Max);
+  return PowerOf2Floor((Max < 32 || Max > 65536) ? 0 : Max);
 }
 
 unsigned RISCVSubtarget::getMinRVVVectorSizeInBits() const {
   assert(hasStdExtV() &&
          "Tried to get vector length without V extension support!");
   assert((RVVVectorBitsMin == 0 ||
-          (RVVVectorBitsMin >= 128 && RVVVectorBitsMax <= 65536 &&
+          (RVVVectorBitsMin >= 32 && RVVVectorBitsMax <= 65536 &&
            isPowerOf2_32(RVVVectorBitsMin))) &&
-         "V extension requires vector length to be in the range of 128 to "
+         "V extension requires vector length to be in the range of 32 to "
          "65536 and a power of 2!");
   assert((RVVVectorBitsMax >= RVVVectorBitsMin || RVVVectorBitsMax == 0) &&
          "Minimum V extension vector length should not be larger than its "
          "maximum!");
+  assert(RVVVectorBitsMin >= ZvlLen &&
+         "Minimum V extension vector length should be at least the length "
+         "of specified zvl extension!");
   unsigned Min = RVVVectorBitsMin;
   if (RVVVectorBitsMax != 0)
     Min = std::min(RVVVectorBitsMin, RVVVectorBitsMax);
-  return PowerOf2Floor((Min < 128 || Min > 65536) ? 0 : Min);
+  return PowerOf2Floor((Min < 32 || Min > 65536) ? 0 : Min);
 }
 
 unsigned RISCVSubtarget::getMaxLMULForFixedLengthVectors() const {
   assert(hasStdExtV() &&
          "Tried to get maximum LMUL without V extension support!");
   assert(RVVVectorLMULMax <= 8 && isPowerOf2_32(RVVVectorLMULMax) &&
          "V extension requires a LMUL to be at most 8 and a power of 2!");
   return PowerOf2Floor(std::max<unsigned>(RVVVectorLMULMax, 1));
 }
 
 bool RISCVSubtarget::useRVVForFixedLengthVectors() const {
   return hasStdExtV() && getMinRVVVectorSizeInBits() != 0;
 }