[RISCV] Lazily add RVV C intrinsics.

[kito-cheng]

Summary

Leverage the method OpenCL uses that adds C intrinsics when the lookup
failed. There is no need to define C intrinsics in the header file any
more. It could help to avoid the large header file to speed up the
compilation of RVV source code. Besides that, only the C intrinsics used
by the users will be added into the declaration table.

This patch is based on https://reviews.llvm.org/D103228 and inspired by
OpenCL implementation.

Experimental Results

TL;DR:

• Binary size of clang increase ~200k, which is +0.07% for debug build and +0.13% for release build.
• Single file compilation speed up ~33x for debug build and ~8.5x for release build
• Regression time reduce ~10% (ninja check-all, enable all targets)

Header size change

       |      size |     LoC |
------------------------------
Before | 4,434,725 |  69,749 |
After  |     6,140 |     162 |

Single File Compilation Time

Testcase:

#include <riscv_vector.h>

vint32m1_t test_vadd_vv_vfloat32m1_t(vint32m1_t op1, vint32m1_t op2, size_t vl) {
  return vadd(op1, op2, vl);
}

Debug build:

Before:

real    0m19.352s
user    0m19.252s
sys     0m0.092s

After:

real    0m0.576s
user    0m0.552s
sys     0m0.024s

~33x speed up for debug build

Release build:

Before:

real    0m0.773s
user    0m0.741s
sys     0m0.032s

After:

real    0m0.092s
user    0m0.080s
sys     0m0.012s

~8.5x speed up for release build

Regression time

Note: the failed case is tools/llvm-debuginfod-find/debuginfod.test which is unrelated to this patch.

Debug build

Before:

Testing Time: 1358.38s
  Skipped          :    11
  Unsupported      :   446
  Passed           : 75767
  Expectedly Failed:   190
  Failed           :     1

After

Testing Time: 1220.29s
  Skipped          :    11
  Unsupported      :   446
  Passed           : 75767
  Expectedly Failed:   190
  Failed           :     1

Release build

Before:

Testing Time: 381.98s
  Skipped          :    12
  Unsupported      :  1407
  Passed           : 74765
  Expectedly Failed:   176
  Failed           :     1

After:

Testing Time: 346.25s
  Skipped          :    12
  Unsupported      :  1407
  Passed           : 74765
  Expectedly Failed:   176
  Failed           :     1

Binary size of clang

Debug build

Before

   text    data     bss     dec     hex filename
335261851       12726004         552812 348540667       14c64efb        bin/clang

After

   text    data     bss     dec     hex filename
335442803       12798708         552940 348794451       14ca2e53        bin/clang

+253K, +0.07% code size

Release build

Before

   text    data     bss     dec     hex filename
144123975       8374648  483140 152981763       91e5103 bin/clang

After

   text    data     bss     dec     hex filename
144255762       8447296  483268 153186326       9217016 bin/clang

+204K, +0.13%

Authored-by: Kito Cheng <[e-mail]>
Co-Authored-by: Hsiangkai Wang <[e-mail]>

[khchen]

It seems like not only one place need to have a consistent way to process intrinsic. (ex. InitIntrinsicList/createRVVIntrinsics and RVVIntrinsic::RVVIntrinsic/InitRVVIntrinsic)
I'm think how to avoid mismatch implementation in the future, because we will support a lot of new builtin with tail and mask policy...

clang/lib/Sema/SemaRVVLookup.cpp

92

why do we need to declare Name as std::string here but RVVIntrinsicRecord use const char*?

93

Nit: I think we use the overload terminology rather than generic.

360–372

IIUC, above code initialize the BuiltinName, Name and MangledName same with RVVIntrinsic::RVVIntrinsic did, right?
If yes, I think we need to have some comment note that.

clang/utils/TableGen/RISCVVEmitter.cpp

85

It will be good to have a description about why we need to have custom SemaLookup.

93

missed comment?

98–99

Forget to remove this code?

102

Could we have comment for signature table.
IIUC, it stores ProtoSeq, ProtoMaskSeq, SuffixProto and MangledSuffixProto information in each entry, and SemaRecord use the index to get the information from signature table, right?

627

Use constant reference to access range-based loop?

634

Don’t Use Braces on Simple Single-Statement Bodies of if/else/loop Statements.
Please check your code again.

llvm/include/llvm/Support/RISCVVIntrinsicUtils.h

23 ↗

