llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-coroutines Author: YexuanXiao (YexuanXiao) <details> <summary>Changes</summary> Includeing the results of `sizeof`, `sizeof...`, `__datasizeof`, `__alignof`, `_Alignof`, `alignof`, `_Countof`, `size_t` literals, and signed `size_t` literals, as well as the results of pointer-pointer subtraction. The goal is to enable clang and downstream tools such as clangd and clang-tidy to provide more portable hints and diagnostics. The previous discussion can be found at #<!-- -->136542. It was implemented by injecting `__size_t`, `__signed_size_t`, and `__ptrdiff_t` into the AST. Additionally, checks for the `z` and `j` format specifiers in format strings for `scanf` and `printf` were added. Several code assume that `SizeType` is canonical and must remain canonical, so I converted `SizeType` to its canonical form. Extensive testing of the modifications indicates that it works very well (aside from the unsightly double underscores). The test `CodeGen/cfi-unrelated-cast.cpp` could not be fixed because I am unfamiliar with LLVM IR. The tests `Modules/new-delete.cpp`, `PCH/cxx-exprs.cpp`, `PCH/cxx1z-aligned-alloc.cpp`, `SemaCXX/delete.cpp`, and `OpenMP/declare_target_codegen.cpp` reported ambiguity issues with `new` and `delete` expressions. Since I have no clue how to resolve them, I was unable to fix these tests. I would be very grateful if someone could fix them. --- Patch is 325.96 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/143653.diff 56 Files Affected: - (modified) clang/include/clang/AST/ASTContext.h (+19-11) - (modified) clang/lib/AST/ASTContext.cpp (+50-17) - (modified) clang/lib/AST/FormatString.cpp (+87-21) - (modified) clang/lib/AST/PrintfFormatString.cpp (+6-3) - (modified) clang/lib/AST/ScanfFormatString.cpp (+12-7) - (modified) clang/lib/CodeGen/CGCall.cpp (+2-1) - (modified) clang/lib/CodeGen/CGCoroutine.cpp (+2-2) - (modified) clang/lib/CodeGen/CGObjCMac.cpp (+1-1) - (modified) clang/lib/Sema/SemaChecking.cpp (+1-1) - (modified) clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp (+44-36) - (modified) clang/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp (+1-1) - (modified) clang/test/AST/ast-dump-array.cpp (+1-1) - (modified) clang/test/AST/ast-dump-expr-json.c (+9-3) - (modified) clang/test/AST/ast-dump-expr-json.cpp (+18-10) - (modified) clang/test/AST/ast-dump-expr.c (+3-3) - (modified) clang/test/AST/ast-dump-expr.cpp (+8-8) - (modified) clang/test/AST/ast-dump-openmp-distribute-parallel-for-simd.c (+10-10) - (modified) clang/test/AST/ast-dump-openmp-distribute-parallel-for.c (+10-10) - (modified) clang/test/AST/ast-dump-openmp-target-teams-distribute-parallel-for-simd.c (+80-80) - (modified) clang/test/AST/ast-dump-openmp-target-teams-distribute-parallel-for.c (+80-80) - (modified) clang/test/AST/ast-dump-openmp-teams-distribute-parallel-for-simd.c (+80-80) - (modified) clang/test/AST/ast-dump-openmp-teams-distribute-parallel-for.c (+80-80) - (modified) clang/test/AST/ast-dump-recovery.c (+1-1) - (modified) clang/test/AST/ast-dump-stmt-json.cpp (+58-28) - (modified) clang/test/AST/ast-dump-stmt.cpp (+2-2) - (modified) clang/test/AST/ast-dump-traits.cpp (+4-4) - (modified) clang/test/AST/ast-dump-types-errors-json.cpp (+3-1) - (modified) clang/test/Analysis/cfg.cpp (+1-1) - (modified) clang/test/Analysis/explain-svals.cpp (+1-1) - (modified) clang/test/Analysis/std-c-library-functions-arg-weakdeps.c (+1-1) - (modified) clang/test/Analysis/std-c-library-functions-lookup.c (+1-1) - (modified) clang/test/Analysis/std-c-library-functions-vs-stream-checker.c (+2-2) - (modified) clang/test/Analysis/std-c-library-functions.c (+2-2) - (modified) clang/test/CXX/drs/cwg2xx.cpp (+1-1) - (modified) clang/test/CXX/lex/lex.literal/lex.ext/p2.cpp (+5-5) - (modified) clang/test/CXX/lex/lex.literal/lex.ext/p5.cpp (+3-3) - (modified) clang/test/CXX/lex/lex.literal/lex.ext/p7.cpp (+1-1) - (modified) clang/test/FixIt/fixit-format-ios-nopedantic.m (+1-1) - (modified) clang/test/FixIt/format.m (+3-3) - (modified) clang/test/Sema/format-strings-fixit-ssize_t.c (+1-1) - (modified) clang/test/Sema/format-strings-int-typedefs.c (+6-6) - (modified) clang/test/Sema/format-strings-scanf.c (+4-4) - (modified) clang/test/Sema/format-strings-size_t.c (+6-7) - (modified) clang/test/Sema/matrix-type-builtins.c (+4-4) - (modified) clang/test/Sema/ptrauth-atomic-ops.c (+1-1) - (modified) clang/test/Sema/ptrauth.c (+1-1) - (modified) clang/test/SemaCXX/cxx2c-trivially-relocatable.cpp (+1-1) - (modified) clang/test/SemaCXX/enum-scoped.cpp (+2-2) - (modified) clang/test/SemaCXX/new-delete.cpp (+1-1) - (modified) clang/test/SemaCXX/static-assert-cxx26.cpp (+7-7) - (modified) clang/test/SemaCXX/type-aware-new-delete-basic-free-declarations.cpp (+1-1) - (modified) clang/test/SemaCXX/unavailable_aligned_allocation.cpp (+12-12) - (modified) clang/test/SemaObjC/format-size-spec-nsinteger.m (+5-12) - (modified) clang/test/SemaObjC/matrix-type-builtins.m (+1-1) - (modified) clang/test/SemaOpenCL/cl20-device-side-enqueue.cl (+3-3) - (modified) clang/test/SemaTemplate/type_pack_element.cpp (+6-6) ``````````diff diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h index 8d24d393eab09..bd4600e479b1b 100644 --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -25,6 +25,7 @@ #include "clang/AST/RawCommentList.h" #include "clang/AST/SYCLKernelInfo.h" #include "clang/AST/TemplateName.h" +#include "clang/AST/Type.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/SourceLocation.h" @@ -1952,6 +1953,13 @@ class ASTContext : public RefCountedBase<ASTContext> { bool IsDependent, QualType Canon) const; + // The core language uses these types as the result types of some expressions, + // which are typically standard integer types and consistent with it's + // typedefs (if any). These variables store the typedefs generated in the AST, + // not the typedefs provided in the header files. + mutable QualType SizeType; // __size_t + mutable QualType SignedSizeType; // __signed_size_t + mutable QualType PtrdiffType; // __ptrdiff_t public: /// Return the unique reference to the type for the specified TagDecl /// (struct/union/class/enum) decl. @@ -1961,11 +1969,20 @@ class ASTContext : public RefCountedBase<ASTContext> { /// <stddef.h>. /// /// The sizeof operator requires this (C99 6.5.3.4p4). - CanQualType getSizeType() const; + QualType getSizeType() const; /// Return the unique signed counterpart of /// the integer type corresponding to size_t. - CanQualType getSignedSizeType() const; + QualType getSignedSizeType() const; + + /// Return the unique type for "ptrdiff_t" (C99 7.17) defined in + /// <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). + QualType getPointerDiffType() const; + + /// Return the unique unsigned counterpart of "ptrdiff_t" + /// integer type. The standard (C11 7.21.6.1p7) refers to this type + /// in the definition of %tu format specifier. + QualType getUnsignedPointerDiffType() const; /// Return the unique type for "intmax_t" (C99 7.18.1.5), defined in /// <stdint.h>. @@ -2006,15 +2023,6 @@ class ASTContext : public RefCountedBase<ASTContext> { /// as defined by the target. QualType getUIntPtrType() const; - /// Return the unique type for "ptrdiff_t" (C99 7.17) defined in - /// <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). - QualType getPointerDiffType() const; - - /// Return the unique unsigned counterpart of "ptrdiff_t" - /// integer type. The standard (C11 7.21.6.1p7) refers to this type - /// in the definition of %tu format specifier. - QualType getUnsignedPointerDiffType() const; - /// Return the unique type for "pid_t" defined in /// <sys/types.h>. We need this to compute the correct type for vfork(). QualType getProcessIDType() const; diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index 45f9602856840..00f8f87466273 100644 --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -6726,17 +6726,63 @@ QualType ASTContext::getTagDeclType(const TagDecl *Decl) const { return getTypeDeclType(const_cast<TagDecl*>(Decl)); } +// Inject __size_t, __signed_size_t, and __ptrdiff_t to provide portable hints +// and diagnostics. In C and C++, expressions of type size_t can be obtained via +// the sizeof operator, expressions of type ptrdiff_t via pointer subtraction, +// and expressions of type signed size_t via the z literal suffix (since C++23). +// However, no core language mechanism directly produces an expression of type +// unsigned ptrdiff_t. The unsigned ptrdiff_t type is solely required by format +// specifiers for printf and scanf. Consequently, no expression's type needs to +// be displayed as unsigned ptrdiff_t. Verification of whether a type is +// unsigned ptrdiff_t is also unnecessary, as no corresponding typedefs exist. +// Therefore, injecting a typedef for signed ptrdiff_t is not required. + /// getSizeType - Return the unique type for "size_t" (C99 7.17), the result /// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and /// needs to agree with the definition in <stddef.h>. -CanQualType ASTContext::getSizeType() const { - return getFromTargetType(Target->getSizeType()); +QualType ASTContext::getSizeType() const { + if (SizeType.isNull()) { + if (auto const &LO = getLangOpts(); !LO.HLSL && (LO.C99 || LO.CPlusPlus)) + SizeType = getTypedefType(buildImplicitTypedef( + getFromTargetType(Target->getSizeType()), "__size_t")); + else + SizeType = getFromTargetType(Target->getSizeType()); + } + return SizeType; } /// Return the unique signed counterpart of the integer type /// corresponding to size_t. -CanQualType ASTContext::getSignedSizeType() const { - return getFromTargetType(Target->getSignedSizeType()); +QualType ASTContext::getSignedSizeType() const { + if (SignedSizeType.isNull()) { + if (auto const &LO = getLangOpts(); !LO.HLSL && (LO.C99 || LO.CPlusPlus)) + SignedSizeType = getTypedefType(buildImplicitTypedef( + getFromTargetType(Target->getSignedSizeType()), "__signed_size_t")); + else + SignedSizeType = getFromTargetType(Target->getSignedSizeType()); + } + return SignedSizeType; +} + +/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17) +/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). +QualType ASTContext::getPointerDiffType() const { + if (PtrdiffType.isNull()) { + if (auto const &LO = getLangOpts(); !LO.HLSL && (LO.C99 || LO.CPlusPlus)) + PtrdiffType = getTypedefType(buildImplicitTypedef( + getFromTargetType(Target->getPtrDiffType(LangAS::Default)), + "__ptrdiff_t")); + else + PtrdiffType = getFromTargetType(Target->getPtrDiffType(LangAS::Default)); + } + return PtrdiffType; +} + +/// Return the unique unsigned counterpart of "ptrdiff_t" +/// integer type. The standard (C11 7.21.6.1p7) refers to this type +/// in the definition of %tu format specifier. +QualType ASTContext::getUnsignedPointerDiffType() const { + return getFromTargetType(Target->getUnsignedPtrDiffType(LangAS::Default)); } /// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5). @@ -6771,19 +6817,6 @@ QualType ASTContext::getUIntPtrType() const { return getCorrespondingUnsignedType(getIntPtrType()); } -/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17) -/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). -QualType ASTContext::getPointerDiffType() const { - return getFromTargetType(Target->getPtrDiffType(LangAS::Default)); -} - -/// Return the unique unsigned counterpart of "ptrdiff_t" -/// integer type. The standard (C11 7.21.6.1p7) refers to this type -/// in the definition of %tu format specifier. -QualType ASTContext::getUnsignedPointerDiffType() const { - return getFromTargetType(Target->getUnsignedPtrDiffType(LangAS::Default)); -} - /// Return the unique type for "pid_t" defined in /// <sys/types.h>. We need this to compute the correct type for vfork(). QualType ASTContext::getProcessIDType() const { diff --git a/clang/lib/AST/FormatString.cpp b/clang/lib/AST/FormatString.cpp index 5d3b56fc4e713..0c1fd33b56f25 100644 --- a/clang/lib/AST/FormatString.cpp +++ b/clang/lib/AST/FormatString.cpp @@ -11,6 +11,7 @@ // //===----------------------------------------------------------------------===// +#include "clang/AST/FormatString.h" #include "FormatStringParsing.h" #include "clang/Basic/LangOptions.h" #include "clang/Basic/TargetInfo.h" @@ -320,6 +321,69 @@ bool clang::analyze_format_string::ParseUTF8InvalidSpecifier( // Methods on ArgType. //===----------------------------------------------------------------------===// +static bool namedTypeToLengthModifierKind(QualType QT, + LengthModifier::Kind &K) { + for (/**/; const auto *TT = QT->getAs<TypedefType>(); + QT = TT->getDecl()->getUnderlyingType()) { + StringRef Name = TT->getDecl()->getIdentifier()->getName(); + if (Name == "size_t" || Name == "__size_t") { + K = LengthModifier::AsSizeT; + return true; + } else if (Name == "__signed_size_t" || + Name == "ssize_t" /*Not C99, but common in Unix.*/) { + K = LengthModifier::AsSizeT; + return true; + } else if (Name == "ptrdiff_t" || Name == "__ptrdiff_t") { + K = LengthModifier::AsPtrDiff; + return true; + } else if (Name == "intmax_t") { + K = LengthModifier::AsIntMax; + return true; + } else if (Name == "uintmax_t") { + K = LengthModifier::AsIntMax; + return true; + } + } + return false; +} + +// Check whether T and E are compatible size_t/ptrdiff_t typedefs. E must be +// consistent with LE. +// T is the type of the actual expression in the code to be checked, and E is +// the expected type parsed from the format string. +static clang::analyze_format_string::ArgType::MatchKind +matchesSizeTPtrdiffT(ASTContext &C, QualType T, QualType E, + LengthModifier::Kind LE) { + using Kind = LengthModifier::Kind; + using MatchKind = clang::analyze_format_string::ArgType::MatchKind; + assert(LE == Kind::AsPtrDiff || LE == Kind::AsSizeT); + + if (!T->isIntegerType()) + return MatchKind::NoMatch; + + if (C.getCorrespondingSignedType(T.getCanonicalType()) != + C.getCorrespondingSignedType(E.getCanonicalType())) + return MatchKind::NoMatch; + + // signed size_t and unsigned ptrdiff_t does not have typedefs in C and C++. + if (LE == Kind::AsSizeT && E->isSignedIntegerType()) + return T->isSignedIntegerType() ? MatchKind::Match + : MatchKind::NoMatchSignedness; + + if (LE == LengthModifier::Kind::AsPtrDiff && E->isUnsignedIntegerType()) + return T->isUnsignedIntegerType() ? MatchKind::Match + : MatchKind::NoMatchSignedness; + + if (Kind Actual = Kind::None; namedTypeToLengthModifierKind(T, Actual)) { + if (Actual == LE) + return MatchKind::Match; + else if (Actual == Kind::AsPtrDiff || Actual == Kind::AsSizeT) + return MatchKind::NoMatchSignedness; + } + + return MatchKind::NoMatch; +} + clang::analyze_format_string::ArgType::MatchKind ArgType::matchesType(ASTContext &C, QualType argTy) const { // When using the format attribute in C++, you can receive a function or an @@ -394,6 +458,13 @@ ArgType::matchesType(ASTContext &C, QualType argTy) const { } case SpecificTy: { + if (TK != TypeKind::DontCare) { + return matchesSizeTPtrdiffT(C, argTy, T, + TK == TypeKind::SizeT + ? LengthModifier::Kind::AsSizeT + : LengthModifier::AsPtrDiff); + } + if (const EnumType *ETy = argTy->getAs<EnumType>()) { // If the enum is incomplete we know nothing about the underlying type. // Assume that it's 'int'. Do not use the underlying type for a scoped @@ -653,6 +724,18 @@ ArgType::matchesArgType(ASTContext &C, const ArgType &Other) const { if (Left.K == AK::SpecificTy) { if (Right.K == AK::SpecificTy) { + if (Left.TK != TypeKind::DontCare) { + return matchesSizeTPtrdiffT(C, Right.T, Left.T, + Left.TK == TypeKind::SizeT + ? LengthModifier::Kind::AsSizeT + : LengthModifier::AsPtrDiff); + } else if (Right.TK != TypeKind::DontCare) { + return matchesSizeTPtrdiffT(C, Left.T, Right.T, + Right.TK == TypeKind::SizeT + ? LengthModifier::Kind::AsSizeT + : LengthModifier::AsPtrDiff); + } + auto Canon1 = C.getCanonicalType(Left.T); auto Canon2 = C.getCanonicalType(Right.T); if (Canon1 == Canon2) @@ -1200,27 +1283,10 @@ FormatSpecifier::getCorrectedLengthModifier() const { bool FormatSpecifier::namedTypeToLengthModifier(QualType QT, LengthModifier &LM) { - for (/**/; const auto *TT = QT->getAs<TypedefType>(); - QT = TT->getDecl()->getUnderlyingType()) { - const TypedefNameDecl *Typedef = TT->getDecl(); - const IdentifierInfo *Identifier = Typedef->getIdentifier(); - if (Identifier->getName() == "size_t") { - LM.setKind(LengthModifier::AsSizeT); - return true; - } else if (Identifier->getName() == "ssize_t") { - // Not C99, but common in Unix. - LM.setKind(LengthModifier::AsSizeT); - return true; - } else if (Identifier->getName() == "intmax_t") { - LM.setKind(LengthModifier::AsIntMax); - return true; - } else if (Identifier->getName() == "uintmax_t") { - LM.setKind(LengthModifier::AsIntMax); - return true; - } else if (Identifier->getName() == "ptrdiff_t") { - LM.setKind(LengthModifier::AsPtrDiff); - return true; - } + if (LengthModifier::Kind Out = LengthModifier::Kind::None; + namedTypeToLengthModifierKind(QT, Out)) { + LM.setKind(Out); + return true; } return false; } diff --git a/clang/lib/AST/PrintfFormatString.cpp b/clang/lib/AST/PrintfFormatString.cpp index 293164ddac8f8..397a1d4c1172f 100644 --- a/clang/lib/AST/PrintfFormatString.cpp +++ b/clang/lib/AST/PrintfFormatString.cpp @@ -543,7 +543,8 @@ ArgType PrintfSpecifier::getScalarArgType(ASTContext &Ctx, case LengthModifier::AsIntMax: return ArgType(Ctx.getIntMaxType(), "intmax_t"); case LengthModifier::AsSizeT: - return ArgType::makeSizeT(ArgType(Ctx.getSignedSizeType(), "ssize_t")); + return ArgType::makeSizeT( + ArgType(Ctx.getSignedSizeType(), "signed size_t")); case LengthModifier::AsInt3264: return Ctx.getTargetInfo().getTriple().isArch64Bit() ? ArgType(Ctx.LongLongTy, "__int64") @@ -626,9 +627,11 @@ ArgType PrintfSpecifier::getScalarArgType(ASTContext &Ctx, case LengthModifier::AsIntMax: return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t")); case LengthModifier::AsSizeT: - return ArgType::PtrTo(ArgType(Ctx.getSignedSizeType(), "ssize_t")); + return ArgType::PtrTo(ArgType::makeSizeT( + ArgType(Ctx.getSignedSizeType(), "signed size_t"))); case LengthModifier::AsPtrDiff: - return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t")); + return ArgType::PtrTo(ArgType::makePtrdiffT( + ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"))); case LengthModifier::AsLongDouble: return ArgType(); // FIXME: Is this a known extension? case LengthModifier::AsAllocate: diff --git a/clang/lib/AST/ScanfFormatString.cpp b/clang/lib/AST/ScanfFormatString.cpp index 7ee21c8c61954..e3926185860db 100644 --- a/clang/lib/AST/ScanfFormatString.cpp +++ b/clang/lib/AST/ScanfFormatString.cpp @@ -251,9 +251,11 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const { case LengthModifier::AsIntMax: return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t")); case LengthModifier::AsSizeT: - return ArgType::PtrTo(ArgType(Ctx.getSignedSizeType(), "ssize_t")); + return ArgType::PtrTo(ArgType::makeSizeT( + ArgType(Ctx.getSignedSizeType(), "signed size_t"))); case LengthModifier::AsPtrDiff: - return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t")); + return ArgType::PtrTo(ArgType::makePtrdiffT( + ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"))); case LengthModifier::AsLongDouble: // GNU extension. return ArgType::PtrTo(Ctx.LongLongTy); @@ -292,10 +294,11 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const { case LengthModifier::AsIntMax: return ArgType::PtrTo(ArgType(Ctx.getUIntMaxType(), "uintmax_t")); case LengthModifier::AsSizeT: - return ArgType::PtrTo(ArgType(Ctx.getSizeType(), "size_t")); - case LengthModifier::AsPtrDiff: return ArgType::PtrTo( - ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptrdiff_t")); + ArgType::makeSizeT(ArgType(Ctx.getSizeType(), "size_t"))); + case LengthModifier::AsPtrDiff: + return ArgType::PtrTo(ArgType::makePtrdiffT( + ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptrdiff_t"))); case LengthModifier::AsLongDouble: // GNU extension. return ArgType::PtrTo(Ctx.UnsignedLongLongTy); @@ -390,9 +393,11 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const { case LengthModifier::AsIntMax: return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t")); case LengthModifier::AsSizeT: - return ArgType::PtrTo(ArgType(Ctx.getSignedSizeType(), "ssize_t")); + return ArgType::PtrTo(ArgType::makeSizeT( + ArgType(Ctx.getSignedSizeType(), "signed size_t"))); case LengthModifier::AsPtrDiff: - return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t")); + return ArgType::PtrTo(ArgType::makePtrdiffT( + ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"))); case LengthModifier::AsLongDouble: return ArgType(); // FIXME: Is this a known extension? case LengthModifier::AsAllocate: diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp index 46a5d64412275..3ff2597d65e54 100644 --- a/clang/lib/CodeGen/CGCall.cpp +++ b/clang/lib/CodeGen/CGCall.cpp @@ -223,7 +223,8 @@ static void appendParameterTypes( for (unsigned I = 0, E = FPT->getNumParams(); I != E; ++I) { prefix.push_back(FPT->getParamType(I)); if (ExtInfos[I].hasPassObjectSize()) - prefix.push_back(CGT.getContext().getSizeType()); + prefix.push_back( + CGT.getContext().getSizeType()->getCanonicalTypeUnqualified()); } addExtParameterInfosForCall(paramInfos, FPT.getTypePtr(), PrefixSize, diff --git a/clang/lib/CodeGen/CGCoroutine.cpp b/clang/lib/CodeGen/CGCoroutine.cpp index 0fc488e98aaf0..265dedf228e69 100644 --- a/clang/lib/CodeGen/CGCoroutine.cpp +++ b/clang/lib/CodeGen/CGCoroutine.cpp @@ -1002,14 +1002,14 @@ RValue CodeGenFunction::EmitCoroutineIntrinsic(const CallExpr *E, } case llvm::Intrinsic::coro_size: { auto &Context = getContext(); - CanQualType SizeTy = Context.getSizeType(); + CanQualType SizeTy = Context.getSizeType()->getCanonicalTypeUnqualified(); llvm::IntegerType *T = Builder.getIntNTy(Context.getTypeSize(SizeTy)); llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::coro_size, T); return RValue::get(Builder.CreateCall(F)); } case llvm::Intrinsic::coro_align: { auto &Context = getContext(); - CanQualType SizeTy = Context.getSizeType(); + CanQualType SizeTy = Context.getSizeType()->getCanonicalTypeUnqualified(); llvm::IntegerType *T = Builder.getIntNTy(Context.getTypeSize(SizeTy)); llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::coro_align, T); return RValue::get(Builder.CreateCall(F)); diff --git a/clang/lib/CodeGen/CGObjCMac.cpp b/clang/lib/CodeGen/CGObjCMac.cpp index 1c23a8b4db918..5a0d2a2286bac 100644 --- a/clang/lib/CodeGen/CGObjCMac.cpp +++ b/clang/lib/CodeGen/CGObjCMac.cpp @@ -285,7 +285,7 @@ class ObjCCommonTypesHelper { SmallVector<CanQualType, 5> Params; Params.push_back(Ctx.VoidPtrTy); Params.push_back(Ctx.VoidPtrTy); - Params.push_back(Ctx.getSizeType()); + Params.push_back(Ctx.getSizeType()->getCanonicalTypeUnqualified()); Params.push_back(Ctx.BoolTy); Params.push_back(Ctx.BoolTy); llvm::FunctionType *FTy = Types.GetFunctionType( diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index 8f8e1ceb7197e..9a0d824a26ae6 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -5131,7 +5131,7 @@ bool Sema::BuiltinVAStartARMMicrosoft(CallExpr *Call) { << 3 /* parameter mismatch */ << 2 << Arg1->getType() << ConstCharPtrTy; - const QualType SizeTy = Context.getSizeType(); + const QualType SizeTy = Context.getSizeTyp... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/143653 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
