@@ -2352,126 +2352,26 @@ static void handleUnusedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
23522352 D->addAttr(::new (S.Context) UnusedAttr(S.Context, AL));
23532353}
23542354
2355- static void diagnoseInvalidPriority(Sema &S, uint32_t Priority,
2356- const ParsedAttr &A,
2357- SourceLocation PriorityLoc) {
2358- constexpr uint32_t ReservedPriorityLower = 101, ReservedPriorityUpper = 65535;
2359-
2360- // Only perform the priority check if the attribute is outside of a system
2361- // header. Values <= 100 are reserved for the implementation, and libc++
2362- // benefits from being able to specify values in that range. Values > 65535
2363- // are reserved for historical reasons.
2364- if ((Priority < ReservedPriorityLower || Priority > ReservedPriorityUpper) &&
2365- !S.getSourceManager().isInSystemHeader(A.getLoc())) {
2366- S.Diag(A.getLoc(), diag::warn_priority_out_of_range)
2367- << PriorityLoc << A << ReservedPriorityLower << ReservedPriorityUpper;
2368- }
2369- }
2370-
2371- static bool FunctionParamsAreMainLike(ASTContext &Context,
2372- const FunctionDecl *FD) {
2373- assert(FD->hasPrototype() && "expected the function to have a prototype");
2374- const auto *FPT = FD->getType()->castAs<FunctionProtoType>();
2375- QualType CharPP =
2376- Context.getPointerType(Context.getPointerType(Context.CharTy));
2377- QualType Expected[] = {Context.IntTy, CharPP, CharPP, CharPP};
2378- for (unsigned I = 0;
2379- I < sizeof(Expected) / sizeof(QualType) && I < FPT->getNumParams();
2380- ++I) {
2381- QualType AT = FPT->getParamType(I);
2382-
2383- if (!Context.hasSameUnqualifiedType(AT, Expected[I])) {
2384- if (Expected[I] == CharPP) {
2385- // As an extension, the following forms are okay:
2386- // char const **
2387- // char const * const *
2388- // char * const *
2389-
2390- QualifierCollector Qs;
2391- const PointerType *PT;
2392- if ((PT = Qs.strip(AT)->getAs<PointerType>()) &&
2393- (PT = Qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
2394- Context.hasSameType(QualType(Qs.strip(PT->getPointeeType()), 0),
2395- Context.CharTy)) {
2396- Qs.removeConst();
2397- if (!Qs.empty())
2398- return false;
2399- continue; // Accepted as an extension.
2400- }
2401- }
2402- return false;
2403- }
2404- }
2405- return true;
2406- }
2407-
2408- template <typename CtorDtorAttr>
2409- static void handleCtorDtorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2410- uint32_t Priority = CtorDtorAttr::DefaultPriority;
2355+ static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2356+ uint32_t priority = ConstructorAttr::DefaultPriority;
24112357 if (S.getLangOpts().HLSL && AL.getNumArgs()) {
24122358 S.Diag(AL.getLoc(), diag::err_hlsl_init_priority_unsupported);
24132359 return;
24142360 }
2361+ if (AL.getNumArgs() &&
2362+ !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
2363+ return;
24152364
2416- // If we're given an argument for the priority, check that it's valid.
2417- if (AL.getNumArgs()) {
2418- if (!checkUInt32Argument(S, AL, AL.getArgAsExpr(0), Priority))
2419- return;
2420-
2421- // Diagnose an invalid priority, but continue to process the attribute.
2422- diagnoseInvalidPriority(S, Priority, AL, AL.getArgAsExpr(0)->getExprLoc());
2423- }
2365+ D->addAttr(::new (S.Context) ConstructorAttr(S.Context, AL, priority));
2366+ }
24242367
2425- // Ensure the function we're attaching to is something that is sensible to
2426- // automatically call before or after main(); it should accept no arguments.
2427- // In theory, a void return type is the only truly safe return type (consider
2428- // that calling conventions may place returned values in a hidden pointer
2429- // argument passed to the function that will not be present when called
2430- // automatically). However, there is a significant amount of existing code
2431- // which uses an int return type. So we will accept void, int, and
2432- // unsigned int return types. Any other return type, or a non-void parameter
2433- // list is treated as an error because it's a form of type system
2434- // incompatibility. The function also cannot be a member function. We allow
2435- // K&R C functions because that's a difficult edge case where it depends on
2436- // how the function is defined as to whether it does or does not expect
2437- // arguments.
2438- //
2439- // However! glibc on ELF will pass the same arguments to a constructor
2440- // function as are given to main(), so we will allow `int, char *[]` and
2441- // `int, char *[], char *[]` (or qualified versions thereof), but only if
2442- // the target is explicitly for glibc.
2443- const auto *FD = cast<FunctionDecl>(D);
2444- QualType RetTy = FD->getReturnType();
2445- bool IsGlibC = S.Context.getTargetInfo().getTriple().isGNUEnvironment();
2446- if (!(RetTy->isVoidType() ||
2447- RetTy->isSpecificBuiltinType(BuiltinType::UInt) ||
2448- RetTy->isSpecificBuiltinType(BuiltinType::Int)) ||
2449- FD->isVariadic() ||
2450- (FD->hasPrototype() &&
2451- ((!IsGlibC && FD->getNumParams() != 0) ||
2452- (IsGlibC && !FunctionParamsAreMainLike(S.Context, FD))))) {
2453- S.Diag(AL.getLoc(), diag::err_ctor_dtor_attr_on_non_void_func)
2454- << AL << FD->getSourceRange();
2455- return;
2456- }
2457- if (FD->getType()->castAs<FunctionType>()->getCallConv() !=
2458- CallingConv::CC_C) {
2459- S.Diag(AL.getLoc(), diag::err_ctor_dtor_calling_conv)
2460- << AL << FD->getSourceRange();
2461- return;
2462- }
2463- if (const auto *MD = dyn_cast<CXXMethodDecl>(FD); MD && MD->isInstance()) {
2464- S.Diag(AL.getLoc(), diag::err_ctor_dtor_member_func)
2465- << AL << FD->getSourceRange();
2466- return;
2467- }
2468- if (FD->isConsteval()) {
2469- S.Diag(AL.getLoc(), diag::err_ctordtor_attr_consteval)
2470- << AL << FD->getSourceRange();
2368+ static void handleDestructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2369+ uint32_t priority = DestructorAttr::DefaultPriority;
2370+ if (AL.getNumArgs() &&
2371+ !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
24712372 return;
2472- }
24732373
2474- D->addAttr(CtorDtorAttr::Create (S.Context, Priority , AL));
2374+ D->addAttr(::new (S.Context) DestructorAttr(S.Context , AL, priority ));
24752375}
24762376
24772377template <typename AttrTy>
@@ -3988,9 +3888,16 @@ static void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
39883888 return;
39893889 }
39903890
3991- // Diagnose an invalid priority, but continue to process the attribute.
3992- diagnoseInvalidPriority(S, prioritynum, AL, E->getExprLoc());
3993-
3891+ // Only perform the priority check if the attribute is outside of a system
3892+ // header. Values <= 100 are reserved for the implementation, and libc++
3893+ // benefits from being able to specify values in that range.
3894+ if ((prioritynum < 101 || prioritynum > 65535) &&
3895+ !S.getSourceManager().isInSystemHeader(AL.getLoc())) {
3896+ S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_range)
3897+ << E->getSourceRange() << AL << 101 << 65535;
3898+ AL.setInvalid();
3899+ return;
3900+ }
39943901 D->addAttr(::new (S.Context) InitPriorityAttr(S.Context, AL, prioritynum));
39953902}
39963903
@@ -9052,13 +8959,13 @@ ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D, const ParsedAttr &AL,
90528959 handlePassObjectSizeAttr(S, D, AL);
90538960 break;
90548961 case ParsedAttr::AT_Constructor:
9055- handleCtorDtorAttr<ConstructorAttr> (S, D, AL);
8962+ handleConstructorAttr (S, D, AL);
90568963 break;
90578964 case ParsedAttr::AT_Deprecated:
90588965 handleDeprecatedAttr(S, D, AL);
90598966 break;
90608967 case ParsedAttr::AT_Destructor:
9061- handleCtorDtorAttr<DestructorAttr> (S, D, AL);
8968+ handleDestructorAttr (S, D, AL);
90628969 break;
90638970 case ParsedAttr::AT_EnableIf:
90648971 handleEnableIfAttr(S, D, AL);
0 commit comments