//===- SemaChecking.cpp - Extra Semantic Checking -------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements extra semantic analysis beyond what is enforced // by the C type system. // //===----------------------------------------------------------------------===// #include "clang/AST/APValue.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Attr.h" #include "clang/AST/AttrIterator.h" #include "clang/AST/CharUnits.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclBase.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclarationName.h" #include "clang/AST/EvaluatedExprVisitor.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/ExprObjC.h" #include "clang/AST/ExprOpenMP.h" #include "clang/AST/FormatString.h" #include "clang/AST/IgnoreExpr.h" #include "clang/AST/NSAPI.h" #include "clang/AST/NonTrivialTypeVisitor.h" #include "clang/AST/OperationKinds.h" #include "clang/AST/RecordLayout.h" #include "clang/AST/Stmt.h" #include "clang/AST/TemplateBase.h" #include "clang/AST/Type.h" #include "clang/AST/TypeLoc.h" #include "clang/AST/UnresolvedSet.h" #include "clang/Basic/AddressSpaces.h" #include "clang/Basic/CharInfo.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/OpenCLOptions.h" #include "clang/Basic/OperatorKinds.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/Specifiers.h" #include "clang/Basic/SyncScope.h" #include "clang/Basic/TargetBuiltins.h" #include "clang/Basic/TargetCXXABI.h" #include "clang/Basic/TargetInfo.h" #include "clang/Basic/TypeTraits.h" #include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering. #include "clang/Sema/Initialization.h" #include "clang/Sema/Lookup.h" #include "clang/Sema/Ownership.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" #include "clang/Sema/Sema.h" #include "clang/Sema/SemaAMDGPU.h" #include "clang/Sema/SemaARM.h" #include "clang/Sema/SemaBPF.h" #include "clang/Sema/SemaHLSL.h" #include "clang/Sema/SemaHexagon.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaLoongArch.h" #include "clang/Sema/SemaMIPS.h" #include "clang/Sema/SemaNVPTX.h" #include "clang/Sema/SemaObjC.h" #include "clang/Sema/SemaOpenCL.h" #include "clang/Sema/SemaPPC.h" #include "clang/Sema/SemaRISCV.h" #include "clang/Sema/SemaSystemZ.h" #include "clang/Sema/SemaWasm.h" #include "clang/Sema/SemaX86.h" #include "llvm/ADT/APFloat.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/APSInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallBitVector.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringSet.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/Support/AtomicOrdering.h" #include "llvm/Support/Casting.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/Format.h" #include "llvm/Support/Locale.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/SaveAndRestore.h" #include "llvm/Support/raw_ostream.h" #include "llvm/TargetParser/RISCVTargetParser.h" #include "llvm/TargetParser/Triple.h" #include <algorithm> #include <bitset> #include <cassert> #include <cctype> #include <cstddef> #include <cstdint> #include <functional> #include <limits> #include <optional> #include <string> #include <tuple> #include <utility> usingnamespaceclang; usingnamespacesema; SourceLocation Sema::getLocationOfStringLiteralByte(const StringLiteral *SL, unsigned ByteNo) const { … } static constexpr unsigned short combineFAPK(Sema::FormatArgumentPassingKind A, Sema::FormatArgumentPassingKind B) { … } bool Sema::checkArgCountAtLeast(CallExpr *Call, unsigned MinArgCount) { … } bool Sema::checkArgCountAtMost(CallExpr *Call, unsigned MaxArgCount) { … } bool Sema::checkArgCountRange(CallExpr *Call, unsigned MinArgCount, unsigned MaxArgCount) { … } bool Sema::checkArgCount(CallExpr *Call, unsigned DesiredArgCount) { … } static bool checkBuiltinVerboseTrap(CallExpr *Call, Sema &S) { … } static bool convertArgumentToType(Sema &S, Expr *&Value, QualType Ty) { … } /// Check that the first argument to __builtin_annotation is an integer /// and the second argument is a non-wide string literal. static bool BuiltinAnnotation(Sema &S, CallExpr *TheCall) { … } static bool BuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall) { … } /// Check that the argument to __builtin_addressof is a glvalue, and set the /// result type to the corresponding pointer type. static bool BuiltinAddressof(Sema &S, CallExpr *TheCall) { … } /// Check that the argument to __builtin_function_start is a function. static bool BuiltinFunctionStart(Sema &S, CallExpr *TheCall) { … } /// Check the number of arguments and set the result type to /// the argument type. static bool BuiltinPreserveAI(Sema &S, CallExpr *TheCall) { … } /// Check that the value argument for __builtin_is_aligned(value, alignment) and /// __builtin_aligned_{up,down}(value, alignment) is an integer or a pointer /// type (but not a function pointer) and that the alignment is a power-of-two. static bool BuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) { … } static bool BuiltinOverflow(Sema &S, CallExpr *TheCall, unsigned BuiltinID) { … } namespace { struct BuiltinDumpStructGenerator { … }; } // namespace static ExprResult BuiltinDumpStruct(Sema &S, CallExpr *TheCall) { … } static bool BuiltinCallWithStaticChain(Sema &S, CallExpr *BuiltinCall) { … } namespace { class ScanfDiagnosticFormatHandler : public analyze_format_string::FormatStringHandler { … }; class EstimateSizeFormatHandler : public analyze_format_string::FormatStringHandler { … }; } // namespace static bool ProcessFormatStringLiteral(const Expr *FormatExpr, StringRef &FormatStrRef, size_t &StrLen, ASTContext &Context) { … } void Sema::checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, CallExpr *TheCall) { … } static bool BuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall, Scope::ScopeFlags NeededScopeFlags, unsigned DiagID) { … } // In OpenCL, __builtin_alloca_* should return a pointer to address space // that corresponds to the stack address space i.e private address space. static void builtinAllocaAddrSpace(Sema &S, CallExpr *TheCall) { … } namespace { enum PointerAuthOpKind { … }; } bool Sema::checkPointerAuthEnabled(SourceLocation Loc, SourceRange Range) { … } static bool checkPointerAuthEnabled(Sema &S, Expr *E) { … } static bool checkPointerAuthKey(Sema &S, Expr *&Arg) { … } bool Sema::checkConstantPointerAuthKey(Expr *Arg, unsigned &Result) { … } static std::pair<const ValueDecl *, CharUnits> findConstantBaseAndOffset(Sema &S, Expr *E) { … } static bool checkPointerAuthValue(Sema &S, Expr *&Arg, PointerAuthOpKind OpKind, bool RequireConstant = false) { … } static ExprResult PointerAuthStrip(Sema &S, CallExpr *Call) { … } static ExprResult PointerAuthBlendDiscriminator(Sema &S, CallExpr *Call) { … } static ExprResult PointerAuthSignGenericData(Sema &S, CallExpr *Call) { … } static ExprResult PointerAuthSignOrAuth(Sema &S, CallExpr *Call, PointerAuthOpKind OpKind, bool RequireConstant) { … } static ExprResult PointerAuthAuthAndResign(Sema &S, CallExpr *Call) { … } static ExprResult PointerAuthStringDiscriminator(Sema &S, CallExpr *Call) { … } static ExprResult BuiltinLaunder(Sema &S, CallExpr *TheCall) { … } static ExprResult BuiltinIsWithinLifetime(Sema &S, CallExpr *TheCall) { … } // Emit an error and return true if the current object format type is in the // list of unsupported types. static bool CheckBuiltinTargetNotInUnsupported( Sema &S, unsigned BuiltinID, CallExpr *TheCall, ArrayRef<llvm::Triple::ObjectFormatType> UnsupportedObjectFormatTypes) { … } // Emit an error and return true if the current architecture is not in the list // of supported architectures. static bool CheckBuiltinTargetInSupported(Sema &S, CallExpr *TheCall, ArrayRef<llvm::Triple::ArchType> SupportedArchs) { … } static void CheckNonNullArgument(Sema &S, const Expr *ArgExpr, SourceLocation CallSiteLoc); bool Sema::CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, CallExpr *TheCall) { … } // Check if \p Ty is a valid type for the elementwise math builtins. If it is // not a valid type, emit an error message and return true. Otherwise return // false. static bool checkMathBuiltinElementType(Sema &S, SourceLocation Loc, QualType ArgTy, int ArgIndex) { … } static bool checkFPMathBuiltinElementType(Sema &S, SourceLocation Loc, QualType ArgTy, int ArgIndex) { … } /// BuiltinCpu{Supports|Is} - Handle __builtin_cpu_{supports|is}(char *). /// This checks that the target supports the builtin and that the string /// argument is constant and valid. static bool BuiltinCpu(Sema &S, const TargetInfo &TI, CallExpr *TheCall, const TargetInfo *AuxTI, unsigned BuiltinID) { … } /// Checks that __builtin_popcountg was called with a single argument, which is /// an unsigned integer. static bool BuiltinPopcountg(Sema &S, CallExpr *TheCall) { … } /// Checks that __builtin_{clzg,ctzg} was called with a first argument, which is /// an unsigned integer, and an optional second argument, which is promoted to /// an 'int'. static bool BuiltinCountZeroBitsGeneric(Sema &S, CallExpr *TheCall) { … } ExprResult Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID, CallExpr *TheCall) { … } bool Sema::ValueIsRunOfOnes(CallExpr *TheCall, unsigned ArgNum) { … } bool Sema::getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember, bool IsVariadic, FormatStringInfo *FSI) { … } /// Checks if a the given expression evaluates to null. /// /// Returns true if the value evaluates to null. static bool CheckNonNullExpr(Sema &S, const Expr *Expr) { … } static void CheckNonNullArgument(Sema &S, const Expr *ArgExpr, SourceLocation CallSiteLoc) { … } /// Determine whether the given type has a non-null nullability annotation. static bool isNonNullType(QualType type) { … } static void CheckNonNullArguments(Sema &S, const NamedDecl *FDecl, const FunctionProtoType *Proto, ArrayRef<const Expr *> Args, SourceLocation CallSiteLoc) { … } void Sema::CheckArgAlignment(SourceLocation Loc, NamedDecl *FDecl, StringRef ParamName, QualType ArgTy, QualType ParamTy) { … } void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, const Expr *ThisArg, ArrayRef<const Expr *> Args, bool IsMemberFunction, SourceLocation Loc, SourceRange Range, VariadicCallType CallType) { … } void Sema::CheckConstrainedAuto(const AutoType *AutoT, SourceLocation Loc) { … } void Sema::CheckConstructorCall(FunctionDecl *FDecl, QualType ThisType, ArrayRef<const Expr *> Args, const FunctionProtoType *Proto, SourceLocation Loc) { … } bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall, const FunctionProtoType *Proto) { … } bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall, const FunctionProtoType *Proto) { … } bool Sema::CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto) { … } static bool isValidOrderingForOp(int64_t Ordering, AtomicExpr::AtomicOp Op) { … } ExprResult Sema::AtomicOpsOverloaded(ExprResult TheCallResult, AtomicExpr::AtomicOp Op) { … } ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, SourceLocation RParenLoc, MultiExprArg Args, AtomicExpr::AtomicOp Op, AtomicArgumentOrder ArgOrder) { … } /// checkBuiltinArgument - Given a call to a builtin function, perform /// normal type-checking on the given argument, updating the call in /// place. This is useful when a builtin function requires custom /// type-checking for some of its arguments but not necessarily all of /// them. /// /// Returns true on error. static bool checkBuiltinArgument(Sema &S, CallExpr *E, unsigned ArgIndex) { … } ExprResult Sema::BuiltinAtomicOverloaded(ExprResult TheCallResult) { … } ExprResult Sema::BuiltinNontemporalOverloaded(ExprResult TheCallResult) { … } /// CheckObjCString - Checks that the format string argument to the os_log() /// and os_trace() functions is correct, and converts it to const char *. ExprResult Sema::CheckOSLogFormatStringArg(Expr *Arg) { … } /// Check that the user is calling the appropriate va_start builtin for the /// target and calling convention. static bool checkVAStartABI(Sema &S, unsigned BuiltinID, Expr *Fn) { … } static bool checkVAStartIsInVariadicFunction(Sema &S, Expr *Fn, ParmVarDecl **LastParam = nullptr) { … } bool Sema::BuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall) { … } bool Sema::BuiltinVAStartARMMicrosoft(CallExpr *Call) { … } bool Sema::BuiltinUnorderedCompare(CallExpr *TheCall, unsigned BuiltinID) { … } bool Sema::BuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs, unsigned BuiltinID) { … } bool Sema::BuiltinComplex(CallExpr *TheCall) { … } /// BuiltinShuffleVector - Handle __builtin_shufflevector. // This is declared to take (...), so we have to check everything. ExprResult Sema::BuiltinShuffleVector(CallExpr *TheCall) { … } ExprResult Sema::ConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo, SourceLocation BuiltinLoc, SourceLocation RParenLoc) { … } bool Sema::BuiltinPrefetch(CallExpr *TheCall) { … } bool Sema::BuiltinArithmeticFence(CallExpr *TheCall) { … } bool Sema::BuiltinAssume(CallExpr *TheCall) { … } bool Sema::BuiltinAllocaWithAlign(CallExpr *TheCall) { … } bool Sema::BuiltinAssumeAligned(CallExpr *TheCall) { … } bool Sema::BuiltinOSLogFormat(CallExpr *TheCall) { … } bool Sema::BuiltinConstantArg(CallExpr *TheCall, int ArgNum, llvm::APSInt &Result) { … } bool Sema::BuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low, int High, bool RangeIsError) { … } bool Sema::BuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum, unsigned Num) { … } bool Sema::BuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum) { … } static bool IsShiftedByte(llvm::APSInt Value) { … } bool Sema::BuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum, unsigned ArgBits) { … } bool Sema::BuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall, int ArgNum, unsigned ArgBits) { … } bool Sema::BuiltinLongjmp(CallExpr *TheCall) { … } bool Sema::BuiltinSetjmp(CallExpr *TheCall) { … } namespace { class UncoveredArgHandler { … }; enum StringLiteralCheckType { … }; } // namespace static void sumOffsets(llvm::APSInt &Offset, llvm::APSInt Addend, BinaryOperatorKind BinOpKind, bool AddendIsRight) { … } namespace { // This is a wrapper class around StringLiteral to support offsetted string // literals as format strings. It takes the offset into account when returning // the string and its length or the source locations to display notes correctly. class FormatStringLiteral { … }; } // namespace static void CheckFormatString( Sema &S, const FormatStringLiteral *FExpr, const Expr *OrigFormatExpr, ArrayRef<const Expr *> Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, Sema::FormatStringType Type, bool inFunctionCall, Sema::VariadicCallType CallType, llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg, bool IgnoreStringsWithoutSpecifiers); static const Expr *maybeConstEvalStringLiteral(ASTContext &Context, const Expr *E); // Determine if an expression is a string literal or constant string. // If this function returns false on the arguments to a function expecting a // format string, we will usually need to emit a warning. // True string literals are then checked by CheckFormatString. static StringLiteralCheckType checkFormatStringExpr(Sema &S, const Expr *E, ArrayRef<const Expr *> Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, Sema::FormatStringType Type, Sema::VariadicCallType CallType, bool InFunctionCall, llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg, llvm::APSInt Offset, bool IgnoreStringsWithoutSpecifiers = false) { … } // If this expression can be evaluated at compile-time, // check if the result is a StringLiteral and return it // otherwise return nullptr static const Expr *maybeConstEvalStringLiteral(ASTContext &Context, const Expr *E) { … } Sema::FormatStringType Sema::GetFormatStringType(const FormatAttr *Format) { … } bool Sema::CheckFormatArguments(const FormatAttr *Format, ArrayRef<const Expr *> Args, bool IsCXXMember, VariadicCallType CallType, SourceLocation Loc, SourceRange Range, llvm::SmallBitVector &CheckedVarArgs) { … } bool Sema::CheckFormatArguments(ArrayRef<const Expr *> Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, FormatStringType Type, VariadicCallType CallType, SourceLocation Loc, SourceRange Range, llvm::SmallBitVector &CheckedVarArgs) { … } namespace { class CheckFormatHandler : public analyze_format_string::FormatStringHandler { … }; } // namespace SourceRange CheckFormatHandler::getFormatStringRange() { … } CharSourceRange CheckFormatHandler:: getSpecifierRange(const char *startSpecifier, unsigned specifierLen) { … } SourceLocation CheckFormatHandler::getLocationOfByte(const char *x) { … } void CheckFormatHandler::HandleIncompleteSpecifier(const char *startSpecifier, unsigned specifierLen){ … } void CheckFormatHandler::HandleInvalidLengthModifier( const analyze_format_string::FormatSpecifier &FS, const analyze_format_string::ConversionSpecifier &CS, const char *startSpecifier, unsigned specifierLen, unsigned DiagID) { … } void CheckFormatHandler::HandleNonStandardLengthModifier( const analyze_format_string::FormatSpecifier &FS, const char *startSpecifier, unsigned specifierLen) { … } void CheckFormatHandler::HandleNonStandardConversionSpecifier( const analyze_format_string::ConversionSpecifier &CS, const char *startSpecifier, unsigned specifierLen) { … } void CheckFormatHandler::HandlePosition(const char *startPos, unsigned posLen) { … } void CheckFormatHandler::HandleInvalidPosition( const char *startSpecifier, unsigned specifierLen, analyze_format_string::PositionContext p) { … } void CheckFormatHandler::HandleZeroPosition(const char *startPos, unsigned posLen) { … } void CheckFormatHandler::HandleNullChar(const char *nullCharacter) { … } // Note that this may return NULL if there was an error parsing or building // one of the argument expressions. const Expr *CheckFormatHandler::getDataArg(unsigned i) const { … } void CheckFormatHandler::DoneProcessing() { … } void UncoveredArgHandler::Diagnose(Sema &S, bool IsFunctionCall, const Expr *ArgExpr) { … } bool CheckFormatHandler::HandleInvalidConversionSpecifier(unsigned argIndex, SourceLocation Loc, const char *startSpec, unsigned specifierLen, const char *csStart, unsigned csLen) { … } void CheckFormatHandler::HandlePositionalNonpositionalArgs(SourceLocation Loc, const char *startSpec, unsigned specifierLen) { … } bool CheckFormatHandler::CheckNumArgs( const analyze_format_string::FormatSpecifier &FS, const analyze_format_string::ConversionSpecifier &CS, const char *startSpecifier, unsigned specifierLen, unsigned argIndex) { … } template<typename Range> void CheckFormatHandler::EmitFormatDiagnostic(PartialDiagnostic PDiag, SourceLocation Loc, bool IsStringLocation, Range StringRange, ArrayRef<FixItHint> FixIt) { … } /// If the format string is not within the function call, emit a note /// so that the function call and string are in diagnostic messages. /// /// \param InFunctionCall if true, the format string is within the function /// call and only one diagnostic message will be produced. Otherwise, an /// extra note will be emitted pointing to location of the format string. /// /// \param ArgumentExpr the expression that is passed as the format string /// argument in the function call. Used for getting locations when two /// diagnostics are emitted. /// /// \param PDiag the callee should already have provided any strings for the /// diagnostic message. This function only adds locations and fixits /// to diagnostics. /// /// \param Loc primary location for diagnostic. If two diagnostics are /// required, one will be at Loc and a new SourceLocation will be created for /// the other one. /// /// \param IsStringLocation if true, Loc points to the format string should be /// used for the note. Otherwise, Loc points to the argument list and will /// be used with PDiag. /// /// \param StringRange some or all of the string to highlight. This is /// templated so it can accept either a CharSourceRange or a SourceRange. /// /// \param FixIt optional fix it hint for the format string. template <typename Range> void CheckFormatHandler::EmitFormatDiagnostic( Sema &S, bool InFunctionCall, const Expr *ArgumentExpr, const PartialDiagnostic &PDiag, SourceLocation Loc, bool IsStringLocation, Range StringRange, ArrayRef<FixItHint> FixIt) { … } //===--- CHECK: Printf format string checking -----------------------------===// namespace { class CheckPrintfHandler : public CheckFormatHandler { … }; } // namespace bool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier( const analyze_printf::PrintfSpecifier &FS, const char *startSpecifier, unsigned specifierLen) { … } void CheckPrintfHandler::handleInvalidMaskType(StringRef MaskType) { … } bool CheckPrintfHandler::HandleAmount( const analyze_format_string::OptionalAmount &Amt, unsigned k, const char *startSpecifier, unsigned specifierLen) { … } void CheckPrintfHandler::HandleInvalidAmount( const analyze_printf::PrintfSpecifier &FS, const analyze_printf::OptionalAmount &Amt, unsigned type, const char *startSpecifier, unsigned specifierLen) { … } void CheckPrintfHandler::HandleFlag(const analyze_printf::PrintfSpecifier &FS, const analyze_printf::OptionalFlag &flag, const char *startSpecifier, unsigned specifierLen) { … } void CheckPrintfHandler::HandleIgnoredFlag( const analyze_printf::PrintfSpecifier &FS, const analyze_printf::OptionalFlag &ignoredFlag, const analyze_printf::OptionalFlag &flag, const char *startSpecifier, unsigned specifierLen) { … } void CheckPrintfHandler::HandleEmptyObjCModifierFlag(const char *startFlag, unsigned flagLen) { … } void CheckPrintfHandler::HandleInvalidObjCModifierFlag(const char *startFlag, unsigned flagLen) { … } void CheckPrintfHandler::HandleObjCFlagsWithNonObjCConversion( const char *flagsStart, const char *flagsEnd, const char *conversionPosition) { … } // Determines if the specified is a C++ class or struct containing // a member with the specified name and kind (e.g. a CXXMethodDecl named // "c_str()"). template<typename MemberKind> static llvm::SmallPtrSet<MemberKind*, 1> CXXRecordMembersNamed(StringRef Name, Sema &S, QualType Ty) { … } /// Check if we could call '.c_str()' on an object. /// /// FIXME: This returns the wrong results in some cases (if cv-qualifiers don't /// allow the call, or if it would be ambiguous). bool Sema::hasCStrMethod(const Expr *E) { … } // Check if a (w)string was passed when a (w)char* was needed, and offer a // better diagnostic if so. AT is assumed to be valid. // Returns true when a c_str() conversion method is found. bool CheckPrintfHandler::checkForCStrMembers( const analyze_printf::ArgType &AT, const Expr *E) { … } bool CheckPrintfHandler::HandlePrintfSpecifier( const analyze_printf::PrintfSpecifier &FS, const char *startSpecifier, unsigned specifierLen, const TargetInfo &Target) { … } static bool requiresParensToAddCast(const Expr *E) { … } static std::pair<QualType, StringRef> shouldNotPrintDirectly(const ASTContext &Context, QualType IntendedTy, const Expr *E) { … } /// Return true if \p ICE is an implicit argument promotion of an arithmetic /// type. Bit-field 'promotions' from a higher ranked type to a lower ranked /// type do not count. static bool isArithmeticArgumentPromotion(Sema &S, const ImplicitCastExpr *ICE) { … } static analyze_format_string::ArgType::MatchKind handleFormatSignedness(analyze_format_string::ArgType::MatchKind Match, DiagnosticsEngine &Diags, SourceLocation Loc) { … } bool CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS, const char *StartSpecifier, unsigned SpecifierLen, const Expr *E) { … } //===--- CHECK: Scanf format string checking ------------------------------===// namespace { class CheckScanfHandler : public CheckFormatHandler { … }; } // namespace void CheckScanfHandler::HandleIncompleteScanList(const char *start, const char *end) { … } bool CheckScanfHandler::HandleInvalidScanfConversionSpecifier( const analyze_scanf::ScanfSpecifier &FS, const char *startSpecifier, unsigned specifierLen) { … } bool CheckScanfHandler::HandleScanfSpecifier( const analyze_scanf::ScanfSpecifier &FS, const char *startSpecifier, unsigned specifierLen) { … } static void CheckFormatString( Sema &S, const FormatStringLiteral *FExpr, const Expr *OrigFormatExpr, ArrayRef<const Expr *> Args, Sema::FormatArgumentPassingKind APK, unsigned format_idx, unsigned firstDataArg, Sema::FormatStringType Type, bool inFunctionCall, Sema::VariadicCallType CallType, llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg, bool IgnoreStringsWithoutSpecifiers) { … } bool Sema::FormatStringHasSArg(const StringLiteral *FExpr) { … } //===--- CHECK: Warn on use of wrong absolute value function. -------------===// // Returns the related absolute value function that is larger, of 0 if one // does not exist. static unsigned getLargerAbsoluteValueFunction(unsigned AbsFunction) { … } // Returns the argument type of the absolute value function. static QualType getAbsoluteValueArgumentType(ASTContext &Context, unsigned AbsType) { … } // Returns the best absolute value function, or zero, based on type and // current absolute value function. static unsigned getBestAbsFunction(ASTContext &Context, QualType ArgType, unsigned AbsFunctionKind) { … } enum AbsoluteValueKind { … }; static AbsoluteValueKind getAbsoluteValueKind(QualType T) { … } // Changes the absolute value function to a different type. Preserves whether // the function is a builtin. static unsigned changeAbsFunction(unsigned AbsKind, AbsoluteValueKind ValueKind) { … } static unsigned getAbsoluteValueFunctionKind(const FunctionDecl *FDecl) { … } // If the replacement is valid, emit a note with replacement function. // Additionally, suggest including the proper header if not already included. static void emitReplacement(Sema &S, SourceLocation Loc, SourceRange Range, unsigned AbsKind, QualType ArgType) { … } template <std::size_t StrLen> static bool IsStdFunction(const FunctionDecl *FDecl, const char (&Str)[StrLen]) { … } enum class MathCheck { … }; static bool IsInfOrNanFunction(StringRef calleeName, MathCheck Check) { … } void Sema::CheckInfNaNFunction(const CallExpr *Call, const FunctionDecl *FDecl) { … } void Sema::CheckAbsoluteValueFunction(const CallExpr *Call, const FunctionDecl *FDecl) { … } //===--- CHECK: Warn on use of std::max and unsigned zero. r---------------===// void Sema::CheckMaxUnsignedZero(const CallExpr *Call, const FunctionDecl *FDecl) { … } //===--- CHECK: Standard memory functions ---------------------------------===// /// Takes the expression passed to the size_t parameter of functions /// such as memcmp, strncat, etc and warns if it's a comparison. /// /// This is to catch typos like `if (memcmp(&a, &b, sizeof(a) > 0))`. static bool CheckMemorySizeofForComparison(Sema &S, const Expr *E, IdentifierInfo *FnName, SourceLocation FnLoc, SourceLocation RParenLoc) { … } /// Determine whether the given type is or contains a dynamic class type /// (e.g., whether it has a vtable). static const CXXRecordDecl *getContainedDynamicClass(QualType T, bool &IsContained) { … } static const UnaryExprOrTypeTraitExpr *getAsSizeOfExpr(const Expr *E) { … } /// If E is a sizeof expression, returns its argument expression, /// otherwise returns NULL. static const Expr *getSizeOfExprArg(const Expr *E) { … } /// If E is a sizeof expression, returns its argument type. static QualType getSizeOfArgType(const Expr *E) { … } namespace { struct SearchNonTrivialToInitializeField : DefaultInitializedTypeVisitor<SearchNonTrivialToInitializeField> { … }; struct SearchNonTrivialToCopyField : CopiedTypeVisitor<SearchNonTrivialToCopyField, false> { … }; } /// Detect if \c SizeofExpr is likely to calculate the sizeof an object. static bool doesExprLikelyComputeSize(const Expr *SizeofExpr) { … } /// Check if the ArgLoc originated from a macro passed to the call at CallLoc. /// /// \code /// #define MACRO 0 /// foo(MACRO); /// foo(0); /// \endcode /// /// This should return true for the first call to foo, but not for the second /// (regardless of whether foo is a macro or function). static bool isArgumentExpandedFromMacro(SourceManager &SM, SourceLocation CallLoc, SourceLocation ArgLoc) { … } /// Diagnose cases like 'memset(buf, sizeof(buf), 0)', which should have the /// last two arguments transposed. static void CheckMemaccessSize(Sema &S, unsigned BId, const CallExpr *Call) { … } void Sema::CheckMemaccessArguments(const CallExpr *Call, unsigned BId, IdentifierInfo *FnName) { … } // A little helper routine: ignore addition and subtraction of integer literals. // This intentionally does not ignore all integer constant expressions because // we don't want to remove sizeof(). static const Expr *ignoreLiteralAdditions(const Expr *Ex, ASTContext &Ctx) { … } static bool isConstantSizeArrayWithMoreThanOneElement(QualType Ty, ASTContext &Context) { … } void Sema::CheckStrlcpycatArguments(const CallExpr *Call, IdentifierInfo *FnName) { … } /// Check if two expressions refer to the same declaration. static bool referToTheSameDecl(const Expr *E1, const Expr *E2) { … } static const Expr *getStrlenExprArg(const Expr *E) { … } void Sema::CheckStrncatArguments(const CallExpr *CE, IdentifierInfo *FnName) { … } namespace { void CheckFreeArgumentsOnLvalue(Sema &S, const std::string &CalleeName, const UnaryOperator *UnaryExpr, const Decl *D) { … } void CheckFreeArgumentsAddressof(Sema &S, const std::string &CalleeName, const UnaryOperator *UnaryExpr) { … } void CheckFreeArgumentsPlus(Sema &S, const std::string &CalleeName, const UnaryOperator *UnaryExpr) { … } void CheckFreeArgumentsStackArray(Sema &S, const std::string &CalleeName, const DeclRefExpr *Lvalue) { … } void CheckFreeArgumentsCast(Sema &S, const std::string &CalleeName, const CastExpr *Cast) { … } } // namespace void Sema::CheckFreeArguments(const CallExpr *E) { … } void Sema::CheckReturnValExpr(Expr *RetValExp, QualType lhsType, SourceLocation ReturnLoc, bool isObjCMethod, const AttrVec *Attrs, const FunctionDecl *FD) { … } void Sema::CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opcode) { … } //===--- CHECK: Integer mixed-sign comparisons (-Wsign-compare) --------===// //===--- CHECK: Lossy implicit conversions (-Wconversion) --------------===// namespace { /// Structure recording the 'active' range of an integer-valued /// expression. struct IntRange { … }; } // namespace static IntRange GetValueRange(ASTContext &C, llvm::APSInt &value, unsigned MaxWidth) { … } static IntRange GetValueRange(ASTContext &C, APValue &result, QualType Ty, unsigned MaxWidth) { … } static QualType GetExprType(const Expr *E) { … } /// Pseudo-evaluate the given integer expression, estimating the /// range of values it might take. /// /// \param MaxWidth The width to which the value will be truncated. /// \param Approximate If \c true, return a likely range for the result: in /// particular, assume that arithmetic on narrower types doesn't leave /// those types. If \c false, return a range including all possible /// result values. static IntRange GetExprRange(ASTContext &C, const Expr *E, unsigned MaxWidth, bool InConstantContext, bool Approximate) { … } static IntRange GetExprRange(ASTContext &C, const Expr *E, bool InConstantContext, bool Approximate) { … } /// Checks whether the given value, which currently has the given /// source semantics, has the same value when coerced through the /// target semantics. static bool IsSameFloatAfterCast(const llvm::APFloat &value, const llvm::fltSemantics &Src, const llvm::fltSemantics &Tgt) { … } /// Checks whether the given value, which currently has the given /// source semantics, has the same value when coerced through the /// target semantics. /// /// The value might be a vector of floats (or a complex number). static bool IsSameFloatAfterCast(const APValue &value, const llvm::fltSemantics &Src, const llvm::fltSemantics &Tgt) { … } static void AnalyzeImplicitConversions(Sema &S, Expr *E, SourceLocation CC, bool IsListInit = false); static bool IsEnumConstOrFromMacro(Sema &S, Expr *E) { … } static bool isKnownToHaveUnsignedValue(Expr *E) { … } namespace { /// The promoted range of values of a type. In general this has the /// following structure: /// /// |-----------| . . . |-----------| /// ^ ^ ^ ^ /// Min HoleMin HoleMax Max /// /// ... where there is only a hole if a signed type is promoted to unsigned /// (in which case Min and Max are the smallest and largest representable /// values). struct PromotedRange { … }; } static bool HasEnumType(Expr *E) { … } static int classifyConstantValue(Expr *Constant) { … } static bool CheckTautologicalComparison(Sema &S, BinaryOperator *E, Expr *Constant, Expr *Other, const llvm::APSInt &Value, bool RhsConstant) { … } /// Analyze the operands of the given comparison. Implements the /// fallback case from AnalyzeComparison. static void AnalyzeImpConvsInComparison(Sema &S, BinaryOperator *E) { … } /// Implements -Wsign-compare. /// /// \param E the binary operator to check for warnings static void AnalyzeComparison(Sema &S, BinaryOperator *E) { … } /// Analyzes an attempt to assign the given value to a bitfield. /// /// Returns true if there was something fishy about the attempt. static bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init, SourceLocation InitLoc) { … } /// Analyze the given simple or compound assignment for warning-worthy /// operations. static void AnalyzeAssignment(Sema &S, BinaryOperator *E) { … } /// Diagnose an implicit cast; purely a helper for CheckImplicitConversion. static void DiagnoseImpCast(Sema &S, Expr *E, QualType SourceType, QualType T, SourceLocation CContext, unsigned diag, bool pruneControlFlow = false) { … } /// Diagnose an implicit cast; purely a helper for CheckImplicitConversion. static void DiagnoseImpCast(Sema &S, Expr *E, QualType T, SourceLocation CContext, unsigned diag, bool pruneControlFlow = false) { … } /// Diagnose an implicit cast from a floating point value to an integer value. static void DiagnoseFloatingImpCast(Sema &S, Expr *E, QualType T, SourceLocation CContext) { … } /// Analyze the given compound assignment for the possible losing of /// floating-point precision. static void AnalyzeCompoundAssignment(Sema &S, BinaryOperator *E) { … } static std::string PrettyPrintInRange(const llvm::APSInt &Value, IntRange Range) { … } static bool IsImplicitBoolFloatConversion(Sema &S, Expr *Ex, bool ToBool) { … } static void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall, SourceLocation CC) { … } static void DiagnoseNullConversion(Sema &S, Expr *E, QualType T, SourceLocation CC) { … } // Helper function to filter out cases for constant width constant conversion. // Don't warn on char array initialization or for non-decimal values. static bool isSameWidthConstantConversion(Sema &S, Expr *E, QualType T, SourceLocation CC) { … } static const IntegerLiteral *getIntegerLiteral(Expr *E) { … } static void DiagnoseIntInBoolContext(Sema &S, Expr *E) { … } void Sema::CheckImplicitConversion(Expr *E, QualType T, SourceLocation CC, bool *ICContext, bool IsListInit) { … } static void CheckConditionalOperator(Sema &S, AbstractConditionalOperator *E, SourceLocation CC, QualType T); static void CheckConditionalOperand(Sema &S, Expr *E, QualType T, SourceLocation CC, bool &ICContext) { … } static void CheckConditionalOperator(Sema &S, AbstractConditionalOperator *E, SourceLocation CC, QualType T) { … } /// Check conversion of given expression to boolean. /// Input argument E is a logical expression. static void CheckBoolLikeConversion(Sema &S, Expr *E, SourceLocation CC) { … } namespace { struct AnalyzeImplicitConversionsWorkItem { … }; } /// Data recursive variant of AnalyzeImplicitConversions. Subexpressions /// that should be visited are added to WorkList. static void AnalyzeImplicitConversions( Sema &S, AnalyzeImplicitConversionsWorkItem Item, llvm::SmallVectorImpl<AnalyzeImplicitConversionsWorkItem> &WorkList) { … } /// AnalyzeImplicitConversions - Find and report any interesting /// implicit conversions in the given expression. There are a couple /// of competing diagnostics here, -Wconversion and -Wsign-compare. static void AnalyzeImplicitConversions(Sema &S, Expr *OrigE, SourceLocation CC, bool IsListInit/*= false*/) { … } // Helper function for Sema::DiagnoseAlwaysNonNullPointer. // Returns true when emitting a warning about taking the address of a reference. static bool CheckForReference(Sema &SemaRef, const Expr *E, const PartialDiagnostic &PD) { … } // Returns true if the SourceLocation is expanded from any macro body. // Returns false if the SourceLocation is invalid, is from not in a macro // expansion, or is from expanded from a top-level macro argument. static bool IsInAnyMacroBody(const SourceManager &SM, SourceLocation Loc) { … } void Sema::DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullKind, bool IsEqual, SourceRange Range) { … } void Sema::CheckImplicitConversions(Expr *E, SourceLocation CC) { … } void Sema::CheckBoolLikeConversion(Expr *E, SourceLocation CC) { … } void Sema::CheckForIntOverflow (const Expr *E) { … } namespace { /// Visitor for expressions which looks for unsequenced operations on the /// same object. class SequenceChecker : public ConstEvaluatedExprVisitor<SequenceChecker> { … }; SequenceChecker::UsageInfo::UsageInfo() = default; } // namespace void Sema::CheckUnsequencedOperations(const Expr *E) { … } void Sema::CheckCompletedExpr(Expr *E, SourceLocation CheckLoc, bool IsConstexpr) { … } void Sema::CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *BitField, Expr *Init) { … } static void diagnoseArrayStarInParamType(Sema &S, QualType PType, SourceLocation Loc) { … } bool Sema::CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters, bool CheckParameterNames) { … } std::optional<std::pair< CharUnits, CharUnits>> static getBaseAlignmentAndOffsetFromPtr(const Expr *E, ASTContext &Ctx); /// Compute the alignment and offset of the base class object given the /// derived-to-base cast expression and the alignment and offset of the derived /// class object. static std::pair<CharUnits, CharUnits> getDerivedToBaseAlignmentAndOffset(const CastExpr *CE, QualType DerivedType, CharUnits BaseAlignment, CharUnits Offset, ASTContext &Ctx) { … } /// Compute the alignment and offset of a binary additive operator. static std::optional<std::pair<CharUnits, CharUnits>> getAlignmentAndOffsetFromBinAddOrSub(const Expr *PtrE, const Expr *IntE, bool IsSub, ASTContext &Ctx) { … } /// This helper function takes an lvalue expression and returns the alignment of /// a VarDecl and a constant offset from the VarDecl. std::optional<std::pair< CharUnits, CharUnits>> static getBaseAlignmentAndOffsetFromLValue(const Expr *E, ASTContext &Ctx) { … } /// This helper function takes a pointer expression and returns the alignment of /// a VarDecl and a constant offset from the VarDecl. std::optional<std::pair< CharUnits, CharUnits>> static getBaseAlignmentAndOffsetFromPtr(const Expr *E, ASTContext &Ctx) { … } static CharUnits getPresumedAlignmentOfPointer(const Expr *E, Sema &S) { … } void Sema::CheckCastAlign(Expr *Op, QualType T, SourceRange TRange) { … } void Sema::CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr, const ArraySubscriptExpr *ASE, bool AllowOnePastEnd, bool IndexNegated) { … } void Sema::CheckArrayAccess(const Expr *expr) { … } static bool checkUnsafeAssignLiteral(Sema &S, SourceLocation Loc, Expr *RHS, bool isProperty) { … } static bool checkUnsafeAssignObject(Sema &S, SourceLocation Loc, Qualifiers::ObjCLifetime LT, Expr *RHS, bool isProperty) { … } bool Sema::checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS) { … } void Sema::checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS) { … } //===--- CHECK: Empty statement body (-Wempty-body) ---------------------===// static bool ShouldDiagnoseEmptyStmtBody(const SourceManager &SourceMgr, SourceLocation StmtLoc, const NullStmt *Body) { … } void Sema::DiagnoseEmptyStmtBody(SourceLocation StmtLoc, const Stmt *Body, unsigned DiagID) { … } void Sema::DiagnoseEmptyLoopBody(const Stmt *S, const Stmt *PossibleBody) { … } //===--- CHECK: Warn on self move with std::move. -------------------------===// void Sema::DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr, SourceLocation OpLoc) { … } //===--- Layout compatibility ----------------------------------------------// static bool isLayoutCompatible(const ASTContext &C, QualType T1, QualType T2); /// Check if two enumeration types are layout-compatible. static bool isLayoutCompatible(const ASTContext &C, const EnumDecl *ED1, const EnumDecl *ED2) { … } /// Check if two fields are layout-compatible. /// Can be used on union members, which are exempt from alignment requirement /// of common initial sequence. static bool isLayoutCompatible(const ASTContext &C, const FieldDecl *Field1, const FieldDecl *Field2, bool AreUnionMembers = false) { … } /// Check if two standard-layout structs are layout-compatible. /// (C++11 [class.mem] p17) static bool isLayoutCompatibleStruct(const ASTContext &C, const RecordDecl *RD1, const RecordDecl *RD2) { … } /// Check if two standard-layout unions are layout-compatible. /// (C++11 [class.mem] p18) static bool isLayoutCompatibleUnion(const ASTContext &C, const RecordDecl *RD1, const RecordDecl *RD2) { … } static bool isLayoutCompatible(const ASTContext &C, const RecordDecl *RD1, const RecordDecl *RD2) { … } /// Check if two types are layout-compatible in C++11 sense. static bool isLayoutCompatible(const ASTContext &C, QualType T1, QualType T2) { … } bool Sema::IsLayoutCompatible(QualType T1, QualType T2) const { … } //===-------------- Pointer interconvertibility ----------------------------// bool Sema::IsPointerInterconvertibleBaseOf(const TypeSourceInfo *Base, const TypeSourceInfo *Derived) { … } //===--- CHECK: pointer_with_type_tag attribute: datatypes should match ----// /// Given a type tag expression find the type tag itself. /// /// \param TypeExpr Type tag expression, as it appears in user's code. /// /// \param VD Declaration of an identifier that appears in a type tag. /// /// \param MagicValue Type tag magic value. /// /// \param isConstantEvaluated whether the evalaution should be performed in /// constant context. static bool FindTypeTagExpr(const Expr *TypeExpr, const ASTContext &Ctx, const ValueDecl **VD, uint64_t *MagicValue, bool isConstantEvaluated) { … } /// Retrieve the C type corresponding to type tag TypeExpr. /// /// \param TypeExpr Expression that specifies a type tag. /// /// \param MagicValues Registered magic values. /// /// \param FoundWrongKind Set to true if a type tag was found, but of a wrong /// kind. /// /// \param TypeInfo Information about the corresponding C type. /// /// \param isConstantEvaluated whether the evalaution should be performed in /// constant context. /// /// \returns true if the corresponding C type was found. static bool GetMatchingCType( const IdentifierInfo *ArgumentKind, const Expr *TypeExpr, const ASTContext &Ctx, const llvm::DenseMap<Sema::TypeTagMagicValue, Sema::TypeTagData> *MagicValues, bool &FoundWrongKind, Sema::TypeTagData &TypeInfo, bool isConstantEvaluated) { … } void Sema::RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, uint64_t MagicValue, QualType Type, bool LayoutCompatible, bool MustBeNull) { … } static bool IsSameCharType(QualType T1, QualType T2) { … } void Sema::CheckArgumentWithTypeTag(const ArgumentWithTypeTagAttr *Attr, const ArrayRef<const Expr *> ExprArgs, SourceLocation CallSiteLoc) { … } void Sema::AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD, CharUnits Alignment) { … } void Sema::DiagnoseMisalignedMembers() { … } void Sema::DiscardMisalignedMemberAddress(const Type *T, Expr *E) { … } void Sema::RefersToMemberWithReducedAlignment( Expr *E, llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)> Action) { … } void Sema::CheckAddressOfPackedMember(Expr *rhs) { … } bool Sema::PrepareBuiltinElementwiseMathOneArgCall(CallExpr *TheCall) { … } bool Sema::BuiltinElementwiseMath(CallExpr *TheCall, bool FPOnly) { … } bool Sema::BuiltinVectorToScalarMath(CallExpr *TheCall) { … } bool Sema::BuiltinVectorMath(CallExpr *TheCall, QualType &Res, bool FPOnly) { … } bool Sema::BuiltinElementwiseTernaryMath(CallExpr *TheCall, bool CheckForFloatArgs) { … } bool Sema::PrepareBuiltinReduceMathOneArgCall(CallExpr *TheCall) { … } bool Sema::BuiltinNonDeterministicValue(CallExpr *TheCall) { … } ExprResult Sema::BuiltinMatrixTranspose(CallExpr *TheCall, ExprResult CallResult) { … } // Get and verify the matrix dimensions. static std::optional<unsigned> getAndVerifyMatrixDimension(Expr *Expr, StringRef Name, Sema &S) { … } ExprResult Sema::BuiltinMatrixColumnMajorLoad(CallExpr *TheCall, ExprResult CallResult) { … } ExprResult Sema::BuiltinMatrixColumnMajorStore(CallExpr *TheCall, ExprResult CallResult) { … } void Sema::CheckTCBEnforcement(const SourceLocation CallExprLoc, const NamedDecl *Callee) { … }
Codebase Browser
llvm