From 6bb630e324efc92f36c95fc2ac11ba71751cd9b4 Mon Sep 17 00:00:00 2001 From: Erich Keane Date: Wed, 20 Dec 2017 18:51:08 +0000 Subject: [PATCH] Add support for ObjectFormat to TargetSpecificAttr Looking through the code, I saw a FIXME on IFunc to switch it to a target specific attribute. In looking through it, i saw that the no-longer-appropriately-named TargetArch didn't support ObjectFormat checking. This patch changes the name of TargetArch to TargetSpecific (since it checks much more than just Arch), makes "Arch" optional, adds support for ObjectFormat, better documents the TargetSpecific type, and changes IFunc over to a TargetSpecificAttr. Differential Revision: https://reviews.llvm.org/D41303 git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@321201 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Basic/Attr.td | 30 ++++++++--- lib/Sema/SemaDeclAttr.cpp | 6 --- test/Sema/attr-ifunc.c | 2 +- utils/TableGen/ClangAttrEmitter.cpp | 82 +++++++++++++++-------------- 4 files changed, 65 insertions(+), 55 deletions(-) diff --git a/include/clang/Basic/Attr.td b/include/clang/Basic/Attr.td index d926fdde4e..8b84c4b8b5 100644 --- a/include/clang/Basic/Attr.td +++ b/include/clang/Basic/Attr.td @@ -267,13 +267,24 @@ def RenderScript : LangOpt<"RenderScript">; def ObjC : LangOpt<"ObjC1">; def BlocksSupported : LangOpt<"Blocks">; -// Defines targets for target-specific attributes. The list of strings should -// specify architectures for which the target applies, based off the ArchType -// enumeration in Triple.h. -class TargetArch arches> { - list Arches = arches; +// Defines targets for target-specific attributes. Empty lists are unchecked. +class TargetSpec { + // Specifies Architectures for which the target applies, based off the + // ArchType enumeration in Triple.h. + list Arches = []; + // Specifies Operating Systems for which the target applies, based off the + // OSType enumeration in Triple.h list OSes; + // Specifies the C++ ABIs for which the target applies, based off the + // TargetCXXABI::Kind in TargetCXXABI.h. list CXXABIs; + // Specifies Object Formats for which the target applies, based off the + // ObjectFormatType enumeration in Triple.h + list ObjectFormats; +} + +class TargetArch arches> : TargetSpec { + let Arches = arches; } def TargetARM : TargetArch<["arm", "thumb", "armeb", "thumbeb"]>; def TargetAVR : TargetArch<["avr"]>; @@ -288,6 +299,9 @@ def TargetWindows : TargetArch<["x86", "x86_64", "arm", "thumb", "aarch64"]> { def TargetMicrosoftCXXABI : TargetArch<["x86", "x86_64", "arm", "thumb", "aarch64"]> { let CXXABIs = ["Microsoft"]; } +def TargetELF : TargetSpec { + let ObjectFormats = ["ELF"]; +} // Attribute subject match rules that are used for #pragma clang attribute. // @@ -465,8 +479,8 @@ class InheritableAttr : Attr; /// A target-specific attribute. This class is meant to be used as a mixin /// with InheritableAttr or Attr depending on the attribute's needs. -class TargetSpecificAttr { - TargetArch Target = target; +class TargetSpecificAttr { + TargetSpec Target = target; // Attributes are generally required to have unique spellings for their names // so that the parser can determine what kind of attribute it has parsed. // However, target-specific attributes are special in that the attribute only @@ -1121,7 +1135,7 @@ def IBOutletCollection : InheritableAttr { let Documentation = [Undocumented]; } -def IFunc : Attr { +def IFunc : Attr, TargetSpecificAttr { let Spellings = [GCC<"ifunc">]; let Args = [StringArgument<"Resolver">]; let Subjects = SubjectList<[Function]>; diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp index 676d00357c..21fe46ad9d 100644 --- a/lib/Sema/SemaDeclAttr.cpp +++ b/lib/Sema/SemaDeclAttr.cpp @@ -1844,12 +1844,6 @@ static void handleIFuncAttr(Sema &S, Decl *D, const AttributeList &Attr) { S.Diag(Attr.getLoc(), diag::err_alias_is_definition) << FD << 1; return; } - // FIXME: it should be handled as a target specific attribute. - if (S.Context.getTargetInfo().getTriple().getObjectFormat() != - llvm::Triple::ELF) { - S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName(); - return; - } D->addAttr(::new (S.Context) IFuncAttr(Attr.getRange(), S.Context, Str, Attr.getAttributeSpellingListIndex())); diff --git a/test/Sema/attr-ifunc.c b/test/Sema/attr-ifunc.c index 8f9c22f849..16fd0dfc98 100644 --- a/test/Sema/attr-ifunc.c +++ b/test/Sema/attr-ifunc.c @@ -5,7 +5,7 @@ #if defined(_WIN32) void foo() {} void bar() __attribute__((ifunc("foo"))); -//expected-warning@-1 {{'ifunc' attribute ignored}} +//expected-warning@-1 {{unknown attribute 'ifunc' ignored}} #else #if defined(CHECK_ALIASES) diff --git a/utils/TableGen/ClangAttrEmitter.cpp b/utils/TableGen/ClangAttrEmitter.cpp index 70ce15f5a2..b0e2ddd913 100644 --- a/utils/TableGen/ClangAttrEmitter.cpp +++ b/utils/TableGen/ClangAttrEmitter.cpp @@ -2622,6 +2622,31 @@ void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS) { OS << " }\n"; } +// Helper function for GenerateTargetSpecificAttrChecks that alters the 'Test' +// parameter with only a single check type, if applicable. +static void GenerateTargetSpecificAttrCheck(const Record *R, std::string &Test, + std::string *FnName, + StringRef ListName, + StringRef CheckAgainst, + StringRef Scope) { + if (!R->isValueUnset(ListName)) { + Test += " && ("; + std::vector Items = R->getValueAsListOfStrings(ListName); + for (auto I = Items.begin(), E = Items.end(); I != E; ++I) { + StringRef Part = *I; + Test += CheckAgainst; + Test += " == "; + Test += Scope; + Test += Part; + if (I + 1 != E) + Test += " || "; + if (FnName) + *FnName += Part; + } + Test += ")"; + } +} + // Generate a conditional expression to check if the current target satisfies // the conditions for a TargetSpecificAttr record, and append the code for // those checks to the Test string. If the FnName string pointer is non-null, @@ -2635,29 +2660,15 @@ static void GenerateTargetSpecificAttrChecks(const Record *R, // named "T" and a TargetInfo object named "Target" within // scope that can be used to determine whether the attribute exists in // a given target. - Test += "("; - - for (auto I = Arches.begin(), E = Arches.end(); I != E; ++I) { - StringRef Part = *I; - Test += "T.getArch() == llvm::Triple::"; - Test += Part; - if (I + 1 != E) - Test += " || "; - if (FnName) - *FnName += Part; - } - Test += ")"; - - // If the attribute is specific to particular OSes, check those. - if (!R->isValueUnset("OSes")) { - // We know that there was at least one arch test, so we need to and in the - // OS tests. + Test += "true"; + // If one or more architectures is specified, check those. Arches are handled + // differently because GenerateTargetRequirements needs to combine the list + // with ParseKind. + if (!Arches.empty()) { Test += " && ("; - std::vector OSes = R->getValueAsListOfStrings("OSes"); - for (auto I = OSes.begin(), E = OSes.end(); I != E; ++I) { + for (auto I = Arches.begin(), E = Arches.end(); I != E; ++I) { StringRef Part = *I; - - Test += "T.getOS() == llvm::Triple::"; + Test += "T.getArch() == llvm::Triple::"; Test += Part; if (I + 1 != E) Test += " || "; @@ -2667,21 +2678,17 @@ static void GenerateTargetSpecificAttrChecks(const Record *R, Test += ")"; } + // If the attribute is specific to particular OSes, check those. + GenerateTargetSpecificAttrCheck(R, Test, FnName, "OSes", "T.getOS()", + "llvm::Triple::"); + // If one or more CXX ABIs are specified, check those as well. - if (!R->isValueUnset("CXXABIs")) { - Test += " && ("; - std::vector CXXABIs = R->getValueAsListOfStrings("CXXABIs"); - for (auto I = CXXABIs.begin(), E = CXXABIs.end(); I != E; ++I) { - StringRef Part = *I; - Test += "Target.getCXXABI().getKind() == TargetCXXABI::"; - Test += Part; - if (I + 1 != E) - Test += " || "; - if (FnName) - *FnName += Part; - } - Test += ")"; - } + GenerateTargetSpecificAttrCheck(R, Test, FnName, "CXXABIs", + "Target.getCXXABI().getKind()", + "TargetCXXABI::"); + // If one or more object formats is specified, check those. + GenerateTargetSpecificAttrCheck(R, Test, FnName, "ObjectFormats", + "T.getObjectFormat()", "llvm::Triple::"); } static void GenerateHasAttrSpellingStringSwitch( @@ -3301,11 +3308,6 @@ static std::string GenerateTargetRequirements(const Record &Attr, // Get the list of architectures to be tested for. const Record *R = Attr.getValueAsDef("Target"); std::vector Arches = R->getValueAsListOfStrings("Arches"); - if (Arches.empty()) { - PrintError(Attr.getLoc(), "Empty list of target architectures for a " - "target-specific attr"); - return "defaultTargetRequirements"; - } // If there are other attributes which share the same parsed attribute kind, // such as target-specific attributes with a shared spelling, collapse the -- 2.40.0