Index: include/clang/AST/DeclBase.h =================================================================== --- include/clang/AST/DeclBase.h (revision 198417) +++ include/clang/AST/DeclBase.h (working copy) @@ -32,6 +32,7 @@ class DependentDiagnostic; class EnumDecl; class FunctionDecl; +class FunctionType; class LinkageComputer; class LinkageSpecDecl; class Module; @@ -943,6 +944,11 @@ LLVM_ATTRIBUTE_USED void dumpColor() const; void dump(raw_ostream &Out) const; + /// \brief Looks through the Decl's underlying type to extract a FunctionType + /// when possible. Will return null if the type underlying the Decl does not + /// have a FunctionType. + const FunctionType *getFunctionType(bool BlocksToo = true) const; + private: void setAttrsImpl(const AttrVec& Attrs, ASTContext &Ctx); void setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC, Index: include/clang/Basic/Attr.td =================================================================== --- include/clang/Basic/Attr.td (revision 198417) +++ include/clang/Basic/Attr.td (working copy) @@ -56,6 +56,21 @@ def GlobalVar : SubsetSubjecthasGlobalStorage()}]>; +// FIXME: this hack is needed because DeclNodes.td defines the base Decl node +// type to be a class, not a definition. This makes it impossible to create an +// attribute subject which accepts a Decl. Normally, this is not a problem, +// because the attribute can have no Subjects clause to accomplish this. But in +// the case of a SubsetSubject, there's no way to express it without this hack. +def DeclBase : AttrSubject; +def FunctionLike : SubsetSubjectgetFunctionType(false) != NULL}]>; + +def HasFunctionProto : SubsetSubjectgetFunctionType(true) != NULL && + isa(S->getFunctionType())) || + isa(S) || + isa(S)}]>; + // A single argument to an attribute class Argument { string Name = name; @@ -408,6 +423,8 @@ let Spellings = [GNU<"launch_bounds">]; let Args = [IntArgument<"MaxThreads">, DefaultIntArgument<"MinBlocks", 0>]; let LangOpts = [CUDA]; + let Subjects = SubjectList<[ObjCMethod, FunctionLike], WarnDiag, + "ExpectedFunctionOrMethod">; // An AST node is created for this attribute, but is not used by other parts // of the compiler. However, this node needs to exist in the AST because // non-LLVM backends may be relying on the attribute's presence. @@ -485,11 +502,15 @@ let Spellings = [GNU<"format">, CXX11<"gnu", "format">]; let Args = [IdentifierArgument<"Type">, IntArgument<"FormatIdx">, IntArgument<"FirstArg">]; + let Subjects = SubjectList<[ObjCMethod, Block, FunctionLike, + HasFunctionProto], WarnDiag, "ExpectedFunction">; } def FormatArg : InheritableAttr { let Spellings = [GNU<"format_arg">, CXX11<"gnu", "format_arg">]; let Args = [IntArgument<"FormatIdx">]; + let Subjects = SubjectList<[ObjCMethod, FunctionLike, HasFunctionProto], + WarnDiag, "ExpectedFunction">; } def GNUInline : InheritableAttr { @@ -604,6 +625,8 @@ def NonNull : InheritableAttr { let Spellings = [GNU<"nonnull">, CXX11<"gnu", "nonnull">]; + let Subjects = SubjectList<[ObjCMethod, FunctionLike, HasFunctionProto], + WarnDiag, "ExpectedFunction">; let Args = [VariadicUnsignedArgument<"Args">]; let AdditionalMembers = [{bool isNonNull(unsigned idx) const { @@ -750,6 +773,8 @@ } }]; let Args = [IdentifierArgument<"Module">, VariadicUnsignedArgument<"Args">]; + let Subjects = SubjectList<[FunctionLike, HasFunctionProto], WarnDiag, + "ExpectedFunction">; } def Packed : InheritableAttr { @@ -875,6 +900,9 @@ def Unused : InheritableAttr { let Spellings = [GNU<"unused">, CXX11<"gnu", "unused">]; + let Subjects = SubjectList<[Var, ObjCIvar, Type, Label, Field, ObjCMethod, + FunctionLike], WarnDiag, + "ExpectedVariableFunctionOrLabel">; } def Used : InheritableAttr { @@ -930,6 +958,8 @@ let Spellings = [GNU<"warn_unused_result">, CXX11<"clang", "warn_unused_result">, CXX11<"gnu", "warn_unused_result">]; + let Subjects = SubjectList<[ObjCMethod, CXXRecord, FunctionLike], WarnDiag, + "ExpectedFunctionMethodOrClass">; } def Weak : InheritableAttr { Index: lib/AST/DeclBase.cpp =================================================================== --- lib/AST/DeclBase.cpp (revision 198417) +++ lib/AST/DeclBase.cpp (working copy) @@ -701,6 +701,24 @@ static Decl::Kind getKind(const Decl *D) { return D->getKind(); } static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); } +const FunctionType *Decl::getFunctionType(bool BlocksToo) const { + QualType Ty; + if (const ValueDecl *D = dyn_cast(this)) + Ty = D->getType(); + else if (const TypedefNameDecl *D = dyn_cast(this)) + Ty = D->getUnderlyingType(); + else + return 0; + + if (Ty->isFunctionPointerType()) + Ty = Ty->getAs()->getPointeeType(); + else if (BlocksToo && Ty->isBlockPointerType()) + Ty = Ty->getAs()->getPointeeType(); + + return Ty->getAs(); +} + + /// Starting at a given context (a Decl or DeclContext), look for a /// code context that is not a closure (a lambda, block, etc.). template static Decl *getNonClosureContext(T *D) { Index: lib/Sema/SemaDeclAttr.cpp =================================================================== --- lib/Sema/SemaDeclAttr.cpp (revision 198424) +++ lib/Sema/SemaDeclAttr.cpp (working copy) @@ -44,54 +44,13 @@ // Helper functions //===----------------------------------------------------------------------===// -static const FunctionType *getFunctionType(const Decl *D, - bool blocksToo = true) { - QualType Ty; - if (const ValueDecl *decl = dyn_cast(D)) - Ty = decl->getType(); - else if (const TypedefNameDecl* decl = dyn_cast(D)) - Ty = decl->getUnderlyingType(); - else - return 0; - - if (Ty->isFunctionPointerType()) - Ty = Ty->getAs()->getPointeeType(); - else if (blocksToo && Ty->isBlockPointerType()) - Ty = Ty->getAs()->getPointeeType(); - - return Ty->getAs(); -} - -// FIXME: We should provide an abstraction around a method or function -// to provide the following bits of information. - -/// isFunction - Return true if the given decl has function -/// type (function or function-typed variable). -static bool isFunction(const Decl *D) { - return getFunctionType(D, false) != NULL; -} - /// isFunctionOrMethod - Return true if the given decl has function /// type (function or function-typed variable) or an Objective-C /// method. static bool isFunctionOrMethod(const Decl *D) { - return isFunction(D) || isa(D); + return (D->getFunctionType() != NULL) || isa(D); } -/// isFunctionOrMethodOrBlock - Return true if the given decl has function -/// type (function or function-typed variable) or an Objective-C -/// method or a block. -static bool isFunctionOrMethodOrBlock(const Decl *D) { - if (isFunctionOrMethod(D)) - return true; - // check for block is more involved. - if (const VarDecl *V = dyn_cast(D)) { - QualType Ty = V->getType(); - return Ty->isBlockPointerType(); - } - return isa(D); -} - /// Return true if the given decl has a declarator that should have /// been processed by Sema::GetTypeForDeclarator. static bool hasDeclarator(const Decl *D) { @@ -104,12 +63,9 @@ /// information. This decl should have already passed /// isFunctionOrMethod or isFunctionOrMethodOrBlock. static bool hasFunctionProto(const Decl *D) { - if (const FunctionType *FnTy = getFunctionType(D)) + if (const FunctionType *FnTy = D->getFunctionType()) return isa(FnTy); - else { - assert(isa(D) || isa(D)); - return true; - } + return isa(D) || isa(D); } /// getFunctionOrMethodNumArgs - Return number of function or method @@ -116,7 +72,7 @@ /// arguments. It is an error to call this on a K&R function (use /// hasFunctionProto first). static unsigned getFunctionOrMethodNumArgs(const Decl *D) { - if (const FunctionType *FnTy = getFunctionType(D)) + if (const FunctionType *FnTy = D->getFunctionType()) return cast(FnTy)->getNumArgs(); if (const BlockDecl *BD = dyn_cast(D)) return BD->getNumParams(); @@ -124,7 +80,7 @@ } static QualType getFunctionOrMethodArgType(const Decl *D, unsigned Idx) { - if (const FunctionType *FnTy = getFunctionType(D)) + if (const FunctionType *FnTy = D->getFunctionType()) return cast(FnTy)->getArgType(Idx); if (const BlockDecl *BD = dyn_cast(D)) return BD->getParamDecl(Idx)->getType(); @@ -133,13 +89,13 @@ } static QualType getFunctionOrMethodResultType(const Decl *D) { - if (const FunctionType *FnTy = getFunctionType(D)) + if (const FunctionType *FnTy = D->getFunctionType()) return cast(FnTy)->getResultType(); return cast(D)->getResultType(); } static bool isFunctionOrMethodVariadic(const Decl *D) { - if (const FunctionType *FnTy = getFunctionType(D)) { + if (const FunctionType *FnTy = D->getFunctionType()) { const FunctionProtoType *proto = cast(FnTy); return proto->isVariadic(); } else if (const BlockDecl *BD = dyn_cast(D)) @@ -1171,14 +1127,6 @@ } static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr) { - // GCC ignores the nonnull attribute on K&R style function prototypes, so we - // ignore it as well - if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) { - S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) - << Attr.getName() << ExpectedFunction; - return; - } - SmallVector NonNullArgs; for (unsigned i = 0; i < Attr.getNumArgs(); ++i) { Expr *Ex = Attr.getArgAsExpr(i); @@ -1276,12 +1224,6 @@ break; } - if (!isFunction(D) || !hasFunctionProto(D)) { - S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) - << AL.getName() << ExpectedFunction; - return; - } - IdentifierInfo *Module = AL.getArgAsIdent(0)->Ident; // Normalize the argument, __foo__ becomes foo. @@ -1606,19 +1548,6 @@ Attr.getAttributeSpellingListIndex())); } -static void handleUnusedAttr(Sema &S, Decl *D, const AttributeList &Attr) { - if (!isa(D) && !isa(D) && !isFunctionOrMethod(D) && - !isa(D) && !isa(D) && !isa(D)) { - S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) - << Attr.getName() << ExpectedVariableFunctionOrLabel; - return; - } - - D->addAttr(::new (S.Context) - UnusedAttr(Attr.getRange(), S.Context, - Attr.getAttributeSpellingListIndex())); -} - static void handleUsedAttr(Sema &S, Decl *D, const AttributeList &Attr) { if (const VarDecl *VD = dyn_cast(D)) { if (VD->hasLocalStorage()) { @@ -2154,7 +2083,8 @@ } else if (const VarDecl *V = dyn_cast(D)) { QualType Ty = V->getType(); if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) { - const FunctionType *FT = Ty->isFunctionPointerType() ? getFunctionType(D) + const FunctionType *FT = Ty->isFunctionPointerType() + ? D->getFunctionType() : Ty->getAs()->getPointeeType()->getAs(); if (!cast(FT)->isVariadic()) { int m = Ty->isFunctionPointerType() ? 0 : 1; @@ -2177,13 +2107,7 @@ } static void handleWarnUnusedResult(Sema &S, Decl *D, const AttributeList &Attr) { - if (!isFunction(D) && !isa(D) && !isa(D)) { - S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) - << Attr.getName() << ExpectedFunctionMethodOrClass; - return; - } - - if (isFunction(D) && getFunctionType(D)->getResultType()->isVoidType()) { + if (D->getFunctionType() && D->getFunctionType()->getResultType()->isVoidType()) { S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method) << Attr.getName() << 0; return; @@ -2376,12 +2300,6 @@ /// Handle __attribute__((format_arg((idx)))) attribute based on /// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr) { - if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) { - S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) - << Attr.getName() << ExpectedFunction; - return; - } - Expr *IdxExpr = Attr.getArgAsExpr(0); uint64_t ArgIdx; if (!checkFunctionOrMethodArgumentIndex(S, D, Attr, 1, IdxExpr, ArgIdx)) @@ -2526,12 +2444,6 @@ return; } - if (!isFunctionOrMethodOrBlock(D) || !hasFunctionProto(D)) { - S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) - << Attr.getName() << ExpectedFunction; - return; - } - // In C++ the implicit 'this' function parameter also counts, and they are // counted from one. bool HasImplicitThisParam = isInstanceMethod(D); @@ -3292,12 +3204,6 @@ return; } - if (!isFunctionOrMethod(D)) { - S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type) - << Attr.getName() << ExpectedFunctionOrMethod; - return; - } - uint32_t MaxThreads, MinBlocks = 0; if (!checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), MaxThreads, 1)) return; @@ -3926,7 +3832,8 @@ break; case AttributeList::AT_ObjCRequiresPropertyDefs: handleSimpleAttribute(S, D, Attr); break; - case AttributeList::AT_Unused: handleUnusedAttr (S, D, Attr); break; + case AttributeList::AT_Unused: + handleSimpleAttribute(S, D, Attr); break; case AttributeList::AT_ReturnsTwice: handleSimpleAttribute(S, D, Attr); break; case AttributeList::AT_Used: handleUsedAttr (S, D, Attr); break; Index: utils/TableGen/ClangAttrEmitter.cpp =================================================================== --- utils/TableGen/ClangAttrEmitter.cpp (revision 198569) +++ utils/TableGen/ClangAttrEmitter.cpp (working copy) @@ -1900,6 +1900,12 @@ return ""; } +static std::string GetSubjectWithSuffix(const Record *R) { + std::string B = R->getName(); + if (B == "DeclBase") + return "Decl"; + return B + "Decl"; +} static std::string GenerateCustomAppertainsTo(const Record &Subject, raw_ostream &OS) { std::string FnName = "is" + Subject.getName(); @@ -1921,9 +1927,9 @@ } OS << "static bool " << FnName << "(const Decl *D) {\n"; - OS << " const " << Base->getName() << "Decl *S = dyn_cast<"; - OS << Base->getName(); - OS << "Decl>(D);\n"; + OS << " const " << GetSubjectWithSuffix(Base) << " *S = dyn_cast<"; + OS << GetSubjectWithSuffix(Base); + OS << ">(D);\n"; OS << " return S && " << Subject.getValueAsString("CheckCode") << ";\n"; OS << "}\n\n"; @@ -1965,7 +1971,7 @@ if ((*I)->isSubClassOf("SubsetSubject")) { SS << "!" << GenerateCustomAppertainsTo(**I, OS) << "(D)"; } else { - SS << "!isa<" << (*I)->getName() << "Decl>(D)"; + SS << "!isa<" << GetSubjectWithSuffix(*I) << ">(D)"; } if (I + 1 != E)