clang 18.0.0git
SemaChecking.cpp
Go to the documentation of this file.
1//===- SemaChecking.cpp - Extra Semantic Checking -------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements extra semantic analysis beyond what is enforced
10// by the C type system.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/APValue.h"
16#include "clang/AST/Attr.h"
18#include "clang/AST/CharUnits.h"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclBase.h"
21#include "clang/AST/DeclCXX.h"
22#include "clang/AST/DeclObjC.h"
25#include "clang/AST/Expr.h"
26#include "clang/AST/ExprCXX.h"
27#include "clang/AST/ExprObjC.h"
30#include "clang/AST/NSAPI.h"
34#include "clang/AST/Stmt.h"
36#include "clang/AST/Type.h"
37#include "clang/AST/TypeLoc.h"
43#include "clang/Basic/LLVM.h"
56#include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering.
58#include "clang/Sema/Lookup.h"
60#include "clang/Sema/Scope.h"
62#include "clang/Sema/Sema.h"
64#include "llvm/ADT/APFloat.h"
65#include "llvm/ADT/APInt.h"
66#include "llvm/ADT/APSInt.h"
67#include "llvm/ADT/ArrayRef.h"
68#include "llvm/ADT/DenseMap.h"
69#include "llvm/ADT/FoldingSet.h"
70#include "llvm/ADT/STLExtras.h"
71#include "llvm/ADT/SmallBitVector.h"
72#include "llvm/ADT/SmallPtrSet.h"
73#include "llvm/ADT/SmallString.h"
74#include "llvm/ADT/SmallVector.h"
75#include "llvm/ADT/StringExtras.h"
76#include "llvm/ADT/StringRef.h"
77#include "llvm/ADT/StringSet.h"
78#include "llvm/ADT/StringSwitch.h"
79#include "llvm/Support/AtomicOrdering.h"
80#include "llvm/Support/Casting.h"
81#include "llvm/Support/Compiler.h"
82#include "llvm/Support/ConvertUTF.h"
83#include "llvm/Support/ErrorHandling.h"
84#include "llvm/Support/Format.h"
85#include "llvm/Support/Locale.h"
86#include "llvm/Support/MathExtras.h"
87#include "llvm/Support/SaveAndRestore.h"
88#include "llvm/Support/raw_ostream.h"
89#include "llvm/TargetParser/RISCVTargetParser.h"
90#include "llvm/TargetParser/Triple.h"
91#include <algorithm>
92#include <bitset>
93#include <cassert>
94#include <cctype>
95#include <cstddef>
96#include <cstdint>
97#include <functional>
98#include <limits>
99#include <optional>
100#include <string>
101#include <tuple>
102#include <utility>
103
104using namespace clang;
105using namespace sema;
106
108 unsigned ByteNo) const {
109 return SL->getLocationOfByte(ByteNo, getSourceManager(), LangOpts,
111}
112
113static constexpr unsigned short combineFAPK(Sema::FormatArgumentPassingKind A,
115 return (A << 8) | B;
116}
117
118/// Checks that a call expression's argument count is at least the desired
119/// number. This is useful when doing custom type-checking on a variadic
120/// function. Returns true on error.
121static bool checkArgCountAtLeast(Sema &S, CallExpr *Call,
122 unsigned MinArgCount) {
123 unsigned ArgCount = Call->getNumArgs();
124 if (ArgCount >= MinArgCount)
125 return false;
126
127 return S.Diag(Call->getEndLoc(), diag::err_typecheck_call_too_few_args)
128 << 0 /*function call*/ << MinArgCount << ArgCount
129 << Call->getSourceRange();
130}
131
132/// Checks that a call expression's argument count is at most the desired
133/// number. This is useful when doing custom type-checking on a variadic
134/// function. Returns true on error.
135static bool checkArgCountAtMost(Sema &S, CallExpr *Call, unsigned MaxArgCount) {
136 unsigned ArgCount = Call->getNumArgs();
137 if (ArgCount <= MaxArgCount)
138 return false;
139 return S.Diag(Call->getEndLoc(),
140 diag::err_typecheck_call_too_many_args_at_most)
141 << 0 /*function call*/ << MaxArgCount << ArgCount
142 << Call->getSourceRange();
143}
144
145/// Checks that a call expression's argument count is in the desired range. This
146/// is useful when doing custom type-checking on a variadic function. Returns
147/// true on error.
148static bool checkArgCountRange(Sema &S, CallExpr *Call, unsigned MinArgCount,
149 unsigned MaxArgCount) {
150 return checkArgCountAtLeast(S, Call, MinArgCount) ||
151 checkArgCountAtMost(S, Call, MaxArgCount);
152}
153
154/// Checks that a call expression's argument count is the desired number.
155/// This is useful when doing custom type-checking. Returns true on error.
156static bool checkArgCount(Sema &S, CallExpr *Call, unsigned DesiredArgCount) {
157 unsigned ArgCount = Call->getNumArgs();
158 if (ArgCount == DesiredArgCount)
159 return false;
160
161 if (checkArgCountAtLeast(S, Call, DesiredArgCount))
162 return true;
163 assert(ArgCount > DesiredArgCount && "should have diagnosed this");
164
165 // Highlight all the excess arguments.
166 SourceRange Range(Call->getArg(DesiredArgCount)->getBeginLoc(),
167 Call->getArg(ArgCount - 1)->getEndLoc());
168
169 return S.Diag(Range.getBegin(), diag::err_typecheck_call_too_many_args)
170 << 0 /*function call*/ << DesiredArgCount << ArgCount
171 << Call->getArg(1)->getSourceRange();
172}
173
175 if (Value->isTypeDependent())
176 return false;
177
178 InitializedEntity Entity =
182 if (Result.isInvalid())
183 return true;
184 Value = Result.get();
185 return false;
186}
187
188/// Check that the first argument to __builtin_annotation is an integer
189/// and the second argument is a non-wide string literal.
190static bool SemaBuiltinAnnotation(Sema &S, CallExpr *TheCall) {
191 if (checkArgCount(S, TheCall, 2))
192 return true;
193
194 // First argument should be an integer.
195 Expr *ValArg = TheCall->getArg(0);
196 QualType Ty = ValArg->getType();
197 if (!Ty->isIntegerType()) {
198 S.Diag(ValArg->getBeginLoc(), diag::err_builtin_annotation_first_arg)
199 << ValArg->getSourceRange();
200 return true;
201 }
202
203 // Second argument should be a constant string.
204 Expr *StrArg = TheCall->getArg(1)->IgnoreParenCasts();
205 StringLiteral *Literal = dyn_cast<StringLiteral>(StrArg);
206 if (!Literal || !Literal->isOrdinary()) {
207 S.Diag(StrArg->getBeginLoc(), diag::err_builtin_annotation_second_arg)
208 << StrArg->getSourceRange();
209 return true;
210 }
211
212 TheCall->setType(Ty);
213 return false;
214}
215
216static bool SemaBuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall) {
217 // We need at least one argument.
218 if (TheCall->getNumArgs() < 1) {
219 S.Diag(TheCall->getEndLoc(), diag::err_typecheck_call_too_few_args_at_least)
220 << 0 << 1 << TheCall->getNumArgs()
221 << TheCall->getCallee()->getSourceRange();
222 return true;
223 }
224
225 // All arguments should be wide string literals.
226 for (Expr *Arg : TheCall->arguments()) {
227 auto *Literal = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
228 if (!Literal || !Literal->isWide()) {
229 S.Diag(Arg->getBeginLoc(), diag::err_msvc_annotation_wide_str)
230 << Arg->getSourceRange();
231 return true;
232 }
233 }
234
235 return false;
236}
237
238/// Check that the argument to __builtin_addressof is a glvalue, and set the
239/// result type to the corresponding pointer type.
240static bool SemaBuiltinAddressof(Sema &S, CallExpr *TheCall) {
241 if (checkArgCount(S, TheCall, 1))
242 return true;
243
244 ExprResult Arg(TheCall->getArg(0));
245 QualType ResultType = S.CheckAddressOfOperand(Arg, TheCall->getBeginLoc());
246 if (ResultType.isNull())
247 return true;
248
249 TheCall->setArg(0, Arg.get());
250 TheCall->setType(ResultType);
251 return false;
252}
253
254/// Check that the argument to __builtin_function_start is a function.
255static bool SemaBuiltinFunctionStart(Sema &S, CallExpr *TheCall) {
256 if (checkArgCount(S, TheCall, 1))
257 return true;
258
260 if (Arg.isInvalid())
261 return true;
262
263 TheCall->setArg(0, Arg.get());
264 const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(
266
267 if (!FD) {
268 S.Diag(TheCall->getBeginLoc(), diag::err_function_start_invalid_type)
269 << TheCall->getSourceRange();
270 return true;
271 }
272
273 return !S.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
274 TheCall->getBeginLoc());
275}
276
277/// Check the number of arguments and set the result type to
278/// the argument type.
279static bool SemaBuiltinPreserveAI(Sema &S, CallExpr *TheCall) {
280 if (checkArgCount(S, TheCall, 1))
281 return true;
282
283 TheCall->setType(TheCall->getArg(0)->getType());
284 return false;
285}
286
287/// Check that the value argument for __builtin_is_aligned(value, alignment) and
288/// __builtin_aligned_{up,down}(value, alignment) is an integer or a pointer
289/// type (but not a function pointer) and that the alignment is a power-of-two.
290static bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {
291 if (checkArgCount(S, TheCall, 2))
292 return true;
293
294 clang::Expr *Source = TheCall->getArg(0);
295 bool IsBooleanAlignBuiltin = ID == Builtin::BI__builtin_is_aligned;
296
297 auto IsValidIntegerType = [](QualType Ty) {
298 return Ty->isIntegerType() && !Ty->isEnumeralType() && !Ty->isBooleanType();
299 };
300 QualType SrcTy = Source->getType();
301 // We should also be able to use it with arrays (but not functions!).
302 if (SrcTy->canDecayToPointerType() && SrcTy->isArrayType()) {
303 SrcTy = S.Context.getDecayedType(SrcTy);
304 }
305 if ((!SrcTy->isPointerType() && !IsValidIntegerType(SrcTy)) ||
306 SrcTy->isFunctionPointerType()) {
307 // FIXME: this is not quite the right error message since we don't allow
308 // floating point types, or member pointers.
309 S.Diag(Source->getExprLoc(), diag::err_typecheck_expect_scalar_operand)
310 << SrcTy;
311 return true;
312 }
313
314 clang::Expr *AlignOp = TheCall->getArg(1);
315 if (!IsValidIntegerType(AlignOp->getType())) {
316 S.Diag(AlignOp->getExprLoc(), diag::err_typecheck_expect_int)
317 << AlignOp->getType();
318 return true;
319 }
320 Expr::EvalResult AlignResult;
321 unsigned MaxAlignmentBits = S.Context.getIntWidth(SrcTy) - 1;
322 // We can't check validity of alignment if it is value dependent.
323 if (!AlignOp->isValueDependent() &&
324 AlignOp->EvaluateAsInt(AlignResult, S.Context,
326 llvm::APSInt AlignValue = AlignResult.Val.getInt();
327 llvm::APSInt MaxValue(
328 llvm::APInt::getOneBitSet(MaxAlignmentBits + 1, MaxAlignmentBits));
329 if (AlignValue < 1) {
330 S.Diag(AlignOp->getExprLoc(), diag::err_alignment_too_small) << 1;
331 return true;
332 }
333 if (llvm::APSInt::compareValues(AlignValue, MaxValue) > 0) {
334 S.Diag(AlignOp->getExprLoc(), diag::err_alignment_too_big)
335 << toString(MaxValue, 10);
336 return true;
337 }
338 if (!AlignValue.isPowerOf2()) {
339 S.Diag(AlignOp->getExprLoc(), diag::err_alignment_not_power_of_two);
340 return true;
341 }
342 if (AlignValue == 1) {
343 S.Diag(AlignOp->getExprLoc(), diag::warn_alignment_builtin_useless)
344 << IsBooleanAlignBuiltin;
345 }
346 }
347
350 SourceLocation(), Source);
351 if (SrcArg.isInvalid())
352 return true;
353 TheCall->setArg(0, SrcArg.get());
354 ExprResult AlignArg =
356 S.Context, AlignOp->getType(), false),
357 SourceLocation(), AlignOp);
358 if (AlignArg.isInvalid())
359 return true;
360 TheCall->setArg(1, AlignArg.get());
361 // For align_up/align_down, the return type is the same as the (potentially
362 // decayed) argument type including qualifiers. For is_aligned(), the result
363 // is always bool.
364 TheCall->setType(IsBooleanAlignBuiltin ? S.Context.BoolTy : SrcTy);
365 return false;
366}
367
368static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall,
369 unsigned BuiltinID) {
370 if (checkArgCount(S, TheCall, 3))
371 return true;
372
373 // First two arguments should be integers.
374 for (unsigned I = 0; I < 2; ++I) {
376 if (Arg.isInvalid()) return true;
377 TheCall->setArg(I, Arg.get());
378
379 QualType Ty = Arg.get()->getType();
380 if (!Ty->isIntegerType()) {
381 S.Diag(Arg.get()->getBeginLoc(), diag::err_overflow_builtin_must_be_int)
382 << Ty << Arg.get()->getSourceRange();
383 return true;
384 }
385 }
386
387 // Third argument should be a pointer to a non-const integer.
388 // IRGen correctly handles volatile, restrict, and address spaces, and
389 // the other qualifiers aren't possible.
390 {
392 if (Arg.isInvalid()) return true;
393 TheCall->setArg(2, Arg.get());
394
395 QualType Ty = Arg.get()->getType();
396 const auto *PtrTy = Ty->getAs<PointerType>();
397 if (!PtrTy ||
398 !PtrTy->getPointeeType()->isIntegerType() ||
399 PtrTy->getPointeeType().isConstQualified()) {
400 S.Diag(Arg.get()->getBeginLoc(),
401 diag::err_overflow_builtin_must_be_ptr_int)
402 << Ty << Arg.get()->getSourceRange();
403 return true;
404 }
405 }
406
407 // Disallow signed bit-precise integer args larger than 128 bits to mul
408 // function until we improve backend support.
409 if (BuiltinID == Builtin::BI__builtin_mul_overflow) {
410 for (unsigned I = 0; I < 3; ++I) {
411 const auto Arg = TheCall->getArg(I);
412 // Third argument will be a pointer.
413 auto Ty = I < 2 ? Arg->getType() : Arg->getType()->getPointeeType();
414 if (Ty->isBitIntType() && Ty->isSignedIntegerType() &&
415 S.getASTContext().getIntWidth(Ty) > 128)
416 return S.Diag(Arg->getBeginLoc(),
417 diag::err_overflow_builtin_bit_int_max_size)
418 << 128;
419 }
420 }
421
422 return false;
423}
424
425namespace {
426struct BuiltinDumpStructGenerator {
427 Sema &S;
428 CallExpr *TheCall;
429 SourceLocation Loc = TheCall->getBeginLoc();
431 DiagnosticErrorTrap ErrorTracker;
432 PrintingPolicy Policy;
433
434 BuiltinDumpStructGenerator(Sema &S, CallExpr *TheCall)
435 : S(S), TheCall(TheCall), ErrorTracker(S.getDiagnostics()),
436 Policy(S.Context.getPrintingPolicy()) {
437 Policy.AnonymousTagLocations = false;
438 }
439
440 Expr *makeOpaqueValueExpr(Expr *Inner) {
441 auto *OVE = new (S.Context)
442 OpaqueValueExpr(Loc, Inner->getType(), Inner->getValueKind(),
443 Inner->getObjectKind(), Inner);
444 Actions.push_back(OVE);
445 return OVE;
446 }
447
448 Expr *getStringLiteral(llvm::StringRef Str) {
450 // Wrap the literal in parentheses to attach a source location.
451 return new (S.Context) ParenExpr(Loc, Loc, Lit);
452 }
453
454 bool callPrintFunction(llvm::StringRef Format,
455 llvm::ArrayRef<Expr *> Exprs = {}) {
457 assert(TheCall->getNumArgs() >= 2);
458 Args.reserve((TheCall->getNumArgs() - 2) + /*Format*/ 1 + Exprs.size());
459 Args.assign(TheCall->arg_begin() + 2, TheCall->arg_end());
460 Args.push_back(getStringLiteral(Format));
461 Args.insert(Args.end(), Exprs.begin(), Exprs.end());
462
463 // Register a note to explain why we're performing the call.
466 Ctx.PointOfInstantiation = Loc;
467 Ctx.CallArgs = Args.data();
468 Ctx.NumCallArgs = Args.size();
470
471 ExprResult RealCall =
472 S.BuildCallExpr(/*Scope=*/nullptr, TheCall->getArg(1),
473 TheCall->getBeginLoc(), Args, TheCall->getRParenLoc());
474
476 if (!RealCall.isInvalid())
477 Actions.push_back(RealCall.get());
478 // Bail out if we've hit any errors, even if we managed to build the
479 // call. We don't want to produce more than one error.
480 return RealCall.isInvalid() || ErrorTracker.hasErrorOccurred();
481 }
482
483 Expr *getIndentString(unsigned Depth) {
484 if (!Depth)
485 return nullptr;
486
488 Indent.resize(Depth * Policy.Indentation, ' ');
489 return getStringLiteral(Indent);
490 }
491
493 return getStringLiteral(T.getAsString(Policy));
494 }
495
496 bool appendFormatSpecifier(QualType T, llvm::SmallVectorImpl<char> &Str) {
497 llvm::raw_svector_ostream OS(Str);
498
499 // Format 'bool', 'char', 'signed char', 'unsigned char' as numbers, rather
500 // than trying to print a single character.
501 if (auto *BT = T->getAs<BuiltinType>()) {
502 switch (BT->getKind()) {
503 case BuiltinType::Bool:
504 OS << "%d";
505 return true;
506 case BuiltinType::Char_U:
507 case BuiltinType::UChar:
508 OS << "%hhu";
509 return true;
510 case BuiltinType::Char_S:
511 case BuiltinType::SChar:
512 OS << "%hhd";
513 return true;
514 default:
515 break;
516 }
517 }
518
520 if (Specifier.fixType(T, S.getLangOpts(), S.Context, /*IsObjCLiteral=*/false)) {
521 // We were able to guess how to format this.
522 if (Specifier.getConversionSpecifier().getKind() ==
523 analyze_printf::PrintfConversionSpecifier::sArg) {
524 // Wrap double-quotes around a '%s' specifier and limit its maximum
525 // length. Ideally we'd also somehow escape special characters in the
526 // contents but printf doesn't support that.
527 // FIXME: '%s' formatting is not safe in general.
528 OS << '"';
529 Specifier.setPrecision(analyze_printf::OptionalAmount(32u));
530 Specifier.toString(OS);
531 OS << '"';
532 // FIXME: It would be nice to include a '...' if the string doesn't fit
533 // in the length limit.
534 } else {
535 Specifier.toString(OS);
536 }
537 return true;
538 }
539
540 if (T->isPointerType()) {
541 // Format all pointers with '%p'.
542 OS << "%p";
543 return true;
544 }
545
546 return false;
547 }
548
549 bool dumpUnnamedRecord(const RecordDecl *RD, Expr *E, unsigned Depth) {
550 Expr *IndentLit = getIndentString(Depth);
551 Expr *TypeLit = getTypeString(S.Context.getRecordType(RD));
552 if (IndentLit ? callPrintFunction("%s%s", {IndentLit, TypeLit})
553 : callPrintFunction("%s", {TypeLit}))
554 return true;
555
556 return dumpRecordValue(RD, E, IndentLit, Depth);
557 }
558
559 // Dump a record value. E should be a pointer or lvalue referring to an RD.
560 bool dumpRecordValue(const RecordDecl *RD, Expr *E, Expr *RecordIndent,
561 unsigned Depth) {
562 // FIXME: Decide what to do if RD is a union. At least we should probably
563 // turn off printing `const char*` members with `%s`, because that is very
564 // likely to crash if that's not the active member. Whatever we decide, we
565 // should document it.
566
567 // Build an OpaqueValueExpr so we can refer to E more than once without
568 // triggering re-evaluation.
569 Expr *RecordArg = makeOpaqueValueExpr(E);
570 bool RecordArgIsPtr = RecordArg->getType()->isPointerType();
571
572 if (callPrintFunction(" {\n"))
573 return true;
574
575 // Dump each base class, regardless of whether they're aggregates.
576 if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
577 for (const auto &Base : CXXRD->bases()) {
578 QualType BaseType =
579 RecordArgIsPtr ? S.Context.getPointerType(Base.getType())
580 : S.Context.getLValueReferenceType(Base.getType());
582 Loc, S.Context.getTrivialTypeSourceInfo(BaseType, Loc), Loc,
583 RecordArg);
584 if (BasePtr.isInvalid() ||
585 dumpUnnamedRecord(Base.getType()->getAsRecordDecl(), BasePtr.get(),
586 Depth + 1))
587 return true;
588 }
589 }
590
591 Expr *FieldIndentArg = getIndentString(Depth + 1);
592
593 // Dump each field.
594 for (auto *D : RD->decls()) {
595 auto *IFD = dyn_cast<IndirectFieldDecl>(D);
596 auto *FD = IFD ? IFD->getAnonField() : dyn_cast<FieldDecl>(D);
597 if (!FD || FD->isUnnamedBitfield() || FD->isAnonymousStructOrUnion())
598 continue;
599
600 llvm::SmallString<20> Format = llvm::StringRef("%s%s %s ");
601 llvm::SmallVector<Expr *, 5> Args = {FieldIndentArg,
602 getTypeString(FD->getType()),
603 getStringLiteral(FD->getName())};
604
605 if (FD->isBitField()) {
606 Format += ": %zu ";
608 llvm::APInt BitWidth(S.Context.getIntWidth(SizeT),
609 FD->getBitWidthValue(S.Context));
610 Args.push_back(IntegerLiteral::Create(S.Context, BitWidth, SizeT, Loc));
611 }
612
613 Format += "=";
614
617 CXXScopeSpec(), Loc, IFD,
618 DeclAccessPair::make(IFD, AS_public), RecordArg, Loc)
620 RecordArg, RecordArgIsPtr, Loc, CXXScopeSpec(), FD,
622 DeclarationNameInfo(FD->getDeclName(), Loc));
623 if (Field.isInvalid())
624 return true;
625
626 auto *InnerRD = FD->getType()->getAsRecordDecl();
627 auto *InnerCXXRD = dyn_cast_or_null<CXXRecordDecl>(InnerRD);
628 if (InnerRD && (!InnerCXXRD || InnerCXXRD->isAggregate())) {
629 // Recursively print the values of members of aggregate record type.
630 if (callPrintFunction(Format, Args) ||
631 dumpRecordValue(InnerRD, Field.get(), FieldIndentArg, Depth + 1))
632 return true;
633 } else {
634 Format += " ";
635 if (appendFormatSpecifier(FD->getType(), Format)) {
636 // We know how to print this field.
637 Args.push_back(Field.get());
638 } else {
639 // We don't know how to print this field. Print out its address
640 // with a format specifier that a smart tool will be able to
641 // recognize and treat specially.
642 Format += "*%p";
643 ExprResult FieldAddr =
644 S.BuildUnaryOp(nullptr, Loc, UO_AddrOf, Field.get());
645 if (FieldAddr.isInvalid())
646 return true;
647 Args.push_back(FieldAddr.get());
648 }
649 Format += "\n";
650 if (callPrintFunction(Format, Args))
651 return true;
652 }
653 }
654
655 return RecordIndent ? callPrintFunction("%s}\n", RecordIndent)
656 : callPrintFunction("}\n");
657 }
658
659 Expr *buildWrapper() {
660 auto *Wrapper = PseudoObjectExpr::Create(S.Context, TheCall, Actions,
662 TheCall->setType(Wrapper->getType());
663 TheCall->setValueKind(Wrapper->getValueKind());
664 return Wrapper;
665 }
666};
667} // namespace
668
670 if (checkArgCountAtLeast(S, TheCall, 2))
671 return ExprError();
672
673 ExprResult PtrArgResult = S.DefaultLvalueConversion(TheCall->getArg(0));
674 if (PtrArgResult.isInvalid())
675 return ExprError();
676 TheCall->setArg(0, PtrArgResult.get());
677
678 // First argument should be a pointer to a struct.
679 QualType PtrArgType = PtrArgResult.get()->getType();
680 if (!PtrArgType->isPointerType() ||
681 !PtrArgType->getPointeeType()->isRecordType()) {
682 S.Diag(PtrArgResult.get()->getBeginLoc(),
683 diag::err_expected_struct_pointer_argument)
684 << 1 << TheCall->getDirectCallee() << PtrArgType;
685 return ExprError();
686 }
687 const RecordDecl *RD = PtrArgType->getPointeeType()->getAsRecordDecl();
688
689 // Second argument is a callable, but we can't fully validate it until we try
690 // calling it.
691 QualType FnArgType = TheCall->getArg(1)->getType();
692 if (!FnArgType->isFunctionType() && !FnArgType->isFunctionPointerType() &&
693 !FnArgType->isBlockPointerType() &&
694 !(S.getLangOpts().CPlusPlus && FnArgType->isRecordType())) {
695 auto *BT = FnArgType->getAs<BuiltinType>();
696 switch (BT ? BT->getKind() : BuiltinType::Void) {
697 case BuiltinType::Dependent:
698 case BuiltinType::Overload:
699 case BuiltinType::BoundMember:
700 case BuiltinType::PseudoObject:
701 case BuiltinType::UnknownAny:
702 case BuiltinType::BuiltinFn:
703 // This might be a callable.
704 break;
705
706 default:
707 S.Diag(TheCall->getArg(1)->getBeginLoc(),
708 diag::err_expected_callable_argument)
709 << 2 << TheCall->getDirectCallee() << FnArgType;
710 return ExprError();
711 }
712 }
713
714 BuiltinDumpStructGenerator Generator(S, TheCall);
715
716 // Wrap parentheses around the given pointer. This is not necessary for
717 // correct code generation, but it means that when we pretty-print the call
718 // arguments in our diagnostics we will produce '(&s)->n' instead of the
719 // incorrect '&s->n'.
720 Expr *PtrArg = PtrArgResult.get();
721 PtrArg = new (S.Context)
722 ParenExpr(PtrArg->getBeginLoc(),
723 S.getLocForEndOfToken(PtrArg->getEndLoc()), PtrArg);
724 if (Generator.dumpUnnamedRecord(RD, PtrArg, 0))
725 return ExprError();
726
727 return Generator.buildWrapper();
728}
729
730static bool SemaBuiltinCallWithStaticChain(Sema &S, CallExpr *BuiltinCall) {
731 if (checkArgCount(S, BuiltinCall, 2))
732 return true;
733
734 SourceLocation BuiltinLoc = BuiltinCall->getBeginLoc();
735 Expr *Builtin = BuiltinCall->getCallee()->IgnoreImpCasts();
736 Expr *Call = BuiltinCall->getArg(0);
737 Expr *Chain = BuiltinCall->getArg(1);
738
739 if (Call->getStmtClass() != Stmt::CallExprClass) {
740 S.Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_not_call)
741 << Call->getSourceRange();
742 return true;
743 }
744
745 auto CE = cast<CallExpr>(Call);
746 if (CE->getCallee()->getType()->isBlockPointerType()) {
747 S.Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_block_call)
748 << Call->getSourceRange();
749 return true;
750 }
751
752 const Decl *TargetDecl = CE->getCalleeDecl();
753 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl))
754 if (FD->getBuiltinID()) {
755 S.Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_builtin_call)
756 << Call->getSourceRange();
757 return true;
758 }
759
760 if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens())) {
761 S.Diag(BuiltinLoc, diag::err_first_argument_to_cwsc_pdtor_call)
762 << Call->getSourceRange();
763 return true;
764 }
765
766 ExprResult ChainResult = S.UsualUnaryConversions(Chain);
767 if (ChainResult.isInvalid())
768 return true;
769 if (!ChainResult.get()->getType()->isPointerType()) {
770 S.Diag(BuiltinLoc, diag::err_second_argument_to_cwsc_not_pointer)
771 << Chain->getSourceRange();
772 return true;
773 }
774
775 QualType ReturnTy = CE->getCallReturnType(S.Context);
776 QualType ArgTys[2] = { ReturnTy, ChainResult.get()->getType() };
777 QualType BuiltinTy = S.Context.getFunctionType(
778 ReturnTy, ArgTys, FunctionProtoType::ExtProtoInfo());
779 QualType BuiltinPtrTy = S.Context.getPointerType(BuiltinTy);
780
781 Builtin =
782 S.ImpCastExprToType(Builtin, BuiltinPtrTy, CK_BuiltinFnToFnPtr).get();
783
784 BuiltinCall->setType(CE->getType());
785 BuiltinCall->setValueKind(CE->getValueKind());
786 BuiltinCall->setObjectKind(CE->getObjectKind());
787 BuiltinCall->setCallee(Builtin);
788 BuiltinCall->setArg(1, ChainResult.get());
789
790 return false;
791}
792
793namespace {
794
795class ScanfDiagnosticFormatHandler
797 // Accepts the argument index (relative to the first destination index) of the
798 // argument whose size we want.
799 using ComputeSizeFunction =
800 llvm::function_ref<std::optional<llvm::APSInt>(unsigned)>;
801
802 // Accepts the argument index (relative to the first destination index), the
803 // destination size, and the source size).
804 using DiagnoseFunction =
805 llvm::function_ref<void(unsigned, unsigned, unsigned)>;
806
807 ComputeSizeFunction ComputeSizeArgument;
808 DiagnoseFunction Diagnose;
809
810public:
811 ScanfDiagnosticFormatHandler(ComputeSizeFunction ComputeSizeArgument,
812 DiagnoseFunction Diagnose)
813 : ComputeSizeArgument(ComputeSizeArgument), Diagnose(Diagnose) {}
814
815 bool HandleScanfSpecifier(const analyze_scanf::ScanfSpecifier &FS,
816 const char *StartSpecifier,
817 unsigned specifierLen) override {
818 if (!FS.consumesDataArgument())
819 return true;
820
821 unsigned NulByte = 0;
822 switch ((FS.getConversionSpecifier().getKind())) {
823 default:
824 return true;
827 NulByte = 1;
828 break;
830 break;
831 }
832
833 analyze_format_string::OptionalAmount FW = FS.getFieldWidth();
834 if (FW.getHowSpecified() !=
835 analyze_format_string::OptionalAmount::HowSpecified::Constant)
836 return true;
837
838 unsigned SourceSize = FW.getConstantAmount() + NulByte;
839
840 std::optional<llvm::APSInt> DestSizeAPS =
841 ComputeSizeArgument(FS.getArgIndex());
842 if (!DestSizeAPS)
843 return true;
844
845 unsigned DestSize = DestSizeAPS->getZExtValue();
846
847 if (DestSize < SourceSize)
848 Diagnose(FS.getArgIndex(), DestSize, SourceSize);
849
850 return true;
851 }
852};
853
854class EstimateSizeFormatHandler
856 size_t Size;
857
858public:
859 EstimateSizeFormatHandler(StringRef Format)
860 : Size(std::min(Format.find(0), Format.size()) +
861 1 /* null byte always written by sprintf */) {}
862
863 bool HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS,
864 const char *, unsigned SpecifierLen,
865 const TargetInfo &) override {
866
867 const size_t FieldWidth = computeFieldWidth(FS);
868 const size_t Precision = computePrecision(FS);
869
870 // The actual format.
871 switch (FS.getConversionSpecifier().getKind()) {
872 // Just a char.
875 Size += std::max(FieldWidth, (size_t)1);
876 break;
877 // Just an integer.
887 Size += std::max(FieldWidth, Precision);
888 break;
889
890 // %g style conversion switches between %f or %e style dynamically.
891 // %g removes trailing zeros, and does not print decimal point if there are
892 // no digits that follow it. Thus %g can print a single digit.
893 // FIXME: If it is alternative form:
894 // For g and G conversions, trailing zeros are not removed from the result.
897 Size += 1;
898 break;
899
900 // Floating point number in the form '[+]ddd.ddd'.
903 Size += std::max(FieldWidth, 1 /* integer part */ +
904 (Precision ? 1 + Precision
905 : 0) /* period + decimal */);
906 break;
907
908 // Floating point number in the form '[-]d.ddde[+-]dd'.
911 Size +=
912 std::max(FieldWidth,
913 1 /* integer part */ +
914 (Precision ? 1 + Precision : 0) /* period + decimal */ +
915 1 /* e or E letter */ + 2 /* exponent */);
916 break;
917
918 // Floating point number in the form '[-]0xh.hhhhp±dd'.
921 Size +=
922 std::max(FieldWidth,
923 2 /* 0x */ + 1 /* integer part */ +
924 (Precision ? 1 + Precision : 0) /* period + decimal */ +
925 1 /* p or P letter */ + 1 /* + or - */ + 1 /* value */);
926 break;
927
928 // Just a string.
931 Size += FieldWidth;
932 break;
933
934 // Just a pointer in the form '0xddd'.
936 Size += std::max(FieldWidth, 2 /* leading 0x */ + Precision);
937 break;
938
939 // A plain percent.
941 Size += 1;
942 break;
943
944 default:
945 break;
946 }
947
948 Size += FS.hasPlusPrefix() || FS.hasSpacePrefix();
949
950 if (FS.hasAlternativeForm()) {
951 switch (FS.getConversionSpecifier().getKind()) {
952 // For o conversion, it increases the precision, if and only if necessary,
953 // to force the first digit of the result to be a zero
954 // (if the value and precision are both 0, a single 0 is printed)
956 // For b conversion, a nonzero result has 0b prefixed to it.
958 // For x (or X) conversion, a nonzero result has 0x (or 0X) prefixed to
959 // it.
962 // Note: even when the prefix is added, if
963 // (prefix_width <= FieldWidth - formatted_length) holds,
964 // the prefix does not increase the format
965 // size. e.g.(("%#3x", 0xf) is "0xf")
966
967 // If the result is zero, o, b, x, X adds nothing.
968 break;
969 // For a, A, e, E, f, F, g, and G conversions,
970 // the result of converting a floating-point number always contains a
971 // decimal-point
980 Size += (Precision ? 0 : 1);
981 break;
982 // For other conversions, the behavior is undefined.
983 default:
984 break;
985 }
986 }
987 assert(SpecifierLen <= Size && "no underflow");
988 Size -= SpecifierLen;
989 return true;
990 }
991
992 size_t getSizeLowerBound() const { return Size; }
993
994private:
995 static size_t computeFieldWidth(const analyze_printf::PrintfSpecifier &FS) {
996 const analyze_format_string::OptionalAmount &FW = FS.getFieldWidth();
997 size_t FieldWidth = 0;
999 FieldWidth = FW.getConstantAmount();
1000 return FieldWidth;
1001 }
1002
1003 static size_t computePrecision(const analyze_printf::PrintfSpecifier &FS) {
1004 const analyze_format_string::OptionalAmount &FW = FS.getPrecision();
1005 size_t Precision = 0;
1006
1007 // See man 3 printf for default precision value based on the specifier.
1008 switch (FW.getHowSpecified()) {
1010 switch (FS.getConversionSpecifier().getKind()) {
1011 default:
1012 break;
1016 Precision = 1;
1017 break;
1024 Precision = 1;
1025 break;
1032 Precision = 6;
1033 break;
1035 Precision = 1;
1036 break;
1037 }
1038 break;
1040 Precision = FW.getConstantAmount();
1041 break;
1042 default:
1043 break;
1044 }
1045 return Precision;
1046 }
1047};
1048
1049} // namespace
1050
1051static bool ProcessFormatStringLiteral(const Expr *FormatExpr,
1052 StringRef &FormatStrRef, size_t &StrLen,
1053 ASTContext &Context) {
1054 if (const auto *Format = dyn_cast<StringLiteral>(FormatExpr);
1055 Format && (Format->isOrdinary() || Format->isUTF8())) {
1056 FormatStrRef = Format->getString();
1057 const ConstantArrayType *T =
1058 Context.getAsConstantArrayType(Format->getType());
1059 assert(T && "String literal not of constant array type!");
1060 size_t TypeSize = T->getSize().getZExtValue();
1061 // In case there's a null byte somewhere.
1062 StrLen = std::min(std::max(TypeSize, size_t(1)) - 1, FormatStrRef.find(0));
1063 return true;
1064 }
1065 return false;
1066}
1067
1068void Sema::checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD,
1069 CallExpr *TheCall) {
1070 if (TheCall->isValueDependent() || TheCall->isTypeDependent() ||
1072 return;
1073
1074 bool UseDABAttr = false;
1075 const FunctionDecl *UseDecl = FD;
1076
1077 const auto *DABAttr = FD->getAttr<DiagnoseAsBuiltinAttr>();
1078 if (DABAttr) {
1079 UseDecl = DABAttr->getFunction();
1080 assert(UseDecl && "Missing FunctionDecl in DiagnoseAsBuiltin attribute!");
1081 UseDABAttr = true;
1082 }
1083
1084 unsigned BuiltinID = UseDecl->getBuiltinID(/*ConsiderWrappers=*/true);
1085
1086 if (!BuiltinID)
1087 return;
1088
1089 const TargetInfo &TI = getASTContext().getTargetInfo();
1090 unsigned SizeTypeWidth = TI.getTypeWidth(TI.getSizeType());
1091
1092 auto TranslateIndex = [&](unsigned Index) -> std::optional<unsigned> {
1093 // If we refer to a diagnose_as_builtin attribute, we need to change the
1094 // argument index to refer to the arguments of the called function. Unless
1095 // the index is out of bounds, which presumably means it's a variadic
1096 // function.
1097 if (!UseDABAttr)
1098 return Index;
1099 unsigned DABIndices = DABAttr->argIndices_size();
1100 unsigned NewIndex = Index < DABIndices
1101 ? DABAttr->argIndices_begin()[Index]
1102 : Index - DABIndices + FD->getNumParams();
1103 if (NewIndex >= TheCall->getNumArgs())
1104 return std::nullopt;
1105 return NewIndex;
1106 };
1107
1108 auto ComputeExplicitObjectSizeArgument =
1109 [&](unsigned Index) -> std::optional<llvm::APSInt> {
1110 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1111 if (!IndexOptional)
1112 return std::nullopt;
1113 unsigned NewIndex = *IndexOptional;
1115 Expr *SizeArg = TheCall->getArg(NewIndex);
1116 if (!SizeArg->EvaluateAsInt(Result, getASTContext()))
1117 return std::nullopt;
1118 llvm::APSInt Integer = Result.Val.getInt();
1119 Integer.setIsUnsigned(true);
1120 return Integer;
1121 };
1122
1123 auto ComputeSizeArgument =
1124 [&](unsigned Index) -> std::optional<llvm::APSInt> {
1125 // If the parameter has a pass_object_size attribute, then we should use its
1126 // (potentially) more strict checking mode. Otherwise, conservatively assume
1127 // type 0.
1128 int BOSType = 0;
1129 // This check can fail for variadic functions.
1130 if (Index < FD->getNumParams()) {
1131 if (const auto *POS =
1132 FD->getParamDecl(Index)->getAttr<PassObjectSizeAttr>())
1133 BOSType = POS->getType();
1134 }
1135
1136 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1137 if (!IndexOptional)
1138 return std::nullopt;
1139 unsigned NewIndex = *IndexOptional;
1140
1141 if (NewIndex >= TheCall->getNumArgs())
1142 return std::nullopt;
1143
1144 const Expr *ObjArg = TheCall->getArg(NewIndex);
1146 if (!ObjArg->tryEvaluateObjectSize(Result, getASTContext(), BOSType))
1147 return std::nullopt;
1148
1149 // Get the object size in the target's size_t width.
1150 return llvm::APSInt::getUnsigned(Result).extOrTrunc(SizeTypeWidth);
1151 };
1152
1153 auto ComputeStrLenArgument =
1154 [&](unsigned Index) -> std::optional<llvm::APSInt> {
1155 std::optional<unsigned> IndexOptional = TranslateIndex(Index);
1156 if (!IndexOptional)
1157 return std::nullopt;
1158 unsigned NewIndex = *IndexOptional;
1159
1160 const Expr *ObjArg = TheCall->getArg(NewIndex);
1162 if (!ObjArg->tryEvaluateStrLen(Result, getASTContext()))
1163 return std::nullopt;
1164 // Add 1 for null byte.
1165 return llvm::APSInt::getUnsigned(Result + 1).extOrTrunc(SizeTypeWidth);
1166 };
1167
1168 std::optional<llvm::APSInt> SourceSize;
1169 std::optional<llvm::APSInt> DestinationSize;
1170 unsigned DiagID = 0;
1171 bool IsChkVariant = false;
1172
1173 auto GetFunctionName = [&]() {
1174 StringRef FunctionName = getASTContext().BuiltinInfo.getName(BuiltinID);
1175 // Skim off the details of whichever builtin was called to produce a better
1176 // diagnostic, as it's unlikely that the user wrote the __builtin
1177 // explicitly.
1178 if (IsChkVariant) {
1179 FunctionName = FunctionName.drop_front(std::strlen("__builtin___"));
1180 FunctionName = FunctionName.drop_back(std::strlen("_chk"));
1181 } else if (FunctionName.startswith("__builtin_")) {
1182 FunctionName = FunctionName.drop_front(std::strlen("__builtin_"));
1183 }
1184 return FunctionName;
1185 };
1186
1187 switch (BuiltinID) {
1188 default:
1189 return;
1190 case Builtin::BI__builtin_strcpy:
1191 case Builtin::BIstrcpy: {
1192 DiagID = diag::warn_fortify_strlen_overflow;
1193 SourceSize = ComputeStrLenArgument(1);
1194 DestinationSize = ComputeSizeArgument(0);
1195 break;
1196 }
1197
1198 case Builtin::BI__builtin___strcpy_chk: {
1199 DiagID = diag::warn_fortify_strlen_overflow;
1200 SourceSize = ComputeStrLenArgument(1);
1201 DestinationSize = ComputeExplicitObjectSizeArgument(2);
1202 IsChkVariant = true;
1203 break;
1204 }
1205
1206 case Builtin::BIscanf:
1207 case Builtin::BIfscanf:
1208 case Builtin::BIsscanf: {
1209 unsigned FormatIndex = 1;
1210 unsigned DataIndex = 2;
1211 if (BuiltinID == Builtin::BIscanf) {
1212 FormatIndex = 0;
1213 DataIndex = 1;
1214 }
1215
1216 const auto *FormatExpr =
1217 TheCall->getArg(FormatIndex)->IgnoreParenImpCasts();
1218
1219 StringRef FormatStrRef;
1220 size_t StrLen;
1221 if (!ProcessFormatStringLiteral(FormatExpr, FormatStrRef, StrLen, Context))
1222 return;
1223
1224 auto Diagnose = [&](unsigned ArgIndex, unsigned DestSize,
1225 unsigned SourceSize) {
1226 DiagID = diag::warn_fortify_scanf_overflow;
1227 unsigned Index = ArgIndex + DataIndex;
1228 StringRef FunctionName = GetFunctionName();
1229 DiagRuntimeBehavior(TheCall->getArg(Index)->getBeginLoc(), TheCall,
1230 PDiag(DiagID) << FunctionName << (Index + 1)
1231 << DestSize << SourceSize);
1232 };
1233
1234 auto ShiftedComputeSizeArgument = [&](unsigned Index) {
1235 return ComputeSizeArgument(Index + DataIndex);
1236 };
1237 ScanfDiagnosticFormatHandler H(ShiftedComputeSizeArgument, Diagnose);
1238 const char *FormatBytes = FormatStrRef.data();
1240 FormatBytes + StrLen, getLangOpts(),
1242
1243 // Unlike the other cases, in this one we have already issued the diagnostic
1244 // here, so no need to continue (because unlike the other cases, here the
1245 // diagnostic refers to the argument number).
1246 return;
1247 }
1248
1249 case Builtin::BIsprintf:
1250 case Builtin::BI__builtin___sprintf_chk: {
1251 size_t FormatIndex = BuiltinID == Builtin::BIsprintf ? 1 : 3;
1252 auto *FormatExpr = TheCall->getArg(FormatIndex)->IgnoreParenImpCasts();
1253
1254 StringRef FormatStrRef;
1255 size_t StrLen;
1256 if (ProcessFormatStringLiteral(FormatExpr, FormatStrRef, StrLen, Context)) {
1257 EstimateSizeFormatHandler H(FormatStrRef);
1258 const char *FormatBytes = FormatStrRef.data();
1260 H, FormatBytes, FormatBytes + StrLen, getLangOpts(),
1261 Context.getTargetInfo(), false)) {
1262 DiagID = diag::warn_fortify_source_format_overflow;
1263 SourceSize = llvm::APSInt::getUnsigned(H.getSizeLowerBound())
1264 .extOrTrunc(SizeTypeWidth);
1265 if (BuiltinID == Builtin::BI__builtin___sprintf_chk) {
1266 DestinationSize = ComputeExplicitObjectSizeArgument(2);
1267 IsChkVariant = true;
1268 } else {
1269 DestinationSize = ComputeSizeArgument(0);
1270 }
1271 break;
1272 }
1273 }
1274 return;
1275 }
1276 case Builtin::BI__builtin___memcpy_chk:
1277 case Builtin::BI__builtin___memmove_chk:
1278 case Builtin::BI__builtin___memset_chk:
1279 case Builtin::BI__builtin___strlcat_chk:
1280 case Builtin::BI__builtin___strlcpy_chk:
1281 case Builtin::BI__builtin___strncat_chk:
1282 case Builtin::BI__builtin___strncpy_chk:
1283 case Builtin::BI__builtin___stpncpy_chk:
1284 case Builtin::BI__builtin___memccpy_chk:
1285 case Builtin::BI__builtin___mempcpy_chk: {
1286 DiagID = diag::warn_builtin_chk_overflow;
1287 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 2);
1288 DestinationSize =
1289 ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 1);
1290 IsChkVariant = true;
1291 break;
1292 }
1293
1294 case Builtin::BI__builtin___snprintf_chk:
1295 case Builtin::BI__builtin___vsnprintf_chk: {
1296 DiagID = diag::warn_builtin_chk_overflow;
1297 SourceSize = ComputeExplicitObjectSizeArgument(1);
1298 DestinationSize = ComputeExplicitObjectSizeArgument(3);
1299 IsChkVariant = true;
1300 break;
1301 }
1302
1303 case Builtin::BIstrncat:
1304 case Builtin::BI__builtin_strncat:
1305 case Builtin::BIstrncpy:
1306 case Builtin::BI__builtin_strncpy:
1307 case Builtin::BIstpncpy:
1308 case Builtin::BI__builtin_stpncpy: {
1309 // Whether these functions overflow depends on the runtime strlen of the
1310 // string, not just the buffer size, so emitting the "always overflow"
1311 // diagnostic isn't quite right. We should still diagnose passing a buffer
1312 // size larger than the destination buffer though; this is a runtime abort
1313 // in _FORTIFY_SOURCE mode, and is quite suspicious otherwise.
1314 DiagID = diag::warn_fortify_source_size_mismatch;
1315 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 1);
1316 DestinationSize = ComputeSizeArgument(0);
1317 break;
1318 }
1319
1320 case Builtin::BImemcpy:
1321 case Builtin::BI__builtin_memcpy:
1322 case Builtin::BImemmove:
1323 case Builtin::BI__builtin_memmove:
1324 case Builtin::BImemset:
1325 case Builtin::BI__builtin_memset:
1326 case Builtin::BImempcpy:
1327 case Builtin::BI__builtin_mempcpy: {
1328 DiagID = diag::warn_fortify_source_overflow;
1329 SourceSize = ComputeExplicitObjectSizeArgument(TheCall->getNumArgs() - 1);
1330 DestinationSize = ComputeSizeArgument(0);
1331 break;
1332 }
1333 case Builtin::BIsnprintf:
1334 case Builtin::BI__builtin_snprintf:
1335 case Builtin::BIvsnprintf:
1336 case Builtin::BI__builtin_vsnprintf: {
1337 DiagID = diag::warn_fortify_source_size_mismatch;
1338 SourceSize = ComputeExplicitObjectSizeArgument(1);
1339 const auto *FormatExpr = TheCall->getArg(2)->IgnoreParenImpCasts();
1340 StringRef FormatStrRef;
1341 size_t StrLen;
1342 if (SourceSize &&
1343 ProcessFormatStringLiteral(FormatExpr, FormatStrRef, StrLen, Context)) {
1344 EstimateSizeFormatHandler H(FormatStrRef);
1345 const char *FormatBytes = FormatStrRef.data();
1347 H, FormatBytes, FormatBytes + StrLen, getLangOpts(),
1348 Context.getTargetInfo(), /*isFreeBSDKPrintf=*/false)) {
1349 llvm::APSInt FormatSize =
1350 llvm::APSInt::getUnsigned(H.getSizeLowerBound())
1351 .extOrTrunc(SizeTypeWidth);
1352 if (FormatSize > *SourceSize && *SourceSize != 0) {
1353 DiagID = diag::warn_fortify_source_format_truncation;
1354 DestinationSize = SourceSize;
1355 SourceSize = FormatSize;
1356 break;
1357 }
1358 }
1359 }
1360 DestinationSize = ComputeSizeArgument(0);
1361 }
1362 }
1363
1364 if (!SourceSize || !DestinationSize ||
1365 llvm::APSInt::compareValues(*SourceSize, *DestinationSize) <= 0)
1366 return;
1367
1368 StringRef FunctionName = GetFunctionName();
1369
1370 SmallString<16> DestinationStr;
1371 SmallString<16> SourceStr;
1372 DestinationSize->toString(DestinationStr, /*Radix=*/10);
1373 SourceSize->toString(SourceStr, /*Radix=*/10);
1374 DiagRuntimeBehavior(TheCall->getBeginLoc(), TheCall,
1375 PDiag(DiagID)
1376 << FunctionName << DestinationStr << SourceStr);
1377}
1378
1379static bool SemaBuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall,
1380 Scope::ScopeFlags NeededScopeFlags,
1381 unsigned DiagID) {
1382 // Scopes aren't available during instantiation. Fortunately, builtin
1383 // functions cannot be template args so they cannot be formed through template
1384 // instantiation. Therefore checking once during the parse is sufficient.
1385 if (SemaRef.inTemplateInstantiation())
1386 return false;
1387
1388 Scope *S = SemaRef.getCurScope();
1389 while (S && !S->isSEHExceptScope())
1390 S = S->getParent();
1391 if (!S || !(S->getFlags() & NeededScopeFlags)) {
1392 auto *DRE = cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
1393 SemaRef.Diag(TheCall->getExprLoc(), DiagID)
1394 << DRE->getDecl()->getIdentifier();
1395 return true;
1396 }
1397
1398 return false;
1399}
1400
1401static inline bool isBlockPointer(Expr *Arg) {
1402 return Arg->getType()->isBlockPointerType();
1403}
1404
1405/// OpenCL C v2.0, s6.13.17.2 - Checks that the block parameters are all local
1406/// void*, which is a requirement of device side enqueue.
1407static bool checkOpenCLBlockArgs(Sema &S, Expr *BlockArg) {
1408 const BlockPointerType *BPT =
1409 cast<BlockPointerType>(BlockArg->getType().getCanonicalType());
1410 ArrayRef<QualType> Params =
1411 BPT->getPointeeType()->castAs<FunctionProtoType>()->getParamTypes();
1412 unsigned ArgCounter = 0;
1413 bool IllegalParams = false;
1414 // Iterate through the block parameters until either one is found that is not
1415 // a local void*, or the block is valid.
1416 for (ArrayRef<QualType>::iterator I = Params.begin(), E = Params.end();
1417 I != E; ++I, ++ArgCounter) {
1418 if (!(*I)->isPointerType() || !(*I)->getPointeeType()->isVoidType() ||
1419 (*I)->getPointeeType().getQualifiers().getAddressSpace() !=
1421 // Get the location of the error. If a block literal has been passed
1422 // (BlockExpr) then we can point straight to the offending argument,
1423 // else we just point to the variable reference.
1424 SourceLocation ErrorLoc;
1425 if (isa<BlockExpr>(BlockArg)) {
1426 BlockDecl *BD = cast<BlockExpr>(BlockArg)->getBlockDecl();
1427 ErrorLoc = BD->getParamDecl(ArgCounter)->getBeginLoc();
1428 } else if (isa<DeclRefExpr>(BlockArg)) {
1429 ErrorLoc = cast<DeclRefExpr>(BlockArg)->getBeginLoc();
1430 }
1431 S.Diag(ErrorLoc,
1432 diag::err_opencl_enqueue_kernel_blocks_non_local_void_args);
1433 IllegalParams = true;
1434 }
1435 }
1436
1437 return IllegalParams;
1438}
1439
1440static bool checkOpenCLSubgroupExt(Sema &S, CallExpr *Call) {
1441 // OpenCL device can support extension but not the feature as extension
1442 // requires subgroup independent forward progress, but subgroup independent
1443 // forward progress is optional in OpenCL C 3.0 __opencl_c_subgroups feature.
1444 if (!S.getOpenCLOptions().isSupported("cl_khr_subgroups", S.getLangOpts()) &&
1445 !S.getOpenCLOptions().isSupported("__opencl_c_subgroups",
1446 S.getLangOpts())) {
1447 S.Diag(Call->getBeginLoc(), diag::err_opencl_requires_extension)
1448 << 1 << Call->getDirectCallee()
1449 << "cl_khr_subgroups or __opencl_c_subgroups";
1450 return true;
1451 }
1452 return false;
1453}
1454
1456 if (checkArgCount(S, TheCall, 2))
1457 return true;
1458
1459 if (checkOpenCLSubgroupExt(S, TheCall))
1460 return true;
1461
1462 // First argument is an ndrange_t type.
1463 Expr *NDRangeArg = TheCall->getArg(0);
1464 if (NDRangeArg->getType().getUnqualifiedType().getAsString() != "ndrange_t") {
1465 S.Diag(NDRangeArg->getBeginLoc(), diag::err_opencl_builtin_expected_type)
1466 << TheCall->getDirectCallee() << "'ndrange_t'";
1467 return true;
1468 }
1469
1470 Expr *BlockArg = TheCall->getArg(1);
1471 if (!isBlockPointer(BlockArg)) {
1472 S.Diag(BlockArg->getBeginLoc(), diag::err_opencl_builtin_expected_type)
1473 << TheCall->getDirectCallee() << "block";
1474 return true;
1475 }
1476 return checkOpenCLBlockArgs(S, BlockArg);
1477}
1478
1479/// OpenCL C v2.0, s6.13.17.6 - Check the argument to the
1480/// get_kernel_work_group_size
1481/// and get_kernel_preferred_work_group_size_multiple builtin functions.
1483 if (checkArgCount(S, TheCall, 1))
1484 return true;
1485
1486 Expr *BlockArg = TheCall->getArg(0);
1487 if (!isBlockPointer(BlockArg)) {
1488 S.Diag(BlockArg->getBeginLoc(), diag::err_opencl_builtin_expected_type)
1489 << TheCall->getDirectCallee() << "block";
1490 return true;
1491 }
1492 return checkOpenCLBlockArgs(S, BlockArg);
1493}
1494
1495/// Diagnose integer type and any valid implicit conversion to it.
1496static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E,
1497 const QualType &IntType);
1498
1500 unsigned Start, unsigned End) {
1501 bool IllegalParams = false;
1502 for (unsigned I = Start; I <= End; ++I)
1503 IllegalParams |= checkOpenCLEnqueueIntType(S, TheCall->getArg(I),
1504 S.Context.getSizeType());
1505 return IllegalParams;
1506}
1507
1508/// OpenCL v2.0, s6.13.17.1 - Check that sizes are provided for all
1509/// 'local void*' parameter of passed block.
1511 Expr *BlockArg,
1512 unsigned NumNonVarArgs) {
1513 const BlockPointerType *BPT =
1514 cast<BlockPointerType>(BlockArg->getType().getCanonicalType());
1515 unsigned NumBlockParams =
1516 BPT->getPointeeType()->castAs<FunctionProtoType>()->getNumParams();
1517 unsigned TotalNumArgs = TheCall->getNumArgs();
1518
1519 // For each argument passed to the block, a corresponding uint needs to
1520 // be passed to describe the size of the local memory.
1521 if (TotalNumArgs != NumBlockParams + NumNonVarArgs) {
1522 S.Diag(TheCall->getBeginLoc(),
1523 diag::err_opencl_enqueue_kernel_local_size_args);
1524 return true;
1525 }
1526
1527 // Check that the sizes of the local memory are specified by integers.
1528 return checkOpenCLEnqueueLocalSizeArgs(S, TheCall, NumNonVarArgs,
1529 TotalNumArgs - 1);
1530}
1531
1532/// OpenCL C v2.0, s6.13.17 - Enqueue kernel function contains four different
1533/// overload formats specified in Table 6.13.17.1.
1534/// int enqueue_kernel(queue_t queue,
1535/// kernel_enqueue_flags_t flags,
1536/// const ndrange_t ndrange,
1537/// void (^block)(void))
1538/// int enqueue_kernel(queue_t queue,
1539/// kernel_enqueue_flags_t flags,
1540/// const ndrange_t ndrange,
1541/// uint num_events_in_wait_list,
1542/// clk_event_t *event_wait_list,
1543/// clk_event_t *event_ret,
1544/// void (^block)(void))
1545/// int enqueue_kernel(queue_t queue,
1546/// kernel_enqueue_flags_t flags,
1547/// const ndrange_t ndrange,
1548/// void (^block)(local void*, ...),
1549/// uint size0, ...)
1550/// int enqueue_kernel(queue_t queue,
1551/// kernel_enqueue_flags_t flags,
1552/// const ndrange_t ndrange,
1553/// uint num_events_in_wait_list,
1554/// clk_event_t *event_wait_list,
1555/// clk_event_t *event_ret,
1556/// void (^block)(local void*, ...),
1557/// uint size0, ...)
1559 unsigned NumArgs = TheCall->getNumArgs();
1560
1561 if (NumArgs < 4) {
1562 S.Diag(TheCall->getBeginLoc(),
1563 diag::err_typecheck_call_too_few_args_at_least)
1564 << 0 << 4 << NumArgs;
1565 return true;
1566 }
1567
1568 Expr *Arg0 = TheCall->getArg(0);
1569 Expr *Arg1 = TheCall->getArg(1);
1570 Expr *Arg2 = TheCall->getArg(2);
1571 Expr *Arg3 = TheCall->getArg(3);
1572
1573 // First argument always needs to be a queue_t type.
1574 if (!Arg0->getType()->isQueueT()) {
1575 S.Diag(TheCall->getArg(0)->getBeginLoc(),
1576 diag::err_opencl_builtin_expected_type)
1577 << TheCall->getDirectCallee() << S.Context.OCLQueueTy;
1578 return true;
1579 }
1580
1581 // Second argument always needs to be a kernel_enqueue_flags_t enum value.
1582 if (!Arg1->getType()->isIntegerType()) {
1583 S.Diag(TheCall->getArg(1)->getBeginLoc(),
1584 diag::err_opencl_builtin_expected_type)
1585 << TheCall->getDirectCallee() << "'kernel_enqueue_flags_t' (i.e. uint)";
1586 return true;
1587 }
1588
1589 // Third argument is always an ndrange_t type.
1590 if (Arg2->getType().getUnqualifiedType().getAsString() != "ndrange_t") {
1591 S.Diag(TheCall->getArg(2)->getBeginLoc(),
1592 diag::err_opencl_builtin_expected_type)
1593 << TheCall->getDirectCallee() << "'ndrange_t'";
1594 return true;
1595 }
1596
1597 // With four arguments, there is only one form that the function could be
1598 // called in: no events and no variable arguments.
1599 if (NumArgs == 4) {
1600 // check that the last argument is the right block type.
1601 if (!isBlockPointer(Arg3)) {
1602 S.Diag(Arg3->getBeginLoc(), diag::err_opencl_builtin_expected_type)
1603 << TheCall->getDirectCallee() << "block";
1604 return true;
1605 }
1606 // we have a block type, check the prototype
1607 const BlockPointerType *BPT =
1608 cast<BlockPointerType>(Arg3->getType().getCanonicalType());
1609 if (BPT->getPointeeType()->castAs<FunctionProtoType>()->getNumParams() > 0) {
1610 S.Diag(Arg3->getBeginLoc(),
1611 diag::err_opencl_enqueue_kernel_blocks_no_args);
1612 return true;
1613 }
1614 return false;
1615 }
1616 // we can have block + varargs.
1617 if (isBlockPointer(Arg3))
1618 return (checkOpenCLBlockArgs(S, Arg3) ||
1619 checkOpenCLEnqueueVariadicArgs(S, TheCall, Arg3, 4));
1620 // last two cases with either exactly 7 args or 7 args and varargs.
1621 if (NumArgs >= 7) {
1622 // check common block argument.
1623 Expr *Arg6 = TheCall->getArg(6);
1624 if (!isBlockPointer(Arg6)) {
1625 S.Diag(Arg6->getBeginLoc(), diag::err_opencl_builtin_expected_type)
1626 << TheCall->getDirectCallee() << "block";
1627 return true;
1628 }
1629 if (checkOpenCLBlockArgs(S, Arg6))
1630 return true;
1631
1632 // Forth argument has to be any integer type.
1633 if (!Arg3->getType()->isIntegerType()) {
1634 S.Diag(TheCall->getArg(3)->getBeginLoc(),
1635 diag::err_opencl_builtin_expected_type)
1636 << TheCall->getDirectCallee() << "integer";
1637 return true;
1638 }
1639 // check remaining common arguments.
1640 Expr *Arg4 = TheCall->getArg(4);
1641 Expr *Arg5 = TheCall->getArg(5);
1642
1643 // Fifth argument is always passed as a pointer to clk_event_t.
1644 if (!Arg4->isNullPointerConstant(S.Context,
1647 S.Diag(TheCall->getArg(4)->getBeginLoc(),
1648 diag::err_opencl_builtin_expected_type)
1649 << TheCall->getDirectCallee()
1651 return true;
1652 }
1653
1654 // Sixth argument is always passed as a pointer to clk_event_t.
1655 if (!Arg5->isNullPointerConstant(S.Context,
1657 !(Arg5->getType()->isPointerType() &&
1658 Arg5->getType()->getPointeeType()->isClkEventT())) {
1659 S.Diag(TheCall->getArg(5)->getBeginLoc(),
1660 diag::err_opencl_builtin_expected_type)
1661 << TheCall->getDirectCallee()
1663 return true;
1664 }
1665
1666 if (NumArgs == 7)
1667 return false;
1668
1669 return checkOpenCLEnqueueVariadicArgs(S, TheCall, Arg6, 7);
1670 }
1671
1672 // None of the specific case has been detected, give generic error
1673 S.Diag(TheCall->getBeginLoc(),
1674 diag::err_opencl_enqueue_kernel_incorrect_args);
1675 return true;
1676}
1677
1678/// Returns OpenCL access qual.
1679static OpenCLAccessAttr *getOpenCLArgAccess(const Decl *D) {
1680 return D->getAttr<OpenCLAccessAttr>();
1681}
1682
1683/// Returns true if pipe element type is different from the pointer.
1684static bool checkOpenCLPipeArg(Sema &S, CallExpr *Call) {
1685 const Expr *Arg0 = Call->getArg(0);
1686 // First argument type should always be pipe.
1687 if (!Arg0->getType()->isPipeType()) {
1688 S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
1689 << Call->getDirectCallee() << Arg0->getSourceRange();
1690 return true;
1691 }
1692 OpenCLAccessAttr *AccessQual =
1693 getOpenCLArgAccess(cast<DeclRefExpr>(Arg0)->getDecl());
1694 // Validates the access qualifier is compatible with the call.
1695 // OpenCL v2.0 s6.13.16 - The access qualifiers for pipe should only be
1696 // read_only and write_only, and assumed to be read_only if no qualifier is
1697 // specified.
1698 switch (Call->getDirectCallee()->getBuiltinID()) {
1699 case Builtin::BIread_pipe:
1700 case Builtin::BIreserve_read_pipe:
1701 case Builtin::BIcommit_read_pipe:
1702 case Builtin::BIwork_group_reserve_read_pipe:
1703 case Builtin::BIsub_group_reserve_read_pipe:
1704 case Builtin::BIwork_group_commit_read_pipe:
1705 case Builtin::BIsub_group_commit_read_pipe:
1706 if (!(!AccessQual || AccessQual->isReadOnly())) {
1707 S.Diag(Arg0->getBeginLoc(),
1708 diag::err_opencl_builtin_pipe_invalid_access_modifier)
1709 << "read_only" << Arg0->getSourceRange();
1710 return true;
1711 }
1712 break;
1713 case Builtin::BIwrite_pipe:
1714 case Builtin::BIreserve_write_pipe:
1715 case Builtin::BIcommit_write_pipe:
1716 case Builtin::BIwork_group_reserve_write_pipe:
1717 case Builtin::BIsub_group_reserve_write_pipe:
1718 case Builtin::BIwork_group_commit_write_pipe:
1719 case Builtin::BIsub_group_commit_write_pipe:
1720 if (!(AccessQual && AccessQual->isWriteOnly())) {
1721 S.Diag(Arg0->getBeginLoc(),
1722 diag::err_opencl_builtin_pipe_invalid_access_modifier)
1723 << "write_only" << Arg0->getSourceRange();
1724 return true;
1725 }
1726 break;
1727 default:
1728 break;
1729 }
1730 return false;
1731}
1732
1733/// Returns true if pipe element type is different from the pointer.
1734static bool checkOpenCLPipePacketType(Sema &S, CallExpr *Call, unsigned Idx) {
1735 const Expr *Arg0 = Call->getArg(0);
1736 const Expr *ArgIdx = Call->getArg(Idx);
1737 const PipeType *PipeTy = cast<PipeType>(Arg0->getType());
1738 const QualType EltTy = PipeTy->getElementType();
1739 const PointerType *ArgTy = ArgIdx->getType()->getAs<PointerType>();
1740 // The Idx argument should be a pointer and the type of the pointer and
1741 // the type of pipe element should also be the same.
1742 if (!ArgTy ||
1744 EltTy, ArgTy->getPointeeType()->getCanonicalTypeInternal())) {
1745 S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1746 << Call->getDirectCallee() << S.Context.getPointerType(EltTy)
1747 << ArgIdx->getType() << ArgIdx->getSourceRange();
1748 return true;
1749 }
1750 return false;
1751}
1752
1753// Performs semantic analysis for the read/write_pipe call.
1754// \param S Reference to the semantic analyzer.
1755// \param Call A pointer to the builtin call.
1756// \return True if a semantic error has been found, false otherwise.
1757static bool SemaBuiltinRWPipe(Sema &S, CallExpr *Call) {
1758 // OpenCL v2.0 s6.13.16.2 - The built-in read/write
1759 // functions have two forms.
1760 switch (Call->getNumArgs()) {
1761 case 2:
1762 if (checkOpenCLPipeArg(S, Call))
1763 return true;
1764 // The call with 2 arguments should be
1765 // read/write_pipe(pipe T, T*).
1766 // Check packet type T.
1767 if (checkOpenCLPipePacketType(S, Call, 1))
1768 return true;
1769 break;
1770
1771 case 4: {
1772 if (checkOpenCLPipeArg(S, Call))
1773 return true;
1774 // The call with 4 arguments should be
1775 // read/write_pipe(pipe T, reserve_id_t, uint, T*).
1776 // Check reserve_id_t.
1777 if (!Call->getArg(1)->getType()->isReserveIDT()) {
1778 S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1779 << Call->getDirectCallee() << S.Context.OCLReserveIDTy
1780 << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
1781 return true;
1782 }
1783
1784 // Check the index.
1785 const Expr *Arg2 = Call->getArg(2);
1786 if (!Arg2->getType()->isIntegerType() &&
1787 !Arg2->getType()->isUnsignedIntegerType()) {
1788 S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1789 << Call->getDirectCallee() << S.Context.UnsignedIntTy
1790 << Arg2->getType() << Arg2->getSourceRange();
1791 return true;
1792 }
1793
1794 // Check packet type T.
1795 if (checkOpenCLPipePacketType(S, Call, 3))
1796 return true;
1797 } break;
1798 default:
1799 S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_arg_num)
1800 << Call->getDirectCallee() << Call->getSourceRange();
1801 return true;
1802 }
1803
1804 return false;
1805}
1806
1807// Performs a semantic analysis on the {work_group_/sub_group_
1808// /_}reserve_{read/write}_pipe
1809// \param S Reference to the semantic analyzer.
1810// \param Call The call to the builtin function to be analyzed.
1811// \return True if a semantic error was found, false otherwise.
1813 if (checkArgCount(S, Call, 2))
1814 return true;
1815
1816 if (checkOpenCLPipeArg(S, Call))
1817 return true;
1818
1819 // Check the reserve size.
1820 if (!Call->getArg(1)->getType()->isIntegerType() &&
1821 !Call->getArg(1)->getType()->isUnsignedIntegerType()) {
1822 S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1823 << Call->getDirectCallee() << S.Context.UnsignedIntTy
1824 << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
1825 return true;
1826 }
1827
1828 // Since return type of reserve_read/write_pipe built-in function is
1829 // reserve_id_t, which is not defined in the builtin def file , we used int
1830 // as return type and need to override the return type of these functions.
1831 Call->setType(S.Context.OCLReserveIDTy);
1832
1833 return false;
1834}
1835
1836// Performs a semantic analysis on {work_group_/sub_group_
1837// /_}commit_{read/write}_pipe
1838// \param S Reference to the semantic analyzer.
1839// \param Call The call to the builtin function to be analyzed.
1840// \return True if a semantic error was found, false otherwise.
1841static bool SemaBuiltinCommitRWPipe(Sema &S, CallExpr *Call) {
1842 if (checkArgCount(S, Call, 2))
1843 return true;
1844
1845 if (checkOpenCLPipeArg(S, Call))
1846 return true;
1847
1848 // Check reserve_id_t.
1849 if (!Call->getArg(1)->getType()->isReserveIDT()) {
1850 S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_invalid_arg)
1851 << Call->getDirectCallee() << S.Context.OCLReserveIDTy
1852 << Call->getArg(1)->getType() << Call->getArg(1)->getSourceRange();
1853 return true;
1854 }
1855
1856 return false;
1857}
1858
1859// Performs a semantic analysis on the call to built-in Pipe
1860// Query Functions.
1861// \param S Reference to the semantic analyzer.
1862// \param Call The call to the builtin function to be analyzed.
1863// \return True if a semantic error was found, false otherwise.
1864static bool SemaBuiltinPipePackets(Sema &S, CallExpr *Call) {
1865 if (checkArgCount(S, Call, 1))
1866 return true;
1867
1868 if (!Call->getArg(0)->getType()->isPipeType()) {
1869 S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_pipe_first_arg)
1870 << Call->getDirectCallee() << Call->getArg(0)->getSourceRange();
1871 return true;
1872 }
1873
1874 return false;
1875}
1876
1877// OpenCL v2.0 s6.13.9 - Address space qualifier functions.
1878// Performs semantic analysis for the to_global/local/private call.
1879// \param S Reference to the semantic analyzer.
1880// \param BuiltinID ID of the builtin function.
1881// \param Call A pointer to the builtin call.
1882// \return True if a semantic error has been found, false otherwise.
1883static bool SemaOpenCLBuiltinToAddr(Sema &S, unsigned BuiltinID,
1884 CallExpr *Call) {
1885 if (checkArgCount(S, Call, 1))
1886 return true;
1887
1888 auto RT = Call->getArg(0)->getType();
1889 if (!RT->isPointerType() || RT->getPointeeType()
1890 .getAddressSpace() == LangAS::opencl_constant) {
1891 S.Diag(Call->getBeginLoc(), diag::err_opencl_builtin_to_addr_invalid_arg)
1892 << Call->getArg(0) << Call->getDirectCallee() << Call->getSourceRange();
1893 return true;
1894 }
1895
1896 if (RT->getPointeeType().getAddressSpace() != LangAS::opencl_generic) {
1897 S.Diag(Call->getArg(0)->getBeginLoc(),
1898 diag::warn_opencl_generic_address_space_arg)
1899 << Call->getDirectCallee()->getNameInfo().getAsString()
1900 << Call->getArg(0)->getSourceRange();
1901 }
1902
1903 RT = RT->getPointeeType();
1904 auto Qual = RT.getQualifiers();
1905 switch (BuiltinID) {
1906 case Builtin::BIto_global:
1907 Qual.setAddressSpace(LangAS::opencl_global);
1908 break;
1909 case Builtin::BIto_local:
1910 Qual.setAddressSpace(LangAS::opencl_local);
1911 break;
1912 case Builtin::BIto_private:
1913 Qual.setAddressSpace(LangAS::opencl_private);
1914 break;
1915 default:
1916 llvm_unreachable("Invalid builtin function");
1917 }
1919 RT.getUnqualifiedType(), Qual)));
1920
1921 return false;
1922}
1923
1925 if (checkArgCount(S, TheCall, 1))
1926 return ExprError();
1927
1928 // Compute __builtin_launder's parameter type from the argument.
1929 // The parameter type is:
1930 // * The type of the argument if it's not an array or function type,
1931 // Otherwise,
1932 // * The decayed argument type.
1933 QualType ParamTy = [&]() {
1934 QualType ArgTy = TheCall->getArg(0)->getType();
1935 if (const ArrayType *Ty = ArgTy->getAsArrayTypeUnsafe())
1936 return S.Context.getPointerType(Ty->getElementType());
1937 if (ArgTy->isFunctionType()) {
1938 return S.Context.getPointerType(ArgTy);
1939 }
1940 return ArgTy;
1941 }();
1942
1943 TheCall->setType(ParamTy);
1944
1945 auto DiagSelect = [&]() -> std::optional<unsigned> {
1946 if (!ParamTy->isPointerType())
1947 return 0;
1948 if (ParamTy->isFunctionPointerType())
1949 return 1;
1950 if (ParamTy->isVoidPointerType())
1951 return 2;
1952 return std::optional<unsigned>{};
1953 }();
1954 if (DiagSelect) {
1955 S.Diag(TheCall->getBeginLoc(), diag::err_builtin_launder_invalid_arg)
1956 << *DiagSelect << TheCall->getSourceRange();
1957 return ExprError();
1958 }
1959
1960 // We either have an incomplete class type, or we have a class template
1961 // whose instantiation has not been forced. Example:
1962 //
1963 // template <class T> struct Foo { T value; };
1964 // Foo<int> *p = nullptr;
1965 // auto *d = __builtin_launder(p);
1966 if (S.RequireCompleteType(TheCall->getBeginLoc(), ParamTy->getPointeeType(),
1967 diag::err_incomplete_type))
1968 return ExprError();
1969
1970 assert(ParamTy->getPointeeType()->isObjectType() &&
1971 "Unhandled non-object pointer case");
1972
1973 InitializedEntity Entity =
1975 ExprResult Arg =
1976 S.PerformCopyInitialization(Entity, SourceLocation(), TheCall->getArg(0));
1977 if (Arg.isInvalid())
1978 return ExprError();
1979 TheCall->setArg(0, Arg.get());
1980
1981 return TheCall;
1982}
1983
1984// Emit an error and return true if the current object format type is in the
1985// list of unsupported types.
1987 Sema &S, unsigned BuiltinID, CallExpr *TheCall,
1988 ArrayRef<llvm::Triple::ObjectFormatType> UnsupportedObjectFormatTypes) {
1989 llvm::Triple::ObjectFormatType CurObjFormat =
1990 S.getASTContext().getTargetInfo().getTriple().getObjectFormat();
1991 if (llvm::is_contained(UnsupportedObjectFormatTypes, CurObjFormat)) {
1992 S.Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
1993 << TheCall->getSourceRange();
1994 return true;
1995 }
1996 return false;
1997}
1998
1999// Emit an error and return true if the current architecture is not in the list
2000// of supported architectures.
2001static bool
2002CheckBuiltinTargetInSupported(Sema &S, unsigned BuiltinID, CallExpr *TheCall,
2003 ArrayRef<llvm::Triple::ArchType> SupportedArchs) {
2004 llvm::Triple::ArchType CurArch =
2005 S.getASTContext().getTargetInfo().getTriple().getArch();
2006 if (llvm::is_contained(SupportedArchs, CurArch))
2007 return false;
2008 S.Diag(TheCall->getBeginLoc(), diag::err_builtin_target_unsupported)
2009 << TheCall->getSourceRange();
2010 return true;
2011}
2012
2013static void CheckNonNullArgument(Sema &S, const Expr *ArgExpr,
2014 SourceLocation CallSiteLoc);
2015
2016bool Sema::CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
2017 CallExpr *TheCall) {
2018 switch (TI.getTriple().getArch()) {
2019 default:
2020 // Some builtins don't require additional checking, so just consider these
2021 // acceptable.
2022 return false;
2023 case llvm::Triple::arm:
2024 case llvm::Triple::armeb:
2025 case llvm::Triple::thumb:
2026 case llvm::Triple::thumbeb:
2027 return CheckARMBuiltinFunctionCall(TI, BuiltinID, TheCall);
2028 case llvm::Triple::aarch64:
2029 case llvm::Triple::aarch64_32:
2030 case llvm::Triple::aarch64_be:
2031 return CheckAArch64BuiltinFunctionCall(TI, BuiltinID, TheCall);
2032 case llvm::Triple::bpfeb:
2033 case llvm::Triple::bpfel:
2034 return CheckBPFBuiltinFunctionCall(BuiltinID, TheCall);
2035 case llvm::Triple::hexagon:
2036 return CheckHexagonBuiltinFunctionCall(BuiltinID, TheCall);
2037 case llvm::Triple::mips:
2038 case llvm::Triple::mipsel:
2039 case llvm::Triple::mips64:
2040 case llvm::Triple::mips64el:
2041 return CheckMipsBuiltinFunctionCall(TI, BuiltinID, TheCall);
2042 case llvm::Triple::systemz:
2043 return CheckSystemZBuiltinFunctionCall(BuiltinID, TheCall);
2044 case llvm::Triple::x86:
2045 case llvm::Triple::x86_64:
2046 return CheckX86BuiltinFunctionCall(TI, BuiltinID, TheCall);
2047 case llvm::Triple::ppc:
2048 case llvm::Triple::ppcle:
2049 case llvm::Triple::ppc64:
2050 case llvm::Triple::ppc64le:
2051 return CheckPPCBuiltinFunctionCall(TI, BuiltinID, TheCall);
2052 case llvm::Triple::amdgcn:
2053 return CheckAMDGCNBuiltinFunctionCall(BuiltinID, TheCall);
2054 case llvm::Triple::riscv32:
2055 case llvm::Triple::riscv64:
2056 return CheckRISCVBuiltinFunctionCall(TI, BuiltinID, TheCall);
2057 case llvm::Triple::loongarch32:
2058 case llvm::Triple::loongarch64:
2059 return CheckLoongArchBuiltinFunctionCall(TI, BuiltinID, TheCall);
2060 case llvm::Triple::wasm32:
2061 case llvm::Triple::wasm64:
2062 return CheckWebAssemblyBuiltinFunctionCall(TI, BuiltinID, TheCall);
2063 case llvm::Triple::nvptx:
2064 case llvm::Triple::nvptx64:
2065 return CheckNVPTXBuiltinFunctionCall(TI, BuiltinID, TheCall);
2066 }
2067}
2068
2069// Check if \p Ty is a valid type for the elementwise math builtins. If it is
2070// not a valid type, emit an error message and return true. Otherwise return
2071// false.
2073 QualType Ty) {
2075 return S.Diag(Loc, diag::err_builtin_invalid_arg_type)
2076 << 1 << /* vector, integer or float ty*/ 0 << Ty;
2077 }
2078
2079 return false;
2080}
2081
2083 QualType ArgTy, int ArgIndex) {
2084 QualType EltTy = ArgTy;
2085 if (auto *VecTy = EltTy->getAs<VectorType>())
2086 EltTy = VecTy->getElementType();
2087
2088 if (!EltTy->isRealFloatingType()) {
2089 return S.Diag(Loc, diag::err_builtin_invalid_arg_type)
2090 << ArgIndex << /* vector or float ty*/ 5 << ArgTy;
2091 }
2092
2093 return false;
2094}
2095
2097Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
2098 CallExpr *TheCall) {
2099 ExprResult TheCallResult(TheCall);
2100
2101 // Find out if any arguments are required to be integer constant expressions.
2102 unsigned ICEArguments = 0;
2104 Context.GetBuiltinType(BuiltinID, Error, &ICEArguments);
2106 ICEArguments = 0; // Don't diagnose previously diagnosed errors.
2107
2108 // If any arguments are required to be ICE's, check and diagnose.
2109 for (unsigned ArgNo = 0; ICEArguments != 0; ++ArgNo) {
2110 // Skip arguments not required to be ICE's.
2111 if ((ICEArguments & (1 << ArgNo)) == 0) continue;
2112
2113 llvm::APSInt Result;
2114 // If we don't have enough arguments, continue so we can issue better
2115 // diagnostic in checkArgCount(...)
2116 if (ArgNo < TheCall->getNumArgs() &&
2117 SemaBuiltinConstantArg(TheCall, ArgNo, Result))
2118 return true;
2119 ICEArguments &= ~(1 << ArgNo);
2120 }
2121
2122 switch (BuiltinID) {
2123 case Builtin::BI__builtin___CFStringMakeConstantString:
2124 // CFStringMakeConstantString is currently not implemented for GOFF (i.e.,
2125 // on z/OS) and for XCOFF (i.e., on AIX). Emit unsupported
2127 *this, BuiltinID, TheCall,
2128 {llvm::Triple::GOFF, llvm::Triple::XCOFF}))
2129 return ExprError();
2130 assert(TheCall->getNumArgs() == 1 &&
2131 "Wrong # arguments to builtin CFStringMakeConstantString");
2132 if (CheckObjCString(TheCall->getArg(0)))
2133 return ExprError();
2134 break;
2135 case Builtin::BI__builtin_ms_va_start:
2136 case Builtin::BI__builtin_stdarg_start:
2137 case Builtin::BI__builtin_va_start:
2138 if (SemaBuiltinVAStart(BuiltinID, TheCall))
2139 return ExprError();
2140 break;
2141 case Builtin::BI__va_start: {
2142 switch (Context.getTargetInfo().getTriple().getArch()) {
2143 case llvm::Triple::aarch64:
2144 case llvm::Triple::arm:
2145 case llvm::Triple::thumb:
2146 if (SemaBuiltinVAStartARMMicrosoft(TheCall))
2147 return ExprError();
2148 break;
2149 default:
2150 if (SemaBuiltinVAStart(BuiltinID, TheCall))
2151 return ExprError();
2152 break;
2153 }
2154 break;
2155 }
2156
2157 // The acquire, release, and no fence variants are ARM and AArch64 only.
2158 case Builtin::BI_interlockedbittestandset_acq:
2159 case Builtin::BI_interlockedbittestandset_rel:
2160 case Builtin::BI_interlockedbittestandset_nf:
2161 case Builtin::BI_interlockedbittestandreset_acq:
2162 case Builtin::BI_interlockedbittestandreset_rel:
2163 case Builtin::BI_interlockedbittestandreset_nf:
2165 *this, BuiltinID, TheCall,
2166 {llvm::Triple::arm, llvm::Triple::thumb, llvm::Triple::aarch64}))
2167 return ExprError();
2168 break;
2169
2170 // The 64-bit bittest variants are x64, ARM, and AArch64 only.
2171 case Builtin::BI_bittest64:
2172 case Builtin::BI_bittestandcomplement64:
2173 case Builtin::BI_bittestandreset64:
2174 case Builtin::BI_bittestandset64:
2175 case Builtin::BI_interlockedbittestandreset64:
2176 case Builtin::BI_interlockedbittestandset64:
2177 if (CheckBuiltinTargetInSupported(*this, BuiltinID, TheCall,
2178 {llvm::Triple::x86_64, llvm::Triple::arm,
2179 llvm::Triple::thumb,
2180 llvm::Triple::aarch64}))
2181 return ExprError();
2182 break;
2183
2184 case Builtin::BI__builtin_set_flt_rounds:
2185 if (CheckBuiltinTargetInSupported(*this, BuiltinID, TheCall,
2186 {llvm::Triple::x86, llvm::Triple::x86_64,
2187 llvm::Triple::arm, llvm::Triple::thumb,
2188 llvm::Triple::aarch64}))
2189 return ExprError();
2190 break;
2191
2192 case Builtin::BI__builtin_isgreater:
2193 case Builtin::BI__builtin_isgreaterequal:
2194 case Builtin::BI__builtin_isless:
2195 case Builtin::BI__builtin_islessequal:
2196 case Builtin::BI__builtin_islessgreater:
2197 case Builtin::BI__builtin_isunordered:
2198 if (SemaBuiltinUnorderedCompare(TheCall))
2199 return ExprError();
2200 break;
2201 case Builtin::BI__builtin_fpclassify:
2202 if (SemaBuiltinFPClassification(TheCall, 6))
2203 return ExprError();
2204 break;
2205 case Builtin::BI__builtin_isfpclass:
2206 if (SemaBuiltinFPClassification(TheCall, 2))
2207 return ExprError();
2208 break;
2209 case Builtin::BI__builtin_isfinite:
2210 case Builtin::BI__builtin_isinf:
2211 case Builtin::BI__builtin_isinf_sign:
2212 case Builtin::BI__builtin_isnan:
2213 case Builtin::BI__builtin_isnormal:
2214 case Builtin::BI__builtin_signbit:
2215 case Builtin::BI__builtin_signbitf:
2216 case Builtin::BI__builtin_signbitl:
2217 if (SemaBuiltinFPClassification(TheCall, 1))
2218 return ExprError();
2219 break;
2220 case Builtin::BI__builtin_shufflevector:
2221 return SemaBuiltinShuffleVector(TheCall);
2222 // TheCall will be freed by the smart pointer here, but that's fine, since
2223 // SemaBuiltinShuffleVector guts it, but then doesn't release it.
2224 case Builtin::BI__builtin_prefetch:
2225 if (SemaBuiltinPrefetch(TheCall))
2226 return ExprError();
2227 break;
2228 case Builtin::BI__builtin_alloca_with_align:
2229 case Builtin::BI__builtin_alloca_with_align_uninitialized:
2230 if (SemaBuiltinAllocaWithAlign(TheCall))
2231 return ExprError();
2232 [[fallthrough]];
2233 case Builtin::BI__builtin_alloca:
2234 case Builtin::BI__builtin_alloca_uninitialized:
2235 Diag(TheCall->getBeginLoc(), diag::warn_alloca)
2236 << TheCall->getDirectCallee();
2237 break;
2238 case Builtin::BI__arithmetic_fence:
2239 if (SemaBuiltinArithmeticFence(TheCall))
2240 return ExprError();
2241 break;
2242 case Builtin::BI__assume:
2243 case Builtin::BI__builtin_assume:
2244 if (SemaBuiltinAssume(TheCall))
2245 return ExprError();
2246 break;
2247 case Builtin::BI__builtin_assume_aligned:
2248 if (SemaBuiltinAssumeAligned(TheCall))
2249 return ExprError();
2250 break;
2251 case Builtin::BI__builtin_dynamic_object_size:
2252 case Builtin::BI__builtin_object_size:
2253 if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 3))
2254 return ExprError();
2255 break;
2256 case Builtin::BI__builtin_longjmp:
2257 if (SemaBuiltinLongjmp(TheCall))
2258 return ExprError();
2259 break;
2260 case Builtin::BI__builtin_setjmp:
2261 if (SemaBuiltinSetjmp(TheCall))
2262 return ExprError();
2263 break;
2264 case Builtin::BI__builtin_classify_type:
2265 if (checkArgCount(*this, TheCall, 1)) return true;
2266 TheCall->setType(Context.IntTy);
2267 break;
2268 case Builtin::BI__builtin_complex:
2269 if (SemaBuiltinComplex(TheCall))
2270 return ExprError();
2271 break;
2272 case Builtin::BI__builtin_constant_p: {
2273 if (checkArgCount(*this, TheCall, 1)) return true;
2275 if (Arg.isInvalid()) return true;
2276 TheCall->setArg(0, Arg.get());
2277 TheCall->setType(Context.IntTy);
2278 break;
2279 }
2280 case Builtin::BI__builtin_launder:
2281 return SemaBuiltinLaunder(*this, TheCall);
2282 case Builtin::BI__sync_fetch_and_add:
2283 case Builtin::BI__sync_fetch_and_add_1:
2284 case Builtin::BI__sync_fetch_and_add_2:
2285 case Builtin::BI__sync_fetch_and_add_4:
2286 case Builtin::BI__sync_fetch_and_add_8:
2287 case Builtin::BI__sync_fetch_and_add_16:
2288 case Builtin::BI__sync_fetch_and_sub:
2289 case Builtin::BI__sync_fetch_and_sub_1:
2290 case Builtin::BI__sync_fetch_and_sub_2:
2291 case Builtin::BI__sync_fetch_and_sub_4:
2292 case Builtin::BI__sync_fetch_and_sub_8:
2293 case Builtin::BI__sync_fetch_and_sub_16:
2294 case Builtin::BI__sync_fetch_and_or:
2295 case Builtin::BI__sync_fetch_and_or_1:
2296 case Builtin::BI__sync_fetch_and_or_2:
2297 case Builtin::BI__sync_fetch_and_or_4:
2298 case Builtin::BI__sync_fetch_and_or_8:
2299 case Builtin::BI__sync_fetch_and_or_16:
2300 case Builtin::BI__sync_fetch_and_and:
2301 case Builtin::BI__sync_fetch_and_and_1:
2302 case Builtin::BI__sync_fetch_and_and_2:
2303 case Builtin::BI__sync_fetch_and_and_4:
2304 case Builtin::BI__sync_fetch_and_and_8:
2305 case Builtin::BI__sync_fetch_and_and_16:
2306 case Builtin::BI__sync_fetch_and_xor:
2307 case Builtin::BI__sync_fetch_and_xor_1:
2308 case Builtin::BI__sync_fetch_and_xor_2:
2309 case Builtin::BI__sync_fetch_and_xor_4:
2310 case Builtin::BI__sync_fetch_and_xor_8:
2311 case Builtin::BI__sync_fetch_and_xor_16:
2312 case Builtin::BI__sync_fetch_and_nand:
2313 case Builtin::BI__sync_fetch_and_nand_1:
2314 case Builtin::BI__sync_fetch_and_nand_2:
2315 case Builtin::BI__sync_fetch_and_nand_4:
2316 case Builtin::BI__sync_fetch_and_nand_8:
2317 case Builtin::BI__sync_fetch_and_nand_16:
2318 case Builtin::BI__sync_add_and_fetch:
2319 case Builtin::BI__sync_add_and_fetch_1:
2320 case Builtin::BI__sync_add_and_fetch_2:
2321 case Builtin::BI__sync_add_and_fetch_4:
2322 case Builtin::BI__sync_add_and_fetch_8:
2323 case Builtin::BI__sync_add_and_fetch_16:
2324 case Builtin::BI__sync_sub_and_fetch:
2325 case Builtin::BI__sync_sub_and_fetch_1:
2326 case Builtin::BI__sync_sub_and_fetch_2:
2327 case Builtin::BI__sync_sub_and_fetch_4:
2328 case Builtin::BI__sync_sub_and_fetch_8:
2329 case Builtin::BI__sync_sub_and_fetch_16:
2330 case Builtin::BI__sync_and_and_fetch:
2331 case Builtin::BI__sync_and_and_fetch_1:
2332 case Builtin::BI__sync_and_and_fetch_2:
2333 case Builtin::BI__sync_and_and_fetch_4:
2334 case Builtin::BI__sync_and_and_fetch_8:
2335 case Builtin::BI__sync_and_and_fetch_16:
2336 case Builtin::BI__sync_or_and_fetch:
2337 case Builtin::BI__sync_or_and_fetch_1:
2338 case Builtin::BI__sync_or_and_fetch_2:
2339 case Builtin::BI__sync_or_and_fetch_4:
2340 case Builtin::BI__sync_or_and_fetch_8:
2341 case Builtin::BI__sync_or_and_fetch_16:
2342 case Builtin::BI__sync_xor_and_fetch:
2343 case Builtin::BI__sync_xor_and_fetch_1:
2344 case Builtin::BI__sync_xor_and_fetch_2:
2345 case Builtin::BI__sync_xor_and_fetch_4:
2346 case Builtin::BI__sync_xor_and_fetch_8:
2347 case Builtin::BI__sync_xor_and_fetch_16:
2348 case Builtin::BI__sync_nand_and_fetch:
2349 case Builtin::BI__sync_nand_and_fetch_1:
2350 case Builtin::BI__sync_nand_and_fetch_2:
2351 case Builtin::BI__sync_nand_and_fetch_4:
2352 case Builtin::BI__sync_nand_and_fetch_8:
2353 case Builtin::BI__sync_nand_and_fetch_16:
2354 case Builtin::BI__sync_val_compare_and_swap:
2355 case Builtin::BI__sync_val_compare_and_swap_1:
2356 case Builtin::BI__sync_val_compare_and_swap_2:
2357 case Builtin::BI__sync_val_compare_and_swap_4:
2358 case Builtin::BI__sync_val_compare_and_swap_8:
2359 case Builtin::BI__sync_val_compare_and_swap_16:
2360 case Builtin::BI__sync_bool_compare_and_swap:
2361 case Builtin::BI__sync_bool_compare_and_swap_1:
2362 case Builtin::BI__sync_bool_compare_and_swap_2:
2363 case Builtin::BI__sync_bool_compare_and_swap_4:
2364 case Builtin::BI__sync_bool_compare_and_swap_8:
2365 case Builtin::BI__sync_bool_compare_and_swap_16:
2366 case Builtin::BI__sync_lock_test_and_set:
2367 case Builtin::BI__sync_lock_test_and_set_1:
2368 case Builtin::BI__sync_lock_test_and_set_2:
2369 case Builtin::BI__sync_lock_test_and_set_4:
2370 case Builtin::BI__sync_lock_test_and_set_8:
2371 case Builtin::BI__sync_lock_test_and_set_16:
2372 case Builtin::BI__sync_lock_release:
2373 case Builtin::BI__sync_lock_release_1:
2374 case Builtin::BI__sync_lock_release_2:
2375 case Builtin::BI__sync_lock_release_4:
2376 case Builtin::BI__sync_lock_release_8:
2377 case Builtin::BI__sync_lock_release_16:
2378 case Builtin::BI__sync_swap:
2379 case Builtin::BI__sync_swap_1:
2380 case Builtin::BI__sync_swap_2:
2381 case Builtin::BI__sync_swap_4:
2382 case Builtin::BI__sync_swap_8:
2383 case Builtin::BI__sync_swap_16:
2384 return SemaBuiltinAtomicOverloaded(TheCallResult);
2385 case Builtin::BI__sync_synchronize:
2386 Diag(TheCall->getBeginLoc(), diag::warn_atomic_implicit_seq_cst)
2387 << TheCall->getCallee()->getSourceRange();
2388 break;
2389 case Builtin::BI__builtin_nontemporal_load:
2390 case Builtin::BI__builtin_nontemporal_store:
2391 return SemaBuiltinNontemporalOverloaded(TheCallResult);
2392 case Builtin::BI__builtin_memcpy_inline: {
2393 clang::Expr *SizeOp = TheCall->getArg(2);
2394 // We warn about copying to or from `nullptr` pointers when `size` is
2395 // greater than 0. When `size` is value dependent we cannot evaluate its
2396 // value so we bail out.
2397 if (SizeOp->isValueDependent())
2398 break;
2399 if (!SizeOp->EvaluateKnownConstInt(Context).isZero()) {
2400 CheckNonNullArgument(*this, TheCall->getArg(0), TheCall->getExprLoc());
2401 CheckNonNullArgument(*this, TheCall->getArg(1), TheCall->getExprLoc());
2402 }
2403 break;
2404 }
2405 case Builtin::BI__builtin_memset_inline: {
2406 clang::Expr *SizeOp = TheCall->getArg(2);
2407 // We warn about filling to `nullptr` pointers when `size` is greater than
2408 // 0. When `size` is value dependent we cannot evaluate its value so we bail
2409 // out.
2410 if (SizeOp->isValueDependent())
2411 break;
2412 if (!SizeOp->EvaluateKnownConstInt(Context).isZero())
2413 CheckNonNullArgument(*this, TheCall->getArg(0), TheCall->getExprLoc());
2414 break;
2415 }
2416#define BUILTIN(ID, TYPE, ATTRS)
2417#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
2418 case Builtin::BI##ID: \
2419 return SemaAtomicOpsOverloaded(TheCallResult, AtomicExpr::AO##ID);
2420#include "clang/Basic/Builtins.def"
2421 case Builtin::BI__annotation:
2422 if (SemaBuiltinMSVCAnnotation(*this, TheCall))
2423 return ExprError();
2424 break;
2425 case Builtin::BI__builtin_annotation:
2426 if (SemaBuiltinAnnotation(*this, TheCall))
2427 return ExprError();
2428 break;
2429 case Builtin::BI__builtin_addressof:
2430 if (SemaBuiltinAddressof(*this, TheCall))
2431 return ExprError();
2432 break;
2433 case Builtin::BI__builtin_function_start:
2434 if (SemaBuiltinFunctionStart(*this, TheCall))
2435 return ExprError();
2436 break;
2437 case Builtin::BI__builtin_is_aligned:
2438 case Builtin::BI__builtin_align_up:
2439 case Builtin::BI__builtin_align_down:
2440 if (SemaBuiltinAlignment(*this, TheCall, BuiltinID))
2441 return ExprError();
2442 break;
2443 case Builtin::BI__builtin_add_overflow:
2444 case Builtin::BI__builtin_sub_overflow:
2445 case Builtin::BI__builtin_mul_overflow:
2446 if (SemaBuiltinOverflow(*this, TheCall, BuiltinID))
2447 return ExprError();
2448 break;
2449 case Builtin::BI__builtin_operator_new:
2450 case Builtin::BI__builtin_operator_delete: {
2451 bool IsDelete = BuiltinID == Builtin::BI__builtin_operator_delete;
2452 ExprResult Res =
2453 SemaBuiltinOperatorNewDeleteOverloaded(TheCallResult, IsDelete);
2454 if (Res.isInvalid())
2455 CorrectDelayedTyposInExpr(TheCallResult.get());
2456 return Res;
2457 }
2458 case Builtin::BI__builtin_dump_struct:
2459 return SemaBuiltinDumpStruct(*this, TheCall);
2460 case Builtin::BI__builtin_expect_with_probability: {
2461 // We first want to ensure we are called with 3 arguments
2462 if (checkArgCount(*this, TheCall, 3))
2463 return ExprError();
2464 // then check probability is constant float in range [0.0, 1.0]
2465 const Expr *ProbArg = TheCall->getArg(2);
2467 Expr::EvalResult Eval;
2468 Eval.Diag = &Notes;
2469 if ((!ProbArg->EvaluateAsConstantExpr(Eval, Context)) ||
2470 !Eval.Val.isFloat()) {
2471 Diag(ProbArg->getBeginLoc(), diag::err_probability_not_constant_float)
2472 << ProbArg->getSourceRange();
2473 for (const PartialDiagnosticAt &PDiag : Notes)
2474 Diag(PDiag.first, PDiag.second);
2475 return ExprError();
2476 }
2477 llvm::APFloat Probability = Eval.Val.getFloat();
2478 bool LoseInfo = false;
2479 Probability.convert(llvm::APFloat::IEEEdouble(),
2480 llvm::RoundingMode::Dynamic, &LoseInfo);
2481 if (!(Probability >= llvm::APFloat(0.0) &&
2482 Probability <= llvm::APFloat(1.0))) {
2483 Diag(ProbArg->getBeginLoc(), diag::err_probability_out_of_range)
2484 << ProbArg->getSourceRange();
2485 return ExprError();
2486 }
2487 break;
2488 }
2489 case Builtin::BI__builtin_preserve_access_index:
2490 if (SemaBuiltinPreserveAI(*this, TheCall))
2491 return ExprError();
2492 break;
2493 case Builtin::BI__builtin_call_with_static_chain:
2494 if (SemaBuiltinCallWithStaticChain(*this, TheCall))
2495 return ExprError();
2496 break;
2497 case Builtin::BI__exception_code:
2498 case Builtin::BI_exception_code:
2500 diag::err_seh___except_block))
2501 return ExprError();
2502 break;
2503 case Builtin::BI__exception_info:
2504 case Builtin::BI_exception_info:
2506 diag::err_seh___except_filter))
2507 return ExprError();
2508 break;
2509 case Builtin::BI__GetExceptionInfo:
2510 if (checkArgCount(*this, TheCall, 1))
2511 return ExprError();
2512
2514 TheCall->getBeginLoc(),
2516 TheCall))
2517 return ExprError();
2518
2519 TheCall->setType(Context.VoidPtrTy);
2520 break;
2521 case Builtin::BIaddressof:
2522 case Builtin::BI__addressof:
2523 case Builtin::BIforward:
2524 case Builtin::BIforward_like:
2525 case Builtin::BImove:
2526 case Builtin::BImove_if_noexcept:
2527 case Builtin::BIas_const: {
2528 // These are all expected to be of the form
2529 // T &/&&/* f(U &/&&)
2530 // where T and U only differ in qualification.
2531 if (checkArgCount(*this, TheCall, 1))
2532 return ExprError();
2533 QualType Param = FDecl->getParamDecl(0)->getType();
2534 QualType Result = FDecl->getReturnType();
2535 bool ReturnsPointer = BuiltinID == Builtin::BIaddressof ||
2536 BuiltinID == Builtin::BI__addressof;
2537 if (!(Param->isReferenceType() &&
2538 (ReturnsPointer ? Result->isAnyPointerType()
2539 : Result->isReferenceType()) &&
2541 Result->getPointeeType()))) {
2542 Diag(TheCall->getBeginLoc(), diag::err_builtin_move_forward_unsupported)
2543 << FDecl;
2544 return ExprError();
2545 }
2546 break;
2547 }
2548 // OpenCL v2.0, s6.13.16 - Pipe functions
2549 case Builtin::BIread_pipe:
2550 case Builtin::BIwrite_pipe:
2551 // Since those two functions are declared with var args, we need a semantic
2552 // check for the argument.
2553 if (SemaBuiltinRWPipe(*this, TheCall))
2554 return ExprError();
2555 break;
2556 case Builtin::BIreserve_read_pipe:
2557 case Builtin::BIreserve_write_pipe:
2558 case Builtin::BIwork_group_reserve_read_pipe:
2559 case Builtin::BIwork_group_reserve_write_pipe:
2560 if (SemaBuiltinReserveRWPipe(*this, TheCall))
2561 return ExprError();
2562 break;
2563 case Builtin::BIsub_group_reserve_read_pipe:
2564 case Builtin::BIsub_group_reserve_write_pipe:
2565 if (checkOpenCLSubgroupExt(*this, TheCall) ||
2566 SemaBuiltinReserveRWPipe(*this, TheCall))
2567 return ExprError();
2568 break;
2569 case Builtin::BIcommit_read_pipe:
2570 case Builtin::BIcommit_write_pipe:
2571 case Builtin::BIwork_group_commit_read_pipe:
2572 case Builtin::BIwork_group_commit_write_pipe:
2573 if (SemaBuiltinCommitRWPipe(*this, TheCall))
2574 return ExprError();
2575 break;
2576 case Builtin::BIsub_group_commit_read_pipe:
2577 case Builtin::BIsub_group_commit_write_pipe:
2578 if (checkOpenCLSubgroupExt(*this, TheCall) ||
2579 SemaBuiltinCommitRWPipe(*this, TheCall))
2580 return ExprError();
2581 break;
2582 case Builtin::BIget_pipe_num_packets:
2583 case Builtin::BIget_pipe_max_packets:
2584 if (SemaBuiltinPipePackets(*this, TheCall))
2585 return ExprError();
2586 break;
2587 case Builtin::BIto_global:
2588 case Builtin::BIto_local:
2589 case Builtin::BIto_private:
2590 if (SemaOpenCLBuiltinToAddr(*this, BuiltinID, TheCall))
2591 return ExprError();
2592 break;
2593 // OpenCL v2.0, s6.13.17 - Enqueue kernel functions.
2594 case Builtin::BIenqueue_kernel:
2595 if (SemaOpenCLBuiltinEnqueueKernel(*this, TheCall))
2596 return ExprError();
2597 break;
2598 case Builtin::BIget_kernel_work_group_size:
2599 case Builtin::BIget_kernel_preferred_work_group_size_multiple:
2600 if (SemaOpenCLBuiltinKernelWorkGroupSize(*this, TheCall))
2601 return ExprError();
2602 break;
2603 case Builtin::BIget_kernel_max_sub_group_size_for_ndrange:
2604 case Builtin::BIget_kernel_sub_group_count_for_ndrange:
2605 if (SemaOpenCLBuiltinNDRangeAndBlock(*this, TheCall))
2606 return ExprError();
2607 break;
2608 case Builtin::BI__builtin_os_log_format:
2610 [[fallthrough]];
2611 case Builtin::BI__builtin_os_log_format_buffer_size:
2612 if (SemaBuiltinOSLogFormat(TheCall))
2613 return ExprError();
2614 break;
2615 case Builtin::BI__builtin_frame_address:
2616 case Builtin::BI__builtin_return_address: {
2617 if (SemaBuiltinConstantArgRange(TheCall, 0, 0, 0xFFFF))
2618 return ExprError();
2619
2620 // -Wframe-address warning if non-zero passed to builtin
2621 // return/frame address.
2623 if (!TheCall->getArg(0)->isValueDependent() &&
2624 TheCall->getArg(0)->EvaluateAsInt(Result, getASTContext()) &&
2625 Result.Val.getInt() != 0)
2626 Diag(TheCall->getBeginLoc(), diag::warn_frame_address)
2627 << ((BuiltinID == Builtin::BI__builtin_return_address)
2628 ? "__builtin_return_address"
2629 : "__builtin_frame_address")
2630 << TheCall->getSourceRange();
2631 break;
2632 }
2633
2634 case Builtin::BI__builtin_nondeterministic_value: {
2635 if (SemaBuiltinNonDeterministicValue(TheCall))
2636 return ExprError();
2637 break;
2638 }
2639
2640 // __builtin_elementwise_abs restricts the element type to signed integers or
2641 // floating point types only.
2642 case Builtin::BI__builtin_elementwise_abs: {
2643 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2644 return ExprError();
2645
2646 QualType ArgTy = TheCall->getArg(0)->getType();
2647 QualType EltTy = ArgTy;
2648
2649 if (auto *VecTy = EltTy->getAs<VectorType>())
2650 EltTy = VecTy->getElementType();
2651 if (EltTy->isUnsignedIntegerType()) {
2652 Diag(TheCall->getArg(0)->getBeginLoc(),
2653 diag::err_builtin_invalid_arg_type)
2654 << 1 << /* signed integer or float ty*/ 3 << ArgTy;
2655 return ExprError();
2656 }
2657 break;
2658 }
2659
2660 // These builtins restrict the element type to floating point
2661 // types only.
2662 case Builtin::BI__builtin_elementwise_ceil:
2663 case Builtin::BI__builtin_elementwise_cos:
2664 case Builtin::BI__builtin_elementwise_exp:
2665 case Builtin::BI__builtin_elementwise_exp2:
2666 case Builtin::BI__builtin_elementwise_floor:
2667 case Builtin::BI__builtin_elementwise_log:
2668 case Builtin::BI__builtin_elementwise_log2:
2669 case Builtin::BI__builtin_elementwise_log10:
2670 case Builtin::BI__builtin_elementwise_roundeven:
2671 case Builtin::BI__builtin_elementwise_round:
2672 case Builtin::BI__builtin_elementwise_rint:
2673 case Builtin::BI__builtin_elementwise_nearbyint:
2674 case Builtin::BI__builtin_elementwise_sin:
2675 case Builtin::BI__builtin_elementwise_sqrt:
2676 case Builtin::BI__builtin_elementwise_trunc:
2677 case Builtin::BI__builtin_elementwise_canonicalize: {
2678 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2679 return ExprError();
2680
2681 QualType ArgTy = TheCall->getArg(0)->getType();
2682 if (checkFPMathBuiltinElementType(*this, TheCall->getArg(0)->getBeginLoc(),
2683 ArgTy, 1))
2684 return ExprError();
2685 break;
2686 }
2687 case Builtin::BI__builtin_elementwise_fma: {
2688 if (SemaBuiltinElementwiseTernaryMath(TheCall))
2689 return ExprError();
2690 break;
2691 }
2692
2693 // These builtins restrict the element type to floating point
2694 // types only, and take in two arguments.
2695 case Builtin::BI__builtin_elementwise_pow: {
2696 if (SemaBuiltinElementwiseMath(TheCall))
2697 return ExprError();
2698
2699 QualType ArgTy = TheCall->getArg(0)->getType();
2700 if (checkFPMathBuiltinElementType(*this, TheCall->getArg(0)->getBeginLoc(),
2701 ArgTy, 1) ||
2702 checkFPMathBuiltinElementType(*this, TheCall->getArg(1)->getBeginLoc(),
2703 ArgTy, 2))
2704 return ExprError();
2705 break;
2706 }
2707
2708 // These builtins restrict the element type to integer
2709 // types only.
2710 case Builtin::BI__builtin_elementwise_add_sat:
2711 case Builtin::BI__builtin_elementwise_sub_sat: {
2712 if (SemaBuiltinElementwiseMath(TheCall))
2713 return ExprError();
2714
2715 const Expr *Arg = TheCall->getArg(0);
2716 QualType ArgTy = Arg->getType();
2717 QualType EltTy = ArgTy;
2718
2719 if (auto *VecTy = EltTy->getAs<VectorType>())
2720 EltTy = VecTy->getElementType();
2721
2722 if (!EltTy->isIntegerType()) {
2723 Diag(Arg->getBeginLoc(), diag::err_builtin_invalid_arg_type)
2724 << 1 << /* integer ty */ 6 << ArgTy;
2725 return ExprError();
2726 }
2727 break;
2728 }
2729
2730 case Builtin::BI__builtin_elementwise_min:
2731 case Builtin::BI__builtin_elementwise_max:
2732 if (SemaBuiltinElementwiseMath(TheCall))
2733 return ExprError();
2734 break;
2735
2736 case Builtin::BI__builtin_elementwise_bitreverse: {
2737 if (PrepareBuiltinElementwiseMathOneArgCall(TheCall))
2738 return ExprError();
2739
2740 const Expr *Arg = TheCall->getArg(0);
2741 QualType ArgTy = Arg->getType();
2742 QualType EltTy = ArgTy;
2743
2744 if (auto *VecTy = EltTy->getAs<VectorType>())
2745 EltTy = VecTy->getElementType();
2746
2747 if (!EltTy->isIntegerType()) {
2748 Diag(Arg->getBeginLoc(), diag::err_builtin_invalid_arg_type)
2749 << 1 << /* integer ty */ 6 << ArgTy;
2750 return ExprError();
2751 }
2752 break;
2753 }
2754
2755 case Builtin::BI__builtin_elementwise_copysign: {
2756 if (checkArgCount(*this, TheCall, 2))
2757 return ExprError();
2758
2759 ExprResult Magnitude = UsualUnaryConversions(TheCall->getArg(0));
2760 ExprResult Sign = UsualUnaryConversions(TheCall->getArg(1));
2761 if (Magnitude.isInvalid() || Sign.isInvalid())
2762 return ExprError();
2763
2764 QualType MagnitudeTy = Magnitude.get()->getType();
2765 QualType SignTy = Sign.get()->getType();
2766 if (checkFPMathBuiltinElementType(*this, TheCall->getArg(0)->getBeginLoc(),
2767 MagnitudeTy, 1) ||
2768 checkFPMathBuiltinElementType(*this, TheCall->getArg(1)->getBeginLoc(),
2769 SignTy, 2)) {
2770 return ExprError();
2771 }
2772
2773 if (MagnitudeTy.getCanonicalType() != SignTy.getCanonicalType()) {
2774 return Diag(Sign.get()->getBeginLoc(),
2775 diag::err_typecheck_call_different_arg_types)
2776 << MagnitudeTy << SignTy;
2777 }
2778
2779 TheCall->setArg(0, Magnitude.get());
2780 TheCall->setArg(1, Sign.get());
2781 TheCall->setType(Magnitude.get()->getType());
2782 break;
2783 }
2784 case Builtin::BI__builtin_reduce_max:
2785 case Builtin::BI__builtin_reduce_min: {
2786 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
2787 return ExprError();
2788
2789 const Expr *Arg = TheCall->getArg(0);
2790 const auto *TyA = Arg->getType()->getAs<VectorType>();
2791 if (!TyA) {
2792 Diag(Arg->getBeginLoc(), diag::err_builtin_invalid_arg_type)
2793 << 1 << /* vector ty*/ 4 << Arg->getType();
2794 return ExprError();
2795 }
2796
2797 TheCall->setType(TyA->getElementType());
2798 break;
2799 }
2800
2801 // These builtins support vectors of integers only.
2802 // TODO: ADD/MUL should support floating-point types.
2803 case Builtin::BI__builtin_reduce_add:
2804 case Builtin::BI__builtin_reduce_mul:
2805 case Builtin::BI__builtin_reduce_xor:
2806 case Builtin::BI__builtin_reduce_or:
2807 case Builtin::BI__builtin_reduce_and: {
2808 if (PrepareBuiltinReduceMathOneArgCall(TheCall))
2809 return ExprError();
2810
2811 const Expr *Arg = TheCall->getArg(0);
2812 const auto *TyA = Arg->getType()->getAs<VectorType>();
2813 if (!TyA || !TyA->getElementType()->isIntegerType()) {
2814 Diag(Arg->getBeginLoc(), diag::err_builtin_invalid_arg_type)
2815 << 1 << /* vector of integers */ 6 << Arg->getType();
2816 return ExprError();
2817 }
2818 TheCall->setType(TyA->getElementType());
2819 break;
2820 }
2821
2822 case Builtin::BI__builtin_matrix_transpose:
2823 return SemaBuiltinMatrixTranspose(TheCall, TheCallResult);
2824
2825 case Builtin::BI__builtin_matrix_column_major_load:
2826 return SemaBuiltinMatrixColumnMajorLoad(TheCall, TheCallResult);
2827
2828 case Builtin::BI__builtin_matrix_column_major_store:
2829 return SemaBuiltinMatrixColumnMajorStore(TheCall, TheCallResult);
2830
2831 case Builtin::BI__builtin_get_device_side_mangled_name: {
2832 auto Check = [](CallExpr *TheCall) {
2833 if (TheCall->getNumArgs() != 1)
2834 return false;
2835 auto *DRE = dyn_cast<DeclRefExpr>(TheCall->getArg(0)->IgnoreImpCasts());
2836 if (!DRE)
2837 return false;
2838 auto *D = DRE->getDecl();
2839 if (!isa<FunctionDecl>(D) && !isa<VarDecl>(D))
2840 return false;
2841 return D->hasAttr<CUDAGlobalAttr>() || D->hasAttr<CUDADeviceAttr>() ||
2842 D->hasAttr<CUDAConstantAttr>() || D->hasAttr<HIPManagedAttr>();
2843 };
2844 if (!Check(TheCall)) {
2845 Diag(TheCall->getBeginLoc(),
2846 diag::err_hip_invalid_args_builtin_mangled_name);
2847 return ExprError();
2848 }
2849 }
2850 }
2851
2852 // Since the target specific builtins for each arch overlap, only check those
2853 // of the arch we are compiling for.
2854 if (Context.BuiltinInfo.isTSBuiltin(BuiltinID)) {
2855 if (Context.BuiltinInfo.isAuxBuiltinID(BuiltinID)) {
2856 assert(Context.getAuxTargetInfo() &&
2857 "Aux Target Builtin, but not an aux target?");
2858
2859 if (CheckTSBuiltinFunctionCall(
2861 Context.BuiltinInfo.getAuxBuiltinID(BuiltinID), TheCall))
2862 return ExprError();
2863 } else {
2864 if (CheckTSBuiltinFunctionCall(Context.getTargetInfo(), BuiltinID,
2865 TheCall))
2866 return ExprError();
2867 }
2868 }
2869
2870 return TheCallResult;
2871}
2872
2873// Get the valid immediate range for the specified NEON type code.
2874static unsigned RFT(unsigned t, bool shift = false, bool ForceQuad = false) {
2876 int IsQuad = ForceQuad ? true : Type.isQuad();
2877 switch (Type.getEltType()) {
2880 return shift ? 7 : (8 << IsQuad) - 1;
2883 return shift ? 15 : (4 << IsQuad) - 1;
2885 return shift ? 31 : (2 << IsQuad) - 1;
2888 return shift ? 63 : (1 << IsQuad) - 1;
2890 return shift ? 127 : (1 << IsQuad) - 1;
2892 assert(!shift && "cannot shift float types!");
2893 return (4 << IsQuad) - 1;
2895 assert(!shift && "cannot shift float types!");
2896 return (2 << IsQuad) - 1;
2898 assert(!shift && "cannot shift float types!");
2899 return (1 << IsQuad) - 1;
2901 assert(!shift && "cannot shift float types!");
2902 return (4 << IsQuad) - 1;
2903 }
2904 llvm_unreachable("Invalid NeonTypeFlag!");
2905}
2906
2907/// getNeonEltType - Return the QualType corresponding to the elements of
2908/// the vector type specified by the NeonTypeFlags. This is used to check
2909/// the pointer arguments for Neon load/store intrinsics.
2911 bool IsPolyUnsigned, bool IsInt64Long) {
2912 switch (Flags.getEltType()) {
2914 return Flags.isUnsigned() ? Context.UnsignedCharTy : Context.SignedCharTy;
2916 return Flags.isUnsigned() ? Context.UnsignedShortTy : Context.ShortTy;
2918 return Flags.isUnsigned() ? Context.UnsignedIntTy : Context.IntTy;
2920 if (IsInt64Long)
2921 return Flags.isUnsigned() ? Context.UnsignedLongTy : Context.LongTy;
2922 else
2923 return Flags.isUnsigned() ? Context.UnsignedLongLongTy
2924 : Context.LongLongTy;
2926 return IsPolyUnsigned ? Context.UnsignedCharTy : Context.SignedCharTy;
2928 return IsPolyUnsigned ? Context.UnsignedShortTy : Context.ShortTy;
2930 if (IsInt64Long)
2931 return Context.UnsignedLongTy;
2932 else
2933 return Context.UnsignedLongLongTy;
2935 break;
2937 return Context.HalfTy;
2939 return Context.FloatTy;
2941 return Context.DoubleTy;
2943 return Context.BFloat16Ty;
2944 }
2945 llvm_unreachable("Invalid NeonTypeFlag!");
2946}
2947
2948bool Sema::CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
2949 // Range check SVE intrinsics that take immediate values.
2951
2952 switch (BuiltinID) {
2953 default:
2954 return false;
2955#define GET_SVE_IMMEDIATE_CHECK
2956#include "clang/Basic/arm_sve_sema_rangechecks.inc"
2957#undef GET_SVE_IMMEDIATE_CHECK
2958#define GET_SME_IMMEDIATE_CHECK
2959#include "clang/Basic/arm_sme_sema_rangechecks.inc"
2960#undef GET_SME_IMMEDIATE_CHECK
2961 }
2962
2963 // Perform all the immediate checks for this builtin call.
2964 bool HasError = false;
2965 for (auto &I : ImmChecks) {
2966 int ArgNum, CheckTy, ElementSizeInBits;
2967 std::tie(ArgNum, CheckTy, ElementSizeInBits) = I;
2968
2969 typedef bool(*OptionSetCheckFnTy)(int64_t Value);
2970
2971 // Function that checks whether the operand (ArgNum) is an immediate
2972 // that is one of the predefined values.
2973 auto CheckImmediateInSet = [&](OptionSetCheckFnTy CheckImm,
2974 int ErrDiag) -> bool {
2975 // We can't check the value of a dependent argument.
2976 Expr *Arg = TheCall->getArg(ArgNum);
2977 if (Arg->isTypeDependent() || Arg->isValueDependent())
2978 return false;
2979
2980 // Check constant-ness first.
2981 llvm::APSInt Imm;
2982 if (SemaBuiltinConstantArg(TheCall, ArgNum, Imm))
2983 return true;
2984
2985 if (!CheckImm(Imm.getSExtValue()))
2986 return Diag(TheCall->getBeginLoc(), ErrDiag) << Arg->getSourceRange();
2987 return false;
2988 };
2989
2990 switch ((SVETypeFlags::ImmCheckType)CheckTy) {
2991 case SVETypeFlags::ImmCheck0_31:
2992 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 31))
2993 HasError = true;
2994 break;
2995 case SVETypeFlags::ImmCheck0_13:
2996 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 13))
2997 HasError = true;
2998 break;
2999 case SVETypeFlags::ImmCheck1_16:
3000 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, 16))
3001 HasError = true;
3002 break;
3003 case SVETypeFlags::ImmCheck0_7:
3004 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 7))
3005 HasError = true;
3006 break;
3007 case SVETypeFlags::ImmCheckExtract:
3008 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
3009 (2048 / ElementSizeInBits) - 1))
3010 HasError = true;
3011 break;
3012 case SVETypeFlags::ImmCheckShiftRight:
3013 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1, ElementSizeInBits))
3014 HasError = true;
3015 break;
3016 case SVETypeFlags::ImmCheckShiftRightNarrow:
3017 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 1,
3018 ElementSizeInBits / 2))
3019 HasError = true;
3020 break;
3021 case SVETypeFlags::ImmCheckShiftLeft:
3022 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
3023 ElementSizeInBits - 1))
3024 HasError = true;
3025 break;
3026 case SVETypeFlags::ImmCheckLaneIndex:
3027 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
3028 (128 / (1 * ElementSizeInBits)) - 1))
3029 HasError = true;
3030 break;
3031 case SVETypeFlags::ImmCheckLaneIndexCompRotate:
3032 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
3033 (128 / (2 * ElementSizeInBits)) - 1))
3034 HasError = true;
3035 break;
3036 case SVETypeFlags::ImmCheckLaneIndexDot:
3037 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0,
3038 (128 / (4 * ElementSizeInBits)) - 1))
3039 HasError = true;
3040 break;
3041 case SVETypeFlags::ImmCheckComplexRot90_270:
3042 if (CheckImmediateInSet([](int64_t V) { return V == 90 || V == 270; },
3043 diag::err_rotation_argument_to_cadd))
3044 HasError = true;
3045 break;
3046 case SVETypeFlags::ImmCheckComplexRotAll90:
3047 if (CheckImmediateInSet(
3048 [](int64_t V) {
3049 return V == 0 || V == 90 || V == 180 || V == 270;
3050 },
3051 diag::err_rotation_argument_to_cmla))
3052 HasError = true;
3053 break;
3054 case SVETypeFlags::ImmCheck0_1:
3055 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 1))
3056 HasError = true;
3057 break;
3058 case SVETypeFlags::ImmCheck0_2:
3059 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 2))
3060 HasError = true;
3061 break;
3062 case SVETypeFlags::ImmCheck0_3:
3063 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 3))
3064 HasError = true;
3065 break;
3066 case SVETypeFlags::ImmCheck0_0:
3067 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 0))
3068 HasError = true;
3069 break;
3070 case SVETypeFlags::ImmCheck0_15:
3071 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 15))
3072 HasError = true;
3073 break;
3074 case SVETypeFlags::ImmCheck0_255:
3075 if (SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, 255))
3076 HasError = true;
3077 break;
3078 }
3079 }
3080
3081 return HasError;
3082}
3083
3084bool Sema::CheckNeonBuiltinFunctionCall(const TargetInfo &TI,
3085 unsigned BuiltinID, CallExpr *TheCall) {
3086 llvm::APSInt Result;
3087 uint64_t mask = 0;
3088 unsigned TV = 0;
3089 int PtrArgNum = -1;
3090 bool HasConstPtr = false;
3091 switch (BuiltinID) {
3092#define GET_NEON_OVERLOAD_CHECK
3093#include "clang/Basic/arm_neon.inc"
3094#include "clang/Basic/arm_fp16.inc"
3095#undef GET_NEON_OVERLOAD_CHECK
3096 }
3097
3098 // For NEON intrinsics which are overloaded on vector element type, validate
3099 // the immediate which specifies which variant to emit.
3100 unsigned ImmArg = TheCall->getNumArgs()-1;
3101 if (mask) {
3102 if (SemaBuiltinConstantArg(TheCall, ImmArg, Result))
3103 return true;
3104
3105 TV = Result.getLimitedValue(64);
3106 if ((TV > 63) || (mask & (1ULL << TV)) == 0)
3107 return Diag(TheCall->getBeginLoc(), diag::err_invalid_neon_type_code)
3108 << TheCall->getArg(ImmArg)->getSourceRange();
3109 }
3110
3111 if (PtrArgNum >= 0) {
3112 // Check that pointer arguments have the specified type.
3113 Expr *Arg = TheCall->getArg(PtrArgNum);
3114 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg))
3115 Arg = ICE->getSubExpr();
3117 QualType RHSTy = RHS.get()->getType();
3118
3119 llvm::Triple::ArchType Arch = TI.getTriple().getArch();
3120 bool IsPolyUnsigned = Arch == llvm::Triple::aarch64 ||
3121 Arch == llvm::Triple::aarch64_32 ||
3122 Arch == llvm::Triple::aarch64_be;
3123 bool IsInt64Long = TI.getInt64Type() == TargetInfo::SignedLong;
3124 QualType EltTy =
3125 getNeonEltType(NeonTypeFlags(TV), Context, IsPolyUnsigned, IsInt64Long);
3126 if (HasConstPtr)
3127 EltTy = EltTy.withConst();
3128 QualType LHSTy = Context.getPointerType(EltTy);
3129 AssignConvertType ConvTy;
3130 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS);
3131 if (RHS.isInvalid())
3132 return true;
3133 if (DiagnoseAssignmentResult(ConvTy, Arg->getBeginLoc(), LHSTy, RHSTy,
3134 RHS.get(), AA_Assigning))
3135 return true;
3136 }
3137
3138 // For NEON intrinsics which take an immediate value as part of the
3139 // instruction, range check them here.
3140 unsigned i = 0, l = 0, u = 0;
3141 switch (BuiltinID) {
3142 default:
3143 return false;
3144 #define GET_NEON_IMMEDIATE_CHECK
3145 #include "clang/Basic/arm_neon.inc"
3146 #include "clang/Basic/arm_fp16.inc"
3147 #undef GET_NEON_IMMEDIATE_CHECK
3148 }
3149
3150 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
3151}
3152
3153bool Sema::CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
3154 switch (BuiltinID) {
3155 default:
3156 return false;
3157 #include "clang/Basic/arm_mve_builtin_sema.inc"
3158 }
3159}
3160
3161bool Sema::CheckCDEBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
3162 CallExpr *TheCall) {
3163 bool Err = false;
3164 switch (BuiltinID) {
3165 default:
3166 return false;
3167#include "clang/Basic/arm_cde_builtin_sema.inc"
3168 }
3169
3170 if (Err)
3171 return true;
3172
3173 return CheckARMCoprocessorImmediate(TI, TheCall->getArg(0), /*WantCDE*/ true);
3174}
3175
3176bool Sema::CheckARMCoprocessorImmediate(const TargetInfo &TI,
3177 const Expr *CoprocArg, bool WantCDE) {
3178 if (isConstantEvaluated())
3179 return false;
3180
3181 // We can't check the value of a dependent argument.
3182 if (CoprocArg->isTypeDependent() || CoprocArg->isValueDependent())
3183 return false;
3184
3185 llvm::APSInt CoprocNoAP = *CoprocArg->getIntegerConstantExpr(Context);
3186 int64_t CoprocNo = CoprocNoAP.getExtValue();
3187 assert(CoprocNo >= 0 && "Coprocessor immediate must be non-negative");
3188
3189 uint32_t CDECoprocMask = TI.getARMCDECoprocMask();
3190 bool IsCDECoproc = CoprocNo <= 7 && (CDECoprocMask & (1 << CoprocNo));
3191
3192 if (IsCDECoproc != WantCDE)
3193 return Diag(CoprocArg->getBeginLoc(), diag::err_arm_invalid_coproc)
3194 << (int)CoprocNo << (int)WantCDE << CoprocArg->getSourceRange();
3195
3196 return false;
3197}
3198
3199bool Sema::CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
3200 unsigned MaxWidth) {
3201 assert((BuiltinID == ARM::BI__builtin_arm_ldrex ||
3202 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3203 BuiltinID == ARM::BI__builtin_arm_strex ||
3204 BuiltinID == ARM::BI__builtin_arm_stlex ||
3205 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3206 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3207 BuiltinID == AArch64::BI__builtin_arm_strex ||
3208 BuiltinID == AArch64::BI__builtin_arm_stlex) &&
3209 "unexpected ARM builtin");
3210 bool IsLdrex = BuiltinID == ARM::BI__builtin_arm_ldrex ||
3211 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3212 BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3213 BuiltinID == AArch64::BI__builtin_arm_ldaex;
3214
3215 DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
3216
3217 // Ensure that we have the proper number of arguments.
3218 if (checkArgCount(*this, TheCall, IsLdrex ? 1 : 2))
3219 return true;
3220
3221 // Inspect the pointer argument of the atomic builtin. This should always be
3222 // a pointer type, whose element is an integral scalar or pointer type.
3223 // Because it is a pointer type, we don't have to worry about any implicit
3224 // casts here.
3225 Expr *PointerArg = TheCall->getArg(IsLdrex ? 0 : 1);
3226 ExprResult PointerArgRes = DefaultFunctionArrayLvalueConversion(PointerArg);
3227 if (PointerArgRes.isInvalid())
3228 return true;
3229 PointerArg = PointerArgRes.get();
3230
3231 const PointerType *pointerType = PointerArg->getType()->getAs<PointerType>();
3232 if (!pointerType) {
3233 Diag(DRE->getBeginLoc(), diag::err_atomic_builtin_must_be_pointer)
3234 << PointerArg->getType() << PointerArg->getSourceRange();
3235 return true;
3236 }
3237
3238 // ldrex takes a "const volatile T*" and strex takes a "volatile T*". Our next
3239 // task is to insert the appropriate casts into the AST. First work out just
3240 // what the appropriate type is.
3241 QualType ValType = pointerType->getPointeeType();
3242 QualType AddrType = ValType.getUnqualifiedType().withVolatile();
3243 if (IsLdrex)
3244 AddrType.addConst();
3245
3246 // Issue a warning if the cast is dodgy.
3247 CastKind CastNeeded = CK_NoOp;
3248 if (!AddrType.isAtLeastAsQualifiedAs(ValType)) {
3249 CastNeeded = CK_BitCast;
3250 Diag(DRE->getBeginLoc(), diag::ext_typecheck_convert_discards_qualifiers)
3251 << PointerArg->getType() << Context.getPointerType(AddrType)
3252 << AA_Passing << PointerArg->getSourceRange();
3253 }
3254
3255 // Finally, do the cast and replace the argument with the corrected version.
3256 AddrType = Context.getPointerType(AddrType);
3257 PointerArgRes = ImpCastExprToType(PointerArg, AddrType, CastNeeded);
3258 if (PointerArgRes.isInvalid())
3259 return true;
3260 PointerArg = PointerArgRes.get();
3261
3262 TheCall->setArg(IsLdrex ? 0 : 1, PointerArg);
3263
3264 // In general, we allow ints, floats and pointers to be loaded and stored.
3265 if (!ValType->isIntegerType() && !ValType->isAnyPointerType() &&
3266 !ValType->isBlockPointerType() && !ValType->isFloatingType()) {
3267 Diag(DRE->getBeginLoc(), diag::err_atomic_builtin_must_be_pointer_intfltptr)
3268 << PointerArg->getType() << PointerArg->getSourceRange();
3269 return true;
3270 }
3271
3272 // But ARM doesn't have instructions to deal with 128-bit versions.
3273 if (Context.getTypeSize(ValType) > MaxWidth) {
3274 assert(MaxWidth == 64 && "Diagnostic unexpectedly inaccurate");
3275 Diag(DRE->getBeginLoc(), diag::err_atomic_exclusive_builtin_pointer_size)
3276 << PointerArg->getType() << PointerArg->getSourceRange();
3277 return true;
3278 }
3279
3280 switch (ValType.getObjCLifetime()) {
3283 // okay
3284 break;
3285
3289 Diag(DRE->getBeginLoc(), diag::err_arc_atomic_ownership)
3290 << ValType << PointerArg->getSourceRange();
3291 return true;
3292 }
3293
3294 if (IsLdrex) {
3295 TheCall->setType(ValType);
3296 return false;
3297 }
3298
3299 // Initialize the argument to be stored.
3300 ExprResult ValArg = TheCall->getArg(0);
3302 Context, ValType, /*consume*/ false);
3303 ValArg = PerformCopyInitialization(Entity, SourceLocation(), ValArg);
3304 if (ValArg.isInvalid())
3305 return true;
3306 TheCall->setArg(0, ValArg.get());
3307
3308 // __builtin_arm_strex always returns an int. It's marked as such in the .def,
3309 // but the custom checker bypasses all default analysis.
3310 TheCall->setType(Context.IntTy);
3311 return false;
3312}
3313
3314bool Sema::CheckARMBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
3315 CallExpr *TheCall) {
3316 if (BuiltinID == ARM::BI__builtin_arm_ldrex ||
3317 BuiltinID == ARM::BI__builtin_arm_ldaex ||
3318 BuiltinID == ARM::BI__builtin_arm_strex ||
3319 BuiltinID == ARM::BI__builtin_arm_stlex) {
3320 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 64);
3321 }
3322
3323 if (BuiltinID == ARM::BI__builtin_arm_prefetch) {
3324 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3325 SemaBuiltinConstantArgRange(TheCall, 2, 0, 1);
3326 }
3327
3328 if (BuiltinID == ARM::BI__builtin_arm_rsr64 ||
3329 BuiltinID == ARM::BI__builtin_arm_wsr64)
3330 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 3, false);
3331
3332 if (BuiltinID == ARM::BI__builtin_arm_rsr ||
3333 BuiltinID == ARM::BI__builtin_arm_rsrp ||
3334 BuiltinID == ARM::BI__builtin_arm_wsr ||
3335 BuiltinID == ARM::BI__builtin_arm_wsrp)
3336 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true);
3337
3338 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
3339 return true;
3340 if (CheckMVEBuiltinFunctionCall(BuiltinID, TheCall))
3341 return true;
3342 if (CheckCDEBuiltinFunctionCall(TI, BuiltinID, TheCall))
3343 return true;
3344
3345 // For intrinsics which take an immediate value as part of the instruction,
3346 // range check them here.
3347 // FIXME: VFP Intrinsics should error if VFP not present.
3348 switch (BuiltinID) {
3349 default: return false;
3350 case ARM::BI__builtin_arm_ssat:
3351 return SemaBuiltinConstantArgRange(TheCall, 1, 1, 32);
3352 case ARM::BI__builtin_arm_usat:
3353 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
3354 case ARM::BI__builtin_arm_ssat16:
3355 return SemaBuiltinConstantArgRange(TheCall, 1, 1, 16);
3356 case ARM::BI__builtin_arm_usat16:
3357 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
3358 case ARM::BI__builtin_arm_vcvtr_f:
3359 case ARM::BI__builtin_arm_vcvtr_d:
3360 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
3361 case ARM::BI__builtin_arm_dmb:
3362 case ARM::BI__builtin_arm_dsb:
3363 case ARM::BI__builtin_arm_isb:
3364 case ARM::BI__builtin_arm_dbg:
3365 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 15);
3366 case ARM::BI__builtin_arm_cdp:
3367 case ARM::BI__builtin_arm_cdp2:
3368 case ARM::BI__builtin_arm_mcr:
3369 case ARM::BI__builtin_arm_mcr2:
3370 case ARM::BI__builtin_arm_mrc:
3371 case ARM::BI__builtin_arm_mrc2:
3372 case ARM::BI__builtin_arm_mcrr:
3373 case ARM::BI__builtin_arm_mcrr2:
3374 case ARM::BI__builtin_arm_mrrc:
3375 case ARM::BI__builtin_arm_mrrc2:
3376 case ARM::BI__builtin_arm_ldc:
3377 case ARM::BI__builtin_arm_ldcl:
3378 case ARM::BI__builtin_arm_ldc2:
3379 case ARM::BI__builtin_arm_ldc2l:
3380 case ARM::BI__builtin_arm_stc:
3381 case ARM::BI__builtin_arm_stcl:
3382 case ARM::BI__builtin_arm_stc2:
3383 case ARM::BI__builtin_arm_stc2l:
3384 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 15) ||
3385 CheckARMCoprocessorImmediate(TI, TheCall->getArg(0),
3386 /*WantCDE*/ false);
3387 }
3388}
3389
3390bool Sema::CheckAArch64BuiltinFunctionCall(const TargetInfo &TI,
3391 unsigned BuiltinID,
3392 CallExpr *TheCall) {
3393 if (BuiltinID == AArch64::BI__builtin_arm_ldrex ||
3394 BuiltinID == AArch64::BI__builtin_arm_ldaex ||
3395 BuiltinID == AArch64::BI__builtin_arm_strex ||
3396 BuiltinID == AArch64::BI__builtin_arm_stlex) {
3397 return CheckARMBuiltinExclusiveCall(BuiltinID, TheCall, 128);
3398 }
3399
3400 if (BuiltinID == AArch64::BI__builtin_arm_prefetch) {
3401 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
3402 SemaBuiltinConstantArgRange(TheCall, 2, 0, 3) ||
3403 SemaBuiltinConstantArgRange(TheCall, 3, 0, 1) ||
3404 SemaBuiltinConstantArgRange(TheCall, 4, 0, 1);
3405 }
3406
3407 if (BuiltinID == AArch64::BI__builtin_arm_rsr64 ||
3408 BuiltinID == AArch64::BI__builtin_arm_wsr64 ||
3409 BuiltinID == AArch64::BI__builtin_arm_rsr128 ||
3410 BuiltinID == AArch64::BI__builtin_arm_wsr128)
3411 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true);
3412
3413 // Memory Tagging Extensions (MTE) Intrinsics
3414 if (BuiltinID == AArch64::BI__builtin_arm_irg ||
3415 BuiltinID == AArch64::BI__builtin_arm_addg ||
3416 BuiltinID == AArch64::BI__builtin_arm_gmi ||
3417 BuiltinID == AArch64::BI__builtin_arm_ldg ||
3418 BuiltinID == AArch64::BI__builtin_arm_stg ||
3419 BuiltinID == AArch64::BI__builtin_arm_subp) {
3420 return SemaBuiltinARMMemoryTaggingCall(BuiltinID, TheCall);
3421 }
3422
3423 if (BuiltinID == AArch64::BI__builtin_arm_rsr ||
3424 BuiltinID == AArch64::BI__builtin_arm_rsrp ||
3425 BuiltinID == AArch64::BI__builtin_arm_wsr ||
3426 BuiltinID == AArch64::BI__builtin_arm_wsrp)
3427 return SemaBuiltinARMSpecialReg(BuiltinID, TheCall, 0, 5, true);
3428
3429 // Only check the valid encoding range. Any constant in this range would be
3430 // converted to a register of the form S1_2_C3_C4_5. Let the hardware throw
3431 // an exception for incorrect registers. This matches MSVC behavior.
3432 if (BuiltinID == AArch64::BI_ReadStatusReg ||
3433 BuiltinID == AArch64::BI_WriteStatusReg)
3434 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 0x7fff);
3435
3436 if (BuiltinID == AArch64::BI__getReg)
3437 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);
3438
3439 if (BuiltinID == AArch64::BI__break)
3440 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 0xffff);
3441
3442 if (CheckNeonBuiltinFunctionCall(TI, BuiltinID, TheCall))
3443 return true;
3444
3445 if (CheckSVEBuiltinFunctionCall(BuiltinID, TheCall))
3446 return true;
3447
3448 // For intrinsics which take an immediate value as part of the instruction,
3449 // range check them here.
3450 unsigned i = 0, l = 0, u = 0;
3451 switch (BuiltinID) {
3452 default: return false;
3453 case AArch64::BI__builtin_arm_dmb:
3454 case AArch64::BI__builtin_arm_dsb:
3455 case AArch64::BI__builtin_arm_isb: l = 0; u = 15; break;
3456 case AArch64::BI__builtin_arm_tcancel: l = 0; u = 65535; break;
3457 }
3458
3459 return SemaBuiltinConstantArgRange(TheCall, i, l, u + l);
3460}
3461
3463 if (Arg->getType()->getAsPlaceholderType())
3464 return false;
3465
3466 // The first argument needs to be a record field access.
3467 // If it is an array element access, we delay decision
3468 // to BPF backend to check whether the access is a
3469 // field access or not.
3470 return (Arg->IgnoreParens()->getObjectKind() == OK_BitField ||
3471 isa<MemberExpr>(Arg->IgnoreParens()) ||
3472 isa<ArraySubscriptExpr>(Arg->IgnoreParens()));
3473}
3474
3476 QualType ArgType = Arg->getType();
3477 if (ArgType->getAsPlaceholderType())
3478 return false;
3479
3480 // for TYPE_EXISTENCE/TYPE_MATCH/TYPE_SIZEOF reloc type
3481 // format:
3482 // 1. __builtin_preserve_type_info(*(<type> *)0, flag);
3483 // 2. <type> var;
3484 // __builtin_preserve_type_info(var, flag);
3485 if (!isa<DeclRefExpr>(Arg->IgnoreParens()) &&
3486 !isa<UnaryOperator>(Arg->IgnoreParens()))
3487 return false;
3488
3489 // Typedef type.
3490 if (ArgType->getAs<TypedefType>())
3491 return true;
3492
3493 // Record type or Enum type.
3494 const Type *Ty = ArgType->getUnqualifiedDesugaredType();
3495 if (const auto *RT = Ty->getAs<RecordType>()) {
3496 if (!RT->getDecl()->getDeclName().isEmpty())
3497 return true;
3498 } else if (const auto *ET = Ty->getAs<EnumType>()) {
3499 if (!ET->getDecl()->getDeclName().isEmpty())
3500 return true;
3501 }
3502
3503 return false;
3504}
3505
3507 QualType ArgType = Arg->getType();
3508 if (ArgType->getAsPlaceholderType())
3509 return false;
3510
3511 // for ENUM_VALUE_EXISTENCE/ENUM_VALUE reloc type
3512 // format:
3513 // __builtin_preserve_enum_value(*(<enum_type> *)<enum_value>,
3514 // flag);
3515 const auto *UO = dyn_cast<UnaryOperator>(Arg->IgnoreParens());
3516 if (!UO)
3517 return false;
3518
3519 const auto *CE = dyn_cast<CStyleCastExpr>(UO->getSubExpr());
3520 if (!CE)
3521 return false;
3522 if (CE->getCastKind() != CK_IntegralToPointer &&
3523 CE->getCastKind() != CK_NullToPointer)
3524 return false;
3525
3526 // The integer must be from an EnumConstantDecl.
3527 const auto *DR = dyn_cast<DeclRefExpr>(CE->getSubExpr());
3528 if (!DR)
3529 return false;
3530
3531 const EnumConstantDecl *Enumerator =
3532 dyn_cast<EnumConstantDecl>(DR->getDecl());
3533 if (!Enumerator)
3534 return false;
3535
3536 // The type must be EnumType.
3537 const Type *Ty = ArgType->getUnqualifiedDesugaredType();
3538 const auto *ET = Ty->getAs<EnumType>();
3539 if (!ET)
3540 return false;
3541
3542 // The enum value must be supported.
3543 return llvm::is_contained(ET->getDecl()->enumerators(), Enumerator);
3544}
3545
3546bool Sema::CheckBPFBuiltinFunctionCall(unsigned BuiltinID,
3547 CallExpr *TheCall) {
3548 assert((BuiltinID == BPF::BI__builtin_preserve_field_info ||
3549 BuiltinID == BPF::BI__builtin_btf_type_id ||
3550 BuiltinID == BPF::BI__builtin_preserve_type_info ||
3551 BuiltinID == BPF::BI__builtin_preserve_enum_value) &&
3552 "unexpected BPF builtin");
3553
3554 if (checkArgCount(*this, TheCall, 2))
3555 return true;
3556
3557 // The second argument needs to be a constant int
3558 Expr *Arg = TheCall->getArg(1);
3559 std::optional<llvm::APSInt> Value = Arg->getIntegerConstantExpr(Context);
3561 if (!Value) {
3562 if (BuiltinID == BPF::BI__builtin_preserve_field_info)
3563 kind = diag::err_preserve_field_info_not_const;
3564 else if (BuiltinID == BPF::BI__builtin_btf_type_id)
3565 kind = diag::err_btf_type_id_not_const;
3566 else if (BuiltinID == BPF::BI__builtin_preserve_type_info)
3567 kind = diag::err_preserve_type_info_not_const;
3568 else
3569 kind = diag::err_preserve_enum_value_not_const;
3570 Diag(Arg->getBeginLoc(), kind) << 2 << Arg->getSourceRange();
3571 return true;
3572 }
3573
3574 // The first argument
3575 Arg = TheCall->getArg(0);
3576 bool InvalidArg = false;
3577 bool ReturnUnsignedInt = true;
3578 if (BuiltinID == BPF::BI__builtin_preserve_field_info) {
3580 InvalidArg = true;
3581 kind = diag::err_preserve_field_info_not_field;
3582 }
3583 } else if (BuiltinID == BPF::BI__builtin_preserve_type_info) {
3585 InvalidArg = true;
3586 kind = diag::err_preserve_type_info_invalid;
3587 }
3588 } else if (BuiltinID == BPF::BI__builtin_preserve_enum_value) {
3590 InvalidArg = true;
3591 kind = diag::err_preserve_enum_value_invalid;
3592 }
3593 ReturnUnsignedInt = false;
3594 } else if (BuiltinID == BPF::BI__builtin_btf_type_id) {
3595 ReturnUnsignedInt = false;
3596 }
3597
3598 if (InvalidArg) {
3599 Diag(Arg->getBeginLoc(), kind) << 1 << Arg->getSourceRange();
3600 return true;
3601 }
3602
3603 if (ReturnUnsignedInt)
3604 TheCall->setType(Context.UnsignedIntTy);
3605 else
3606 TheCall->setType(Context.UnsignedLongTy);
3607 return false;
3608}
3609
3610bool Sema::CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall) {
3611 struct ArgInfo {
3612 uint8_t OpNum;
3613 bool IsSigned;
3614 uint8_t BitWidth;
3615 uint8_t Align;
3616 };
3617 struct BuiltinInfo {
3618 unsigned BuiltinID;
3619 ArgInfo Infos[2];
3620 };
3621
3622 static BuiltinInfo Infos[] = {
3623 { Hexagon::BI__builtin_circ_ldd, {{ 3, true, 4, 3 }} },
3624 { Hexagon::BI__builtin_circ_ldw, {{ 3, true, 4, 2 }} },
3625 { Hexagon::BI__builtin_circ_ldh, {{ 3, true, 4, 1 }} },
3626 { Hexagon::BI__builtin_circ_lduh, {{ 3, true, 4, 1 }} },
3627 { Hexagon::BI__builtin_circ_ldb, {{ 3, true, 4, 0 }} },
3628 { Hexagon::BI__builtin_circ_ldub, {{ 3, true, 4, 0 }} },
3629 { Hexagon::BI__builtin_circ_std, {{ 3, true, 4, 3 }} },
3630 { Hexagon::BI__builtin_circ_stw, {{ 3, true, 4, 2 }} },
3631 { Hexagon::BI__builtin_circ_sth, {{ 3, true, 4, 1 }} },
3632 { Hexagon::BI__builtin_circ_sthhi, {{ 3, true, 4, 1 }} },
3633 { Hexagon::BI__builtin_circ_stb, {{ 3, true, 4, 0 }} },
3634
3635 { Hexagon::BI__builtin_HEXAGON_L2_loadrub_pci, {{ 1, true, 4, 0 }} },
3636 { Hexagon::BI__builtin_HEXAGON_L2_loadrb_pci, {{ 1, true, 4, 0 }} },
3637 { Hexagon::BI__builtin_HEXAGON_L2_loadruh_pci, {{ 1, true, 4, 1 }} },
3638 { Hexagon::BI__builtin_HEXAGON_L2_loadrh_pci, {{ 1, true, 4, 1 }} },
3639 { Hexagon::BI__builtin_HEXAGON_L2_loadri_pci, {{ 1, true, 4, 2 }} },
3640 { Hexagon::BI__builtin_HEXAGON_L2_loadrd_pci, {{ 1, true, 4, 3 }} },
3641 { Hexagon::BI__builtin_HEXAGON_S2_storerb_pci, {{ 1, true, 4, 0 }} },
3642 { Hexagon::BI__builtin_HEXAGON_S2_storerh_pci, {{ 1, true, 4, 1 }} },
3643 { Hexagon::BI__builtin_HEXAGON_S2_storerf_pci, {{ 1, true, 4, 1 }} },
3644 { Hexagon::BI__builtin_HEXAGON_S2_storeri_pci, {{ 1, true, 4, 2 }} },
3645 { Hexagon::BI__builtin_HEXAGON_S2_storerd_pci, {{ 1, true, 4, 3 }} },
3646
3647 { Hexagon::BI__builtin_HEXAGON_A2_combineii, {{ 1, true, 8, 0 }} },
3648 { Hexagon::BI__builtin_HEXAGON_A2_tfrih, {{ 1, false, 16, 0 }} },
3649 { Hexagon::BI__builtin_HEXAGON_A2_tfril, {{ 1, false, 16, 0 }} },
3650 { Hexagon::BI__builtin_HEXAGON_A2_tfrpi, {{ 0, true, 8, 0 }} },
3651 { Hexagon::BI__builtin_HEXAGON_A4_bitspliti, {{ 1, false, 5, 0 }} },
3652 { Hexagon::BI__builtin_HEXAGON_A4_cmpbeqi, {{ 1, false, 8, 0 }} },
3653 { Hexagon::BI__builtin_HEXAGON_A4_cmpbgti, {{ 1, true, 8, 0 }} },
3654 { Hexagon::BI__builtin_HEXAGON_A4_cround_ri, {{ 1, false, 5, 0 }} },
3655 { Hexagon::BI__builtin_HEXAGON_A4_round_ri, {{ 1, false, 5, 0 }} },
3656 { Hexagon::BI__builtin_HEXAGON_A4_round_ri_sat, {{ 1, false, 5, 0 }} },
3657 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbeqi, {{ 1, false, 8, 0 }} },
3658 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgti, {{ 1, true, 8, 0 }} },
3659 { Hexagon::BI__builtin_HEXAGON_A4_vcmpbgtui, {{ 1, false, 7, 0 }} },
3660 { Hexagon::BI__builtin_HEXAGON_A4_vcmpheqi, {{ 1, true, 8, 0 }} },
3661 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgti, {{ 1, true, 8, 0 }} },
3662 { Hexagon::BI__builtin_HEXAGON_A4_vcmphgtui, {{ 1, false, 7, 0 }} },
3663 { Hexagon::BI__builtin_HEXAGON_A4_vcmpweqi, {{ 1, true, 8, 0 }} },
3664 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgti, {{ 1, true, 8, 0 }} },
3665 { Hexagon::BI__builtin_HEXAGON_A4_vcmpwgtui, {{ 1, false, 7, 0 }} },
3666 { Hexagon::BI__builtin_HEXAGON_C2_bitsclri, {{ 1, false, 6, 0 }} },
3667 { Hexagon::BI__builtin_HEXAGON_C2_muxii, {{ 2, true, 8, 0 }} },
3668 { Hexagon::BI__builtin_HEXAGON_C4_nbitsclri, {{ 1, false, 6, 0 }} },
3669 { Hexagon::BI__builtin_HEXAGON_F2_dfclass, {{ 1, false, 5, 0 }} },
3670 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_n, {{ 0, false, 10, 0 }} },
3671 { Hexagon::BI__builtin_HEXAGON_F2_dfimm_p, {{ 0, false, 10, 0 }} },
3672 { Hexagon::BI__builtin_HEXAGON_F2_sfclass, {{ 1, false, 5, 0 }} },
3673 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_n, {{ 0, false, 10, 0 }} },
3674 { Hexagon::BI__builtin_HEXAGON_F2_sfimm_p, {{ 0, false, 10, 0 }} },
3675 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addi, {{ 2, false, 6, 0 }} },
3676 { Hexagon::BI__builtin_HEXAGON_M4_mpyri_addr_u2, {{ 1, false, 6, 2 }} },
3677 { Hexagon::BI__builtin_HEXAGON_S2_addasl_rrri, {{ 2, false, 3, 0 }} },
3678 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_acc, {{ 2, false, 6, 0 }} },
3679 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_and, {{ 2, false, 6, 0 }} },
3680 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p, {{ 1, false, 6, 0 }} },
3681 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_nac, {{ 2, false, 6, 0 }} },
3682 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_or, {{ 2, false, 6, 0 }} },
3683 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_p_xacc, {{ 2, false, 6, 0 }} },
3684 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_acc, {{ 2, false, 5, 0 }} },
3685 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_and, {{ 2, false, 5, 0 }} },
3686 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r, {{ 1, false, 5, 0 }} },
3687 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_nac, {{ 2, false, 5, 0 }} },
3688 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_or, {{ 2, false, 5, 0 }} },
3689 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_sat, {{ 1, false, 5, 0 }} },
3690 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_r_xacc, {{ 2, false, 5, 0 }} },
3691 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vh, {{ 1, false, 4, 0 }} },
3692 { Hexagon::BI__builtin_HEXAGON_S2_asl_i_vw, {{ 1, false, 5, 0 }} },
3693 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_acc, {{ 2, false, 6, 0 }} },
3694 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_and, {{ 2, false, 6, 0 }} },
3695 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p, {{ 1, false, 6, 0 }} },
3696 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_nac, {{ 2, false, 6, 0 }} },
3697 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_or, {{ 2, false, 6, 0 }} },
3698 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd_goodsyntax,
3699 {{ 1, false, 6, 0 }} },
3700 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_p_rnd, {{ 1, false, 6, 0 }} },
3701 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_acc, {{ 2, false, 5, 0 }} },
3702 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_and, {{ 2, false, 5, 0 }} },
3703 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r, {{ 1, false, 5, 0 }} },
3704 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_nac, {{ 2, false, 5, 0 }} },
3705 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_or, {{ 2, false, 5, 0 }} },
3706 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax,
3707 {{ 1, false, 5, 0 }} },
3708 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_r_rnd, {{ 1, false, 5, 0 }} },
3709 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_svw_trun, {{ 1, false, 5, 0 }} },
3710 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vh, {{ 1, false, 4, 0 }} },
3711 { Hexagon::BI__builtin_HEXAGON_S2_asr_i_vw, {{ 1, false, 5, 0 }} },
3712 { Hexagon::BI__builtin_HEXAGON_S2_clrbit_i, {{ 1, false, 5, 0 }} },
3713 { Hexagon::BI__builtin_HEXAGON_S2_extractu, {{ 1, false, 5, 0 },
3714 { 2, false, 5, 0 }} },
3715 { Hexagon::BI__builtin_HEXAGON_S2_extractup, {{ 1, false, 6, 0 },
3716 { 2, false, 6, 0 }} },
3717 { Hexagon::BI__builtin_HEXAGON_S2_insert, {{ 2, false, 5, 0 },
3718 { 3, false, 5, 0 }} },
3719 { Hexagon::BI__builtin_HEXAGON_S2_insertp, {{ 2, false, 6, 0 },
3720 { 3, false, 6, 0 }} },
3721 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_acc, {{ 2, false, 6, 0 }} },
3722 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_and, {{ 2, false, 6, 0 }} },
3723 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p, {{ 1, false, 6, 0 }} },
3724 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_nac, {{ 2, false, 6, 0 }} },
3725 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_or, {{ 2, false, 6, 0 }} },
3726 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_p_xacc, {{ 2, false, 6, 0 }} },
3727 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_acc, {{ 2, false, 5, 0 }} },
3728 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_and, {{ 2, false, 5, 0 }} },
3729 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r, {{ 1, false, 5, 0 }} },
3730 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_nac, {{ 2, false, 5, 0 }} },
3731 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_or, {{ 2, false, 5, 0 }} },
3732 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_r_xacc, {{ 2, false, 5, 0 }} },
3733 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vh, {{ 1, false, 4, 0 }} },
3734 { Hexagon::BI__builtin_HEXAGON_S2_lsr_i_vw, {{ 1, false, 5, 0 }} },
3735 { Hexagon::BI__builtin_HEXAGON_S2_setbit_i, {{ 1, false, 5, 0 }} },
3736 { Hexagon::BI__builtin_HEXAGON_S2_tableidxb_goodsyntax,
3737 {{ 2, false, 4, 0 },
3738 { 3, false, 5, 0 }} },
3739 { Hexagon::BI__builtin_HEXAGON_S2_tableidxd_goodsyntax,
3740 {{ 2, false, 4, 0 },
3741 { 3, false, 5, 0 }} },
3742 { Hexagon::BI__builtin_HEXAGON_S2_tableidxh_goodsyntax,
3743 {{ 2, false, 4, 0 },
3744 { 3, false, 5, 0 }} },
3745 { Hexagon::BI__builtin_HEXAGON_S2_tableidxw_goodsyntax,
3746 {{ 2, false, 4, 0 },
3747 { 3, false, 5, 0 }} },
3748 { Hexagon::BI__builtin_HEXAGON_S2_togglebit_i, {{ 1, false, 5, 0 }} },
3749 { Hexagon::BI__builtin_HEXAGON_S2_tstbit_i, {{ 1, false, 5, 0 }} },
3750 { Hexagon::BI__builtin_HEXAGON_S2_valignib, {{ 2, false, 3, 0 }} },
3751 { Hexagon::BI__builtin_HEXAGON_S2_vspliceib, {{ 2, false, 3, 0 }} },
3752 { Hexagon::BI__builtin_HEXAGON_S4_addi_asl_ri, {{ 2, false, 5, 0 }} },
3753 { Hexagon::BI__builtin_HEXAGON_S4_addi_lsr_ri, {{ 2, false, 5, 0 }} },
3754 { Hexagon::BI__builtin_HEXAGON_S4_andi_asl_ri, {{ 2, false, 5, 0 }} },
3755 { Hexagon::BI__builtin_HEXAGON_S4_andi_lsr_ri, {{ 2, false, 5, 0 }} },
3756 { Hexagon::BI__builtin_HEXAGON_S4_clbaddi, {{ 1, true , 6, 0 }} },
3757 { Hexagon::BI__builtin_HEXAGON_S4_clbpaddi, {{ 1, true, 6, 0 }} },
3758 { Hexagon::BI__builtin_HEXAGON_S4_extract, {{ 1, false, 5, 0 },
3759 { 2, false, 5, 0 }} },
3760 { Hexagon::BI__builtin_HEXAGON_S4_extractp, {{ 1, false, 6, 0 },
3761 { 2, false, 6, 0 }} },
3762 { Hexagon::BI__builtin_HEXAGON_S4_lsli, {{ 0, true, 6, 0 }} },
3763 { Hexagon::BI__builtin_HEXAGON_S4_ntstbit_i, {{ 1, false, 5, 0 }} },
3764 { Hexagon::BI__builtin_HEXAGON_S4_ori_asl_ri, {{ 2, false, 5, 0 }} },
3765 { Hexagon::BI__builtin_HEXAGON_S4_ori_lsr_ri, {{ 2, false, 5, 0 }} },
3766 { Hexagon::BI__builtin_HEXAGON_S4_subi_asl_ri, {{ 2, false, 5, 0 }} },
3767 { Hexagon::BI__builtin_HEXAGON_S4_subi_lsr_ri, {{ 2, false, 5, 0 }} },
3768 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate_acc, {{ 3, false, 2, 0 }} },
3769 { Hexagon::BI__builtin_HEXAGON_S4_vrcrotate, {{ 2, false, 2, 0 }} },
3770 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_rnd_sat_goodsyntax,
3771 {{ 1, false, 4, 0 }} },
3772 { Hexagon::BI__builtin_HEXAGON_S5_asrhub_sat, {{ 1, false, 4, 0 }} },
3773 { Hexagon::BI__builtin_HEXAGON_S5_vasrhrnd_goodsyntax,
3774 {{ 1, false, 4, 0 }} },
3775 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p, {{ 1, false, 6, 0 }} },
3776 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_acc, {{ 2, false, 6, 0 }} },
3777 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_and, {{ 2, false, 6, 0 }} },
3778 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_nac, {{ 2, false, 6, 0 }} },
3779 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_or, {{ 2, false, 6, 0 }} },
3780 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_p_xacc, {{ 2, false, 6, 0 }} },
3781 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r, {{ 1, false, 5, 0 }} },
3782 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_acc, {{ 2, false, 5, 0 }} },
3783 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_and, {{ 2, false, 5, 0 }} },
3784 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_nac, {{ 2, false, 5, 0 }} },
3785 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_or, {{ 2, false, 5, 0 }} },
3786 { Hexagon::BI__builtin_HEXAGON_S6_rol_i_r_xacc, {{ 2, false, 5, 0 }} },
3787 { Hexagon::BI__builtin_HEXAGON_V6_valignbi, {{ 2, false, 3, 0 }} },
3788 { Hexagon::BI__builtin_HEXAGON_V6_valignbi_128B, {{ 2, false, 3, 0 }} },
3789 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi, {{ 2, false, 3, 0 }} },
3790 { Hexagon::BI__builtin_HEXAGON_V6_vlalignbi_128B, {{ 2, false, 3, 0 }} },
3791 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi, {{ 2, false, 1, 0 }} },
3792 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_128B, {{ 2, false, 1, 0 }} },
3793 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc, {{ 3, false, 1, 0 }} },
3794 { Hexagon::BI__builtin_HEXAGON_V6_vrmpybusi_acc_128B,
3795 {{ 3, false, 1, 0 }} },
3796 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi, {{ 2, false, 1, 0 }} },
3797 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_128B, {{ 2, false, 1, 0 }} },
3798 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc, {{ 3, false, 1, 0 }} },
3799 { Hexagon::BI__builtin_HEXAGON_V6_vrmpyubi_acc_128B,
3800 {{ 3, false, 1, 0 }} },
3801 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi, {{ 2, false, 1, 0 }} },
3802 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_128B, {{ 2, false, 1, 0 }} },
3803 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc, {{ 3, false, 1, 0 }} },
3804 { Hexagon::BI__builtin_HEXAGON_V6_vrsadubi_acc_128B,
3805 {{ 3, false, 1, 0 }} },
3806
3807 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10, {{ 2, false, 2, 0 }} },
3808 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_128B,
3809 {{ 2, false, 2, 0 }} },
3810 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx,
3811 {{ 3, false, 2, 0 }} },
3812 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyhubs10_vxx_128B,
3813 {{ 3, false, 2, 0 }} },
3814 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10, {{ 2, false, 2, 0 }} },
3815 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_128B,
3816 {{ 2, false, 2, 0 }} },
3817 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx,
3818 {{ 3, false, 2, 0 }} },
3819 { Hexagon::BI__builtin_HEXAGON_V6_v6mpyvubs10_vxx_128B,
3820 {{ 3, false, 2, 0 }} },
3821 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi, {{ 2, false, 3, 0 }} },
3822 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvbi_128B, {{ 2, false, 3, 0 }} },
3823 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci, {{ 3, false, 3, 0 }} },
3824 { Hexagon::BI__builtin_HEXAGON_V6_vlutvvb_oracci_128B,
3825 {{ 3, false, 3, 0 }} },
3826 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi, {{ 2, false, 3, 0 }} },
3827 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwhi_128B, {{ 2, false, 3, 0 }} },
3828 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci, {{ 3, false, 3, 0 }} },
3829 { Hexagon::BI__builtin_HEXAGON_V6_vlutvwh_oracci_128B,
3830 {{ 3, false, 3, 0 }} },
3831 };
3832
3833 // Use a dynamically initialized static to sort the table exactly once on
3834 // first run.
3835 static const bool SortOnce =
3836 (llvm::sort(Infos,
3837 [](const BuiltinInfo &LHS, const BuiltinInfo &RHS) {
3838 return LHS.BuiltinID < RHS.BuiltinID;
3839 }),
3840 true);
3841 (void)SortOnce;
3842
3843 const BuiltinInfo *F = llvm::partition_point(
3844 Infos, [=](const BuiltinInfo &BI) { return BI.BuiltinID < BuiltinID; });
3845 if (F == std::end(Infos) || F->BuiltinID != BuiltinID)
3846 return false;
3847
3848 bool Error = false;
3849
3850 for (const ArgInfo &A : F->Infos) {
3851 // Ignore empty ArgInfo elements.
3852 if (A.BitWidth == 0)
3853 continue;
3854
3855 int32_t Min = A.IsSigned ? -(1 << (A.BitWidth - 1)) : 0;
3856 int32_t Max = (1 << (A.IsSigned ? A.BitWidth - 1 : A.BitWidth)) - 1;
3857 if (!A.Align) {
3858 Error |= SemaBuiltinConstantArgRange(TheCall, A.OpNum, Min, Max);
3859 } else {
3860 unsigned M = 1 << A.Align;
3861 Min *= M;
3862 Max *= M;
3863 Error |= SemaBuiltinConstantArgRange(TheCall, A.OpNum, Min, Max);
3864 Error |= SemaBuiltinConstantArgMultiple(TheCall, A.OpNum, M);
3865 }
3866 }
3867 return Error;
3868}
3869
3870bool Sema::CheckHexagonBuiltinFunctionCall(unsigned BuiltinID,
3871 CallExpr *TheCall) {
3872 return CheckHexagonBuiltinArgument(BuiltinID, TheCall);
3873}
3874
3875bool Sema::CheckLoongArchBuiltinFunctionCall(const TargetInfo &TI,
3876 unsigned BuiltinID,
3877 CallExpr *TheCall) {
3878 switch (BuiltinID) {
3879 default:
3880 break;
3881 case LoongArch::BI__builtin_loongarch_cacop_d:
3882 case LoongArch::BI__builtin_loongarch_cacop_w: {
3883 SemaBuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(5));
3884 SemaBuiltinConstantArgRange(TheCall, 2, llvm::minIntN(12),
3885 llvm::maxIntN(12));
3886 break;
3887 }
3888 case LoongArch::BI__builtin_loongarch_break:
3889 case LoongArch::BI__builtin_loongarch_dbar:
3890 case LoongArch::BI__builtin_loongarch_ibar:
3891 case LoongArch::BI__builtin_loongarch_syscall:
3892 // Check if immediate is in [0, 32767].
3893 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 32767);
3894 case LoongArch::BI__builtin_loongarch_csrrd_w:
3895 case LoongArch::BI__builtin_loongarch_csrrd_d:
3896 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 16383);
3897 case LoongArch::BI__builtin_loongarch_csrwr_w:
3898 case LoongArch::BI__builtin_loongarch_csrwr_d:
3899 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 16383);
3900 case LoongArch::BI__builtin_loongarch_csrxchg_w:
3901 case LoongArch::BI__builtin_loongarch_csrxchg_d:
3902 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 16383);
3903 case LoongArch::BI__builtin_loongarch_lddir_d:
3904 case LoongArch::BI__builtin_loongarch_ldpte_d:
3905 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
3906 case LoongArch::BI__builtin_loongarch_movfcsr2gr:
3907 case LoongArch::BI__builtin_loongarch_movgr2fcsr:
3908 return SemaBuiltinConstantArgRange(TheCall, 0, 0, llvm::maxUIntN(2));
3909 }
3910
3911 return false;
3912}
3913
3914bool Sema::CheckMipsBuiltinFunctionCall(const TargetInfo &TI,
3915 unsigned BuiltinID, CallExpr *TheCall) {
3916 return CheckMipsBuiltinCpu(TI, BuiltinID, TheCall) ||
3917 CheckMipsBuiltinArgument(BuiltinID, TheCall);
3918}
3919
3920bool Sema::CheckMipsBuiltinCpu(const TargetInfo &TI, unsigned BuiltinID,
3921 CallExpr *TheCall) {
3922
3923 if (Mips::BI__builtin_mips_addu_qb <= BuiltinID &&
3924 BuiltinID <= Mips::BI__builtin_mips_lwx) {
3925 if (!TI.hasFeature("dsp"))
3926 return Diag(TheCall->getBeginLoc(), diag::err_mips_builtin_requires_dsp);
3927 }
3928
3929 if (Mips::BI__builtin_mips_absq_s_qb <= BuiltinID &&
3930 BuiltinID <= Mips::BI__builtin_mips_subuh_r_qb) {
3931 if (!TI.hasFeature("dspr2"))
3932 return Diag(TheCall->getBeginLoc(),
3933 diag::err_mips_builtin_requires_dspr2);
3934 }
3935
3936 if (Mips::BI__builtin_msa_add_a_b <= BuiltinID &&
3937 BuiltinID <= Mips::BI__builtin_msa_xori_b) {
3938 if (!TI.hasFeature("msa"))
3939 return Diag(TheCall->getBeginLoc(), diag::err_mips_builtin_requires_msa);
3940 }
3941
3942 return false;
3943}
3944
3945// CheckMipsBuiltinArgument - Checks the constant value passed to the
3946// intrinsic is correct. The switch statement is ordered by DSP, MSA. The
3947// ordering for DSP is unspecified. MSA is ordered by the data format used
3948// by the underlying instruction i.e., df/m, df/n and then by size.
3949//
3950// FIXME: The size tests here should instead be tablegen'd along with the
3951// definitions from include/clang/Basic/BuiltinsMips.def.
3952// FIXME: GCC is strict on signedness for some of these intrinsics, we should
3953// be too.
3954bool Sema::CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall) {
3955 unsigned i = 0, l = 0, u = 0, m = 0;
3956 switch (BuiltinID) {
3957 default: return false;
3958 case Mips::BI__builtin_mips_wrdsp: i = 1; l = 0; u = 63; break;
3959 case Mips::BI__builtin_mips_rddsp: i = 0; l = 0; u = 63; break;
3960 case Mips::BI__builtin_mips_append: i = 2; l = 0; u = 31; break;
3961 case Mips::BI__builtin_mips_balign: i = 2; l = 0; u = 3; break;
3962 case Mips::BI__builtin_mips_precr_sra_ph_w: i = 2; l = 0; u = 31; break;
3963 case Mips::BI__builtin_mips_precr_sra_r_ph_w: i = 2; l = 0; u = 31; break;
3964 case Mips::BI__builtin_mips_prepend: i = 2; l = 0; u = 31; break;
3965 // MSA intrinsics. Instructions (which the intrinsics maps to) which use the
3966 // df/m field.
3967 // These intrinsics take an unsigned 3 bit immediate.
3968 case Mips::BI__builtin_msa_bclri_b:
3969 case Mips::BI__builtin_msa_bnegi_b:
3970 case Mips::BI__builtin_msa_bseti_b:
3971 case Mips::BI__builtin_msa_sat_s_b:
3972 case Mips::BI__builtin_msa_sat_u_b:
3973 case Mips::BI__builtin_msa_slli_b:
3974 case Mips::BI__builtin_msa_srai_b:
3975 case Mips::BI__builtin_msa_srari_b:
3976 case Mips::BI__builtin_msa_srli_b:
3977 case Mips::BI__builtin_msa_srlri_b: i = 1; l = 0; u = 7; break;
3978 case Mips::BI__builtin_msa_binsli_b:
3979 case Mips::BI__builtin_msa_binsri_b: i = 2; l = 0; u = 7; break;
3980 // These intrinsics take an unsigned 4 bit immediate.
3981 case Mips::BI__builtin_msa_bclri_h:
3982 case Mips::BI__builtin_msa_bnegi_h:
3983 case Mips::BI__builtin_msa_bseti_h:
3984 case Mips::BI__builtin_msa_sat_s_h:
3985 case Mips::BI__builtin_msa_sat_u_h:
3986 case Mips::BI__builtin_msa_slli_h:
3987 case Mips::BI__builtin_msa_srai_h:
3988 case Mips::BI__builtin_msa_srari_h:
3989 case Mips::BI__builtin_msa_srli_h:
3990 case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15; break;
3991 case Mips::BI__builtin_msa_binsli_h:
3992 case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15; break;
3993 // These intrinsics take an unsigned 5 bit immediate.
3994 // The first block of intrinsics actually have an unsigned 5 bit field,
3995 // not a df/n field.
3996 case Mips::BI__builtin_msa_cfcmsa:
3997 case Mips::BI__builtin_msa_ctcmsa: i = 0; l = 0; u = 31; break;
3998 case Mips::BI__builtin_msa_clei_u_b:
3999 case Mips::BI__builtin_msa_clei_u_h:
4000 case Mips::BI__builtin_msa_clei_u_w:
4001 case Mips::BI__builtin_msa_clei_u_d:
4002 case Mips::BI__builtin_msa_clti_u_b:
4003 case Mips::BI__builtin_msa_clti_u_h:
4004 case Mips::BI__builtin_msa_clti_u_w:
4005 case Mips::BI__builtin_msa_clti_u_d:
4006 case Mips::BI__builtin_msa_maxi_u_b:
4007 case Mips::BI__builtin_msa_maxi_u_h:
4008 case Mips::BI__builtin_msa_maxi_u_w:
4009 case Mips::BI__builtin_msa_maxi_u_d:
4010 case Mips::BI__builtin_msa_mini_u_b:
4011 case Mips::BI__builtin_msa_mini_u_h:
4012 case Mips::BI__builtin_msa_mini_u_w:
4013 case Mips::BI__builtin_msa_mini_u_d:
4014 case Mips::BI__builtin_msa_addvi_b:
4015 case Mips::BI__builtin_msa_addvi_h:
4016 case Mips::BI__builtin_msa_addvi_w:
4017 case Mips::BI__builtin_msa_addvi_d:
4018 case Mips::BI__builtin_msa_bclri_w:
4019 case Mips::BI__builtin_msa_bnegi_w:
4020 case Mips::BI__builtin_msa_bseti_w:
4021 case Mips::BI__builtin_msa_sat_s_w:
4022 case Mips::BI__builtin_msa_sat_u_w:
4023 case Mips::BI__builtin_msa_slli_w:
4024 case Mips::BI__builtin_msa_srai_w:
4025 case Mips::BI__builtin_msa_srari_w:
4026 case Mips::BI__builtin_msa_srli_w:
4027 case Mips::BI__builtin_msa_srlri_w:
4028 case Mips::BI__builtin_msa_subvi_b:
4029 case Mips::BI__builtin_msa_subvi_h:
4030 case Mips::BI__builtin_msa_subvi_w:
4031 case Mips::BI__builtin_msa_subvi_d: i = 1; l = 0; u = 31; break;
4032 case Mips::BI__builtin_msa_binsli_w:
4033 case Mips::BI__builtin_msa_binsri_w: i = 2; l = 0; u = 31; break;
4034 // These intrinsics take an unsigned 6 bit immediate.
4035 case Mips::BI__builtin_msa_bclri_d:
4036 case Mips::BI__builtin_msa_bnegi_d:
4037 case Mips::BI__builtin_msa_bseti_d:
4038 case Mips::BI__builtin_msa_sat_s_d:
4039 case Mips::BI__builtin_msa_sat_u_d:
4040 case Mips::BI__builtin_msa_slli_d:
4041 case Mips::BI__builtin_msa_srai_d:
4042 case Mips::BI__builtin_msa_srari_d:
4043 case Mips::BI__builtin_msa_srli_d:
4044 case Mips::BI__builtin_msa_srlri_d: i = 1; l = 0; u = 63; break;
4045 case Mips::BI__builtin_msa_binsli_d:
4046 case Mips::BI__builtin_msa_binsri_d: i = 2; l = 0; u = 63; break;
4047 // These intrinsics take a signed 5 bit immediate.
4048 case Mips::BI__builtin_msa_ceqi_b:
4049 case Mips::BI__builtin_msa_ceqi_h:
4050 case Mips::BI__builtin_msa_ceqi_w:
4051 case Mips::BI__builtin_msa_ceqi_d:
4052 case Mips::BI__builtin_msa_clti_s_b:
4053 case Mips::BI__builtin_msa_clti_s_h:
4054 case Mips::BI__builtin_msa_clti_s_w:
4055 case Mips::BI__builtin_msa_clti_s_d:
4056 case Mips::BI__builtin_msa_clei_s_b:
4057 case Mips::BI__builtin_msa_clei_s_h:
4058 case Mips::BI__builtin_msa_clei_s_w:
4059 case Mips::BI__builtin_msa_clei_s_d:
4060 case Mips::BI__builtin_msa_maxi_s_b:
4061 case Mips::BI__builtin_msa_maxi_s_h:
4062 case Mips::BI__builtin_msa_maxi_s_w:
4063 case Mips::BI__builtin_msa_maxi_s_d:
4064 case Mips::BI__builtin_msa_mini_s_b:
4065 case Mips::BI__builtin_msa_mini_s_h:
4066 case Mips::BI__builtin_msa_mini_s_w:
4067 case Mips::BI__builtin_msa_mini_s_d: i = 1; l = -16; u = 15; break;
4068 // These intrinsics take an unsigned 8 bit immediate.
4069 case Mips::BI__builtin_msa_andi_b:
4070 case Mips::BI__builtin_msa_nori_b:
4071 case Mips::BI__builtin_msa_ori_b:
4072 case Mips::BI__builtin_msa_shf_b:
4073 case Mips::BI__builtin_msa_shf_h:
4074 case Mips::BI__builtin_msa_shf_w:
4075 case Mips::BI__builtin_msa_xori_b: i = 1; l = 0; u = 255; break;
4076 case Mips::BI__builtin_msa_bseli_b:
4077 case Mips::BI__builtin_msa_bmnzi_b:
4078 case Mips::BI__builtin_msa_bmzi_b: i = 2; l = 0; u = 255; break;
4079 // df/n format
4080 // These intrinsics take an unsigned 4 bit immediate.
4081 case Mips::BI__builtin_msa_copy_s_b:
4082 case Mips::BI__builtin_msa_copy_u_b:
4083 case Mips::BI__builtin_msa_insve_b:
4084 case Mips::BI__builtin_msa_splati_b: i = 1; l = 0; u = 15; break;
4085 case Mips::BI__builtin_msa_sldi_b: i = 2; l = 0; u = 15; break;
4086 // These intrinsics take an unsigned 3 bit immediate.
4087 case Mips::BI__builtin_msa_copy_s_h:
4088 case Mips::BI__builtin_msa_copy_u_h:
4089 case Mips::BI__builtin_msa_insve_h:
4090 case Mips::BI__builtin_msa_splati_h: i = 1; l = 0; u = 7; break;
4091 case Mips::BI__builtin_msa_sldi_h: i = 2; l = 0; u = 7; break;
4092 // These intrinsics take an unsigned 2 bit immediate.
4093 case Mips::BI__builtin_msa_copy_s_w:
4094 case Mips::BI__builtin_msa_copy_u_w:
4095 case Mips::BI__builtin_msa_insve_w:
4096 case Mips::BI__builtin_msa_splati_w: i = 1; l = 0; u = 3; break;
4097 case Mips::BI__builtin_msa_sldi_w: i = 2; l = 0; u = 3; break;
4098 // These intrinsics take an unsigned 1 bit immediate.
4099 case Mips::BI__builtin_msa_copy_s_d:
4100 case Mips::BI__builtin_msa_copy_u_d:
4101 case Mips::BI__builtin_msa_insve_d:
4102 case Mips::BI__builtin_msa_splati_d: i = 1; l = 0; u = 1; break;
4103 case Mips::BI__builtin_msa_sldi_d: i = 2; l = 0; u = 1; break;
4104 // Memory offsets and immediate loads.
4105 // These intrinsics take a signed 10 bit immediate.
4106 case Mips::BI__builtin_msa_ldi_b: i = 0; l = -128; u = 255; break;
4107 case Mips::BI__builtin_msa_ldi_h:
4108 case Mips::BI__builtin_msa_ldi_w:
4109 case Mips::BI__builtin_msa_ldi_d: i = 0; l = -512; u = 511; break;
4110 case Mips::BI__builtin_msa_ld_b: i = 1; l = -512; u = 511; m = 1; break;
4111 case Mips::BI__builtin_msa_ld_h: i = 1; l = -1024; u = 1022; m = 2; break;
4112 case Mips::BI__builtin_msa_ld_w: i = 1; l = -2048; u = 2044; m = 4; break;
4113 case Mips::BI__builtin_msa_ld_d: i = 1; l = -4096; u = 4088; m = 8; break;
4114 case Mips::BI__builtin_msa_ldr_d: i = 1; l = -4096; u = 4088; m = 8; break;
4115 case Mips::BI__builtin_msa_ldr_w: i = 1; l = -2048; u = 2044; m = 4; break;
4116 case Mips::BI__builtin_msa_st_b: i = 2; l = -512; u = 511; m = 1; break;
4117 case Mips::BI__builtin_msa_st_h: i = 2; l = -1024; u = 1022; m = 2; break;
4118 case Mips::BI__builtin_msa_st_w: i = 2; l = -2048; u = 2044; m = 4; break;
4119 case Mips::BI__builtin_msa_st_d: i = 2; l = -4096; u = 4088; m = 8; break;
4120 case Mips::BI__builtin_msa_str_d: i = 2; l = -4096; u = 4088; m = 8; break;
4121 case Mips::BI__builtin_msa_str_w: i = 2; l = -2048; u = 2044; m = 4; break;
4122 }
4123
4124 if (!m)
4125 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
4126
4127 return SemaBuiltinConstantArgRange(TheCall, i, l, u) ||
4128 SemaBuiltinConstantArgMultiple(TheCall, i, m);
4129}
4130
4131/// DecodePPCMMATypeFromStr - This decodes one PPC MMA type descriptor from Str,
4132/// advancing the pointer over the consumed characters. The decoded type is
4133/// returned. If the decoded type represents a constant integer with a
4134/// constraint on its value then Mask is set to that value. The type descriptors
4135/// used in Str are specific to PPC MMA builtins and are documented in the file
4136/// defining the PPC builtins.
4137static QualType DecodePPCMMATypeFromStr(ASTContext &Context, const char *&Str,
4138 unsigned &Mask) {
4139 bool RequireICE = false;
4141 switch (*Str++) {
4142 case 'V':
4143 return Context.getVectorType(Context.UnsignedCharTy, 16,
4145 case 'i': {
4146 char *End;
4147 unsigned size = strtoul(Str, &End, 10);
4148 assert(End != Str && "Missing constant parameter constraint");
4149 Str = End;
4150 Mask = size;
4151 return Context.IntTy;
4152 }
4153 case 'W': {
4154 char *End;
4155 unsigned size = strtoul(Str, &End, 10);
4156 assert(End != Str && "Missing PowerPC MMA type size");
4157 Str = End;
4158 QualType Type;
4159 switch (size) {
4160 #define PPC_VECTOR_TYPE(typeName, Id, size) \
4161 case size: Type = Context.Id##Ty; break;
4162 #include "clang/Basic/PPCTypes.def"
4163 default: llvm_unreachable("Invalid PowerPC MMA vector type");
4164 }
4165 bool CheckVectorArgs = false;
4166 while (!CheckVectorArgs) {
4167 switch (*Str++) {
4168 case '*':
4169 Type = Context.getPointerType(Type);
4170 break;
4171 case 'C':
4172 Type = Type.withConst();
4173 break;
4174 default:
4175 CheckVectorArgs = true;
4176 --Str;
4177 break;
4178 }
4179 }
4180 return Type;
4181 }
4182 default:
4183 return Context.DecodeTypeStr(--Str, Context, Error, RequireICE, true);
4184 }
4185}
4186
4187static bool isPPC_64Builtin(unsigned BuiltinID) {
4188 // These builtins only work on PPC 64bit targets.
4189 switch (BuiltinID) {
4190 case PPC::BI__builtin_divde:
4191 case PPC::BI__builtin_divdeu:
4192 case PPC::BI__builtin_bpermd:
4193 case PPC::BI__builtin_pdepd:
4194 case PPC::BI__builtin_pextd:
4195 case PPC::BI__builtin_ppc_ldarx:
4196 case PPC::BI__builtin_ppc_stdcx:
4197 case PPC::BI__builtin_ppc_tdw:
4198 case PPC::BI__builtin_ppc_trapd:
4199 case PPC::BI__builtin_ppc_cmpeqb:
4200 case PPC::BI__builtin_ppc_setb:
4201 case PPC::BI__builtin_ppc_mulhd:
4202 case PPC::BI__builtin_ppc_mulhdu:
4203 case PPC::BI__builtin_ppc_maddhd:
4204 case PPC::BI__builtin_ppc_maddhdu:
4205 case PPC::BI__builtin_ppc_maddld:
4206 case PPC::BI__builtin_ppc_load8r:
4207 case PPC::BI__builtin_ppc_store8r:
4208 case PPC::BI__builtin_ppc_insert_exp:
4209 case PPC::BI__builtin_ppc_extract_sig:
4210 case PPC::BI__builtin_ppc_addex:
4211 case PPC::BI__builtin_darn:
4212 case PPC::BI__builtin_darn_raw:
4213 case PPC::BI__builtin_ppc_compare_and_swaplp:
4214 case PPC::BI__builtin_ppc_fetch_and_addlp:
4215 case PPC::BI__builtin_ppc_fetch_and_andlp:
4216 case PPC::BI__builtin_ppc_fetch_and_orlp:
4217 case PPC::BI__builtin_ppc_fetch_and_swaplp:
4218 return true;
4219 }
4220 return false;
4221}
4222
4223/// Returns true if the argument consists of one contiguous run of 1s with any
4224/// number of 0s on either side. The 1s are allowed to wrap from LSB to MSB, so
4225/// 0x000FFF0, 0x0000FFFF, 0xFF0000FF, 0x0 are all runs. 0x0F0F0000 is not,
4226/// since all 1s are not contiguous.
4227bool Sema::SemaValueIsRunOfOnes(CallExpr *TheCall, unsigned ArgNum) {
4228 llvm::APSInt Result;
4229 // We can't check the value of a dependent argument.
4230 Expr *Arg = TheCall->getArg(ArgNum);
4231 if (Arg->isTypeDependent() || Arg->isValueDependent())
4232 return false;
4233
4234 // Check constant-ness first.
4235 if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
4236 return true;
4237
4238 // Check contiguous run of 1s, 0xFF0000FF is also a run of 1s.
4239 if (Result.isShiftedMask() || (~Result).isShiftedMask())
4240 return false;
4241
4242 return Diag(TheCall->getBeginLoc(),
4243 diag::err_argument_not_contiguous_bit_field)
4244 << ArgNum << Arg->getSourceRange();
4245}
4246
4247bool Sema::CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
4248 CallExpr *TheCall) {
4249 unsigned i = 0, l = 0, u = 0;
4250 bool IsTarget64Bit = TI.getTypeWidth(TI.getIntPtrType()) == 64;
4251 llvm::APSInt Result;
4252
4253 if (isPPC_64Builtin(BuiltinID) && !IsTarget64Bit)
4254 return Diag(TheCall->getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt)
4255 << TheCall->getSourceRange();
4256
4257 switch (BuiltinID) {
4258 default: return false;
4259 case PPC::BI__builtin_altivec_crypto_vshasigmaw:
4260 case PPC::BI__builtin_altivec_crypto_vshasigmad:
4261 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1) ||
4262 SemaBuiltinConstantArgRange(TheCall, 2, 0, 15);
4263 case PPC::BI__builtin_altivec_dss:
4264 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3);
4265 case PPC::BI__builtin_tbegin:
4266 case PPC::BI__builtin_tend:
4267 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1);
4268 case PPC::BI__builtin_tsr:
4269 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 7);
4270 case PPC::BI__builtin_tabortwc:
4271 case PPC::BI__builtin_tabortdc:
4272 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);
4273 case PPC::BI__builtin_tabortwci:
4274 case PPC::BI__builtin_tabortdci:
4275 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31) ||
4276 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
4277 // According to GCC 'Basic PowerPC Built-in Functions Available on ISA 2.05',
4278 // __builtin_(un)pack_longdouble are available only if long double uses IBM
4279 // extended double representation.
4280 case PPC::BI__builtin_unpack_longdouble:
4281 if (SemaBuiltinConstantArgRange(TheCall, 1, 0, 1))
4282 return true;
4283 [[fallthrough]];
4284 case PPC::BI__builtin_pack_longdouble:
4285 if (&TI.getLongDoubleFormat() != &llvm::APFloat::PPCDoubleDouble())
4286 return Diag(TheCall->getBeginLoc(), diag::err_ppc_builtin_requires_abi)
4287 << "ibmlongdouble";
4288 return false;
4289 case PPC::BI__builtin_altivec_dst:
4290 case PPC::BI__builtin_altivec_dstt:
4291 case PPC::BI__builtin_altivec_dstst:
4292 case PPC::BI__builtin_altivec_dststt:
4293 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
4294 case PPC::BI__builtin_vsx_xxpermdi:
4295 case PPC::BI__builtin_vsx_xxsldwi:
4296 return SemaBuiltinVSX(TheCall);
4297 case PPC::BI__builtin_unpack_vector_int128:
4298 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
4299 case PPC::BI__builtin_altivec_vgnb:
4300 return SemaBuiltinConstantArgRange(TheCall, 1, 2, 7);
4301 case PPC::BI__builtin_vsx_xxeval:
4302 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 255);
4303 case PPC::BI__builtin_altivec_vsldbi:
4304 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
4305 case PPC::BI__builtin_altivec_vsrdbi:
4306 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 7);
4307 case PPC::BI__builtin_vsx_xxpermx:
4308 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 7);
4309 case PPC::BI__builtin_ppc_tw:
4310 case PPC::BI__builtin_ppc_tdw:
4311 return SemaBuiltinConstantArgRange(TheCall, 2, 1, 31);
4312 case PPC::BI__builtin_ppc_cmprb:
4313 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1);
4314 // For __rlwnm, __rlwimi and __rldimi, the last parameter mask must
4315 // be a constant that represents a contiguous bit field.
4316 case PPC::BI__builtin_ppc_rlwnm:
4317 return SemaValueIsRunOfOnes(TheCall, 2);
4318 case PPC::BI__builtin_ppc_rlwimi:
4319 case PPC::BI__builtin_ppc_rldimi:
4320 return SemaBuiltinConstantArg(TheCall, 2, Result) ||
4321 SemaValueIsRunOfOnes(TheCall, 3);
4322 case PPC::BI__builtin_ppc_addex: {
4323 if (SemaBuiltinConstantArgRange(TheCall, 2, 0, 3))
4324 return true;
4325 // Output warning for reserved values 1 to 3.
4326 int ArgValue =
4327 TheCall->getArg(2)->getIntegerConstantExpr(Context)->getSExtValue();
4328 if (ArgValue != 0)
4329 Diag(TheCall->getBeginLoc(), diag::warn_argument_undefined_behaviour)
4330 << ArgValue;
4331 return false;
4332 }
4333 case PPC::BI__builtin_ppc_mtfsb0:
4334 case PPC::BI__builtin_ppc_mtfsb1:
4335 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 31);
4336 case PPC::BI__builtin_ppc_mtfsf:
4337 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 255);
4338 case PPC::BI__builtin_ppc_mtfsfi:
4339 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 7) ||
4340 SemaBuiltinConstantArgRange(TheCall, 1, 0, 15);
4341 case PPC::BI__builtin_ppc_alignx:
4342 return SemaBuiltinConstantArgPower2(TheCall, 0);
4343 case PPC::BI__builtin_ppc_rdlam:
4344 return SemaValueIsRunOfOnes(TheCall, 2);
4345 case PPC::BI__builtin_vsx_ldrmb:
4346 case PPC::BI__builtin_vsx_strmb:
4347 return SemaBuiltinConstantArgRange(TheCall, 1, 1, 16);
4348 case PPC::BI__builtin_altivec_vcntmbb:
4349 case PPC::BI__builtin_altivec_vcntmbh:
4350 case PPC::BI__builtin_altivec_vcntmbw:
4351 case PPC::BI__builtin_altivec_vcntmbd:
4352 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 1);
4353 case PPC::BI__builtin_vsx_xxgenpcvbm:
4354 case PPC::BI__builtin_vsx_xxgenpcvhm:
4355 case PPC::BI__builtin_vsx_xxgenpcvwm:
4356 case PPC::BI__builtin_vsx_xxgenpcvdm:
4357 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 3);
4358 case PPC::BI__builtin_ppc_test_data_class: {
4359 // Check if the first argument of the __builtin_ppc_test_data_class call is
4360 // valid. The argument must be 'float' or 'double' or '__float128'.
4361 QualType ArgType = TheCall->getArg(0)->getType();
4362 if (ArgType != QualType(Context.FloatTy) &&
4363 ArgType != QualType(Context.DoubleTy) &&
4364 ArgType != QualType(Context.Float128Ty))
4365 return Diag(TheCall->getBeginLoc(),
4366 diag::err_ppc_invalid_test_data_class_type);
4367 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 127);
4368 }
4369 case PPC::BI__builtin_ppc_maxfe:
4370 case PPC::BI__builtin_ppc_minfe:
4371 case PPC::BI__builtin_ppc_maxfl:
4372 case PPC::BI__builtin_ppc_minfl:
4373 case PPC::BI__builtin_ppc_maxfs:
4374 case PPC::BI__builtin_ppc_minfs: {
4375 if (Context.getTargetInfo().getTriple().isOSAIX() &&
4376 (BuiltinID == PPC::BI__builtin_ppc_maxfe ||
4377 BuiltinID == PPC::BI__builtin_ppc_minfe))
4378 return Diag(TheCall->getBeginLoc(), diag::err_target_unsupported_type)
4379 << "builtin" << true << 128 << QualType(Context.LongDoubleTy)
4380 << false << Context.getTargetInfo().getTriple().str();
4381 // Argument type should be exact.
4383 if (BuiltinID == PPC::BI__builtin_ppc_maxfl ||
4384 BuiltinID == PPC::BI__builtin_ppc_minfl)
4385 ArgType = QualType(Context.DoubleTy);
4386 else if (BuiltinID == PPC::BI__builtin_ppc_maxfs ||
4387 BuiltinID == PPC::BI__builtin_ppc_minfs)
4388 ArgType = QualType(Context.FloatTy);
4389 for (unsigned I = 0, E = TheCall->getNumArgs(); I < E; ++I)
4390 if (TheCall->getArg(I)->getType() != ArgType)
4391 return Diag(TheCall->getBeginLoc(),
4392 diag::err_typecheck_convert_incompatible)
4393 << TheCall->getArg(I)->getType() << ArgType << 1 << 0 << 0;
4394 return false;
4395 }
4396#define CUSTOM_BUILTIN(Name, Intr, Types, Acc, Feature) \
4397 case PPC::BI__builtin_##Name: \
4398 return SemaBuiltinPPCMMACall(TheCall, BuiltinID, Types);
4399#include "clang/Basic/BuiltinsPPC.def"
4400 }
4401 return SemaBuiltinConstantArgRange(TheCall, i, l, u);
4402}
4403
4404// Check if the given type is a non-pointer PPC MMA type. This function is used
4405// in Sema to prevent invalid uses of restricted PPC MMA types.
4406bool Sema::CheckPPCMMAType(QualType Type, SourceLocation TypeLoc) {
4407 if (Type->isPointerType() || Type->isArrayType())
4408 return false;
4409
4410 QualType CoreType = Type.getCanonicalType().getUnqualifiedType();
4411#define PPC_VECTOR_TYPE(Name, Id, Size) || CoreType == Context.Id##Ty
4412 if (false
4413#include "clang/Basic/PPCTypes.def"
4414 ) {
4415 Diag(TypeLoc, diag::err_ppc_invalid_use_mma_type);
4416 return true;
4417 }
4418 return false;
4419}
4420
4421bool Sema::CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID,
4422 CallExpr *TheCall) {
4423 // position of memory order and scope arguments in the builtin
4424 unsigned OrderIndex, ScopeIndex;
4425 switch (BuiltinID) {
4426 case AMDGPU::BI__builtin_amdgcn_atomic_inc32:
4427 case AMDGPU::BI__builtin_amdgcn_atomic_inc64:
4428 case AMDGPU::BI__builtin_amdgcn_atomic_dec32:
4429 case AMDGPU::BI__builtin_amdgcn_atomic_dec64:
4430 OrderIndex = 2;
4431 ScopeIndex = 3;
4432 break;
4433 case AMDGPU::BI__builtin_amdgcn_fence:
4434 OrderIndex = 0;
4435 ScopeIndex = 1;
4436 break;
4437 default:
4438 return false;
4439 }
4440
4441 ExprResult Arg = TheCall->getArg(OrderIndex);
4442 auto ArgExpr = Arg.get();
4443 Expr::EvalResult ArgResult;
4444
4445 if (!ArgExpr->EvaluateAsInt(ArgResult, Context))
4446 return Diag(ArgExpr->getExprLoc(), diag::err_typecheck_expect_int)
4447 << ArgExpr->getType();
4448 auto Ord = ArgResult.Val.getInt().getZExtValue();
4449
4450 // Check validity of memory ordering as per C11 / C++11's memody model.
4451 // Only fence needs check. Atomic dec/inc allow all memory orders.
4452 if (!llvm::isValidAtomicOrderingCABI(Ord))
4453 return Diag(ArgExpr->getBeginLoc(),
4454 diag::warn_atomic_op_has_invalid_memory_order)
4455 << ArgExpr->getSourceRange();
4456 switch (static_cast<llvm::AtomicOrderingCABI>(Ord)) {
4457 case llvm::AtomicOrderingCABI::relaxed:
4458 case llvm::AtomicOrderingCABI::consume:
4459 if (BuiltinID == AMDGPU::BI__builtin_amdgcn_fence)
4460 return Diag(ArgExpr->getBeginLoc(),
4461 diag::warn_atomic_op_has_invalid_memory_order)
4462 << ArgExpr->getSourceRange();
4463 break;
4464 case llvm::AtomicOrderingCABI::acquire:
4465 case llvm::AtomicOrderingCABI::release:
4466 case llvm::AtomicOrderingCABI::acq_rel:
4467 case llvm::AtomicOrderingCABI::seq_cst:
4468 break;
4469 }
4470
4471 Arg = TheCall->getArg(ScopeIndex);
4472 ArgExpr = Arg.get();
4473 Expr::EvalResult ArgResult1;
4474 // Check that sync scope is a constant literal
4475 if (!ArgExpr->EvaluateAsConstantExpr(ArgResult1, Context))
4476 return Diag(ArgExpr->getExprLoc(), diag::err_expr_not_string_literal)
4477 << ArgExpr->getType();
4478
4479 return false;
4480}
4481
4482bool Sema::CheckRISCVLMUL(CallExpr *TheCall, unsigned ArgNum) {
4483 llvm::APSInt Result;
4484
4485 // We can't check the value of a dependent argument.
4486 Expr *Arg = TheCall->getArg(ArgNum);
4487 if (Arg->isTypeDependent() || Arg->isValueDependent())
4488 return false;
4489
4490 // Check constant-ness first.
4491 if (SemaBuiltinConstantArg(TheCall, ArgNum, Result))
4492 return true;
4493
4494 int64_t Val = Result.getSExtValue();
4495 if ((Val >= 0 && Val <= 3) || (Val >= 5 && Val <= 7))
4496 return false;
4497
4498 return Diag(TheCall->getBeginLoc(), diag::err_riscv_builtin_invalid_lmul)
4499 << Arg->getSourceRange();
4500}
4501
4502static bool CheckInvalidVLENandLMUL(const TargetInfo &TI, CallExpr *TheCall,
4503 Sema &S, QualType Type, int EGW) {
4504 assert((EGW == 128 || EGW == 256) && "EGW can only be 128 or 256 bits");
4505
4506 // LMUL * VLEN >= EGW
4507 unsigned ElemSize = Type->isRVVType(32, false) ? 32 : 64;
4508 unsigned MinElemCount = Type->isRVVType(1) ? 1
4509 : Type->isRVVType(2) ? 2
4510 : Type->isRVVType(4) ? 4
4511 : Type->isRVVType(8) ? 8
4512 : 16;
4513
4514 unsigned EGS = EGW / ElemSize;
4515 // If EGS is less than or equal to the minimum number of elements, then the
4516 // type is valid.
4517 if (EGS <= MinElemCount)
4518 return false;
4519
4520 // Otherwise, we need vscale to be at least EGS / MinElemCont.
4521 assert(EGS % MinElemCount == 0);
4522 unsigned VScaleFactor = EGS / MinElemCount;
4523 // Vscale is VLEN/RVVBitsPerBlock.
4524 unsigned MinRequiredVLEN = VScaleFactor * llvm::RISCV::RVVBitsPerBlock;
4525 std::string RequiredExt = "zvl" + std::to_string(MinRequiredVLEN) + "b";
4526 if (!TI.hasFeature(RequiredExt))
4527 return S.Diag(TheCall->getBeginLoc(),
4528 diag::err_riscv_type_requires_extension) << Type << RequiredExt;
4529
4530 return false;
4531}
4532
4533bool Sema::CheckRISCVBuiltinFunctionCall(const TargetInfo &TI,
4534 unsigned BuiltinID,
4535 CallExpr *TheCall) {
4536 // CodeGenFunction can also detect this, but this gives a better error
4537 // message.
4538 bool FeatureMissing = false;
4539 SmallVector<StringRef> ReqFeatures;
4540 StringRef Features = Context.BuiltinInfo.getRequiredFeatures(BuiltinID);
4541 Features.split(ReqFeatures, ',', -1, false);
4542
4543 // Check if each required feature is included
4544 for (StringRef F : ReqFeatures) {
4545 SmallVector<StringRef> ReqOpFeatures;
4546 F.split(ReqOpFeatures, '|');
4547
4548 if (llvm::none_of(ReqOpFeatures,
4549 [&TI](StringRef OF) { return TI.hasFeature(OF); })) {
4550 std::string FeatureStrs;
4551 bool IsExtension = true;
4552 for (StringRef OF : ReqOpFeatures) {
4553 // If the feature is 64bit, alter the string so it will print better in
4554 // the diagnostic.
4555 if (OF == "64bit") {
4556 assert(ReqOpFeatures.size() == 1 && "Expected '64bit' to be alone");
4557 OF = "RV64";
4558 IsExtension = false;
4559 }
4560 if (OF == "32bit") {
4561 assert(ReqOpFeatures.size() == 1 && "Expected '32bit' to be alone");
4562 OF = "RV32";
4563 IsExtension = false;
4564 }
4565
4566 // Convert features like "zbr" and "experimental-zbr" to "Zbr".
4567 OF.consume_front("experimental-");
4568 std::string FeatureStr = OF.str();
4569 FeatureStr[0] = std::toupper(FeatureStr[0]);
4570 // Combine strings.
4571 FeatureStrs += FeatureStrs.empty() ? "" : ", ";
4572 FeatureStrs += "'";
4573 FeatureStrs += FeatureStr;
4574 FeatureStrs += "'";
4575 }
4576 // Error message
4577 FeatureMissing = true;
4578 Diag(TheCall->getBeginLoc(), diag::err_riscv_builtin_requires_extension)
4579 << IsExtension
4580 << TheCall->getSourceRange() << StringRef(FeatureStrs);
4581 }
4582 }
4583
4584 if (FeatureMissing)
4585 return true;
4586
4587 // vmulh.vv, vmulh.vx, vmulhu.vv, vmulhu.vx, vmulhsu.vv, vmulhsu.vx,
4588 // vsmul.vv, vsmul.vx are not included for EEW=64 in Zve64*.
4589 switch (BuiltinID) {
4590 default:
4591 break;
4592 case RISCVVector::BI__builtin_rvv_vmulhsu_vv:
4593 case RISCVVector::BI__builtin_rvv_vmulhsu_vx:
4594 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tu:
4595 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tu:
4596 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_m:
4597 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_m:
4598 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_mu:
4599 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_mu:
4600 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tum:
4601 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tum:
4602 case RISCVVector::BI__builtin_rvv_vmulhsu_vv_tumu:
4603 case RISCVVector::BI__builtin_rvv_vmulhsu_vx_tumu:
4604 case RISCVVector::BI__builtin_rvv_vmulhu_vv:
4605 case RISCVVector::BI__builtin_rvv_vmulhu_vx:
4606 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tu:
4607 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tu:
4608 case RISCVVector::BI__builtin_rvv_vmulhu_vv_m:
4609 case RISCVVector::BI__builtin_rvv_vmulhu_vx_m:
4610 case RISCVVector::BI__builtin_rvv_vmulhu_vv_mu:
4611 case RISCVVector::BI__builtin_rvv_vmulhu_vx_mu:
4612 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tum:
4613 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tum:
4614 case RISCVVector::BI__builtin_rvv_vmulhu_vv_tumu:
4615 case RISCVVector::BI__builtin_rvv_vmulhu_vx_tumu:
4616 case RISCVVector::BI__builtin_rvv_vmulh_vv:
4617 case RISCVVector::BI__builtin_rvv_vmulh_vx:
4618 case RISCVVector::BI__builtin_rvv_vmulh_vv_tu:
4619 case RISCVVector::BI__builtin_rvv_vmulh_vx_tu:
4620 case RISCVVector::BI__builtin_rvv_vmulh_vv_m:
4621 case RISCVVector::BI__builtin_rvv_vmulh_vx_m:
4622 case RISCVVector::BI__builtin_rvv_vmulh_vv_mu:
4623 case RISCVVector::BI__builtin_rvv_vmulh_vx_mu:
4624 case RISCVVector::BI__builtin_rvv_vmulh_vv_tum:
4625 case RISCVVector::BI__builtin_rvv_vmulh_vx_tum:
4626 case RISCVVector::BI__builtin_rvv_vmulh_vv_tumu:
4627 case RISCVVector::BI__builtin_rvv_vmulh_vx_tumu:
4628 case RISCVVector::BI__builtin_rvv_vsmul_vv:
4629 case RISCVVector::BI__builtin_rvv_vsmul_vx:
4630 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
4631 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
4632 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
4633 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
4634 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
4635 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
4636 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
4637 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
4638 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
4639 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu: {
4640 bool RequireV = false;
4641 for (unsigned ArgNum = 0; ArgNum < TheCall->getNumArgs(); ++ArgNum)
4642 RequireV |= TheCall->getArg(ArgNum)->getType()->isRVVType(
4643 /* Bitwidth */ 64, /* IsFloat */ false);
4644
4645 if (RequireV && !TI.hasFeature("v"))
4646 return Diag(TheCall->getBeginLoc(),
4647 diag::err_riscv_builtin_requires_extension)
4648 << /* IsExtension */ false << TheCall->getSourceRange() << "v";
4649
4650 break;
4651 }
4652 }
4653
4654 switch (BuiltinID) {
4655 case RISCVVector::BI__builtin_rvv_vsetvli:
4656 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 3) ||
4657 CheckRISCVLMUL(TheCall, 2);
4658 case RISCVVector::BI__builtin_rvv_vsetvlimax:
4659 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4660 CheckRISCVLMUL(TheCall, 1);
4661 case RISCVVector::BI__builtin_rvv_vget_v: {
4663 Context.getBuiltinVectorTypeInfo(cast<BuiltinType>(
4664 TheCall->getType().getCanonicalType().getTypePtr()));
4666 Context.getBuiltinVectorTypeInfo(cast<BuiltinType>(
4667 TheCall->getArg(0)->getType().getCanonicalType().getTypePtr()));
4668 unsigned MaxIndex;
4669 if (VecInfo.NumVectors != 1) // vget for tuple type
4670 MaxIndex = VecInfo.NumVectors;
4671 else // vget for non-tuple type
4672 MaxIndex = (VecInfo.EC.getKnownMinValue() * VecInfo.NumVectors) /
4673 (ResVecInfo.EC.getKnownMinValue() * ResVecInfo.NumVectors);
4674 return SemaBuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
4675 }
4676 case RISCVVector::BI__builtin_rvv_vset_v: {
4678 Context.getBuiltinVectorTypeInfo(cast<BuiltinType>(
4679 TheCall->getType().getCanonicalType().getTypePtr()));
4681 Context.getBuiltinVectorTypeInfo(cast<BuiltinType>(
4682 TheCall->getArg(2)->getType().getCanonicalType().getTypePtr()));
4683 unsigned MaxIndex;
4684 if (ResVecInfo.NumVectors != 1) // vset for tuple type
4685 MaxIndex = ResVecInfo.NumVectors;
4686 else // vset fo non-tuple type
4687 MaxIndex = (ResVecInfo.EC.getKnownMinValue() * ResVecInfo.NumVectors) /
4688 (VecInfo.EC.getKnownMinValue() * VecInfo.NumVectors);
4689 return SemaBuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
4690 }
4691 // Vector Crypto
4692 case RISCVVector::BI__builtin_rvv_vaeskf1_vi_tu:
4693 case RISCVVector::BI__builtin_rvv_vaeskf2_vi_tu:
4694 case RISCVVector::BI__builtin_rvv_vaeskf2_vi:
4695 case RISCVVector::BI__builtin_rvv_vsm4k_vi_tu: {
4696 QualType Op1Type = TheCall->getArg(0)->getType();
4697 QualType Op2Type = TheCall->getArg(1)->getType();
4698 return CheckInvalidVLENandLMUL(TI, TheCall, *this, Op1Type, 128) ||
4699 CheckInvalidVLENandLMUL(TI, TheCall, *this, Op2Type, 128) ||
4700 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
4701 }
4702 case RISCVVector::BI__builtin_rvv_vsm3c_vi_tu:
4703 case RISCVVector::BI__builtin_rvv_vsm3c_vi: {
4704 QualType Op1Type = TheCall->getArg(0)->getType();
4705 return CheckInvalidVLENandLMUL(TI, TheCall, *this, Op1Type, 256) ||
4706 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
4707 }
4708 case RISCVVector::BI__builtin_rvv_vaeskf1_vi:
4709 case RISCVVector::BI__builtin_rvv_vsm4k_vi: {
4710 QualType Op1Type = TheCall->getArg(0)->getType();
4711 return CheckInvalidVLENandLMUL(TI, TheCall, *this, Op1Type, 128) ||
4712 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
4713 }
4714 case RISCVVector::BI__builtin_rvv_vaesdf_vv:
4715 case RISCVVector::BI__builtin_rvv_vaesdf_vs:
4716 case RISCVVector::BI__builtin_rvv_vaesdm_vv:
4717 case RISCVVector::BI__builtin_rvv_vaesdm_vs:
4718 case RISCVVector::BI__builtin_rvv_vaesef_vv:
4719 case RISCVVector::BI__builtin_rvv_vaesef_vs:
4720 case RISCVVector::BI__builtin_rvv_vaesem_vv:
4721 case RISCVVector::BI__builtin_rvv_vaesem_vs:
4722 case RISCVVector::BI__builtin_rvv_vaesz_vs:
4723 case RISCVVector::BI__builtin_rvv_vsm4r_vv:
4724 case RISCVVector::BI__builtin_rvv_vsm4r_vs:
4725 case RISCVVector::BI__builtin_rvv_vaesdf_vv_tu:
4726 case RISCVVector::BI__builtin_rvv_vaesdf_vs_tu:
4727 case RISCVVector::BI__builtin_rvv_vaesdm_vv_tu:
4728 case RISCVVector::BI__builtin_rvv_vaesdm_vs_tu:
4729 case RISCVVector::BI__builtin_rvv_vaesef_vv_tu:
4730 case RISCVVector::BI__builtin_rvv_vaesef_vs_tu:
4731 case RISCVVector::BI__builtin_rvv_vaesem_vv_tu:
4732 case RISCVVector::BI__builtin_rvv_vaesem_vs_tu:
4733 case RISCVVector::BI__builtin_rvv_vaesz_vs_tu:
4734 case RISCVVector::BI__builtin_rvv_vsm4r_vv_tu:
4735 case RISCVVector::BI__builtin_rvv_vsm4r_vs_tu: {
4736 QualType Op1Type = TheCall->getArg(0)->getType();
4737 QualType Op2Type = TheCall->getArg(1)->getType();
4738 return CheckInvalidVLENandLMUL(TI, TheCall, *this, Op1Type, 128) ||
4739 CheckInvalidVLENandLMUL(TI, TheCall, *this, Op2Type, 128);
4740 }
4741 case RISCVVector::BI__builtin_rvv_vsha2ch_vv:
4742 case RISCVVector::BI__builtin_rvv_vsha2cl_vv:
4743 case RISCVVector::BI__builtin_rvv_vsha2ms_vv:
4744 case RISCVVector::BI__builtin_rvv_vsha2ch_vv_tu:
4745 case RISCVVector::BI__builtin_rvv_vsha2cl_vv_tu:
4746 case RISCVVector::BI__builtin_rvv_vsha2ms_vv_tu: {
4747 QualType Op1Type = TheCall->getArg(0)->getType();
4748 QualType Op2Type = TheCall->getArg(1)->getType();
4749 QualType Op3Type = TheCall->getArg(2)->getType();
4750 uint64_t ElemSize = Op1Type->isRVVType(32, false) ? 32 : 64;
4751 if (ElemSize == 64 && !TI.hasFeature("experimental-zvknhb"))
4752 return
4753 Diag(TheCall->getBeginLoc(), diag::err_riscv_type_requires_extension)
4754 << Op1Type << "experimental-zvknhb";
4755
4756 return CheckInvalidVLENandLMUL(TI, TheCall, *this, Op1Type, ElemSize << 2) ||
4757 CheckInvalidVLENandLMUL(TI, TheCall, *this, Op2Type, ElemSize << 2) ||
4758 CheckInvalidVLENandLMUL(TI, TheCall, *this, Op3Type, ElemSize << 2);
4759 }
4760
4761 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8mf8:
4762 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8mf4:
4763 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8mf2:
4764 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8m1:
4765 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8m2:
4766 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8m4:
4767 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8m8:
4768 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16mf4:
4769 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16mf2:
4770 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16m1:
4771 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16m2:
4772 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16m4:
4773 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u16m8:
4774 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u32mf2:
4775 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u32m1:
4776 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u32m2:
4777 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u32m4:
4778 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u32m8:
4779 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u64m1:
4780 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u64m2:
4781 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u64m4:
4782 case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u64m8:
4783 // bit_27_26, bit_24_20, bit_11_7, simm5
4784 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4785 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
4786 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31) ||
4787 SemaBuiltinConstantArgRange(TheCall, 3, -16, 15);
4788 case RISCVVector::BI__builtin_rvv_sf_vc_iv_se:
4789 // bit_27_26, bit_11_7, vs2, simm5
4790 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4791 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
4792 SemaBuiltinConstantArgRange(TheCall, 3, -16, 15);
4793 case RISCVVector::BI__builtin_rvv_sf_vc_v_i:
4794 case RISCVVector::BI__builtin_rvv_sf_vc_v_i_se:
4795 // bit_27_26, bit_24_20, simm5
4796 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4797 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
4798 SemaBuiltinConstantArgRange(TheCall, 2, -16, 15);
4799 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv:
4800 case RISCVVector::BI__builtin_rvv_sf_vc_v_iv_se:
4801 // bit_27_26, vs2, simm5
4802 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4803 SemaBuiltinConstantArgRange(TheCall, 2, -16, 15);
4804 case RISCVVector::BI__builtin_rvv_sf_vc_ivv_se:
4805 case RISCVVector::BI__builtin_rvv_sf_vc_ivw_se:
4806 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv:
4807 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw:
4808 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivv_se:
4809 case RISCVVector::BI__builtin_rvv_sf_vc_v_ivw_se:
4810 // bit_27_26, vd, vs2, simm5
4811 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4812 SemaBuiltinConstantArgRange(TheCall, 3, -16, 15);
4813 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8mf8:
4814 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8mf4:
4815 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8mf2:
4816 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8m1:
4817 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8m2:
4818 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8m4:
4819 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u8m8:
4820 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16mf4:
4821 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16mf2:
4822 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16m1:
4823 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16m2:
4824 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16m4:
4825 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u16m8:
4826 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u32mf2:
4827 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u32m1:
4828 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u32m2:
4829 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u32m4:
4830 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u32m8:
4831 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u64m1:
4832 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u64m2:
4833 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u64m4:
4834 case RISCVVector::BI__builtin_rvv_sf_vc_x_se_u64m8:
4835 // bit_27_26, bit_24_20, bit_11_7, xs1
4836 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4837 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31) ||
4838 SemaBuiltinConstantArgRange(TheCall, 2, 0, 31);
4839 case RISCVVector::BI__builtin_rvv_sf_vc_xv_se:
4840 case RISCVVector::BI__builtin_rvv_sf_vc_vv_se:
4841 // bit_27_26, bit_11_7, vs2, xs1/vs1
4842 case RISCVVector::BI__builtin_rvv_sf_vc_v_x:
4843 case RISCVVector::BI__builtin_rvv_sf_vc_v_x_se:
4844 // bit_27_26, bit_24-20, xs1
4845 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3) ||
4846 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
4847 case RISCVVector::BI__builtin_rvv_sf_vc_vvv_se:
4848 case RISCVVector::BI__builtin_rvv_sf_vc_xvv_se:
4849 case RISCVVector::BI__builtin_rvv_sf_vc_vvw_se:
4850 case RISCVVector::BI__builtin_rvv_sf_vc_xvw_se:
4851 // bit_27_26, vd, vs2, xs1
4852 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv:
4853 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv:
4854 case RISCVVector::BI__builtin_rvv_sf_vc_v_xv_se:
4855 case RISCVVector::BI__builtin_rvv_sf_vc_v_vv_se:
4856 // bit_27_26, vs2, xs1/vs1
4857 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv:
4858 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv:
4859 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw:
4860 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw:
4861 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvv_se:
4862 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvv_se:
4863 case RISCVVector::BI__builtin_rvv_sf_vc_v_xvw_se:
4864 case RISCVVector::BI__builtin_rvv_sf_vc_v_vvw_se:
4865 // bit_27_26, vd, vs2, xs1/vs1
4866 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 3);
4867 case RISCVVector::BI__builtin_rvv_sf_vc_fv_se:
4868 // bit_26, bit_11_7, vs2, fs1
4869 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1) ||
4870 SemaBuiltinConstantArgRange(TheCall, 1, 0, 31);
4871 case RISCVVector::BI__builtin_rvv_sf_vc_fvv_se:
4872 case RISCVVector::BI__builtin_rvv_sf_vc_fvw_se:
4873 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv:
4874 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw:
4875 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvv_se:
4876 case RISCVVector::BI__builtin_rvv_sf_vc_v_fvw_se:
4877 // bit_26, vd, vs2, fs1
4878 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv:
4879 case RISCVVector::BI__builtin_rvv_sf_vc_v_fv_se:
4880 // bit_26, vs2, fs1
4881 return SemaBuiltinConstantArgRange(TheCall, 0, 0, 1);
4882 // Check if byteselect is in [0, 3]
4883 case RISCV::BI__builtin_riscv_aes32dsi:
4884 case RISCV::BI__builtin_riscv_aes32dsmi:
4885 case RISCV::BI__builtin_riscv_aes32esi:
4886 case RISCV::BI__builtin_riscv_aes32esmi:
4887 case RISCV::BI__builtin_riscv_sm4ks:
4888 case RISCV::BI__builtin_riscv_sm4ed:
4889 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
4890 // Check if rnum is in [0, 10]
4891 case RISCV::BI__builtin_riscv_aes64ks1i:
4892 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 10);
4893 // Check if value range for vxrm is in [0, 3]
4894 case RISCVVector::BI__builtin_rvv_vaaddu_vv:
4895 case RISCVVector::BI__builtin_rvv_vaaddu_vx:
4896 case RISCVVector::BI__builtin_rvv_vaadd_vv:
4897 case RISCVVector::BI__builtin_rvv_vaadd_vx:
4898 case RISCVVector::BI__builtin_rvv_vasubu_vv:
4899 case RISCVVector::BI__builtin_rvv_vasubu_vx:
4900 case RISCVVector::BI__builtin_rvv_vasub_vv:
4901 case RISCVVector::BI__builtin_rvv_vasub_vx:
4902 case RISCVVector::BI__builtin_rvv_vsmul_vv:
4903 case RISCVVector::BI__builtin_rvv_vsmul_vx:
4904 case RISCVVector::BI__builtin_rvv_vssra_vv:
4905 case RISCVVector::BI__builtin_rvv_vssra_vx:
4906 case RISCVVector::BI__builtin_rvv_vssrl_vv:
4907 case RISCVVector::BI__builtin_rvv_vssrl_vx:
4908 case RISCVVector::BI__builtin_rvv_vnclip_wv:
4909 case RISCVVector::BI__builtin_rvv_vnclip_wx:
4910 case RISCVVector::BI__builtin_rvv_vnclipu_wv:
4911 case RISCVVector::BI__builtin_rvv_vnclipu_wx:
4912 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 3);
4913 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tu:
4914 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tu:
4915 case RISCVVector::BI__builtin_rvv_vaadd_vv_tu:
4916 case RISCVVector::BI__builtin_rvv_vaadd_vx_tu:
4917 case RISCVVector::BI__builtin_rvv_vasubu_vv_tu:
4918 case RISCVVector::BI__builtin_rvv_vasubu_vx_tu:
4919 case RISCVVector::BI__builtin_rvv_vasub_vv_tu:
4920 case RISCVVector::BI__builtin_rvv_vasub_vx_tu:
4921 case RISCVVector::BI__builtin_rvv_vsmul_vv_tu:
4922 case RISCVVector::BI__builtin_rvv_vsmul_vx_tu:
4923 case RISCVVector::BI__builtin_rvv_vssra_vv_tu:
4924 case RISCVVector::BI__builtin_rvv_vssra_vx_tu:
4925 case RISCVVector::BI__builtin_rvv_vssrl_vv_tu:
4926 case RISCVVector::BI__builtin_rvv_vssrl_vx_tu:
4927 case RISCVVector::BI__builtin_rvv_vnclip_wv_tu:
4928 case RISCVVector::BI__builtin_rvv_vnclip_wx_tu:
4929 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tu:
4930 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tu:
4931 case RISCVVector::BI__builtin_rvv_vaaddu_vv_m:
4932 case RISCVVector::BI__builtin_rvv_vaaddu_vx_m:
4933 case RISCVVector::BI__builtin_rvv_vaadd_vv_m:
4934 case RISCVVector::BI__builtin_rvv_vaadd_vx_m:
4935 case RISCVVector::BI__builtin_rvv_vasubu_vv_m:
4936 case RISCVVector::BI__builtin_rvv_vasubu_vx_m:
4937 case RISCVVector::BI__builtin_rvv_vasub_vv_m:
4938 case RISCVVector::BI__builtin_rvv_vasub_vx_m:
4939 case RISCVVector::BI__builtin_rvv_vsmul_vv_m:
4940 case RISCVVector::BI__builtin_rvv_vsmul_vx_m:
4941 case RISCVVector::BI__builtin_rvv_vssra_vv_m:
4942 case RISCVVector::BI__builtin_rvv_vssra_vx_m:
4943 case RISCVVector::BI__builtin_rvv_vssrl_vv_m:
4944 case RISCVVector::BI__builtin_rvv_vssrl_vx_m:
4945 case RISCVVector::BI__builtin_rvv_vnclip_wv_m:
4946 case RISCVVector::BI__builtin_rvv_vnclip_wx_m:
4947 case RISCVVector::BI__builtin_rvv_vnclipu_wv_m:
4948 case RISCVVector::BI__builtin_rvv_vnclipu_wx_m:
4949 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 3);
4950 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tum:
4951 case RISCVVector::BI__builtin_rvv_vaaddu_vv_tumu:
4952 case RISCVVector::BI__builtin_rvv_vaaddu_vv_mu:
4953 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tum:
4954 case RISCVVector::BI__builtin_rvv_vaaddu_vx_tumu:
4955 case RISCVVector::BI__builtin_rvv_vaaddu_vx_mu:
4956 case RISCVVector::BI__builtin_rvv_vaadd_vv_tum:
4957 case RISCVVector::BI__builtin_rvv_vaadd_vv_tumu:
4958 case RISCVVector::BI__builtin_rvv_vaadd_vv_mu:
4959 case RISCVVector::BI__builtin_rvv_vaadd_vx_tum:
4960 case RISCVVector::BI__builtin_rvv_vaadd_vx_tumu:
4961 case RISCVVector::BI__builtin_rvv_vaadd_vx_mu:
4962 case RISCVVector::BI__builtin_rvv_vasubu_vv_tum:
4963 case RISCVVector::BI__builtin_rvv_vasubu_vv_tumu:
4964 case RISCVVector::BI__builtin_rvv_vasubu_vv_mu:
4965 case RISCVVector::BI__builtin_rvv_vasubu_vx_tum:
4966 case RISCVVector::BI__builtin_rvv_vasubu_vx_tumu:
4967 case RISCVVector::BI__builtin_rvv_vasubu_vx_mu:
4968 case RISCVVector::BI__builtin_rvv_vasub_vv_tum:
4969 case RISCVVector::BI__builtin_rvv_vasub_vv_tumu:
4970 case RISCVVector::BI__builtin_rvv_vasub_vv_mu:
4971 case RISCVVector::BI__builtin_rvv_vasub_vx_tum:
4972 case RISCVVector::BI__builtin_rvv_vasub_vx_tumu:
4973 case RISCVVector::BI__builtin_rvv_vasub_vx_mu:
4974 case RISCVVector::BI__builtin_rvv_vsmul_vv_mu:
4975 case RISCVVector::BI__builtin_rvv_vsmul_vx_mu:
4976 case RISCVVector::BI__builtin_rvv_vssra_vv_mu:
4977 case RISCVVector::BI__builtin_rvv_vssra_vx_mu:
4978 case RISCVVector::BI__builtin_rvv_vssrl_vv_mu:
4979 case RISCVVector::BI__builtin_rvv_vssrl_vx_mu:
4980 case RISCVVector::BI__builtin_rvv_vnclip_wv_mu:
4981 case RISCVVector::BI__builtin_rvv_vnclip_wx_mu:
4982 case RISCVVector::BI__builtin_rvv_vnclipu_wv_mu:
4983 case RISCVVector::BI__builtin_rvv_vnclipu_wx_mu:
4984 case RISCVVector::BI__builtin_rvv_vsmul_vv_tum:
4985 case RISCVVector::BI__builtin_rvv_vsmul_vx_tum:
4986 case RISCVVector::BI__builtin_rvv_vssra_vv_tum:
4987 case RISCVVector::BI__builtin_rvv_vssra_vx_tum:
4988 case RISCVVector::BI__builtin_rvv_vssrl_vv_tum:
4989 case RISCVVector::BI__builtin_rvv_vssrl_vx_tum:
4990 case RISCVVector::BI__builtin_rvv_vnclip_wv_tum:
4991 case RISCVVector::BI__builtin_rvv_vnclip_wx_tum:
4992 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tum:
4993 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tum:
4994 case RISCVVector::BI__builtin_rvv_vsmul_vv_tumu:
4995 case RISCVVector::BI__builtin_rvv_vsmul_vx_tumu:
4996 case RISCVVector::BI__builtin_rvv_vssra_vv_tumu:
4997 case RISCVVector::BI__builtin_rvv_vssra_vx_tumu:
4998 case RISCVVector::BI__builtin_rvv_vssrl_vv_tumu:
4999 case RISCVVector::BI__builtin_rvv_vssrl_vx_tumu:
5000 case RISCVVector::BI__builtin_rvv_vnclip_wv_tumu:
5001 case RISCVVector::BI__builtin_rvv_vnclip_wx_tumu:
5002 case RISCVVector::BI__builtin_rvv_vnclipu_wv_tumu:
5003 case RISCVVector::BI__builtin_rvv_vnclipu_wx_tumu:
5004 return SemaBuiltinConstantArgRange(TheCall, 4, 0, 3);
5005 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm:
5006 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm:
5007 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm:
5008 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm:
5009 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm:
5010 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm:
5011 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm:
5012 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm:
5013 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm:
5014 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm:
5015 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm:
5016 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm:
5017 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm:
5018 return SemaBuiltinConstantArgRange(TheCall, 1, 0, 4);
5019 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm:
5020 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm:
5021 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm:
5022 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm:
5023 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm:
5024 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm:
5025 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm:
5026 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm:
5027 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm:
5028 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm:
5029 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm:
5030 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm:
5031 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm:
5032 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm:
5033 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm:
5034 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm:
5035 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm:
5036 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm:
5037 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm:
5038 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm:
5039 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm:
5040 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm:
5041 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm:
5042 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm:
5043 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tu:
5044 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tu:
5045 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tu:
5046 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tu:
5047 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tu:
5048 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tu:
5049 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tu:
5050 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tu:
5051 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tu:
5052 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tu:
5053 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tu:
5054 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tu:
5055 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tu:
5056 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_m:
5057 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_m:
5058 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_m:
5059 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_m:
5060 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_m:
5061 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_m:
5062 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_m:
5063 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_m:
5064 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_m:
5065 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_m:
5066 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_m:
5067 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_m:
5068 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_m:
5069 return SemaBuiltinConstantArgRange(TheCall, 2, 0, 4);
5070 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tu:
5071 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tu:
5072 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tu:
5073 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tu:
5074 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tu:
5075 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tu:
5076 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tu:
5077 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tu:
5078 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tu:
5079 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tu:
5080 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tu:
5081 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tu:
5082 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tu:
5083 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tu:
5084 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tu:
5085 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tu:
5086 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tu:
5087 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tu:
5088 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tu:
5089 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tu:
5090 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tu:
5091 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tu:
5092 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tu:
5093 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tu:
5094 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm:
5095 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm:
5096 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm:
5097 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm:
5098 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm:
5099 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm:
5100 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm:
5101 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm:
5102 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm:
5103 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm:
5104 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm:
5105 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm:
5106 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm:
5107 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm:
5108 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm:
5109 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm:
5110 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm:
5111 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm:
5112 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm:
5113 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm:
5114 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm:
5115 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm:
5116 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm:
5117 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm:
5118 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tu:
5119 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tu:
5120 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tu:
5121 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tu:
5122 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tu:
5123 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tu:
5124 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tu:
5125 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tu:
5126 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tu:
5127 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tu:
5128 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tu:
5129 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tu:
5130 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tu:
5131 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tu:
5132 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tu:
5133 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tu:
5134 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tu:
5135 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tu:
5136 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tu:
5137 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tu:
5138 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tu:
5139 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tu:
5140 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tu:
5141 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tu:
5142 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_m:
5143 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_m:
5144 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_m:
5145 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_m:
5146 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_m:
5147 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_m:
5148 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_m:
5149 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_m:
5150 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_m:
5151 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_m:
5152 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_m:
5153 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_m:
5154 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_m:
5155 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_m:
5156 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_m:
5157 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_m:
5158 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_m:
5159 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_m:
5160 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_m:
5161 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_m:
5162 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_m:
5163 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_m:
5164 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_m:
5165 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_m:
5166 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tum:
5167 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tum:
5168 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tum:
5169 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tum:
5170 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tum:
5171 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tum:
5172 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tum:
5173 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tum:
5174 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tum:
5175 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tum:
5176 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tum:
5177 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tum:
5178 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tum:
5179 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_tumu:
5180 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_tumu:
5181 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_tumu:
5182 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_tumu:
5183 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_tumu:
5184 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_tumu:
5185 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_tumu:
5186 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_tumu:
5187 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_tumu:
5188 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_tumu:
5189 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_tumu:
5190 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_tumu:
5191 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_tumu:
5192 case RISCVVector::BI__builtin_rvv_vfsqrt_v_rm_mu:
5193 case RISCVVector::BI__builtin_rvv_vfrec7_v_rm_mu:
5194 case RISCVVector::BI__builtin_rvv_vfcvt_x_f_v_rm_mu:
5195 case RISCVVector::BI__builtin_rvv_vfcvt_xu_f_v_rm_mu:
5196 case RISCVVector::BI__builtin_rvv_vfcvt_f_x_v_rm_mu:
5197 case RISCVVector::BI__builtin_rvv_vfcvt_f_xu_v_rm_mu:
5198 case RISCVVector::BI__builtin_rvv_vfwcvt_x_f_v_rm_mu:
5199 case RISCVVector::BI__builtin_rvv_vfwcvt_xu_f_v_rm_mu:
5200 case RISCVVector::BI__builtin_rvv_vfncvt_x_f_w_rm_mu:
5201 case RISCVVector::BI__builtin_rvv_vfncvt_xu_f_w_rm_mu:
5202 case RISCVVector::BI__builtin_rvv_vfncvt_f_x_w_rm_mu:
5203 case RISCVVector::BI__builtin_rvv_vfncvt_f_xu_w_rm_mu:
5204 case RISCVVector::BI__builtin_rvv_vfncvt_f_f_w_rm_mu:
5205 return SemaBuiltinConstantArgRange(TheCall, 3, 0, 4);
5206 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_m:
5207 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_m:
5208 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_m:
5209 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_m:
5210 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_m:
5211 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_m:
5212 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_m:
5213 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_m:
5214 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_m:
5215 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_m:
5216 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_m:
5217 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_m:
5218 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_m:
5219 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_m:
5220 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_m:
5221 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_m:
5222 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_m:
5223 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_m:
5224 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_m:
5225 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_m:
5226 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_m:
5227 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_m:
5228 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_m:
5229 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_m:
5230 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tum:
5231 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tum:
5232 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tum:
5233 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tum:
5234 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tum:
5235 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tum:
5236 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tum:
5237 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tum:
5238 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tum:
5239 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tum:
5240 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tum:
5241 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tum:
5242 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tum:
5243 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tum:
5244 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tum:
5245 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tum:
5246 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tum:
5247 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tum:
5248 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tum:
5249 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tum:
5250 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tum:
5251 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tum:
5252 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tum:
5253 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tum:
5254 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tum:
5255 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tum:
5256 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tum:
5257 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tum:
5258 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tum:
5259 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tum:
5260 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tum:
5261 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tum:
5262 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tum:
5263 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tum:
5264 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tum:
5265 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tum:
5266 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tum:
5267 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tum:
5268 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tum:
5269 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tum:
5270 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tum:
5271 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tum:
5272 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tum:
5273 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tum:
5274 case RISCVVector::BI__builtin_rvv_vfredosum_vs_rm_tum:
5275 case RISCVVector::BI__builtin_rvv_vfredusum_vs_rm_tum:
5276 case RISCVVector::BI__builtin_rvv_vfwredosum_vs_rm_tum:
5277 case RISCVVector::BI__builtin_rvv_vfwredusum_vs_rm_tum:
5278 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_tumu:
5279 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_tumu:
5280 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_tumu:
5281 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_tumu:
5282 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_tumu:
5283 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_tumu:
5284 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_tumu:
5285 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_tumu:
5286 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_tumu:
5287 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_tumu:
5288 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_tumu:
5289 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_tumu:
5290 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_tumu:
5291 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_tumu:
5292 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_tumu:
5293 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_tumu:
5294 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_tumu:
5295 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_tumu:
5296 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_tumu:
5297 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_tumu:
5298 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_tumu:
5299 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_tumu:
5300 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_tumu:
5301 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_tumu:
5302 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_tumu:
5303 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_tumu:
5304 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_tumu:
5305 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_tumu:
5306 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_tumu:
5307 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_tumu:
5308 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_tumu:
5309 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_tumu:
5310 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_tumu:
5311 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_tumu:
5312 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_tumu:
5313 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_tumu:
5314 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_tumu:
5315 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_tumu:
5316 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_tumu:
5317 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_tumu:
5318 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_tumu:
5319 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_tumu:
5320 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_tumu:
5321 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_tumu:
5322 case RISCVVector::BI__builtin_rvv_vfadd_vv_rm_mu:
5323 case RISCVVector::BI__builtin_rvv_vfadd_vf_rm_mu:
5324 case RISCVVector::BI__builtin_rvv_vfsub_vv_rm_mu:
5325 case RISCVVector::BI__builtin_rvv_vfsub_vf_rm_mu:
5326 case RISCVVector::BI__builtin_rvv_vfrsub_vf_rm_mu:
5327 case RISCVVector::BI__builtin_rvv_vfwadd_vv_rm_mu:
5328 case RISCVVector::BI__builtin_rvv_vfwadd_vf_rm_mu:
5329 case RISCVVector::BI__builtin_rvv_vfwsub_vv_rm_mu:
5330 case RISCVVector::BI__builtin_rvv_vfwsub_vf_rm_mu:
5331 case RISCVVector::BI__builtin_rvv_vfwadd_wv_rm_mu:
5332 case RISCVVector::BI__builtin_rvv_vfwadd_wf_rm_mu:
5333 case RISCVVector::BI__builtin_rvv_vfwsub_wv_rm_mu:
5334 case RISCVVector::BI__builtin_rvv_vfwsub_wf_rm_mu:
5335 case RISCVVector::BI__builtin_rvv_vfmul_vv_rm_mu:
5336 case RISCVVector::BI__builtin_rvv_vfmul_vf_rm_mu:
5337 case RISCVVector::BI__builtin_rvv_vfdiv_vv_rm_mu:
5338 case RISCVVector::BI__builtin_rvv_vfdiv_vf_rm_mu:
5339 case RISCVVector::BI__builtin_rvv_vfrdiv_vf_rm_mu:
5340 case RISCVVector::BI__builtin_rvv_vfwmul_vv_rm_mu:
5341 case RISCVVector::BI__builtin_rvv_vfwmul_vf_rm_mu:
5342 case RISCVVector::BI__builtin_rvv_vfmacc_vv_rm_mu:
5343 case RISCVVector::BI__builtin_rvv_vfmacc_vf_rm_mu:
5344 case RISCVVector::BI__builtin_rvv_vfnmacc_vv_rm_mu:
5345 case RISCVVector::BI__builtin_rvv_vfnmacc_vf_rm_mu:
5346 case RISCVVector::BI__builtin_rvv_vfmsac_vv_rm_mu:
5347 case RISCVVector::BI__builtin_rvv_vfmsac_vf_rm_mu:
5348 case RISCVVector::BI__builtin_rvv_vfnmsac_vv_rm_mu:
5349 case RISCVVector::BI__builtin_rvv_vfnmsac_vf_rm_mu:
5350 case RISCVVector::BI__builtin_rvv_vfmadd_vv_rm_mu:
5351 case RISCVVector::BI__builtin_rvv_vfmadd_vf_rm_mu:
5352 case RISCVVector::BI__builtin_rvv_vfnmadd_vv_rm_mu:
5353 case RISCVVector::BI__builtin_rvv_vfnmadd_vf_rm_mu:
5354 case RISCVVector::BI__builtin_rvv_vfmsub_vv_rm_mu:
5355 case RISCVVector::BI__builtin_rvv_vfmsub_vf_rm_mu:
5356 case RISCVVector::BI__builtin_rvv_vfnmsub_vv_rm_mu:
5357 case RISCVVector::BI__builtin_rvv_vfnmsub_vf_rm_mu:
5358 case RISCVVector::BI__builtin_rvv_vfwmacc_vv_rm_mu:
5359 case RISCVVector::BI__builtin_rvv_vfwmacc_vf_rm_mu:
5360 case RISCVVector::BI__builtin_rvv_vfwnmacc_vv_rm_mu:
5361 case RISCVVector::BI__builtin_rvv_vfwnmacc_vf_rm_mu:
5362 case RISCVVector::BI__builtin_rvv_vfwmsac_vv_rm_mu:
5363 case RISCVVector::BI__builtin_rvv_vfwmsac_vf_rm_mu:
5364 case RISCVVector::BI__builtin_rvv_vfwnmsac_vv_rm_mu:
5365 case RISCVVector::BI__builtin_rvv_vfwnmsac_vf_rm_mu:
5366 return SemaBuiltinConstantArgRange(TheCall, 4, 0, 4);
5367 case RISCV::BI__builtin_riscv_ntl_load:
5368 case RISCV::BI__builtin_riscv_ntl_store:
5369 DeclRefExpr *DRE =
5370 cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
5371 assert((BuiltinID == RISCV::BI__builtin_riscv_ntl_store ||
5372 BuiltinID == RISCV::BI__builtin_riscv_ntl_load) &&
5373 "Unexpected RISC-V nontemporal load/store builtin!");
5374 bool IsStore = BuiltinID == RISCV::BI__builtin_riscv_ntl_store;
5375 unsigned NumArgs = IsStore ? 3 : 2;
5376
5377 if (checkArgCountAtLeast(*this, TheCall, NumArgs - 1))
5378 return true;
5379
5380 if (checkArgCountAtMost(*this, TheCall, NumArgs))
5381 return true;
5382
5383 // Domain value should be compile-time constant.
5384 // 2 <= domain <= 5
5385 if (TheCall->getNumArgs() == NumArgs &&
5386 SemaBuiltinConstantArgRange(TheCall, NumArgs - 1, 2, 5))
5387 return true;
5388
5389 Expr *PointerArg = TheCall->getArg(0);
5390 ExprResult PointerArgResult =
5392
5393 if (PointerArgResult.