[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

91 ↗

(On Diff #400358)

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

92 ↗

(On Diff #400358)

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

359–371 ↗

(On Diff #400358)

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

314

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

320

missed comment?

336

Forget to remove this code?

344

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?

1534

Use constant reference to access range-based loop?

1541

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

91 ↗

(On Diff #400358)

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.

92 ↗

(On Diff #400358)

Updated.

359–371 ↗

(On Diff #400358)

More comment added.

[khchen]

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

clang/lib/Sema/SemaLookup.cpp

1055

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

clang/lib/Support/RISCVVIntrinsicUtils.cpp

884 ↗

(On Diff #426285)

maybe this changed should be in another NFC patch.

clang/utils/TableGen/RISCVVEmitter.cpp

1296

maybe all renaming stuffs should be in another NFC patch.

1395

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?

1528

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

1395

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)
...

1528

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

[khchen]

clang/lib/Sema/SemaRVVLookup.cpp

175 ↗

(On Diff #431646)

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

clang/utils/TableGen/RISCVVEmitter.cpp

316

and also init SemaRecords?

318

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

336–353

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

340

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

1504

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

1544

we only need SemaRecords initialization part of createRVVIntrinsics, right?

1546

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

79

please use ArrayRef

319

maybe SemaRecords could have default argument as nullptr.

323

please use ArrayRef

1051

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

890

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

1590 ↗

(On Diff #441320)

funtion -> functions

clang/include/clang/Support/RISCVVIntrinsicUtils.h

110 ↗

(On Diff #441320)

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

114 ↗

(On Diff #441320)

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<.

364 ↗

(On Diff #441320)

"if can" -> "if it can"

395 ↗

(On Diff #441320)

Missing period at end of comment.

clang/lib/Parse/ParsePragma.cpp

3829

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

3837

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

clang/lib/Sema/CMakeLists.txt

49 ↗

(On Diff #441320)

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

78

Is hsignature a typo?

1405

Drop curly braces

[craig.topper]

clang/utils/TableGen/RISCVVEmitter.cpp

1411

Drop curly braces

1434

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

114 ↗

(On Diff #441320)

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

clang/utils/TableGen/RISCVVEmitter.cpp

1051

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

3832

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).

3840

Same here.

3847

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

43

76

1048–1049

Pretty sure you can go with this instead.

1081–1086

[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

185–186 ↗

(On Diff #441610)

+1

49 ↗

(On Diff #441684)

Indices (or Indexes)?

218 ↗

(On Diff #441684)

Drop curly braces

clang/utils/TableGen/RISCVVEmitter.cpp

49

Comment is plural, variable is singular.

320

all records, plural?

1399

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

1464

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

3832

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

3832

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

1464

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 ↗

(On Diff #442431)

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

346 ↗

(On Diff #444188)

362 ↗

(On Diff #444188)

400 ↗

(On Diff #444188)

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

65

[kito-cheng]

@aaron.ballman thanks for your review!

clang/include/clang/Support/RISCVVIntrinsicUtils.h

400 ↗

(On Diff #444188)

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 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/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(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(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 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.setPredefines("#define __riscv_pragma_vector_intrinsics");
+}

clang/lib/Sema/SemaLookup.cpp

 #include "clang/AST/DeclLookups.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/LangOptions.h"
+#include "clang/Basic/TargetBuiltins.h"
+#include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/ModuleLoader.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Overload.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"

 #include <algorithm>
 #include <iterator>
 #include <list>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "OpenCLBuiltins.inc"
+#include "clang/Basic/riscv_vector_builtin_sema.inc"
 
 using namespace clang;
 using namespace sema;
 
 namespace {
   class UnqualUsingEntry {
     const DeclContext *Nominated;
     const DeclContext *CommonAncestor;
for (unsigned SignatureIndex = 0; SignatureIndex < Len; SignatureIndex++) {
     }
   }
 
   // If we added overloads, need to resolve the lookup result.
   if (Len > 1 || HasGenType)
     LR.resolveKind();
 }
 
+static void GetQualTypesForRVVBuiltin(Sema &S, const RVVBuiltinStruct &Builtin,
+                                      QualType &RetType,
+                                      SmallVector<QualType, 5> &ArgTypes) {
+  // Get the QualType instance of the return type.
+  unsigned Sig = RVVSignatureTable[Builtin.SigTableIndex];
+  RVV2Qual(S, RVVTypeTable[Sig], RetType);
+
+  // Get the QualType instances of the arguments.
+  // First type is the return type, skip it.
+  for (unsigned Index = 1; Index < Builtin.NumTypes; Index++) {
+    QualType Ty;
+    RVV2Qual(S, RVVTypeTable[RVVSignatureTable[Builtin.SigTableIndex + Index]],
+             Ty);
+    ArgTypes.push_back(std::move(Ty));
+  }
+}
+
+static void GetRVVBuiltinFuncType(ASTContext &Context,
+                                  QualType &BuiltinFuncType, QualType &RetType,
+                                  SmallVector<QualType, 5> &ArgTypes) {
+  FunctionProtoType::ExtProtoInfo PI(
+      Context.getDefaultCallingConvention(false, false, true));
+  PI.Variadic = false;
+
+  BuiltinFuncType = Context.getFunctionType(RetType, ArgTypes, PI);
+}
+
+static unsigned GetTargetFeatures(const TargetInfo &TI) {
+  bool HasF = TI.hasFeature("f");
+  bool HasD = TI.hasFeature("d");
+  bool HasZfh = TI.hasFeature("experimental-zfh");
+  bool HasZvlsseg = TI.hasFeature("experimental-zvlsseg");
+  unsigned Features = 0;
+  if (HasF)
+    Features |= RISCVFeature_F;
+  if (HasD)
+    Features |= RISCVFeature_D;
+  if (HasZfh)
+    Features |= RISCVFeature_ZFH;
+  if (HasZvlsseg)
+    Features |= RISCVFeature_ZVLSSEG;
+
+  return Features;
+}
+
+static void InsertRVVBuiltinDeclarationsFromTable(
+    Sema &S, LookupResult &LR, IdentifierInfo *II, Preprocessor &PP,
+    const unsigned FctIndex, const unsigned Len, const unsigned BuiltinIndex) {
+
+  // FIXME:
+  // It is hacky here. If we create the implicit funciton declarations, these
+  // overloaded builtins will trigger "call to %0 is ambiguous" error message.
+  // For example,
+  // vint8m1_t vloxei8(const int8_t *, vuint8m1_t, size_t);
+  // vuint8m1_t vloxei8(const uint8_t *, vuint8m1_t, size_t);
+  // The first pointer type is implicitly convertible. These two declarations
+  // are ambiguous.
+  if (II->getName() == "vloxei8" || II->getName() == "vloxei16" ||
+      II->getName() == "vloxei32" || II->getName() == "vloxei64" ||
+      II->getName() == "vluxei8" || II->getName() == "vluxei16" ||
+      II->getName() == "vluxei32" || II->getName() == "vluxei64")
+    return;
+
+  ASTContext &Context = S.Context;
+  unsigned RVVTargetFeatures = GetTargetFeatures(Context.getTargetInfo());
+
+  for (unsigned SignatureIndex = 0; SignatureIndex < Len; SignatureIndex++) {
+    const RVVBuiltinStruct &RVVBuiltin =
+        RVVBuiltinTable[FctIndex + SignatureIndex];
+
+    if ((RVVBuiltin.RequiredExts & RVVTargetFeatures) !=
+        RVVBuiltin.RequiredExts)
+      continue;
+
+    QualType RetType;
+    SmallVector<QualType, 5> ArgTypes;
+    GetQualTypesForRVVBuiltin(S, RVVBuiltin, RetType, ArgTypes);
+
+    QualType BuiltinFuncType;
+    GetRVVBuiltinFuncType(Context, BuiltinFuncType, RetType, ArgTypes);
+
+    SourceLocation Loc = LR.getNameLoc();
+    DeclContext *Parent = Context.getTranslationUnitDecl();
+    FunctionDecl *NewRVVBuiltin = FunctionDecl::Create(
+        Context, Parent, Loc, Loc, II, BuiltinFuncType, /*TInfo=*/nullptr,
+        SC_Extern, S.getCurFPFeatures().isFPConstrained(), false,
+        BuiltinFuncType->isFunctionProtoType());
+    NewRVVBuiltin->setImplicit();
+
+    // Create Decl objects for each parameter, adding them to the
+    // FunctionDecl.
+    const auto *FP = cast<FunctionProtoType>(BuiltinFuncType);
+    SmallVector<ParmVarDecl *, 5> ParmList;
+    for (unsigned IParm = 0, e = FP->getNumParams(); IParm != e; ++IParm) {
+      ParmVarDecl *Parm = ParmVarDecl::Create(
+          Context, NewRVVBuiltin, SourceLocation(), SourceLocation(), nullptr,
+          FP->getParamType(IParm), nullptr, SC_None, nullptr);
+      Parm->setScopeInfo(0, IParm);
+      ParmList.push_back(Parm);
+    }
+    NewRVVBuiltin->setParams(ParmList);
+    NewRVVBuiltin->addAttr(OverloadableAttr::CreateImplicit(Context));
+    // Add __clang_builtin_alias__(BuiltinName) attribute.
+    unsigned BuiltinID = BuiltinIndex;
+    // If it is a generic C builtin, find the clang builtin by
+    // (name, signature index).
+    if (Len > 1)
+      BuiltinID = RVVGenericBuiltinMap[std::make_pair(
+          II->getName(), RVVBuiltin.SigTableIndex)];
+    auto &IntrinsicII = PP.getIdentifierTable().get(RVVBuiltinName[BuiltinID]);
+    NewRVVBuiltin->addAttr(
+        BuiltinAliasAttr::CreateImplicit(S.Context, &IntrinsicII));
+
+    LR.addDecl(NewRVVBuiltin);
+  }
+
+  if (Len > 1)
+    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 (II) {
         auto Index = isOpenCLBuiltin(II->getName());
         if (Index.first) {
           InsertOCLBuiltinDeclarationsFromTable(*this, R, II, Index.first - 1,
                                                 Index.second);
           return true;
         }
       }
 
+      // TODO: Find a better way to detect RVV.
+      if (PP.getPredefines() == "#define __riscv_pragma_vector_intrinsics") {
+        unsigned SigIndex, SigSize, BuiltinIndex;
+        std::tie(SigIndex, SigSize, BuiltinIndex) = isRVVBuiltin(II->getName());
+        if (SigIndex) {
+          InsertRVVBuiltinDeclarationsFromTable(*this, R, II, PP, SigIndex - 1,
+                                                SigSize, BuiltinIndex);
+          return true;
+        }
+      }
+
       // If this is a builtin on this (or all) targets, create the decl.
       if (unsigned BuiltinID = II->getBuiltinID()) {
         // In C++ 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) &&
             Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
           return false;
 

clang/utils/TableGen/RISCVVEmitter.cpp

 // includes a declaration and definition of each intrinsic functions specified
 // in https://github.com/riscv/rvv-intrinsic-doc.
 //
 // See also the documentation in include/clang/Basic/riscv_vector.td.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/StringMatcher.h"
+#include "llvm/TableGen/TableGenBackend.h"
 #include <numeric>
 
 using namespace llvm;
 using BasicType = char;
 using VScaleVal = Optional<unsigned>;
 
 namespace {
 
 // Exponential LMUL
 struct LMULType {
   int Log2LMUL;
   LMULType(int Log2LMUL);
   // Return the C/C++ string representation of LMUL
   std::string str() const;
   Optional<unsigned> getScale(unsigned ElementBitwidth) const;
   void MulLog2LMUL(int Log2LMUL);
   LMULType &operator*=(uint32_t RHS);
 };
 
 // This class is compact representation of a valid and invalid RVVType.
 class RVVType {
   enum ScalarTypeKind : uint32_t {
     Void,
     Size_t,
     Ptrdiff_t,
     UnsignedLong,
     SignedLong,
     Boolean,
     SignedInteger,
     UnsignedInteger,
     Float,
     Invalid,
   };
-  BasicType BT;
   ScalarTypeKind ScalarType = Invalid;
   LMULType LMUL;
   bool IsPointer = false;
   // IsConstant indices are "int", but have the constant expression.
   bool IsImmediate = false;
   // Const qualifier for pointer to const object or object of const type.
   bool IsConstant = false;
   unsigned ElementBitwidth = 0;
   VScaleVal Scale = 0;
   bool Valid;
 
   std::string BuiltinStr;
   std::string ClangBuiltinStr;
   std::string Str;
   std::string ShortStr;
+  std::string QualExpr;
 
 public:
   RVVType() : RVVType(BasicType(), 0, StringRef()) {}
   RVVType(BasicType BT, int Log2LMUL, StringRef prototype);
 
+  const std::string getMangledStr() const {
+    if (!Valid)
+      return "";
+
+    Twine ScalarTypeStr =
+        Twine(Twine(ScalarType) + Twine(IsPointer) + Twine(IsImmediate) +
+              Twine(IsConstant) + Twine(ElementBitwidth));
+    if (isScalar()) {
+      return ScalarTypeStr.str();
+    } else {
+      return Twine(ScalarTypeStr + Twine(Scale.getValue()) + LMUL.str()).str();
+    }
+  }
+
   // Return the string representation of a type, which is an encoded string for
   // passing to the BUILTIN() macro in Builtins.def.
   const std::string &getBuiltinStr() const { return BuiltinStr; }
 
   // Return the clang builtin type for RVV vector type which are used in the
   // riscv_vector.h header file.
   const std::string &getClangBuiltinStr() const { return ClangBuiltinStr; }
 
   // Return the C/C++ string representation of a type for use in the
   // riscv_vector.h header file.
   const std::string &getTypeStr() const { return Str; }
 
   // Return the short name of a type for C/C++ name suffix.
   const std::string &getShortStr() {
     // Not all types are used in short name, so compute the short name by
     // demanded.
     if (ShortStr.empty())
       initShortStr();
     return ShortStr;
   }
 
+  const std::string &getQualExpr() { return QualExpr; }
+
   bool isValid() const { return Valid; }
   bool isScalar() const { return Scale.hasValue() && Scale.getValue() == 0; }
   bool isVector() const { return Scale.hasValue() && Scale.getValue() != 0; }
   bool isFloat() const { return ScalarType == ScalarTypeKind::Float; }
   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 isPointer() const { return IsPointer; }
+  bool isConstant() const { return IsConstant; }
 
 private:
   // Verify RVV vector type and set Valid.
   bool verifyType() const;
 
   // Creates a type based on basic types of TypeRange
-  void applyBasicType();
+  void applyBasicType(BasicType BT);
 
   // Applies a prototype modifier to the current type. The result maybe an
   // invalid type.
   void applyModifier(StringRef prototype);
 
   // Compute and record a string for legal type.
   void initBuiltinStr();
   // Compute and record a builtin RVV vector type string.
   void initClangBuiltinStr();
   // Compute and record a type string for used in the header.
   void initTypeStr();
   // Compute and record a short name of a type for C/C++ name suffix.
   void initShortStr();
+  // Compute and record the expression to create QualType.
+  void initQualExpr();
 };
 
 using RVVTypePtr = RVVType *;
 using RVVTypes = std::vector<RVVTypePtr>;
 
 enum RISCVExtension : uint8_t {
   Basic = 0,
   F = 1 << 1,
private:
   std::string MangledName;
   std::string IRName;
   bool IsMask;
   bool HasVL;
   bool HasPolicy;
   bool HasNoMaskedOverloaded;
   bool HasAutoDef; // There is automiatic definition in header
   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.
+  // input types. -1 means the return type.
   std::vector<int64_t> IntrinsicTypes;
   uint8_t RISCVExtensions = 0;
   unsigned NF = 1;
+  const RVVTypes Types;
 
 public:
   RVVIntrinsic(StringRef Name, StringRef Suffix, StringRef MangledName,
                StringRef MangledSuffix, StringRef IRName, bool IsMask,
                bool HasMaskedOffOperand, bool HasVL, bool HasPolicy,
                bool HasNoMaskedOverloaded, bool HasAutoDef,
                StringRef ManualCodegen, const RVVTypes &Types,
                const std::vector<int64_t> &IntrinsicTypes,
public:
   bool isMask() const { return IsMask; }
   StringRef getIRName() const { return IRName; }
   StringRef getManualCodegen() const { return ManualCodegen; }
   uint8_t getRISCVExtensions() const { return RISCVExtensions; }
   unsigned getNF() const { return NF; }
   const std::vector<int64_t> &getIntrinsicTypes() const {
     return IntrinsicTypes;
   }
+  const RVVTypes &getRVVTypes() const { return Types; }
 
   // Return the type string for a BUILTIN() macro in Builtins.def.
   std::string getBuiltinTypeStr() const;
 
   // Emit the code block for switch body in EmitRISCVBuiltinExpr, it should
   // init the RVVIntrinsic ID and IntrinsicTypes.
   void emitCodeGenSwitchBody(raw_ostream &o) const;
 
-  // Emit the macros for mapping C/C++ intrinsic function to builtin functions.
-  void emitIntrinsicFuncDef(raw_ostream &o) const;
-
   // Emit the mangled function definition.
   void emitMangledFuncDef(raw_ostream &o) const;
 };
 
+// A list of signatures that are shared by one or more builtin functions.
+struct BuiltinTableEntries {
+  SmallVector<StringRef, 4> Names;
+  SmallVector<unsigned, 4> BuiltinIndex;
+  std::vector<std::pair<RVVIntrinsic *, unsigned>> Signatures;
+};
+
 class RVVEmitter {
 private:
+  // A list of indices into the builtin function table.
+  using BuiltinIndexListTy = SmallVector<unsigned, 11>;
+
   RecordKeeper &Records;
+  std::vector<std::unique_ptr<RVVIntrinsic>> Defs;
   std::string HeaderCode;
   // Concat BasicType, LMUL and Proto as key
   StringMap<RVVType> LegalTypes;
   StringSet<> IllegalTypes;
 
+  MapVector<RVVType *, unsigned> TypeMap;
+  std::vector<RVVType *> TypeList;
+  std::vector<std::string> BuiltinList;
+  // Map (generic name, RVVSignatureTable index) to RVVBuiltinName index
+  MapVector<std::pair<StringRef, unsigned>, unsigned> GenericBuiltinMap;
+
+  // Contains a list of the available signatures, without the name of the
+  // function. Each pair consists of a signature and a cumulative index.
+  // E.g.:  <<vint8m1_t, vint8m1_t, vint8m1_t, size_t>, 0>,
+  //        <<vint8m1_t, vbool8_t, vint8m1_t, vint8m1_t, vint8m1_t, size_t>, 4>,
+  //        <<vint8m2_t, vint8m2_t, vint8m2_t, size_t>, 10>,
+  std::vector<std::pair<const RVVTypes, unsigned>> SignaturesList;
+
+  // Map the name of a builtin function to its prototypes (instances of the
+  // "RVVIntrinsic" class).
+  // Each prototype is registered as a pair of:
+  //   <pointer to the "RVVIntrinsic" instance,
+  //    cumulative index of the associated signature in the SignaturesList>
+  // E.g.:  The function vadd:
+  // vint8m1_t vadd(vint8m1_t, vint8m1_t, size_t);
+  // vint8m1_t vadd(vbool8_t, vint8m1_t, vint8m1_t, vint8m1_t, size_t);
+  // vint8m2_t vadd(vint8m2_t, vint8m2_t, size_t);
+  // ...
+  //        <"vadd", <<ptr to RVVIntrinsic for vadd_vv_i8m1, 0>,
+  //                  <ptr to RVVIntrinsic for vadd_vv_i8m1_m, 4>,
+  //                  <ptr to RVVIntrinsic for vadd_vv_i8m2, 10>,
+  //                  ...>>
+  MapVector<StringRef, std::vector<std::pair<RVVIntrinsic *, unsigned>>>
+      FctOverloadMap;
+
+  // Map an ordered vector of signatures to their original RVVIntrinsic
+  // instances, and to a list of function names that share these signatures.
+  //
+  // For example, suppose the "vadd" and "vsub" functions have only three
+  // signatures, and these signatures are at index Ix in the SignatureTable:
+  //            vadd      |           vsub    |  Signature    | Index
+  //  vint8m1_t vadd()    | vint8m1_t vsub()  |  Signature1   | I1
+  //  vint8m2_t vadd()    | vint8m2_t vsub()  |  Signature2   | I2
+  //  vint8m4_t vadd()    | vint8m4_t vsub()  |  Signature3   | I3
+  //
+  // Then we will create a mapping of the vector of signatures:
+  // SignatureListMap[<I1, I2, I3>] = <
+  //                  <"vadd", "vsub">,
+  //                  <Signature1, Signature2, Signature3>>
+  // The function "vand", having the same signatures, would be mapped to the
+  // same entry (<I1, I2, I3>).
+  MapVector<BuiltinIndexListTy *, BuiltinTableEntries> SignatureListMap;
+
 public:
-  RVVEmitter(RecordKeeper &R) : Records(R) {}
+  RVVEmitter(RecordKeeper &R) : Records(R) { createRVVIntrinsics(Defs); }
 
   /// 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 SemaLookup.cpp.
+  void createSema(raw_ostream &o);
+
   std::string getSuffixStr(char Type, int Log2LMUL, StringRef Prototypes);
 
 private:
   /// Create all intrinsics and add them to \p Out
   void createRVVIntrinsics(std::vector<std::unique_ptr<RVVIntrinsic>> &Out);
   /// Create Headers and add them to \p Out
   void createRVVHeaders(raw_ostream &OS);
   /// Compute output and input types by applying different config (basic type
   /// and LMUL with type transformers). It also record result of type in legal
   /// or illegal set to avoid compute the  same config again. The result maybe
   /// have illegal RVVType.
   Optional<RVVTypes> computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
                                   ArrayRef<std::string> PrototypeSeq);
   Optional<RVVTypePtr> computeType(BasicType BT, int Log2LMUL, StringRef Proto);
 
   /// 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 emitExtDefStr(uint8_t Extensions, raw_ostream &o);
   // Slice Prototypes string into sub prototype string and process each sub
   // prototype string individually in the Handler.
   void parsePrototypes(StringRef Prototypes,
                        std::function<void(StringRef)> Handler);
+
+  void EmitDeclarations(raw_ostream &o);
+  void GetOverloads(raw_ostream &o);
+  bool CanReuseSignature(
+      BuiltinIndexListTy *Candidate,
+      std::vector<std::pair<RVVIntrinsic *, unsigned>> &SignatureList);
+  void GroupBySignature(raw_ostream &OS);
+
+  void EmitSignatureTable(raw_ostream &o);
+  void EmitBuiltinTable(raw_ostream &o);
+  void EmitBuiltinMapTable(raw_ostream &o);
+  void EmitStringMatcher(raw_ostream &o);
+  void EmitQualTypeFinder(raw_ostream &o);
 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Type implementation
 //===----------------------------------------------------------------------===//
 

 
 LMULType &LMULType::operator*=(uint32_t RHS) {
   assert(isPowerOf2_32(RHS));
   this->Log2LMUL = this->Log2LMUL + Log2_32(RHS);
   return *this;
 }
 
 RVVType::RVVType(BasicType BT, int Log2LMUL, StringRef prototype)
-    : BT(BT), LMUL(LMULType(Log2LMUL)) {
-  applyBasicType();
+    : LMUL(LMULType(Log2LMUL)) {
+  applyBasicType(BT);
   applyModifier(prototype);
   Valid = verifyType();
   if (Valid) {
     initBuiltinStr();
     initTypeStr();
+    initQualExpr();
     if (isVector()) {
       initClangBuiltinStr();
     }
   }
 }
 
 // clang-format off
 // boolean type are encoded the ratio of n (SEW/LMUL)
case ScalarTypeKind::Float:
     ShortStr = "f" + utostr(ElementBitwidth);
     break;
   case ScalarTypeKind::SignedInteger:
     ShortStr = "i" + utostr(ElementBitwidth);
     break;
   case ScalarTypeKind::UnsignedInteger:
     ShortStr = "u" + utostr(ElementBitwidth);
     break;
+  case ScalarTypeKind::Void:
+    ShortStr = "void";
+    break;
+  case ScalarTypeKind::Size_t:
+    ShortStr = "size_t";
+    break;
+  case ScalarTypeKind::Ptrdiff_t:
+    ShortStr = "ptrdiff_t";
+    break;
+  case ScalarTypeKind::UnsignedLong:
+    ShortStr = "ulong";
+    break;
+  case ScalarTypeKind::SignedLong:
+    ShortStr = "long";
+    break;
   default:
     PrintFatalError("Unhandled case!");
   }
   if (isVector())
     ShortStr += LMUL.str();
 }
 
-void RVVType::applyBasicType() {
+void RVVType::initQualExpr() {
+  switch (ScalarType) {
+  case ScalarTypeKind::Invalid:
+    llvm_unreachable("Type is not valid.");
+  case ScalarTypeKind::Void:
+    QualExpr = "Context.VoidTy";
+    break;
+  case ScalarTypeKind::Size_t:
+    QualExpr = "Context.getSizeType()";
+    break;
+  case ScalarTypeKind::Ptrdiff_t:
+    QualExpr = "Context.getPointerDiffType()";
+    break;
+  case ScalarTypeKind::UnsignedLong:
+    QualExpr = "Context.UnsignedLongTy";
+    break;
+  case ScalarTypeKind::SignedLong:
+    QualExpr = "Context.LongTy";
+    break;
+  case ScalarTypeKind::Boolean:
+    QualExpr = "Context.BoolTy";
+    break;
+  case ScalarTypeKind::SignedInteger:
+    switch (ElementBitwidth) {
+    case 8:
+      QualExpr = "Context.SignedCharTy";
+      break;
+    case 16:
+      QualExpr = "Context.ShortTy";
+      break;
+    case 32:
+      QualExpr = "Context.IntTy";
+      break;
+    case 64:
+      QualExpr = "Context.LongLongTy";
+      break;
+    }
+    break;
+  case ScalarTypeKind::UnsignedInteger:
+    switch (ElementBitwidth) {
+    case 8:
+      QualExpr = "Context.UnsignedCharTy";
+      break;
+    case 16:
+      QualExpr = "Context.UnsignedShortTy";
+      break;
+    case 32:
+      QualExpr = "Context.UnsignedIntTy";
+      break;
+    case 64:
+      QualExpr = "Context.UnsignedLongLongTy";
+      break;
+    }
+    break;
+  case ScalarTypeKind::Float:
+    switch (ElementBitwidth) {
+    case 16:
+      QualExpr = "Context.Float16Ty";
+      break;
+    case 32:
+      QualExpr = "Context.FloatTy";
+      break;
+    case 64:
+      QualExpr = "Context.DoubleTy";
+      break;
+    }
+    break;
+  }
+
+  if (isScalar())
+    return;
+
+  assert(isVector() && "Unexpected type.");
+  QualExpr = Twine("Context.getScalableVectorType(" + QualExpr + ", " +
+                   Twine(Scale.getValue()) + ")")
+                 .str();
+}
+
+void RVVType::applyBasicType(BasicType BT) {
   switch (BT) {
   case 'c':
     ElementBitwidth = 8;
     ScalarType = ScalarTypeKind::SignedInteger;
     break;
   case 's':
     ElementBitwidth = 16;
     ScalarType = ScalarTypeKind::SignedInteger;
case 'P':
       break;
     case 'C':
       if (IsConstant)
         PrintFatalError("'C' transformer cannot be used twice");
       IsConstant = true;
       break;
     case 'K':
       IsImmediate = true;
+      IsConstant = true;
       break;
     case 'U':
       ScalarType = ScalarTypeKind::UnsignedInteger;
       break;
     case 'I':
       ScalarType = ScalarTypeKind::SignedInteger;
       break;
     case 'F':
RVVIntrinsic::RVVIntrinsic(StringRef NewName, StringRef Suffix,
                            StringRef IRName, bool IsMask,
                            bool HasMaskedOffOperand, bool HasVL, bool HasPolicy,
                            bool HasNoMaskedOverloaded, bool HasAutoDef,
                            StringRef ManualCodegen, const RVVTypes &OutInTypes,
                            const std::vector<int64_t> &NewIntrinsicTypes,
                            StringRef RequiredExtension, unsigned NF)
     : IRName(IRName), IsMask(IsMask), HasVL(HasVL), HasPolicy(HasPolicy),
       HasNoMaskedOverloaded(HasNoMaskedOverloaded), HasAutoDef(HasAutoDef),
-      ManualCodegen(ManualCodegen.str()), NF(NF) {
+      ManualCodegen(ManualCodegen.str()), NF(NF), Types(OutInTypes) {
 
   // Init BuiltinName, Name and MangledName
   BuiltinName = NewName.str();
   Name = BuiltinName;
   if (NewMangledName.empty())
     MangledName = NewName.split("_").first.str();
   else
     MangledName = NewMangledName.str();
for (const auto &T : OutInTypes) {
     else if (T->isFloatVector(32) || T->isFloat(32))
       RISCVExtensions |= RISCVExtension::F;
     else if (T->isFloatVector(64) || T->isFloat(64))
       RISCVExtensions |= RISCVExtension::D;
   }
   if (RequiredExtension == "Zvlsseg")
     RISCVExtensions |= RISCVExtension::Zvlsseg;
 
-  // Init OutputType and InputTypes
-  OutputType = OutInTypes[0];
-  InputTypes.assign(OutInTypes.begin() + 1, OutInTypes.end());
-
   // IntrinsicTypes is nonmasked version index. Need to update it
   // if there is maskedoff operand (It is always in first operand).
   IntrinsicTypes = NewIntrinsicTypes;
   if (IsMask && HasMaskedOffOperand) {
     for (auto &I : IntrinsicTypes) {
       if (I >= 0)
         I += NF;
     }
   }
 }
 
 std::string RVVIntrinsic::getBuiltinTypeStr() const {
   std::string S;
-  S += OutputType->getBuiltinStr();
-  for (const auto &T : InputTypes) {
-    S += T->getBuiltinStr();
-  }
+  S += Types[0]->getBuiltinStr();
+  for (unsigned i = 1; i < Types.size(); ++i)
+    S += Types[i]->getBuiltinStr();
   return S;
 }
 
 void RVVIntrinsic::emitCodeGenSwitchBody(raw_ostream &OS) const {
   if (!getIRName().empty())
     OS << "  ID = Intrinsic::riscv_" + getIRName() + ";\n";
   if (NF >= 2)
     OS << "  NF = " + utostr(getNF()) + ";\n";
void RVVIntrinsic::emitCodeGenSwitchBody(raw_ostream &OS) const {
   // VL could be i64 or i32, need to encode it in IntrinsicTypes. VL is
   // always last operand.
   if (hasVL())
     OS << ", Ops.back()->getType()";
   OS << "};\n";
   OS << "  break;\n";
 }
 
-void RVVIntrinsic::emitIntrinsicFuncDef(raw_ostream &OS) const {
-  OS << "__attribute__((__clang_builtin_alias__(";
-  OS << "__builtin_rvv_" << getBuiltinName() << ")))\n";
-  OS << OutputType->getTypeStr() << " " << getName() << "(";
-  // Emit function arguments
-  if (!InputTypes.empty()) {
-    ListSeparator LS;
-    for (unsigned i = 0; i < InputTypes.size(); ++i)
-      OS << LS << InputTypes[i]->getTypeStr();
-  }
-  OS << ");\n";
-}
-
 void RVVIntrinsic::emitMangledFuncDef(raw_ostream &OS) const {
-  OS << "__attribute__((__clang_builtin_alias__(";
+  // FIXME:
+  // It is hacky here. If we create the implicit funciton declarations, these
+  // overloaded builtins will trigger "call to %0 is ambiguous" error message.
+  // For example,
+  // vint8m1_t vloxei8(const int8_t *, vuint8m1_t, size_t);
+  // vuint8m1_t vloxei8(const uint8_t *, vuint8m1_t, size_t);
+  // The first pointer type is implicitly convertible. These two declarations
+  // are ambiguous.
+  if (getMangledName() == "vloxei8" || getMangledName() == "vloxei16" ||
+      getMangledName() == "vloxei32" || getMangledName() == "vloxei64" ||
+      getMangledName() == "vluxei8" || getMangledName() == "vluxei16" ||
+      getMangledName() == "vluxei32" || getMangledName() == "vluxei64") {
+    OS << "__rvv_aio __attribute__((__clang_builtin_alias__(";
     OS << "__builtin_rvv_" << getBuiltinName() << ")))\n";
-  OS << OutputType->getTypeStr() << " " << getMangledName() << "(";
+    OS << Types[0]->getTypeStr() << " " << getMangledName() << "(";
     // Emit function arguments
-  if (!InputTypes.empty()) {
+    if (Types.size() > 1) {
       ListSeparator LS;
-    for (unsigned i = 0; i < InputTypes.size(); ++i)
-      OS << LS << InputTypes[i]->getTypeStr();
+      for (unsigned i = 1; i < Types.size(); ++i)
+        OS << LS << Types[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 "
         "Exceptions.\n"
         " * See https://llvm.org/LICENSE.txt for license information.\n"
         " * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception\n"
         " *\n"
         " *===-----------------------------------------------------------------"
         "------===\n"
         " */\n\n";
 
   OS << "#ifndef __RISCV_VECTOR_H\n";
   OS << "#define __RISCV_VECTOR_H\n\n";
 
   OS << "#include <stdint.h>\n";
   OS << "#include <stddef.h>\n\n";
 
   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";
+  OS << "#pragma riscv intrinsic vector\n\n";
 
   createRVVHeaders(OS);
 
-  std::vector<std::unique_ptr<RVVIntrinsic>> Defs;
-  createRVVIntrinsics(Defs);
-
   // Print header code
   if (!HeaderCode.empty()) {
     OS << HeaderCode;
   }
 
   auto printType = [&](auto T) {
     OS << "typedef " << T->getClangBuiltinStr() << " " << T->getTypeStr()
        << ";\n";
void RVVEmitter::createHeader(raw_ostream &OS) {
   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->getRISCVExtensions() < B->getRISCVExtensions();
   });
 
-  OS << "#define __rvv_ai static __inline__\n";
-
-  // Print intrinsic functions with macro
-  emitArchMacroAndBody(Defs, OS, [](raw_ostream &OS, const RVVIntrinsic &Inst) {
-    OS << "__rvv_ai ";
-    Inst.emitIntrinsicFuncDef(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.isMask() && !Inst.hasNoMaskedOverloaded())
       return;
-    OS << "__rvv_aio ";
     Inst.emitMangledFuncDef(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;
-  createRVVIntrinsics(Defs);
-
   // Map to keep track of which builtin names have already been emitted.
   StringMap<RVVIntrinsic *> BuiltinMap;
 
   OS << "#if defined(TARGET_BUILTIN) && !defined(RISCVV_BUILTIN)\n";
   OS << "#define RISCVV_BUILTIN(ID, TYPE, ATTRS) TARGET_BUILTIN(ID, TYPE, "
         "ATTRS, \"experimental-v\")\n";
   OS << "#endif\n";
   for (auto &Def : Defs) {
for (auto &Def : Defs) {
     if (!Def->hasAutoDef())
       OS << Def->getBuiltinTypeStr();
     OS << "\", \"n\")\n";
   }
   OS << "#undef RISCVV_BUILTIN\n";
 }
 
 void RVVEmitter::createCodeGen(raw_ostream &OS) {
-  std::vector<std::unique_ptr<RVVIntrinsic>> Defs;
-  createRVVIntrinsics(Defs);
   // IR name could be empty, use the stable sort preserves the relative order.
   llvm::stable_sort(Defs, [](const std::unique_ptr<RVVIntrinsic> &A,
                              const std::unique_ptr<RVVIntrinsic> &B) {
     return A->getIRName() < B->getIRName();
   });
 
   // Map to keep track of which builtin names have already been emitted.
   StringMap<RVVIntrinsic *> BuiltinMap;
std::string RVVEmitter::getSuffixStr(char Type, int Log2LMUL,
   return join(SuffixStrs, "_");
 }
 
 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 MangledName = R->getValueAsString("MangledName");
     StringRef MangledSuffixProto = R->getValueAsString("MangledSuffix");
     StringRef Prototypes = R->getValueAsString("Prototype");
     StringRef TypeRange = R->getValueAsString("TypeRange");
     bool HasMask = R->getValueAsBit("HasMask");
     bool HasMaskedOffOperand = R->getValueAsBit("HasMaskedOffOperand");
     bool HasVL = R->getValueAsBit("HasVL");
     bool HasPolicy = R->getValueAsBit("HasPolicy");
for (char I : TypeRange) {
               HasNoMaskedOverloaded, HasAutoDef, ManualCodegenMask,
               MaskTypes.getValue(), IntrinsicTypes, RequiredExtension, NF));
         }
       } // end for Log2LMULList
     }   // end for TypeRange
   }
 }
 
 void RVVEmitter::createRVVHeaders(raw_ostream &OS) {
   std::vector<Record *> RVVHeaders =
       Records.getAllDerivedDefinitions("RVVHeader");
   for (auto *R : RVVHeaders) {
     StringRef HeaderCodeStr = R->getValueAsString("HeaderCode");
     OS << HeaderCodeStr.str();
   }
 }
 
 Optional<RVVTypes>
 RVVEmitter::computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
                          ArrayRef<std::string> PrototypeSeq) {
   // LMUL x NF must be less than or equal to 8.
   if ((Log2LMUL >= 1) && (1 << Log2LMUL) * NF > 8)
     return llvm::None;
 
   RVVTypes Types;
   for (const std::string &Proto : PrototypeSeq) {
     auto T = computeType(BT, Log2LMUL, Proto);
     if (!T.hasValue())
       return llvm::None;
     // Record legal type index
     Types.push_back(T.getValue());
   }
   return Types;
 }
 
 Optional<RVVTypePtr> RVVEmitter::computeType(BasicType BT, int Log2LMUL,
                                              StringRef Proto) {
-  std::string Idx = Twine(Twine(BT) + Twine(Log2LMUL) + Proto).str();
-  // Search first
+  RVVType T(BT, Log2LMUL, Proto);
+  std::string Idx = T.getMangledStr();
   auto It = LegalTypes.find(Idx);
   if (It != LegalTypes.end())
     return &(It->second);
   if (IllegalTypes.count(Idx))
     return llvm::None;
-  // Compute type and record the result.
-  RVVType T(BT, Log2LMUL, Proto);
   if (T.isValid()) {
     // Record legal type index and value.
     LegalTypes.insert({Idx, T});
+    TypeList.push_back(&(LegalTypes[Idx]));
     return &(LegalTypes[Idx]);
   }
   // Record illegal type index.
   IllegalTypes.insert(Idx);
   return llvm::None;
 }
 
 void RVVEmitter::emitArchMacroAndBody(
if (Def->hasAutoDef())
       PrintBody(OS, *Def);
   }
   if (NeedEndif)
     OS << "#endif\n\n";
 }
 
 bool RVVEmitter::emitExtDefStr(uint8_t Extents, raw_ostream &OS) {
   if (Extents == RISCVExtension::Basic)
     return false;
   OS << "#if ";
   ListSeparator LS(" && ");
   if (Extents & RISCVExtension::F)
     OS << LS << "defined(__riscv_f)";
   if (Extents & RISCVExtension::D)
     OS << LS << "defined(__riscv_d)";
   if (Extents & RISCVExtension::Zfh)
     OS << LS << "defined(__riscv_zfh)";
   if (Extents & RISCVExtension::Zvlsseg)
     OS << LS << "defined(__riscv_zvlsseg)";
   OS << "\n";
   return true;
 }
 
+void RVVEmitter::EmitDeclarations(raw_ostream &OS) {
+  // Structure definitions.
+  OS << R"(
+enum RISCVFeatures {
+  RISCVFeature_F = 1 << 1,
+  RISCVFeature_D = 1 << 2,
+  RISCVFeature_ZFH = 1 << 3,
+  RISCVFeature_ZVLSSEG = 1 << 4,
+};
+
+// One overload of an RVV builtin function.
+struct RVVBuiltinStruct {
+  // Index of the signature in the RVVSignatureTable table.
+  const unsigned SigTableIndex;
+  // Entries between index SigTableIndex and (SigTableIndex + NumTypes - 1) in
+  // the RVVSignatureTable represent the complete signature.  The first type at
+  // index SigTableIndex is the return type.
+  const unsigned NumTypes;
+  // Required extensions for the builtin.
+  const uint8_t RequiredExts;
+};
+
+)";
+
+  unsigned I = 0;
+  for (auto *Ty : TypeList)
+    TypeMap.insert(std::make_pair(Ty, I++));
+
+  // Enum of scalar/vector type names (float, int, ...).
+  OS << "enum RVVTypeID {\n";
+  StringMap<bool> Seen;
+  for (const auto &T : TypeMap) {
+    auto *RVVTy = T.first;
+    if (Seen.find(RVVTy->getShortStr()) == Seen.end()) {
+      OS << "  RVVT_" + RVVTy->getShortStr() << ",\n";
+      Seen.insert(std::make_pair(RVVTy->getShortStr(), true));
+    }
+  }
+  OS << "};\n\n";
+
+  OS << R"(
+// Represents a return type or argument type.
+struct RVVTypeStruct {
+  // A type (e.g. float, int, ...).
+  const RVVTypeID ID;
+  // 0 if the type is not a pointer.
+  const bool IsPointer : 1;
+  // 0 if the type is not const.
+  const bool IsConst : 1;
+};
+
+)";
+
+  OS << "static const RVVTypeStruct RVVTypeTable[] = {\n";
+  for (const auto &T : TypeMap) {
+    auto *RVVTy = T.first;
+    OS << "  // " << T.second << ", " << RVVTy->getTypeStr() << "\n"
+       << "  {RVVT_" << RVVTy->getShortStr() << ", " << RVVTy->isPointer()
+       << ", " << RVVTy->isConstant() << "},\n";
+  }
+  OS << "};\n\n";
+}
+
+void RVVEmitter::GetOverloads(raw_ostream &OS) {
+  // Populate the SignaturesList and the FctOverloadMap.
+  unsigned CumulativeSignIndex = 0;
+  for (auto &Def : Defs) {
+    StringRef IName = Def->getName();
+    if (FctOverloadMap.find(IName) == FctOverloadMap.end()) {
+      FctOverloadMap.insert(std::make_pair(
+          IName, std::vector<std::pair<RVVIntrinsic *, unsigned>>{}));
+    }
+
+    auto Signature = Def->getRVVTypes();
+    auto it = llvm::find_if(SignaturesList,
+                            [&](const std::pair<const RVVTypes, unsigned> &a) {
+                              return a.first == Signature;
+                            });
+    unsigned SignIndex;
+    if (it == SignaturesList.end()) {
+      SignaturesList.push_back(std::make_pair(Signature, CumulativeSignIndex));
+      SignIndex = CumulativeSignIndex;
+      CumulativeSignIndex += Signature.size();
+    } else {
+      SignIndex = it->second;
+    }
+    FctOverloadMap[IName].push_back(std::make_pair(Def.get(), SignIndex));
+
+    if (Def->isMask() || Def->hasNoMaskedOverloaded()) {
+      // Put the generic builtin into FctOverloadMap.
+      // For example, vadd_vv_i8m1 has 'vadd' generic builtin.
+      StringRef GName = Def->getMangledName();
+      if (FctOverloadMap.find(GName) == FctOverloadMap.end()) {
+        FctOverloadMap.insert(std::make_pair(
+            GName, std::vector<std::pair<RVVIntrinsic *, unsigned>>{}));
+      }
+      FctOverloadMap[GName].push_back(std::make_pair(Def.get(), SignIndex));
+    }
+
+    auto builtin_it = llvm::find_if(BuiltinList, [&](const std::string &a) {
+      return a == "__builtin_rvv_" + Def->getBuiltinName().str();
+    });
+    unsigned BuiltinIdx = builtin_it - BuiltinList.begin();
+    if (Def->isMask() || Def->hasNoMaskedOverloaded()) {
+      StringRef GName = Def->getMangledName();
+      GenericBuiltinMap.insert(
+          std::make_pair(std::make_pair(GName, SignIndex), BuiltinIdx));
+    }
+
+    if (builtin_it == BuiltinList.end()) {
+      BuiltinList.push_back("__builtin_rvv_" + Def->getBuiltinName().str());
+    }
+  }
+}
+
+bool RVVEmitter::CanReuseSignature(
+    BuiltinIndexListTy *Candidate,
+    std::vector<std::pair<RVVIntrinsic *, unsigned>> &SignatureList) {
+  assert(Candidate->size() == SignatureList.size() &&
+         "signature lists should have the same size");
+
+  auto &CandidateSigs = SignatureListMap.find(Candidate)->second.Signatures;
+  for (unsigned Index = 0; Index < Candidate->size(); Index++) {
+    auto *Rec = SignatureList[Index].first;
+    auto *Rec2 = CandidateSigs[Index].first;
+    if (Rec->getRISCVExtensions() == Rec2->getRISCVExtensions())
+      return true;
+  }
+  return false;
+}
+
+void RVVEmitter::GroupBySignature(raw_ostream &OS) {
+  // List of signatures known to be emitted.
+  std::vector<BuiltinIndexListTy *> KnownSignatures;
+
+  for (auto &Fct : FctOverloadMap) {
+    bool FoundReusableSig = false;
+
+    // Gather all signatures for the current function.
+    auto *CurSignatureList = new BuiltinIndexListTy();
+    for (const auto &Signature : Fct.second)
+      CurSignatureList->push_back(Signature.second);
+
+    // Sort the list to facilitate future comparisons.
+    llvm::sort(*CurSignatureList);
+
+    auto it = llvm::find_if(BuiltinList, [&](const std::string &a) {
+      return a ==
+             "__builtin_rvv_" + Fct.second[0].first->getBuiltinName().str();
+    });
+    unsigned BuiltinIndex = it - BuiltinList.begin();
+    // Check if we have already seen another function with the same list of
+    // signatures.  If so, just add the name of the function.
+    for (auto *Candidate : KnownSignatures) {
+      if (Candidate->size() == CurSignatureList->size() &&
+          *Candidate == *CurSignatureList) {
+        if (CanReuseSignature(Candidate, Fct.second)) {
+          SignatureListMap.find(Candidate)->second.Names.push_back(Fct.first);
+          SignatureListMap.find(Candidate)->second.BuiltinIndex.push_back(
+              BuiltinIndex);
+          FoundReusableSig = true;
+        }
+      }
+    }
+
+    if (FoundReusableSig) {
+      delete CurSignatureList;
+    } else {
+      // Add a new entry.
+      SignatureListMap[CurSignatureList] = {
+          SmallVector<StringRef, 4>(1, Fct.first),
+          SmallVector<unsigned, 4>(1, BuiltinIndex), Fct.second};
+      KnownSignatures.push_back(CurSignatureList);
+    }
+  }
+
+  for (auto *I : KnownSignatures)
+    delete I;
+}
+
+void RVVEmitter::EmitSignatureTable(raw_ostream &OS) {
+  // The type is stored as an index
+  // of RVVTypeTable. Multiple entries following each other form a
+  // signature.
+  OS << "static const unsigned short RVVSignatureTable[] = {\n";
+  for (const auto &P : SignaturesList) {
+    OS << "  // " << P.second << ", ";
+    for (auto *Ty : P.first)
+      OS << Ty->getTypeStr() << " ";
+    OS << "\n";
+    for (auto *Ty : P.first) {
+      unsigned Entry = TypeMap.find(Ty)->second;
+      if (Entry > USHRT_MAX) {
+        // Report an error when seeing an entry that is too large for the
+        // current index type (unsigned short).  When hitting this, the type
+        // of SignatureTable will need to be changed.
+        PrintFatalError("Entry in SignatureTable exceeds limit.");
+      }
+      OS << Entry << ", ";
+    }
+    OS << "\n";
+  }
+  OS << "};\n\n";
+}
+
+void RVVEmitter::EmitBuiltinTable(raw_ostream &OS) {
+  OS << "static const char *RVVBuiltinName[] = {\n";
+  for (const auto &B : BuiltinList)
+    OS << "  \"" << B << "\",\n";
+  OS << "};\n\n";
+
+  unsigned Index = 0;
+  OS << "static const RVVBuiltinStruct RVVBuiltinTable[] = {\n";
+  for (const auto &SLM : SignatureListMap) {
+
+    OS << "  // " << (Index + 1) << ": ";
+    for (const auto &Name : SLM.second.Names) {
+      OS << Name << ", ";
+    }
+    OS << "\n";
+
+    OS << "  // Builtins: ";
+    for (const auto &BuiltinIndex : SLM.second.BuiltinIndex) {
+      OS << BuiltinList[BuiltinIndex] << ", ";
+    }
+    OS << "\n";
+
+    for (const auto &Overload : SLM.second.Signatures) {
+      RVVIntrinsic *Intr = Overload.first;
+      OS << "  {" << Overload.second << ", " << Intr->getRVVTypes().size()
+         << ", " << +Intr->getRISCVExtensions() << "},\n";
+      Index++;
+    }
+  }
+  OS << "};\n";
+}
+
+void RVVEmitter::EmitBuiltinMapTable(raw_ostream &OS) {
+  OS << "static std::map<std::pair<StringRef, unsigned>, unsigned> ";
+  OS << " RVVGenericBuiltinMap = {\n";
+  for (const auto &M : GenericBuiltinMap) {
+    OS << " // " << BuiltinList[M.second] << "\n";
+    OS << "  {std::make_pair(\"" << M.first.first << "\", " << M.first.second
+       << "), ";
+    OS << M.second << "},\n";
+  }
+  OS << "};\n";
+}
+
+void RVVEmitter::EmitStringMatcher(raw_ostream &OS) {
+  std::vector<StringMatcher::StringPair> ValidBuiltins;
+  unsigned CumulativeIndex = 1;
+
+  for (const auto &SLM : SignatureListMap) {
+    const auto &Ovl = SLM.second.Signatures;
+
+    // A single signature list may be used by different builtins.  Return the
+    // same <index, length> pair for each of those builtins.
+    for (unsigned i = 0; i < SLM.second.Names.size(); ++i) {
+      const auto &FctName = SLM.second.Names[i];
+      unsigned BuiltinIndex = SLM.second.BuiltinIndex[i];
+      std::string RetStmt;
+      raw_string_ostream SS(RetStmt);
+      SS << "return std::make_tuple(" << CumulativeIndex << ", " << Ovl.size()
+         << ", " << BuiltinIndex << ");";
+      SS.flush();
+      ValidBuiltins.push_back(
+          StringMatcher::StringPair(std::string(FctName), RetStmt));
+    }
+    CumulativeIndex += Ovl.size();
+  }
+
+  OS << R"(
+// Find out whether a string matches an existing RVV builtin function name.
+// Returns: A tuple <0, 0, 0> if no name matches.
+//          A tuple <Index, Len, BuiltinIdx> indexing the RVVBuiltinTable if the name is
+//          matching an RVV builtin function.
+static std::tuple<unsigned, unsigned, unsigned> isRVVBuiltin(llvm::StringRef Name) {
+
+)";
+
+  StringMatcher("Name", ValidBuiltins, OS).Emit(0, true);
+
+  OS << "  return std::make_tuple(0, 0, 0);\n";
+  OS << "} // isRVVBuiltin\n";
+}
+
+void RVVEmitter::EmitQualTypeFinder(raw_ostream &OS) {
+  OS << R"(
+
+// Convert a RVVTypeStruct type to a QualTypes.
+static void RVV2Qual(Sema &S, const RVVTypeStruct &Ty, QualType &QT) {
+  ASTContext &Context = S.Context;
+)";
+
+  // Step 1.
+  // Start of switch statement over all types.
+  OS << "\n  switch (Ty.ID) {\n";
+
+  // Only insert the plain scalar type; vector information and type qualifiers
+  // are added in step 2.
+  StringMap<bool> TypesSeen;
+  for (const auto &T : TypeMap) {
+    auto *RVVTy = T.first;
+    if (TypesSeen.find(RVVTy->getShortStr()) != TypesSeen.end())
+      continue;
+    TypesSeen.insert(std::make_pair(RVVTy->getShortStr(), true));
+    // Get QualType
+    OS << "    case RVVT_" << RVVTy->getShortStr() << ":\n";
+    OS << "      QT = " << RVVTy->getQualExpr() << ";\n";
+    OS << "      break;\n";
+  }
+  // End of switch statement.
+  OS << "  } // end of switch (Ty.ID)\n\n";
+
+  // Step 2.
+  // Assign the right attributes to the types.
+  OS << R"(
+  if (Ty.IsConst != 0) {
+    QT = Context.getConstType(QT);
+  }
+
+  // Transform the type to a pointer as the last step, if necessary.
+  if (Ty.IsPointer != 0) {
+    QT = Context.getPointerType(QT);
+  }
+)";
+
+  // End of the "RVV2Qual" function.
+  OS << "\n} // RVV2Qual\n";
+}
+
+void RVVEmitter::createSema(raw_ostream &OS) {
+  emitSourceFileHeader("RISC-V Vector Builtin handling", OS);
+
+  OS << "#include \"llvm/ADT/StringRef.h\"\n";
+  OS << "using namespace clang;\n\n";
+
+  // Emit enums and structs.
+  EmitDeclarations(OS);
+
+  // Parse the Records to populate the internal lists.
+  GetOverloads(OS);
+  GroupBySignature(OS);
+
+  // Emit tables.
+  EmitSignatureTable(OS);
+  EmitBuiltinTable(OS);
+  EmitBuiltinMapTable(OS);
+
+  // Emit functions.
+  EmitStringMatcher(OS);
+  EmitQualTypeFinder(OS);
+}
+
 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);

llvm/docs/CommandGuide/tblgen.rst

 .. option:: -gen-riscv-vector-builtins
 
   Generate ``riscv_vector_builtins.inc`` for Clang.
 
 .. option:: -gen-riscv-vector-builtin-codegen
 
   Generate ``riscv_vector_builtin_cg.inc`` for Clang.
 
+.. option:: -gen-riscv-vector-builtin-sema
+
+  Generate ``riscv_vector_builtin_sema.inc`` for Clang.
+
 .. option:: -gen-attr-docs
 
   Generate attribute documentation.
 
 .. option:: -gen-diag-docs
 
   Generate diagnostic documentation.