(On Diff #400358)

I think using typed enums is clearer because we would use TypeRangeMask to record supported basic types.
It should have the same type with TypeRangeMask.

84 ↗

(On Diff #400358)

different naming rule and initialize way comparing to RVVBasicTypeMaxOffset

[kito-cheng]

Changes:

• Split out refactor part to D124730.
• Add more comment.

[kito-cheng]

Changes:

• Add more comments.

[kito-cheng]

Changes:

• Minor tweak.

clang/lib/Sema/SemaRVVLookup.cpp

92

RVVIntrinsicRecord::Name is raw name of a intrinsic, RVVIntrinsicDef::Name is expanded with type infos, e.g. RVVIntrinsicRecord::Name is vadd and RVVIntrinsicDef::Name is vadd_vv_i32m1.

93

Updated.

360–372

More comment added.

[khchen]

Do we need to have some tests in clang/test/PCH/ for new #pragma?

clang/lib/Sema/SemaLookup.cpp

932

Don’t Use Braces on Simple Single-Statement Bodies.

clang/lib/Support/RISCVVIntrinsicUtils.cpp

903–905

maybe this changed should be in another NFC patch.

clang/utils/TableGen/RISCVVEmitter.cpp

370

maybe all renaming stuffs should be in another NFC patch.

480

I feel little tricky to checking the name here. what do you mean they are handled by riscv_vector.h?
do you mean they have vsetvl_macro:RVVHeader?

621

I'm thinking is it possible to have an unittest or test to make sure we won't screw up in the future implementation?
Is it possible to have unittest to test implement really have sync correctly?
Is it easy to debug the mismatch problem during implementation without any new test added?
We will add a new implementation (really cool speed up and meaningful improvement), but unfortunately we don't have any tests, that make me a little hesitating...

What do you think?

[kito-cheng]

Changes:

• Split out several NFC changes to individual NFC patchs.
• Moving most code emission logic into RISCVVIntrinsicUtils to prevent require sync manually.
• PCH support is WIP, will update soon.

[kito-cheng]

clang/utils/TableGen/RISCVVEmitter.cpp

480

Yeah, they are defined in riscv_vector.h like this:

#define vsetvl_e8mf8(avl) __builtin_rvv_vsetvli((size_t)(avl), 0, 5)
#define vsetvl_e8mf4(avl) __builtin_rvv_vsetvli((size_t)(avl), 0, 6)
#define vsetvl_e8mf2(avl) __builtin_rvv_vsetvli((size_t)(avl), 0, 7)
#define vsetvl_e8m1(avl) __builtin_rvv_vsetvli((size_t)(avl), 0, 0)
#define vsetvl_e8m2(avl) __builtin_rvv_vsetvli((size_t)(avl), 0, 1)
...

621

Change to another way to preventing sync those file manually, thanks for point out that!

[khchen]

clang/lib/Sema/SemaRVVLookup.cpp

175

Those code logic need to sync with createRVVIntrinsics, maybe we could add more comment address that.

clang/utils/TableGen/RISCVVEmitter.cpp

91

and also init SemaRecords?

93

I think it should be "Create all intrinsics record and SemaSignatureTable from SemaRecords"?

99

/// Construct a compressed signature table from SemaRecords which is used for createSema.
maybe better.

103

This is ambiguous of naming and comment because it also insert signature into SemaSignatureTable if not found in the table.

597

maybe we need an assert to check SemaRecords is not empty.

637

we only need SemaRecords initialization part of createRVVIntrinsics, right?

639

createRVVIntrinsicRecord also init SemaSignatureTable implicitly.

[kito-cheng]

Changes:

• Rebase
• Address @khchen's comment

[khchen]

LGTM. Other than that last comments.

clang/utils/TableGen/RISCVVEmitter.cpp

77

please use ArrayRef

94

maybe SemaRecords could have default argument as nullptr.

98

please use ArrayRef

185

Does it mean empty Signature always at 0?
If yes, maybe we could check the table from Index = 1 in below loop?

[khchen]

@craig.topper @rogfer01 - do you have other comments?

[craig.topper]

clang/include/clang/Basic/TokenKinds.def

911

Why only 2 periods at the end. Should be 3 like on like 908 or in the middle of line 903

clang/include/clang/Sema/Sema.h

1585

funtion -> functions

clang/include/clang/Support/RISCVVIntrinsicUtils.h

110

I think it's more conventional to define operator== as PD.PT == PT && PD.VTM == VTM && PD.TM == TM and operator!= as !(*this == PD)

111

This can be written as

return std::tie(PD.PT, PD.VTM, PD.TM) > std::tie(PT, VTM, TM);

Though it's still surprising that PD is on the left. This is operator> but the implementation looks more like operator<.

355

"if can" -> "if it can"

386

Missing period at end of comment.

clang/lib/Parse/ParsePragma.cpp

3966

Drop parenthese arounds (!II->isStr("intrinsic"))

3974

Drop parentheses around (!II->isStr("vector"))

clang/lib/Sema/CMakeLists.txt

49

These are supposed to be in alphabetical order

clang/lib/Sema/SemaRISCVVectorLookup.cpp

68 ↗

(On Diff #441320)

Can this use makeArrayRef?

117 ↗

(On Diff #441320)

Drop curly braces

122 ↗

(On Diff #441320)

Drop curly braces

262 ↗

(On Diff #441320)

Drop curly braces

277 ↗

(On Diff #441320)

Drop curly braces

311 ↗

(On Diff #441320)

Drop curly braces

364 ↗

(On Diff #441320)

Drop curly braces

382 ↗

(On Diff #441320)

"It's not an RVV intrinsic."

389 ↗

(On Diff #441320)

Should this be a member of Sema instead of a function static? RVVIntrinsicManager holds a reference to ASTContext but will outlive it.

clang/utils/TableGen/RISCVVEmitter.cpp

76

Is hsignature a typo?

490

Drop curly braces

[craig.topper]

clang/utils/TableGen/RISCVVEmitter.cpp

496

Drop curly braces

519

This lambda doesn't seem to provide much value.

What's wrong with

SR.Suffix = parsePrototypes(SuffixProto);
SR.OverloadedSuffix = parsePrototypes(OverloadedSuffixProto);

[kito-cheng]

Changes:

• Address @craig.topper's comment
• Address @khchen's comment

clang/include/clang/Support/RISCVVIntrinsicUtils.h

111

Rewrite as operator> and updated the use site, thank!

clang/utils/TableGen/RISCVVEmitter.cpp

185

Actually empty signature could be indicate into any index, we have hold length when we emit the index.

Add comment to mention that.

[kito-cheng]

Oh, have one comment not address yet

[aaron.ballman]

Some drive-by comments from the peanut gallery.

clang/lib/Parse/ParsePragma.cpp

3969

It's fine to warn on this, but then you need to eat tokens until the end of directive is found so that parsing recovery is correct. e.g.,

#pragma clang riscv int i = 12;

See HandlePragmaAttribute() for an example (though you'll look for eod instead of eof).

3977

Same here.

3984

And here as well.

clang/lib/Sema/SemaRISCVVectorLookup.cpp

100 ↗

(On Diff #441610)

I almost hate to ask, but... long double? Any of the 16-bit float types?

111 ↗

(On Diff #441610)

Might as well handle Invalid and then drop the default entirely so it's a fully covered switch.

121 ↗

(On Diff #441610)

Double-checking -- do you have to care about references as well?

185–186 ↗

(On Diff #441610)

Given that we're bit twiddling with this, I'd feel more comfortable if this was unsigned int rather than int (same for BaseTypeI).

223–225 ↗

(On Diff #441610)

227–229 ↗

(On Diff #441610)

You should spell the type explicitly here instead of using auto.

235–237 ↗

(On Diff #441610)

299–301 ↗

(On Diff #441610)

Spell out the types instead of using auto.

322 ↗

(On Diff #441610)

No need to calculate this, we already know.

328 ↗

(On Diff #441610)

Naming style fix.

342 ↗

(On Diff #441610)

Spell out type name.

358 ↗

(On Diff #441610)

Spell out the type.

clang/utils/TableGen/RISCVVEmitter.cpp

41

74

184–185

Pretty sure you can go with this instead.

217–222

[kito-cheng]

Changes:

• Address @craig.topper's comment
  • Introduce RISCVIntrinsicManager.h and let it become member of Sema, that make sure the it won't outlive than Sema.

[frasercrmck]

Just nits from me.

clang/include/clang/Sema/RISCVIntrinsicManager.h

9 ↗

(On Diff #441684)

handles

clang/lib/Sema/SemaRISCVVectorLookup.cpp

49 ↗

(On Diff #441684)

Indices (or Indexes)?

218 ↗

(On Diff #441684)

Drop curly braces

185–186 ↗

(On Diff #441610)

+1

clang/utils/TableGen/RISCVVEmitter.cpp

47

Comment is plural, variable is singular.

95

all records, plural?

484

if (!SemaRecords) continue;? Might make things a little more readable.

566

I assume the compiler's able to avoid recomputing Out.back() multiple times? We could take a reference to Out.back() and use that, just in case?

[kito-cheng]

Changes:

• Address @aaron.ballman’s comment
  • Add 2 new testcase:
    • riscv-bad-intrnisic-pragma.c
    • riscv-intrnisic-pragma.c

clang/lib/Parse/ParsePragma.cpp

3969

Seems like it already work correctly, and I saw other HandlePragma also just return? I add a testcase to make sure it work.

clang/lib/Sema/SemaRISCVVectorLookup.cpp

100 ↗

(On Diff #441610)

Have 16 bit floating below, but we don't support long double in our intrinsic for now, add an assertion to make sure.

121 ↗

(On Diff #441610)

We don't have any references type in argument type, so we don't care about that.

[aaron.ballman]

clang/lib/Parse/ParsePragma.cpp

3969

Ah, you're right, it's the *other* form of pragma handling that needs to do that dance, sorry for the noise but thank you for the additional test coverage!

clang/lib/Sema/SemaRISCVVectorLookup.cpp

100 ↗

(On Diff #441610)

Very glad to hear about long double, but I was unclear on the 16-bit float, I was more wondering if you need to differentiate between Float16Ty, BFloat16Ty, and HalfTy since those will all have the same bit widths but be different types.

121 ↗

(On Diff #441610)

Excellent, thank you

[kito-cheng]

Changes:

• Address @frasercrmck's comment

clang/lib/Sema/SemaRISCVVectorLookup.cpp

100 ↗

(On Diff #441610)

RISC-V vector intrinsic only support _Float16(Float16Ty) for now, __fp16(HalfTy, half in OpenCL) won't support, BFloat16Ty will be another ScalarTypeKind like ScalarTypeKind::BFloat, we didn't add yet since we don't have any bfloat16 instruction in RISC-V extension now.

clang/utils/TableGen/RISCVVEmitter.cpp

566

Checked code gen with following program, got almost same code gen:

#include <vector>
struct X{
    int a;
    int b;
    int c;
};

#ifdef BACK
void foo(std::vector<X> &Out){
    X x;
    Out.emplace_back(x);
    Out.back().a =12;
    Out.back().b =23;
    Out.back().c =30;
}
#else
void foo2(std::vector<X> &Out){
    Out.emplace_back(X());
    X &x = Out.back();
    x.a =12;
    x.b =23;
    x.c =30;
}
#endif

But I think later one might be more readable, let me tweak that.

[kito-cheng]

Changes:

• Less invasive way to fix this issue.

[kito-cheng]

Changes:

Restore the patch, I just accidentally updated wrong revision here...

[craig.topper]

clang/test/Sema/riscv-bad-intrnisic-pragma.c

1 ↗

(On Diff #442431)

this test file name is misspelled

clang/test/Sema/riscv-intrnisic-pragma.c

1 ↗

(On Diff #442431)

test file name is misspelled

[craig.topper]

clang/include/clang/Support/RISCVVIntrinsicUtils.h

17

Do we need the header or is a forward declaration enough?

[kito-cheng]

Changes:

• Correct filename for testcases.
• Use forward declaration for llvm::raw_ostream

[kito-cheng]

ping

[kito-cheng]

@aaron.ballman do you mind give few more look on this patch, we would like gather LGTM from both RISC-V folks and clang folks, thanks :)

[aaron.ballman]

LGTM, only minor nits found (feel free to ignore any that you disagree with).

clang/include/clang/Support/RISCVVIntrinsicUtils.h

339

355

393

clang/lib/Sema/SemaRISCVVectorLookup.cpp

32 ↗

(On Diff #444188)

40 ↗

(On Diff #444188)

131 ↗

(On Diff #444188)

You can drop all uses of clang:: in this file.

181–187 ↗

(On Diff #444188)

Please don't use auto when the type is not spelled out in the initialization.

307–308 ↗

(On Diff #444188)

clang/utils/TableGen/RISCVVEmitter.cpp

63

[kito-cheng]

@aaron.ballman thanks for your review!

clang/include/clang/Support/RISCVVIntrinsicUtils.h

393

That the term used in RVV spec, so I keep this as NF :)

clang/include/clang/Basic/CMakeLists.txt

clang_tablegen(arm_cde_builtin_aliases.inc -gen-arm-cde-builtin-aliases
   SOURCE arm_cde.td
   TARGET ClangARMCdeBuiltinAliases)
 clang_tablegen(riscv_vector_builtins.inc -gen-riscv-vector-builtins
   SOURCE riscv_vector.td
   TARGET ClangRISCVVectorBuiltins)
 clang_tablegen(riscv_vector_builtin_cg.inc -gen-riscv-vector-builtin-codegen
   SOURCE riscv_vector.td
   TARGET ClangRISCVVectorBuiltinCG)
+clang_tablegen(riscv_vector_builtin_sema.inc -gen-riscv-vector-builtin-sema
+  SOURCE riscv_vector.td
+  TARGET ClangRISCVVectorBuiltinSema)

clang/include/clang/Basic/TokenKinds.def

 // handles #pragma loop ... directives.
 PRAGMA_ANNOTATION(pragma_loop_hint)
 
 PRAGMA_ANNOTATION(pragma_fp)
 
 // Annotation for the attribute pragma directives - #pragma clang attribute ...
 PRAGMA_ANNOTATION(pragma_attribute)
 
+// Annotation for the riscv pragma directives - #pragma clang riscv intrinsic ..
+PRAGMA_ANNOTATION(pragma_riscv)
+
 // Annotations for module import translated from #include etc.
 ANNOTATION(module_include)
 ANNOTATION(module_begin)
 ANNOTATION(module_end)
 
 // Annotation for a header_name token that has been looked up and transformed
 // into the name of a header unit.
 ANNOTATION(header_unit)

clang/include/clang/Parse/Parser.h

class Parser : public CodeCompletionHandler {
   std::unique_ptr<PragmaHandler> FPHandler;
   std::unique_ptr<PragmaHandler> STDCFenvAccessHandler;
   std::unique_ptr<PragmaHandler> STDCFenvRoundHandler;
   std::unique_ptr<PragmaHandler> STDCCXLIMITHandler;
   std::unique_ptr<PragmaHandler> STDCUnknownHandler;
   std::unique_ptr<PragmaHandler> AttributePragmaHandler;
   std::unique_ptr<PragmaHandler> MaxTokensHerePragmaHandler;
   std::unique_ptr<PragmaHandler> MaxTokensTotalPragmaHandler;
+  std::unique_ptr<PragmaHandler> RISCVPragmaHandler;
 
   std::unique_ptr<CommentHandler> CommentSemaHandler;
 
   /// Whether the '>' token acts as an operator or not. This will be
   /// true except when we are parsing an expression within a C++
   /// template argument list, where the '>' closes the template
   /// argument list.
   bool GreaterThanIsOperator;

clang/include/clang/Sema/Sema.h

 
   bool WarnedStackExhausted = false;
 
   /// Increment when we find a reference; decrement when we find an ignored
   /// assignment.  Ultimately the value is 0 if every reference is an ignored
   /// assignment.
   llvm::DenseMap<const VarDecl *, int> RefsMinusAssignments;
 
+  /// Indicate RVV builtin funtions enabled or not.
+  bool DeclareRVVBuiltins = false;
+
 private:
   Optional<std::unique_ptr<DarwinSDKInfo>> CachedDarwinSDKInfo;
 
   bool WarnedDarwinSDKInfoMissing = false;
 
 public:
   Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
        TranslationUnitKind TUKind = TU_Complete,

 };
 
 template <>
 void Sema::PragmaStack<Sema::AlignPackInfo>::Act(SourceLocation PragmaLocation,
                                                  PragmaMsStackAction Action,
                                                  llvm::StringRef StackSlotLabel,
                                                  AlignPackInfo Value);
 
+bool GetRVVBuiltinInfo(Sema &S, LookupResult &LR, IdentifierInfo *II,
+                       Preprocessor &PP);
 } // end namespace clang
 
 namespace llvm {
 // Hash a FunctionDeclAndLoc by looking at both its FunctionDecl and its
 // SourceLocation.
 template <> struct DenseMapInfo<clang::Sema::FunctionDeclAndLoc> {
   using FunctionDeclAndLoc = clang::Sema::FunctionDeclAndLoc;
   using FDBaseInfo = DenseMapInfo<clang::CanonicalDeclPtr<clang::FunctionDecl>>;

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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_SUPPORT_RISCVVINTRINSICUTILS_H
 #define CLANG_SUPPORT_RISCVVINTRINSICUTILS_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace RISCV {
 
 using VScaleVal = llvm::Optional<unsigned>;
struct PrototypeDescriptor {
 
   uint8_t PT = static_cast<uint8_t>(BaseTypeModifier::Invalid);
   uint8_t VTM = static_cast<uint8_t>(VectorTypeModifier::NoModifier);
   uint8_t TM = static_cast<uint8_t>(TypeModifier::NoModifier);
 
   bool operator!=(const PrototypeDescriptor &PD) const {
     return PD.PT != PT || PD.VTM != VTM || PD.TM != TM;
   }
   bool operator>(const PrototypeDescriptor &PD) const {
     return !(PD.PT <= PT && PD.VTM <= VTM && PD.TM <= TM);
   }
 
   static const PrototypeDescriptor Mask;
   static const PrototypeDescriptor Vector;
   static const PrototypeDescriptor VL;
   static llvm::Optional<PrototypeDescriptor>
   parsePrototypeDescriptor(llvm::StringRef PrototypeStr);
 };
bool isSignedInteger() const {
     return ScalarType == ScalarTypeKind::SignedInteger;
   }
   bool isFloatVector(unsigned Width) const {
     return isVector() && isFloat() && ElementBitwidth == Width;
   }
   bool isFloat(unsigned Width) const {
     return isFloat() && ElementBitwidth == Width;
   }
+  bool isConstant() const { return IsConstant; }
+  bool isPointer() const { return IsPointer; }
+  unsigned getElementBitwidth() const { return ElementBitwidth; }
+
+  ScalarTypeKind getScalarType() const { return ScalarType; }
+  VScaleVal getScale() const { return Scale; }
 
 private:
   // Verify RVV vector type and set Valid.
   bool verifyType() const;
 
   // Creates a type based on basic types of TypeRange
   void applyBasicType();
 
public:
   /// have illegal RVVType.
   static llvm::Optional<RVVTypes>
   computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
                llvm::ArrayRef<PrototypeDescriptor> PrototypeSeq);
   static llvm::Optional<RVVTypePtr> computeType(BasicType BT, int Log2LMUL,
                                                 PrototypeDescriptor Proto);
 };
 
-using RISCVPredefinedMacroT = uint8_t;
-
-enum RISCVPredefinedMacro : RISCVPredefinedMacroT {
-  Basic = 0,
-  V = 1 << 1,
-  Zvfh = 1 << 2,
-  RV64 = 1 << 3,
-  VectorMaxELen64 = 1 << 4,
-  VectorMaxELenFp32 = 1 << 5,
-  VectorMaxELenFp64 = 1 << 6,
-};
-
 enum PolicyScheme : uint8_t {
   SchemeNone,
   HasPassthruOperand,
   HasPolicyOperand,
 };
 
 // TODO refactor RVVIntrinsic class design after support all intrinsic
 // combination. This represents an instantiation of an intrinsic with a
private:
   bool HasUnMaskedOverloaded;
   bool HasBuiltinAlias;
   std::string ManualCodegen;
   RVVTypePtr OutputType; // Builtin output type
   RVVTypes InputTypes;   // Builtin input types
   // The types we use to obtain the specific LLVM intrinsic. They are index of
   // InputTypes. -1 means the return type.
   std::vector<int64_t> IntrinsicTypes;
-  RISCVPredefinedMacroT RISCVPredefinedMacros = 0;
   unsigned NF = 1;
 
 public:
   RVVIntrinsic(llvm::StringRef Name, llvm::StringRef Suffix, llvm::StringRef MangledName,
                llvm::StringRef MangledSuffix, llvm::StringRef IRName, bool IsMasked,
                bool HasMaskedOffOperand, bool HasVL, PolicyScheme Scheme,
                bool HasUnMaskedOverloaded, bool HasBuiltinAlias,
                llvm::StringRef ManualCodegen, const RVVTypes &Types,
public:
   bool hasPolicyOperand() const { return Scheme == HasPolicyOperand; }
   bool hasUnMaskedOverloaded() const { return HasUnMaskedOverloaded; }
   bool hasBuiltinAlias() const { return HasBuiltinAlias; }
   bool hasManualCodegen() const { return !ManualCodegen.empty(); }
   bool isMasked() const { return IsMasked; }
   llvm::StringRef getIRName() const { return IRName; }
   llvm::StringRef getManualCodegen() const { return ManualCodegen; }
   PolicyScheme getPolicyScheme() const { return Scheme; }
-  RISCVPredefinedMacroT getRISCVPredefinedMacros() const {
-    return RISCVPredefinedMacros;
-  }
   unsigned getNF() const { return NF; }
   const std::vector<int64_t> &getIntrinsicTypes() const {
     return IntrinsicTypes;
   }
 
   // Return the type string for a BUILTIN() macro in Builtins.def.
   std::string getBuiltinTypeStr() const;
 
   static std::string
   getSuffixStr(BasicType Type, int Log2LMUL,
                llvm::ArrayRef<PrototypeDescriptor> PrototypeDescriptors);
 };
 
+// RVVRequire should be sync with target features, but only
+// required features used in riscv_vector.td.
+enum RVVRequire : uint8_t {
+  RVV_REQ_None = 0,
+  RVV_REQ_RV64 = 1 << 0,
+  RVV_REQ_FullMultiply = 1 << 1,
+
+  LLVM_MARK_AS_BITMASK_ENUM(RVV_REQ_FullMultiply)
+};
+
+// Raw RVV intrinsic info, used to expand later.
+// This struct is highly compact for minimized code size.
+struct RVVIntrinsicRecord {
+  // Intrinsic name, e.g. vadd_vv
+  const char *Name;
+
+  // Overloaded intrinsic name, could be empty if can be computed from Name
+  // e.g. vadd
+  const char *OverloadedName;
+
+  // Prototype for this intrinsic, index of RVVSignatureTable.
+  uint16_t PrototypeIndex;
+
+  // Prototype for masked intrinsic, index of RVVSignatureTable.
+  uint16_t MaskedPrototypeIndex;
+
+  // Suffix of intrinsic name, index of RVVSignatureTable.
+  uint16_t SuffixIndex;
+
+  // Suffix of overloaded intrinsic name, index of RVVSignatureTable.
+  uint16_t OverloadedSuffixIndex;
+
+  // Length of the prototype.
+  uint8_t PrototypeLength;
+
+  // Length of prototype of masked intrinsic.
+  uint8_t MaskedPrototypeLength;
+
+  // Length of intrinsic name suffix.
+  uint8_t SuffixLength;
+
+  // Length of overloaded intrinsic suffix.
+  uint8_t OverloadedSuffixSize;
+
+  // Required target features for this intrinsic.
+  uint8_t RequiredExtension;
+
+  // Supported type, mask of BasicType
+  uint8_t TypeRangeMask;
+
+  // Supported LMUL.
+  uint8_t Log2LMULMask;
+
+  // Number of field, large than 1 if it's segment load/store.
+  uint8_t NF;
+};
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                              const RVVIntrinsicRecord &RVVInstrRecord);
+
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 } // end namespace RISCV
 
 } // end namespace clang
 
 #endif // CLANG_SUPPORT_RISCVVINTRINSICUTILS_H

clang/lib/Parse/ParsePragma.cpp

 };
 
 struct PragmaMaxTokensTotalHandler : public PragmaHandler {
   PragmaMaxTokensTotalHandler() : PragmaHandler("max_tokens_total") {}
   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                     Token &FirstToken) override;
 };
 
+struct PragmaRISCVHandler : public PragmaHandler {
+  PragmaRISCVHandler(Sema &Actions)
+      : PragmaHandler("riscv"), Actions(Actions) {}
+  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
+                    Token &FirstToken) override;
+
+private:
+  Sema &Actions;
+};
+
 void markAsReinjectedForRelexing(llvm::MutableArrayRef<clang::Token> Toks) {
   for (auto &T : Toks)
     T.setFlag(clang::Token::IsReinjected);
 }
 }  // end namespace
 
 void Parser::initializePragmaHandlers() {
   AlignHandler = std::make_unique<PragmaAlignHandler>();
AttributePragmaHandler =
       std::make_unique<PragmaAttributeHandler>(AttrFactory);
   PP.AddPragmaHandler("clang", AttributePragmaHandler.get());
 
   MaxTokensHerePragmaHandler = std::make_unique<PragmaMaxTokensHereHandler>();
   PP.AddPragmaHandler("clang", MaxTokensHerePragmaHandler.get());
 
   MaxTokensTotalPragmaHandler = std::make_unique<PragmaMaxTokensTotalHandler>();
   PP.AddPragmaHandler("clang", MaxTokensTotalPragmaHandler.get());
+
+  if (getTargetInfo().getTriple().isRISCV()) {
+    RISCVPragmaHandler = std::make_unique<PragmaRISCVHandler>(Actions);
+    PP.AddPragmaHandler("clang", RISCVPragmaHandler.get());
+  }
 }
 
 void Parser::resetPragmaHandlers() {
   // Remove the pragma handlers we installed.
   PP.RemovePragmaHandler(AlignHandler.get());
   AlignHandler.reset();
   PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get());
   GCCVisibilityHandler.reset();
void Parser::resetPragmaHandlers() {
   PP.RemovePragmaHandler("clang", AttributePragmaHandler.get());
   AttributePragmaHandler.reset();
 
   PP.RemovePragmaHandler("clang", MaxTokensHerePragmaHandler.get());
   MaxTokensHerePragmaHandler.reset();
 
   PP.RemovePragmaHandler("clang", MaxTokensTotalPragmaHandler.get());
   MaxTokensTotalPragmaHandler.reset();
+
+  if (getTargetInfo().getTriple().isRISCV()) {
+    PP.RemovePragmaHandler("clang", RISCVPragmaHandler.get());
+    RISCVPragmaHandler.reset();
+  }
 }
 
 /// Handle the annotation token produced for #pragma unused(...)
 ///
 /// Each annot_pragma_unused is followed by the argument token so e.g.
 /// "#pragma unused(x,y)" becomes:
 /// annot_pragma_unused 'x' annot_pragma_unused 'y'
 void Parser::HandlePragmaUnused() {
void PragmaMaxTokensTotalHandler::HandlePragma(Preprocessor &PP,
   if (Tok.isNot(tok::eod)) {
     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
         << "clang max_tokens_total";
     return;
   }
 
   PP.overrideMaxTokens(MaxTokens, Loc);
 }
+
+// Handle '#pragma clang riscv intrinsic vector'.
+void PragmaRISCVHandler::HandlePragma(Preprocessor &PP,
+                                      PragmaIntroducer Introducer,
+                                      Token &FirstToken) {
+  Token Tok;
+  PP.Lex(Tok);
+  IdentifierInfo *II = Tok.getIdentifierInfo();
+  if (!II || (!II->isStr("intrinsic"))) {
+    PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_argument)
+        << PP.getSpelling(Tok) << "riscv" << /*Expected=*/true << "'intrinsic'";
+    return;
+  }
+
+  PP.Lex(Tok);
+  II = Tok.getIdentifierInfo();
+  if (!II || (!II->isStr("vector"))) {
+    PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_argument)
+        << PP.getSpelling(Tok) << "riscv" << /*Expected=*/true << "'vector'";
+    return;
+  }
+
+  PP.Lex(Tok);
+  if (Tok.isNot(tok::eod)) {
+    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
+        << "clang riscv intrinsic";
+    return;
+  }
+
+  Actions.DeclareRVVBuiltins = true;
+}

clang/lib/Sema/CMakeLists.txt

add_clang_library(clangSema
   SemaExpr.cpp
   SemaExprCXX.cpp
   SemaExprMember.cpp
   SemaExprObjC.cpp
   SemaFixItUtils.cpp
   SemaInit.cpp
   SemaLambda.cpp
   SemaLookup.cpp
+  SemaRVVLookup.cpp
   SemaModule.cpp
   SemaObjCProperty.cpp
   SemaOpenMP.cpp
   SemaOverload.cpp
   SemaPseudoObject.cpp
   SemaStmt.cpp
   SemaStmtAsm.cpp
   SemaStmtAttr.cpp
add_clang_library(clangSema
   omp_gen
 
   LINK_LIBS
   clangAST
   clangAnalysis
   clangBasic
   clangEdit
   clangLex
+  clangSupport
   )

clang/lib/Sema/SemaLookup.cpp

static void InsertOCLBuiltinDeclarationsFromTable(Sema &S, LookupResult &LR,
 
   // If we added overloads, need to resolve the lookup result.
   if (Len > 1 || HasGenType)
     LR.resolveKind();
 }
 
 /// Lookup a builtin function, when name lookup would otherwise
 /// fail.
 bool Sema::LookupBuiltin(LookupResult &R) {
   Sema::LookupNameKind NameKind = R.getLookupKind();
 
   // If we didn't find a use of this identifier, and if the identifier
   // corresponds to a compiler builtin, create the decl object for the builtin
   // now, injecting it into translation unit scope, and return it.
   if (NameKind == Sema::LookupOrdinaryName ||
       NameKind == Sema::LookupRedeclarationWithLinkage) {
     IdentifierInfo *II = R.getLookupName().getAsIdentifierInfo();
     if (II) {
       if (getLangOpts().CPlusPlus && NameKind == Sema::LookupOrdinaryName) {
         if (II == getASTContext().getMakeIntegerSeqName()) {
           R.addDecl(getASTContext().getMakeIntegerSeqDecl());
           return true;
         } else if (II == getASTContext().getTypePackElementName()) {
           R.addDecl(getASTContext().getTypePackElementDecl());
           return true;
         }
       }
 
       // Check if this is an OpenCL Builtin, and if so, insert its overloads.
       if (getLangOpts().OpenCL && getLangOpts().DeclareOpenCLBuiltins) {
         auto Index = isOpenCLBuiltin(II->getName());
         if (Index.first) {
           InsertOCLBuiltinDeclarationsFromTable(*this, R, II, Index.first - 1,
                                                 Index.second);
           return true;
         }
       }
 
+      if (DeclareRVVBuiltins && GetRVVBuiltinInfo(*this, R, II, PP))
+        return true;
+
       // If this is a builtin on this (or all) targets, create the decl.
       if (unsigned BuiltinID = II->getBuiltinID()) {
         // In C++, C2x, and OpenCL (spec v1.2 s6.9.f), we don't have any
         // predefined library functions like 'malloc'. Instead, we'll just
         // error.
         if ((getLangOpts().CPlusPlus || getLangOpts().OpenCL ||
              getLangOpts().C2x) &&
             Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
           return false;
 
         if (NamedDecl *D =
                 LazilyCreateBuiltin(II, BuiltinID, TUScope,
                                     R.isForRedeclaration(), R.getNameLoc())) {
           R.addDecl(D);
           return true;
         }
       }
     }
   }
 
   return false;
 }
 
 /// Looks up the declaration of "struct objc_super" and
 /// saves it for later use in building builtin declaration of
 /// objc_msgSendSuper and objc_msgSendSuper_stret.
 static void LookupPredefedObjCSuperType(Sema &Sema, Scope *S) {
   ASTContext &Context = Sema.Context;
   LookupResult Result(Sema, &Context.Idents.get("objc_super"), SourceLocation(),
                       Sema::LookupTagName);
   Sema.LookupName(Result, S);
   if (Result.getResultKind() == LookupResult::Found)
     if (const TagDecl *TD = Result.getAsSingle<TagDecl>())
       Context.setObjCSuperType(Context.getTagDeclType(TD));
 }
 
 void Sema::LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID) {
   if (ID == Builtin::BIobjc_msgSendSuper)

clang/lib/Sema/SemaRVVLookup.cpp

+//===-- SemaRVVLookup.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
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file implements name lookup for RISC-V vector intrinsic.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/Basic/Builtins.h"
+#include "clang/Basic/TargetInfo.h"
+#include "clang/Lex/Preprocessor.h"
+#include "clang/Sema/Lookup.h"
+#include "clang/Sema/Sema.h"
+#include "clang/Support/RISCVVIntrinsicUtils.h"
+#include "llvm/ADT/SmallVector.h"
+#include <string>
+#include <vector>
+
+using namespace llvm;
+using namespace clang;
+using namespace clang::RISCV;
+
+namespace {
+
+// Function definition of a RVV intrinsic
+struct RVVIntrinsicDef {
+  /// Full function name with suffix, e.g. vadd_vv_i32m1.
+  std::string Name;
+
+  /// Overloaded function name, e.g. vadd.
+  std::string OverloadName;
+
+  /// Mapping to which clang built-in function, e.g. __builtin_rvv_vadd
+  std::string BuiltinName;
+
+  /// Function signature, first element is return type.
+  RVVTypes Signature;
+};
+
+struct RVVOverloadIntrinsicDef {
+  // Index of RVVIntrinsicManager::IntrinsicList.
+  SmallVector<size_t, 8> Indexs;
+};
+
+} // namespace
+
+static const PrototypeDescriptor RVVSignatureTable[] = {
+#define DECL_SIGNATURE_TABLE
+#include "clang/Basic/riscv_vector_builtin_sema.inc"
+#undef DECL_SIGNATURE_TABLE
+};
+
+static const RVVIntrinsicRecord RVVIntrinsicRecords[] = {
+#define DECL_INTRINSIC_RECORDS
+#include "clang/Basic/riscv_vector_builtin_sema.inc"
+#undef DECL_INTRINSIC_RECORDS
+};
+
+// Get subsequence of signature table.
+static ArrayRef<PrototypeDescriptor> ProtoSeq2ArrayRef(uint16_t Index,
+                                                       uint8_t Length) {
+  return ArrayRef<PrototypeDescriptor>(&RVVSignatureTable[Index], Length);
+}
+
+static QualType RVVType2Qual(ASTContext &Context, const RVVType *Type) {
+  QualType QT;
+  switch (Type->getScalarType()) {
+  case ScalarTypeKind::Void:
+    QT = Context.VoidTy;
+    break;
+  case ScalarTypeKind::Size_t:
+    QT = Context.getSizeType();
+    break;
+  case ScalarTypeKind::Ptrdiff_t:
+    QT = Context.getPointerDiffType();
+    break;
+  case ScalarTypeKind::UnsignedLong:
+    QT = Context.UnsignedLongTy;
+    break;
+  case ScalarTypeKind::SignedLong:
+    QT = Context.LongTy;
+    break;
+  case ScalarTypeKind::Boolean:
+    QT = Context.BoolTy;
+    break;
+  case ScalarTypeKind::SignedInteger:
+    QT = Context.getIntTypeForBitwidth(Type->getElementBitwidth(), true);
+    break;
+  case ScalarTypeKind::UnsignedInteger:
+    QT = Context.getIntTypeForBitwidth(Type->getElementBitwidth(), false);
+    break;
+  case ScalarTypeKind::Float:
+    switch (Type->getElementBitwidth()) {
+    case 64:
+      QT = Context.DoubleTy;
+      break;
+    case 32:
+      QT = Context.FloatTy;
+      break;
+    case 16:
+      QT = Context.Float16Ty;
+      break;
+    }
+    break;
+  default:
+    return QT;
+  }
+  if (Type->isVector())
+    QT = Context.getScalableVectorType(QT, Type->getScale().getValue());
+
+  if (Type->isConstant()) {
+    QT = Context.getConstType(QT);
+  }
+
+  // Transform the type to a pointer as the last step, if necessary.
+  if (Type->isPointer()) {
+    QT = Context.getPointerType(QT);
+  }
+
+  return QT;
+}
+
+namespace {
+class RVVIntrinsicManager {
+private:
+  // List of all RVV intrinsic.
+  std::vector<RVVIntrinsicDef> IntrinsicList;
+  // Mapping function name to index of IntrinsicList.
+  StringMap<size_t> Intrinsics;
+  // Mapping function name to RVVOverloadIntrinsicDef.
+  StringMap<RVVOverloadIntrinsicDef> OverloadIntrinsics;
+
+  ASTContext &Context;
+
+  // Create IntrinsicList
+  void InitIntrinsicList();
+
+  // Create RVVIntrinsicDef.
+  void InitRVVIntrinsic(const RVVIntrinsicRecord &Record, StringRef SuffixStr,
+                        StringRef OverloadedSuffixStr, bool IsMask,
+                        RVVTypes &Types);
+
+  // Create FunctionDecl for a vector intrinsic.
+  void CreateRVVIntrinsicDecl(Sema &S, LookupResult &LR, IdentifierInfo *II,
+                              Preprocessor &PP, unsigned Index,
+                              bool IsOverload);
+
+public:
+  RVVIntrinsicManager(ASTContext &Context) : Context(Context) {
+    InitIntrinsicList();
+  }
+
+  // Create RISC-V vector intrinsic and insert into symbol table if found, and
+  // return true, otherwise return false.
+  bool CreateIntrinsicIfFound(Sema &S, LookupResult &LR, IdentifierInfo *II,
+                              Preprocessor &PP);
+};
+} // namespace
+
+void RVVIntrinsicManager::InitIntrinsicList() {
+  const TargetInfo &TI = Context.getTargetInfo();
+  bool HasVectorFloat32 = TI.hasFeature("zve32f");
+  bool HasVectorFloat64 = TI.hasFeature("zve64d");
+  bool HasZvfh = TI.hasFeature("experimental-zvfh");
+  bool HasRV64 = TI.hasFeature("64bit");
+  bool HasFullMultiply = TI.hasFeature("v");
+
+  for (auto &Record : RVVIntrinsicRecords) {
+    // Create Intrinsics for each type and LMUL.
+    BasicType BaseType = BasicType::Unknown;
+    auto ProtoSeq =
+        ProtoSeq2ArrayRef(Record.PrototypeIndex, Record.PrototypeLength);
+    auto ProtoMaskSeq = ProtoSeq2ArrayRef(Record.MaskedPrototypeIndex,
+                                          Record.MaskedPrototypeLength);
+    auto SuffixProto =
+        ProtoSeq2ArrayRef(Record.SuffixIndex, Record.SuffixLength);
+    auto MangledSuffixProto = ProtoSeq2ArrayRef(Record.OverloadedSuffixIndex,
+                                                Record.OverloadedSuffixSize);
+    for (int TypeRangeMaskShift = 0;
+         TypeRangeMaskShift <= static_cast<int>(BasicType::MaxOffset);
+         ++TypeRangeMaskShift) {
+      int BaseTypeI = 1 << TypeRangeMaskShift;
+      BaseType = static_cast<BasicType>(BaseTypeI);
+
+      if ((BaseTypeI & Record.TypeRangeMask) != BaseTypeI)
+        continue;
+
+      // Check requirement.
+      if (BaseType == BasicType::Float16 && !HasZvfh)
+        continue;
+
+      if (BaseType == BasicType::Float32 && !HasVectorFloat32)
+        continue;
+
+      if (BaseType == BasicType::Float64 && !HasVectorFloat64)
+        continue;
+
+      if (((Record.RequiredExtension & RVV_REQ_RV64) == RVV_REQ_RV64) &&
+          !HasRV64)
+        continue;
+
+      if ((BaseType == BasicType::Int64) &&
+          ((Record.RequiredExtension & RVV_REQ_FullMultiply) ==
+           RVV_REQ_FullMultiply) &&
+          !HasFullMultiply)
+        continue;
+
+      // Expanded with different LMUL.
+      for (int Log2LMUL = -3; Log2LMUL <= 3; Log2LMUL++) {
+        if (!(Record.Log2LMULMask & (1 << (Log2LMUL + 3)))) {
+          continue;
+        }
+        Optional<RVVTypes> Types =
+            RVVType::computeTypes(BaseType, Log2LMUL, Record.NF, ProtoSeq);
+
+        // Ignored to create new intrinsic if there are any illegal types.
+        if (!Types.hasValue()) {
+          continue;
+        }
+
+        auto SuffixStr =
+            RVVIntrinsic::getSuffixStr(BaseType, Log2LMUL, SuffixProto);
+        auto OverloadedSuffixStr =
+            RVVIntrinsic::getSuffixStr(BaseType, Log2LMUL, MangledSuffixProto);
+
+        // Create non-masked intrinsic.
+        InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr, false, *Types);
+
+        bool HasMask = Record.MaskedPrototypeLength != 0;
+
+        if (HasMask) {
+          // Create masked intrinsic.
+          Optional<RVVTypes> MaskTypes = RVVType::computeTypes(
+              BaseType, Log2LMUL, Record.NF, ProtoMaskSeq);
+
+          InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr, true,
+                           *MaskTypes);
+        }
+      }
+    }
+  }
+}
+
+// Compute name and signatures for intrinsic with practical types.
+void RVVIntrinsicManager::InitRVVIntrinsic(const RVVIntrinsicRecord &Record,
+                                           StringRef SuffixStr,
+                                           StringRef OverloadedSuffixStr,
+                                           bool IsMask, RVVTypes &Signature) {
+  // Function name, e.g. vadd_vv_i32m1.
+  std::string Name = Record.Name;
+  if (!SuffixStr.empty())
+    Name += "_" + SuffixStr.str();
+
+  if (IsMask) {
+    Name += "_m";
+  }
+
+  // Overloaded function name, e.g. vadd.
+  std::string OverloadedName;
+  if (!Record.OverloadedName)
+    OverloadedName = StringRef(Record.Name).split("_").first.str();
+  else
+    OverloadedName = Record.OverloadedName;
+  if (!OverloadedSuffixStr.empty())
+    OverloadedName += "_" + OverloadedSuffixStr.str();
+
+  // clang built-in function name, e.g. __builtin_rvv_vadd.
+  std::string BuiltinName = "__builtin_rvv_" + std::string(Record.Name);
+  if (IsMask) {
+    BuiltinName += "_m";
+  }
+
+  // Put into IntrinsicList.
+  size_t Index = IntrinsicList.size();
+  IntrinsicList.push_back({Name, OverloadedName, BuiltinName, Signature});
+
+  // Creating mapping to Intrinsics.
+  Intrinsics.insert({Name, Index});
+
+  // Get the RVVOverloadIntrinsicDef.
+  RVVOverloadIntrinsicDef &OverloadIntrinsicDef =
+      OverloadIntrinsics[OverloadedName];
+
+  // And added the index.
+  OverloadIntrinsicDef.Indexs.push_back(Index);
+}
+
+void RVVIntrinsicManager::CreateRVVIntrinsicDecl(Sema &S, LookupResult &LR,
+                                                 IdentifierInfo *II,
+                                                 Preprocessor &PP,
+                                                 unsigned Index,
+                                                 bool IsOverload) {
+  ASTContext &Context = S.Context;
+  RVVIntrinsicDef &IDef = IntrinsicList[Index];
+  auto Sigs = IDef.Signature;
+  size_t SigLength = Sigs.size();
+  auto ReturnType = Sigs[0];
+  QualType RetType = RVVType2Qual(Context, ReturnType);
+  SmallVector<QualType, 8> ArgTypes;
+  QualType BuiltinFuncType;
+
+  // Skip return type, and convert RVVType to QualType for arguments.
+  for (size_t i = 1; i < SigLength; ++i) {
+    ArgTypes.push_back(RVVType2Qual(Context, Sigs[i]));
+  }
+
+  FunctionProtoType::ExtProtoInfo PI(
+      Context.getDefaultCallingConvention(false, false, true));
+
+  PI.Variadic = false;
+
+  SourceLocation Loc = LR.getNameLoc();
+  BuiltinFuncType = Context.getFunctionType(RetType, ArgTypes, PI);
+  DeclContext *Parent = Context.getTranslationUnitDecl();
+
+  FunctionDecl *RVVIntrinsicDecl = FunctionDecl::Create(
+      Context, Parent, Loc, Loc, II, BuiltinFuncType, /*TInfo=*/nullptr,
+      SC_Extern, S.getCurFPFeatures().isFPConstrained(), false,
+      BuiltinFuncType->isFunctionProtoType());
+
+  // Create Decl objects for each parameter, adding them to the
+  // FunctionDecl.
+  const auto *FP = cast<FunctionProtoType>(BuiltinFuncType);
+  SmallVector<ParmVarDecl *, 8> ParmList;
+  for (unsigned IParm = 0, e = FP->getNumParams(); IParm != e; ++IParm) {
+    ParmVarDecl *Parm =
+        ParmVarDecl::Create(Context, RVVIntrinsicDecl, Loc, Loc, nullptr,
+                            FP->getParamType(IParm), nullptr, SC_None, nullptr);
+    Parm->setScopeInfo(0, IParm);
+    ParmList.push_back(Parm);
+  }
+  RVVIntrinsicDecl->setParams(ParmList);
+
+  // Add function attributes.
+  if (IsOverload)
+    RVVIntrinsicDecl->addAttr(OverloadableAttr::CreateImplicit(Context));
+
+  // Setup alias to __builtin_rvv_*
+  auto &IntrinsicII = PP.getIdentifierTable().get(IDef.BuiltinName);
+  RVVIntrinsicDecl->addAttr(
+      BuiltinAliasAttr::CreateImplicit(S.Context, &IntrinsicII));
+
+  // Add to symbol table.
+  LR.addDecl(RVVIntrinsicDecl);
+}
+
+bool RVVIntrinsicManager::CreateIntrinsicIfFound(Sema &S, LookupResult &LR,
+                                                 IdentifierInfo *II,
+                                                 Preprocessor &PP) {
+  StringRef Name = II->getName();
+
+  // Lookup the function name from the overload intrinsics first.
+  auto OvIItr = OverloadIntrinsics.find(Name);
+  if (OvIItr != OverloadIntrinsics.end()) {
+    auto OvIntrinsicDef = OvIItr->second;
+    for (auto Index : OvIntrinsicDef.Indexs) {
+      CreateRVVIntrinsicDecl(S, LR, II, PP, Index,
+                             /*IsOverload*/ true);
+    }
+
+    // If we added overloads, need to resolve the lookup result.
+    LR.resolveKind();
+    return true;
+  }
+
+  // Lookup the function name from the intrinsics.
+  auto Itr = Intrinsics.find(Name);
+  if (Itr != Intrinsics.end()) {
+    CreateRVVIntrinsicDecl(S, LR, II, PP, Itr->second,
+                           /*IsOverload*/ false);
+    return true;
+  }
+
+  // It's not RVV intrinsics.
+  return false;
+}
+
+namespace clang {
+bool GetRVVBuiltinInfo(Sema &S, LookupResult &LR, IdentifierInfo *II,
+                       Preprocessor &PP) {
+  static std::unique_ptr<RVVIntrinsicManager> IntrinsicManager =
+      std::make_unique<RVVIntrinsicManager>(S.Context);
+
+  return IntrinsicManager->CreateIntrinsicIfFound(S, LR, II, PP);
+}
+} // namespace clang

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
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Support/RISCVVIntrinsicUtils.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/raw_ostream.h"
 #include <numeric>
 #include <set>
 #include <unordered_map>
 
 using namespace llvm;
 
if (!Suffix.empty())
     Name += "_" + Suffix.str();
   if (!MangledSuffix.empty())
     MangledName += "_" + MangledSuffix.str();
   if (IsMasked) {
     BuiltinName += "_m";
     Name += "_m";
   }
 
-  // Init RISC-V extensions
-  for (const auto &T : OutInTypes) {
-    if (T->isFloatVector(16) || T->isFloat(16))
-      RISCVPredefinedMacros |= RISCVPredefinedMacro::Zvfh;
-    if (T->isFloatVector(32))
-      RISCVPredefinedMacros |= RISCVPredefinedMacro::VectorMaxELenFp32;
-    if (T->isFloatVector(64))
-      RISCVPredefinedMacros |= RISCVPredefinedMacro::VectorMaxELenFp64;
-    if (T->isVector(64))
-      RISCVPredefinedMacros |= RISCVPredefinedMacro::VectorMaxELen64;
-  }
-  for (auto Feature : RequiredFeatures) {
-    if (Feature == "RV64")
-      RISCVPredefinedMacros |= RISCVPredefinedMacro::RV64;
-    // Note: Full multiply instruction (mulh, mulhu, mulhsu, smul) for EEW=64
-    // require V.
-    if (Feature == "FullMultiply" &&
-        (RISCVPredefinedMacros & RISCVPredefinedMacro::VectorMaxELen64))
-      RISCVPredefinedMacros |= RISCVPredefinedMacro::V;
-  }
-
   // Init OutputType and InputTypes
   OutputType = OutInTypes[0];
   InputTypes.assign(OutInTypes.begin() + 1, OutInTypes.end());
 
   // IntrinsicTypes is unmasked TA version index. Need to update it
   // if there is merge operand (It is always in first operand).
   IntrinsicTypes = NewIntrinsicTypes;
   if ((IsMasked && HasMaskedOffOperand) ||
std::string RVVIntrinsic::getBuiltinTypeStr() const {
   std::string S;
   S += OutputType->getBuiltinStr();
   for (const auto &T : InputTypes) {
     S += T->getBuiltinStr();
   }
   return S;
 }
 
 std::string RVVIntrinsic::getSuffixStr(
     BasicType Type, int Log2LMUL,
     llvm::ArrayRef<PrototypeDescriptor> PrototypeDescriptors) {
   SmallVector<std::string> SuffixStrs;
   for (auto PD : PrototypeDescriptors) {
     auto T = RVVType::computeType(Type, Log2LMUL, PD);
     SuffixStrs.push_back(T.getValue()->getShortStr());
   }
   return join(SuffixStrs, "_");
 }
 
while (!Prototypes.empty()) {
     if (!PD)
       llvm_unreachable("Error during parsing prototype.");
     PrototypeDescriptors.push_back(*PD);
     Prototypes = Prototypes.drop_front(Idx + 1);
   }
   return PrototypeDescriptors;
 }
 
+raw_ostream &operator<<(raw_ostream &OS, const RVVIntrinsicRecord &Record) {
+  OS << "{";
+  OS << "\"" << Record.Name << "\",";
+  if (Record.OverloadedName == nullptr ||
+      StringRef(Record.OverloadedName).empty())
+    OS << "nullptr,";
+  else
+    OS << "\"" << Record.OverloadedName << "\",";
+  OS << Record.PrototypeIndex << ",";
+  OS << Record.MaskedPrototypeIndex << ",";
+  OS << Record.SuffixIndex << ",";
+  OS << Record.OverloadedSuffixIndex << ",";
+  OS << (int)Record.PrototypeLength << ",";
+  OS << (int)Record.MaskedPrototypeLength << ",";
+  OS << (int)Record.SuffixLength << ",";
+  OS << (int)Record.OverloadedSuffixSize << ",";
+  OS << (int)Record.RequiredExtension << ",";
+  OS << (int)Record.TypeRangeMask << ",";
+  OS << (int)Record.Log2LMULMask << ",";
+  OS << (int)Record.NF << ",";
+  OS << "},\n";
+  return OS;
+}
+
 } // end namespace RISCV
 } // end namespace clang

clang/utils/TableGen/RISCVVEmitter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/Support/RISCVVIntrinsicUtils.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include <numeric>
 
 using namespace llvm;
 using namespace clang::RISCV;
 
 namespace {
+struct SemaRecord {
+  // Intrinsic name, e.g. vadd_vv
+  std::string Name;
+
+  // Overloaded intrinsic name, could be empty if can be computed from Name
+  // e.g. vadd
+  std::string OverloadedName;
+
+  // Supported type, mask of BasicType
+  unsigned TypeRangeMask;
+
+  // Supported LMUL.
+  unsigned Log2LMULMask;
+
+  // Required extensions for this intrinsic.
+  unsigned RequiredExtension;
+
+  // Prototype for this intrinsic.
+  SmallVector<PrototypeDescriptor> Prototype;
+
+  // Prototype for masked intrinsic.
+  SmallVector<PrototypeDescriptor> MaskedPrototype;
+
+  // Suffix of intrinsic name.
+  SmallVector<PrototypeDescriptor> Suffix;
+
+  // Suffix of overloaded intrinsic name.
+  SmallVector<PrototypeDescriptor> OverloadedSuffix;
+
+  // Number of field, large than 1 if it's segment load/store.
+  unsigned NF;
+};
+
 class RVVEmitter {
 private:
   RecordKeeper &Records;
 
+  std::vector<SemaRecord> SemaRecords;
+  std::vector<PrototypeDescriptor> SemaSignatureTable;
+
 public:
   RVVEmitter(RecordKeeper &R) : Records(R) {}
 
   /// Emit riscv_vector.h
   void createHeader(raw_ostream &o);
 
   /// Emit all the __builtin prototypes and code needed by Sema.
   void createBuiltins(raw_ostream &o);
 
   /// Emit all the information needed to map builtin -> LLVM IR intrinsic.
   void createCodeGen(raw_ostream &o);
 
+  /// Emit all the information needed by SemaRVVLookup.cpp.
+  /// We've large number of intrinsic function for RVV, creating a customized
+  /// could speed up the compilation time.
+  void createSema(raw_ostream &o);
+
 private:
   /// Create all intrinsics and add them to \p Out
   void createRVVIntrinsics(std::vector<std::unique_ptr<RVVIntrinsic>> &Out);
+  /// Create all intrinsics record from RVVIntrinsics.
+  void createRVVIntrinsicRecord(std::vector<RVVIntrinsicRecord> &Out);
+
   /// Print HeaderCode in RVVHeader Record to \p Out
   void printHeaderCode(raw_ostream &OS);
 
-  /// Emit Acrh predecessor definitions and body, assume the element of Defs are
-  /// sorted by extension.
-  void emitArchMacroAndBody(
-      std::vector<std::unique_ptr<RVVIntrinsic>> &Defs, raw_ostream &o,
-      std::function<void(raw_ostream &, const RVVIntrinsic &)>);
-
-  // Emit the architecture preprocessor definitions. Return true when emits
-  // non-empty string.
-  bool emitMacroRestrictionStr(RISCVPredefinedMacroT PredefinedMacros,
-                               raw_ostream &o);
+  /// Construct a compressed signature table used for createSema.
+  void ConstructSemaSignatureTable();
+  /// Get index from the signature table.
+  unsigned
+  GetSemaSignatureIndex(const SmallVector<PrototypeDescriptor> &Signature);
 };
 
 } // namespace
 
 static BasicType ParseBasicType(char c) {
   switch (c) {
   case 'c':
     return BasicType::Int8;
void emitCodeGenSwitchBody(const RVVIntrinsic *RVVI, raw_ostream &OS) {
   // VL could be i64 or i32, need to encode it in IntrinsicTypes. VL is
   // always last operand.
   if (RVVI->hasVL())
     OS << ", Ops.back()->getType()";
   OS << "};\n";
   OS << "  break;\n";
 }
 
-void emitIntrinsicFuncDef(const RVVIntrinsic &RVVI, raw_ostream &OS) {
-  OS << "__attribute__((__clang_builtin_alias__(";
-  OS << "__builtin_rvv_" << RVVI.getBuiltinName() << ")))\n";
-  OS << RVVI.getOutputType()->getTypeStr() << " " << RVVI.getName() << "(";
-  // Emit function arguments
-  const RVVTypes &InputTypes = RVVI.getInputTypes();
-  if (!InputTypes.empty()) {
-    ListSeparator LS;
-    for (unsigned i = 0; i < InputTypes.size(); ++i)
-      OS << LS << InputTypes[i]->getTypeStr();
-  }
-  OS << ");\n";
-}
-
-void emitMangledFuncDef(const RVVIntrinsic &RVVI, raw_ostream &OS) {
-  OS << "__attribute__((__clang_builtin_alias__(";
-  OS << "__builtin_rvv_" << RVVI.getBuiltinName() << ")))\n";
-  OS << RVVI.getOutputType()->getTypeStr() << " " << RVVI.getMangledName()
-     << "(";
-  // Emit function arguments
-  const RVVTypes &InputTypes = RVVI.getInputTypes();
-  if (!InputTypes.empty()) {
-    ListSeparator LS;
-    for (unsigned i = 0; i < InputTypes.size(); ++i)
-      OS << LS << InputTypes[i]->getTypeStr();
-  }
-  OS << ");\n";
-}
-
 //===----------------------------------------------------------------------===//
 // RVVEmitter implementation
 //===----------------------------------------------------------------------===//
 void RVVEmitter::createHeader(raw_ostream &OS) {
 
   OS << "/*===---- riscv_vector.h - RISC-V V-extension RVVIntrinsics "
         "-------------------===\n"
         " *\n"
         " *\n"
         " * Part of the LLVM Project, under the Apache License v2.0 with LLVM "
void RVVEmitter::createHeader(raw_ostream &OS) {
   OS << "#ifndef __riscv_vector\n";
   OS << "#error \"Vector intrinsics require the vector extension.\"\n";
   OS << "#endif\n\n";
 
   OS << "#ifdef __cplusplus\n";
   OS << "extern \"C\" {\n";
   OS << "#endif\n\n";
 
-  printHeaderCode(OS);
+  OS << "#pragma clang riscv intrinsic vector\n\n";
 
-  std::vector<std::unique_ptr<RVVIntrinsic>> Defs;
-  createRVVIntrinsics(Defs);
+  printHeaderCode(OS);
 
   auto printType = [&](auto T) {
     OS << "typedef " << T->getClangBuiltinStr() << " " << T->getTypeStr()
        << ";\n";
   };
 
   constexpr int Log2LMULs[] = {-3, -2, -1, 0, 1, 2, 3};
   // Print RVV boolean types.
   for (int Log2LMUL : Log2LMULs) {
     auto T = RVVType::computeType(BasicType::Int8, Log2LMUL,
                                   PrototypeDescriptor::Mask);
     if (T.hasValue())
void RVVEmitter::createHeader(raw_ostream &OS) {
   for (int Log2LMUL : Log2LMULs) {
     auto T = RVVType::computeType(BasicType::Float64, Log2LMUL,
                                   PrototypeDescriptor::Vector);
     if (T.hasValue())
       printType(T.getValue());
   }
   OS << "#endif\n\n";
 
-  // The same extension include in the same arch guard marco.
-  llvm::stable_sort(Defs, [](const std::unique_ptr<RVVIntrinsic> &A,
-                             const std::unique_ptr<RVVIntrinsic> &B) {
-    return A->getRISCVPredefinedMacros() < B->getRISCVPredefinedMacros();
-  });
-
-  OS << "#define __rvv_ai static __inline__\n";
-
-  // Print intrinsic functions with macro
-  emitArchMacroAndBody(Defs, OS, [](raw_ostream &OS, const RVVIntrinsic &Inst) {
-    OS << "__rvv_ai ";
-    emitIntrinsicFuncDef(Inst, OS);
-  });
-
-  OS << "#undef __rvv_ai\n\n";
-
   OS << "#define __riscv_v_intrinsic_overloading 1\n";
 
-  // Print Overloaded APIs
-  OS << "#define __rvv_aio static __inline__ "
-        "__attribute__((__overloadable__))\n";
-
-  emitArchMacroAndBody(Defs, OS, [](raw_ostream &OS, const RVVIntrinsic &Inst) {
-    if (!Inst.isMasked() && !Inst.hasUnMaskedOverloaded())
-      return;
-    OS << "__rvv_aio ";
-    emitMangledFuncDef(Inst, OS);
-  });
-
-  OS << "#undef __rvv_aio\n";
-
   OS << "\n#ifdef __cplusplus\n";
   OS << "}\n";
   OS << "#endif // __cplusplus\n";
   OS << "#endif // __RISCV_VECTOR_H\n";
 }
 
 void RVVEmitter::createBuiltins(raw_ostream &OS) {
   std::vector<std::unique_ptr<RVVIntrinsic>> Defs;
void RVVEmitter::createCodeGen(raw_ostream &OS) {
   OS << "\n";
 }
 
 void RVVEmitter::createRVVIntrinsics(
     std::vector<std::unique_ptr<RVVIntrinsic>> &Out) {
   std::vector<Record *> RV = Records.getAllDerivedDefinitions("RVVBuiltin");
   for (auto *R : RV) {
     StringRef Name = R->getValueAsString("Name");
     StringRef SuffixProto = R->getValueAsString("Suffix");
     StringRef OverloadedName = R->getValueAsString("MangledName");
     StringRef OverloadedSuffixProto = R->getValueAsString("MangledSuffix");
     StringRef Prototypes = R->getValueAsString("Prototype");
     StringRef TypeRange = R->getValueAsString("TypeRange");
     bool HasMasked = R->getValueAsBit("HasMasked");
     bool HasMaskedOffOperand = R->getValueAsBit("HasMaskedOffOperand");
     bool HasVL = R->getValueAsBit("HasVL");
     Record *MaskedPolicyRecord = R->getValueAsDef("MaskedPolicy");
for (char I : TypeRange) {
               Name, SuffixStr, OverloadedName, OverloadedSuffixStr,
               MaskedIRName,
               /*IsMasked=*/true, HasMaskedOffOperand, HasVL, MaskedPolicy,
               HasUnMaskedOverloaded, HasBuiltinAlias, MaskedManualCodegen,
               MaskTypes.getValue(), IntrinsicTypes, RequiredFeatures, NF));
         }
       } // end for Log2LMULList
     }   // end for TypeRange
+
+    // We don't emit vsetvli and vsetvlimax for SemaRecord.
+    // They are written in riscv_vector.td and will emit those marco define in
+    // riscv_vector.h
+    if (Name == "vsetvli" || Name == "vsetvlimax")
+      continue;
+
+    // Create SemaRecord
+    SemaRecord SR;
+    SR.Name = Name.str();
+    SR.OverloadedName = OverloadedName.str();
+    BasicType TypeRangeMask = BasicType::Unknown;
+    for (char I : TypeRange) {
+      TypeRangeMask |= ParseBasicType(I);
+    }
+    SR.TypeRangeMask = static_cast<unsigned>(TypeRangeMask);
+
+    unsigned Log2LMULMask = 0;
+    for (int Log2LMUL : Log2LMULList) {
+      Log2LMULMask |= 1 << (Log2LMUL + 3);
+    }
+
+    SR.Log2LMULMask = Log2LMULMask;
+
+    SR.RequiredExtension = 0;
+    for (auto RequiredFeature : RequiredFeatures) {
+      RVVRequire RequireExt = StringSwitch<RVVRequire>(RequiredFeature)
+                                  .Case("RV64", RVV_REQ_RV64)
+                                  .Case("FullMultiply", RVV_REQ_FullMultiply)
+                                  .Default(RVV_REQ_None);
+      assert(RequireExt != RVV_REQ_None && "Unrecognized required feature?");
+      SR.RequiredExtension |= RequireExt;
+    }
+
+    SR.NF = NF;
+
+    SR.Prototype = std::move(Prototype);
+
+    if (HasMasked)
+      SR.MaskedPrototype = std::move(MaskedPrototype);
+
+    auto InitSuffixtype = [&](SmallVectorImpl<PrototypeDescriptor> &PS,
+                              StringRef Prototypes) {
+      PS = parsePrototypes(Prototypes);
+    };
+
+    InitSuffixtype(SR.Suffix, SuffixProto);
+    InitSuffixtype(SR.OverloadedSuffix, OverloadedSuffixProto);
+
+    SemaRecords.push_back(SR);
   }
 }
 
 void RVVEmitter::printHeaderCode(raw_ostream &OS) {
   std::vector<Record *> RVVHeaders =
       Records.getAllDerivedDefinitions("RVVHeader");
   for (auto *R : RVVHeaders) {
     StringRef HeaderCodeStr = R->getValueAsString("HeaderCode");
     OS << HeaderCodeStr.str();
   }
 }
 
-void RVVEmitter::emitArchMacroAndBody(
-    std::vector<std::unique_ptr<RVVIntrinsic>> &Defs, raw_ostream &OS,
-    std::function<void(raw_ostream &, const RVVIntrinsic &)> PrintBody) {
-  RISCVPredefinedMacroT PrevMacros =
-      (*Defs.begin())->getRISCVPredefinedMacros();
-  bool NeedEndif = emitMacroRestrictionStr(PrevMacros, OS);
-  for (auto &Def : Defs) {
-    RISCVPredefinedMacroT CurMacros = Def->getRISCVPredefinedMacros();
-    if (CurMacros != PrevMacros) {
-      if (NeedEndif)
-        OS << "#endif\n\n";
-      NeedEndif = emitMacroRestrictionStr(CurMacros, OS);
-      PrevMacros = CurMacros;
+unsigned RVVEmitter::GetSemaSignatureIndex(
+    const SmallVector<PrototypeDescriptor> &Signature) {
+  if (Signature.size() == 0)
+    return 0;
+
+  // Checking Signature already in table or not.
+  if (Signature.size() < SemaSignatureTable.size()) {
+    size_t Bound = SemaSignatureTable.size() - Signature.size() + 1;
+    for (size_t Index = 0; Index < Bound; ++Index) {
+      bool Match = true;
+      for (size_t i = 0; i < Signature.size(); ++i) {
+        if (Signature[i] != SemaSignatureTable[Index + i]) {
+          Match = false;
+          break;
         }
-    if (Def->hasBuiltinAlias())
-      PrintBody(OS, *Def);
       }
-  if (NeedEndif)
-    OS << "#endif\n\n";
+      // Reuse if found in table.
+      if (Match)
+        return Index;
+    }
+  }
+
+  // Insert Signature into SemaSignatureTable if not found in the table.
+  size_t Index = SemaSignatureTable.size();
+  for (const auto &Type : Signature) {
+    SemaSignatureTable.push_back(Type);
+  }
+  return Index;
+}
+
+void RVVEmitter::ConstructSemaSignatureTable() {
+  // Sort signature entries by length, let longer signature insert first, to
+  // make it more possible to reuse table entries, that can reduce ~10% table
+  // size.
+  struct Compare {
+    bool operator()(const SmallVector<PrototypeDescriptor> &A,
+                    const SmallVector<PrototypeDescriptor> &B) {
+      if (A.size() != B.size())
+        return A.size() > B.size();
+
+      size_t Len = A.size();
+      for (size_t i = 0; i < Len; ++i) {
+        if (A[i] != B[i])
+          return A[i] > B[i];
       }
 
-bool RVVEmitter::emitMacroRestrictionStr(RISCVPredefinedMacroT PredefinedMacros,
-                                         raw_ostream &OS) {
-  if (PredefinedMacros == RISCVPredefinedMacro::Basic)
       return false;
-  OS << "#if ";
-  ListSeparator LS(" && ");
-  if (PredefinedMacros & RISCVPredefinedMacro::V)
-    OS << LS << "defined(__riscv_v)";
-  if (PredefinedMacros & RISCVPredefinedMacro::Zvfh)
-    OS << LS << "defined(__riscv_zvfh)";
-  if (PredefinedMacros & RISCVPredefinedMacro::RV64)
-    OS << LS << "(__riscv_xlen == 64)";
-  if (PredefinedMacros & RISCVPredefinedMacro::VectorMaxELen64)
-    OS << LS << "(__riscv_v_elen >= 64)";
-  if (PredefinedMacros & RISCVPredefinedMacro::VectorMaxELenFp32)
-    OS << LS << "(__riscv_v_elen_fp >= 32)";
-  if (PredefinedMacros & RISCVPredefinedMacro::VectorMaxELenFp64)
-    OS << LS << "(__riscv_v_elen_fp >= 64)";
-  OS << "\n";
-  return true;
+    }
+  };
+
+  std::set<SmallVector<PrototypeDescriptor>, Compare> Signatures;
+  auto InsertToSignatureSet =
+      [&](const SmallVector<PrototypeDescriptor> &Signature) {
+        if (Signature.empty())
+          return;
+
+        Signatures.insert(Signature);
+      };
+
+  for (const auto &SemaRecord : SemaRecords) {
+    InsertToSignatureSet(SemaRecord.Prototype);
+    InsertToSignatureSet(SemaRecord.MaskedPrototype);
+    InsertToSignatureSet(SemaRecord.Suffix);
+    InsertToSignatureSet(SemaRecord.OverloadedSuffix);
+  }
+
+  for (const auto &Sig : Signatures) {
+    GetSemaSignatureIndex(Sig);
+  }
+}
+
+void RVVEmitter::createRVVIntrinsicRecord(
+    std::vector<RVVIntrinsicRecord> &Out) {
+  ConstructSemaSignatureTable();
+
+  for (const auto &SR : SemaRecords) {
+    RVVIntrinsicRecord Record;
+    Record.Name = SR.Name.c_str();
+    Record.OverloadedName = SR.OverloadedName.c_str();
+    Record.PrototypeIndex = GetSemaSignatureIndex(SR.Prototype);
+    Record.MaskedPrototypeIndex = GetSemaSignatureIndex(SR.MaskedPrototype);
+    Record.SuffixIndex = GetSemaSignatureIndex(SR.Suffix);
+    Record.OverloadedSuffixIndex = GetSemaSignatureIndex(SR.OverloadedSuffix);
+    Record.PrototypeLength = SR.Prototype.size();
+    Record.MaskedPrototypeLength = SR.MaskedPrototype.size();
+    Record.SuffixLength = SR.Suffix.size();
+    Record.OverloadedSuffixSize = SR.OverloadedSuffix.size();
+    Record.RequiredExtension = SR.RequiredExtension;
+    Record.TypeRangeMask = SR.TypeRangeMask;
+    Record.Log2LMULMask = SR.Log2LMULMask;
+    Record.NF = SR.NF;
+    Out.push_back(Record);
+  }
+}
+
+void RVVEmitter::createSema(raw_ostream &OS) {
+  std::vector<std::unique_ptr<RVVIntrinsic>> Defs;
+  std::vector<RVVIntrinsicRecord> RVVIntrinsicRecords;
+  createRVVIntrinsics(Defs);
+
+  createRVVIntrinsicRecord(RVVIntrinsicRecords);
+
+  // Emit signature table for SemaRVVLookup.cpp.
+  OS << "#ifdef DECL_SIGNATURE_TABLE\n";
+  for (const auto &Sig : SemaSignatureTable)
+    OS << "PrototypeDescriptor(" << static_cast<int>(Sig.PT) << ", "
+       << static_cast<int>(Sig.VTM) << ", " << static_cast<int>(Sig.TM)
+       << "),\n";
+  OS << "#endif\n";
+
+  // Emit RVVIntrinsicRecords for SemaRVVLookup.cpp.
+  OS << "#ifdef DECL_INTRINSIC_RECORDS\n";
+  for (const RVVIntrinsicRecord &Record : RVVIntrinsicRecords)
+    OS << Record;
+  OS << "#endif\n";
 }
 
 namespace clang {
 void EmitRVVHeader(RecordKeeper &Records, raw_ostream &OS) {
   RVVEmitter(Records).createHeader(OS);
 }
 
 void EmitRVVBuiltins(RecordKeeper &Records, raw_ostream &OS) {
   RVVEmitter(Records).createBuiltins(OS);
 }
 
 void EmitRVVBuiltinCG(RecordKeeper &Records, raw_ostream &OS) {
   RVVEmitter(Records).createCodeGen(OS);
 }
 
+void EmitRVVBuiltinSema(RecordKeeper &Records, raw_ostream &OS) {
+  RVVEmitter(Records).createSema(OS);
+}
+
 } // End namespace clang

clang/utils/TableGen/TableGen.cpp

enum ActionType {
   GenArmCdeHeader,
   GenArmCdeBuiltinDef,
   GenArmCdeBuiltinSema,
   GenArmCdeBuiltinCG,
   GenArmCdeBuiltinAliases,
   GenRISCVVectorHeader,
   GenRISCVVectorBuiltins,
   GenRISCVVectorBuiltinCG,
+  GenRISCVVectorBuiltinSema,
   GenAttrDocs,
   GenDiagDocs,
   GenOptDocs,
   GenDataCollectors,
   GenTestPragmaAttributeSupportedAttributes
 };
 
 namespace {
cl::values(
         clEnumValN(GenArmCdeBuiltinAliases, "gen-arm-cde-builtin-aliases",
                    "Generate list of valid ARM CDE builtin aliases for clang"),
         clEnumValN(GenRISCVVectorHeader, "gen-riscv-vector-header",
                    "Generate riscv_vector.h for clang"),
         clEnumValN(GenRISCVVectorBuiltins, "gen-riscv-vector-builtins",
                    "Generate riscv_vector_builtins.inc for clang"),
         clEnumValN(GenRISCVVectorBuiltinCG, "gen-riscv-vector-builtin-codegen",
                    "Generate riscv_vector_builtin_cg.inc for clang"),
+        clEnumValN(GenRISCVVectorBuiltinSema, "gen-riscv-vector-builtin-sema",
+                   "Generate riscv_vector_builtin_sema.inc for clang"),
         clEnumValN(GenAttrDocs, "gen-attr-docs",
                    "Generate attribute documentation"),
         clEnumValN(GenDiagDocs, "gen-diag-docs",
                    "Generate diagnostic documentation"),
         clEnumValN(GenOptDocs, "gen-opt-docs", "Generate option documentation"),
         clEnumValN(GenDataCollectors, "gen-clang-data-collectors",
                    "Generate data collectors for AST nodes"),
         clEnumValN(GenTestPragmaAttributeSupportedAttributes,
case GenRISCVVectorHeader:
     EmitRVVHeader(Records, OS);
     break;
   case GenRISCVVectorBuiltins:
     EmitRVVBuiltins(Records, OS);
     break;
   case GenRISCVVectorBuiltinCG:
     EmitRVVBuiltinCG(Records, OS);
     break;
+  case GenRISCVVectorBuiltinSema:
+    EmitRVVBuiltinSema(Records, OS);
+    break;
   case GenAttrDocs:
     EmitClangAttrDocs(Records, OS);
     break;
   case GenDiagDocs:
     EmitClangDiagDocs(Records, OS);
     break;
   case GenOptDocs:
     EmitClangOptDocs(Records, OS);

clang/utils/TableGen/TableGenBackends.h

 void EmitMveBuiltinDef(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitMveBuiltinSema(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitMveBuiltinCG(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitMveBuiltinAliases(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
 void EmitRVVHeader(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitRVVBuiltins(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitRVVBuiltinCG(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
+void EmitRVVBuiltinSema(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
 void EmitCdeHeader(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitCdeBuiltinDef(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitCdeBuiltinSema(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitCdeBuiltinCG(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 void EmitCdeBuiltinAliases(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);
 
 void EmitClangAttrDocs(llvm::RecordKeeper &Records, llvm::raw_ostream &OS);