+++ /dev/null
-//===--- Attributes.h - Attributes header -----------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_BASIC_ATTRIBUTES_H
-#define LLVM_CLANG_BASIC_ATTRIBUTES_H
-
-#include "llvm/ADT/Triple.h"
-#include "clang/Basic/LangOptions.h"
-
-namespace clang {
-
-class IdentifierInfo;
-
-enum class AttrSyntax {
- /// Is the attribute identifier generally known for any syntax?
- Generic,
- /// Is the identifier known as a GNU-style attribute?
- GNU,
- /// Is the identifier known as a __declspec-style attribute?
- Declspec,
- // Is the identifier known as a C++-style attribute?
- CXX
-};
-
-/// \brief Return true if we recognize and implement the attribute specified by
-/// the given information.
-bool HasAttribute(AttrSyntax Syntax, const IdentifierInfo *Scope,
- const IdentifierInfo *Attr, const llvm::Triple &T,
- const LangOptions &LangOpts);
-
-} // end namespace clang
-
-#endif // LLVM_CLANG_BASIC_ATTRIBUTES_H
SOURCE Attr.td
TARGET ClangAttrList)
-clang_tablegen(AttrHasAttributeImpl.inc -gen-clang-attr-has-attribute-impl
- -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
- SOURCE Attr.td
- TARGET ClangAttrHasAttributeImpl
- )
-
# ARM NEON
clang_tablegen(arm_neon.inc -gen-arm-neon-sema
SOURCE arm_neon.td
DiagnosticFrontendKinds.inc DiagnosticLexKinds.inc \
DiagnosticParseKinds.inc DiagnosticSemaKinds.inc \
DiagnosticSerializationKinds.inc \
- AttrHasAttributeImpl.inc \
DiagnosticIndexName.inc DiagnosticGroups.inc AttrList.inc arm_neon.inc \
Version.inc
$(Verb) $(ClangTableGen) -gen-clang-attr-list -o $(call SYSPATH, $@) \
-I $(PROJ_SRC_DIR)/../.. $<
-$(ObjDir)/AttrHasAttributeImpl.inc.tmp : Attr.td $(CLANG_TBLGEN) \
- $(ObjDir)/.dir
- $(Echo) "Building Clang __has_attribute implementation with tblgen"
- $(Verb) $(ClangTableGen) -gen-clang-attr-has-attribute-impl -o $(call SYSPATH, $@) \
- -I $(PROJ_SRC_DIR)/../../ $<
-
$(ObjDir)/arm_neon.inc.tmp : arm_neon.td $(CLANG_TBLGEN) $(ObjDir)/.dir
$(Echo) "Building Clang arm_neon.inc with tblgen"
$(Verb) $(ClangTableGen) -gen-arm-neon-sema -o $(call SYSPATH, $@) $<
add_subdirectory(AST)
add_subdirectory(Basic)
add_subdirectory(Driver)
+add_subdirectory(Lex)
add_subdirectory(Parse)
add_subdirectory(Sema)
add_subdirectory(Serialization)
--- /dev/null
+clang_tablegen(AttrSpellings.inc -gen-clang-attr-spelling-list
+ -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
+ SOURCE ../Basic/Attr.td
+ TARGET ClangAttrSpellings
+ )
--- /dev/null
+CLANG_LEVEL := ../../..
+TD_SRC_DIR = $(PROJ_SRC_DIR)/../Basic
+BUILT_SOURCES = AttrSpellings.inc
+
+TABLEGEN_INC_FILES_COMMON = 1
+
+include $(CLANG_LEVEL)/Makefile
+
+$(ObjDir)/AttrSpellings.inc.tmp : $(TD_SRC_DIR)/Attr.td $(CLANG_TBLGEN) \
+ $(ObjDir)/.dir
+ $(Echo) "Building Clang attribute spellings with tblgen"
+ $(Verb) $(ClangTableGen) -gen-clang-attr-spelling-list -o $(call SYSPATH, $@) \
+ -I $(PROJ_SRC_DIR)/../../ $<
CLANG_LEVEL := ../..
-DIRS := AST Basic Driver Parse Sema Serialization
+DIRS := AST Basic Driver Lex Parse Sema Serialization
include $(CLANG_LEVEL)/Makefile
+++ /dev/null
-#include "clang/Basic/Attributes.h"
-#include "clang/Basic/IdentifierTable.h"
-#include "llvm/ADT/StringSwitch.h"
-
-namespace clang {
-
-bool HasAttribute(AttrSyntax Syntax, const IdentifierInfo *Scope,
- const IdentifierInfo *Attr, const llvm::Triple &T,
- const LangOptions &LangOpts) {
- StringRef Name = Attr->getName();
- // Normalize the attribute name, __foo__ becomes foo.
- if (Name.size() >= 4 && Name.startswith("__") && Name.endswith("__"))
- Name = Name.substr(2, Name.size() - 4);
-
-#include "clang/Basic/AttrHasAttributeImpl.inc"
-
- return false;
-}
-
-} // end namespace clang
)
add_clang_library(clangBasic
- Attributes.cpp
Builtins.cpp
CharInfo.cpp
Diagnostic.cpp
//===----------------------------------------------------------------------===//
#include "clang/Lex/Preprocessor.h"
-#include "clang/Basic/Attributes.h"
#include "clang/Basic/FileManager.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetInfo.h"
.Default(false);
}
+/// HasAttribute - Return true if we recognize and implement the attribute
+/// specified by the given identifier.
+static bool HasAttribute(const IdentifierInfo *II, const llvm::Triple &T) {
+ StringRef Name = II->getName();
+ // Normalize the attribute name, __foo__ becomes foo.
+ if (Name.size() >= 4 && Name.startswith("__") && Name.endswith("__"))
+ Name = Name.substr(2, Name.size() - 4);
+
+ // FIXME: Do we need to handle namespaces here?
+ return llvm::StringSwitch<bool>(Name)
+#include "clang/Lex/AttrSpellings.inc"
+ .Default(false);
+}
+
/// EvaluateHasIncludeCommon - Process a '__has_include("path")'
/// or '__has_include_next("path")' expression.
/// Returns true if successful.
// Check for a builtin is trivial.
Value = FeatureII->getBuiltinID() != 0;
} else if (II == Ident__has_attribute)
- Value = HasAttribute(AttrSyntax::Generic, nullptr, FeatureII,
- getTargetInfo().getTriple(), getLangOpts());
+ Value = HasAttribute(FeatureII, getTargetInfo().getTriple());
else if (II == Ident__has_extension)
Value = HasExtension(*this, FeatureII);
else {
OS << " }\n";
}
-static void GenerateHasAttrSpellingStringSwitch(
- const std::vector<Record *> &Attrs, raw_ostream &OS,
- const std::string &Variety = "", const std::string &Scope = "") {
- for (const auto *Attr : Attrs) {
+// Emits the list of spellings for attributes.
+void EmitClangAttrSpellingList(RecordKeeper &Records, raw_ostream &OS) {
+ emitSourceFileHeader("llvm::StringSwitch code to match attributes based on "
+ "the target triple, T", OS);
+
+ std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
+
+ for (auto I : Attrs) {
+ Record &Attr = *I;
+
// It is assumed that there will be an llvm::Triple object named T within
// scope that can be used to determine whether the attribute exists in
// a given target.
std::string Test;
- if (Attr->isSubClassOf("TargetSpecificAttr")) {
- const Record *R = Attr->getValueAsDef("Target");
+ if (Attr.isSubClassOf("TargetSpecificAttr")) {
+ const Record *R = Attr.getValueAsDef("Target");
std::vector<std::string> Arches = R->getValueAsListOfStrings("Arches");
Test += "(";
}
Test += ")";
}
-
- // If this is the C++11 variety, also add in the LangOpts test.
- if (Variety == "CXX11")
- Test += " && LangOpts.CPlusPlus11";
- } else if (Variety == "CXX11")
- // C++11 mode should be checked against LangOpts, which is presumed to be
- // present in the caller.
- Test = "LangOpts.CPlusPlus11";
- else
+ } else
Test = "true";
- std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
+ std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
for (const auto &S : Spellings)
- if (Variety.empty() || (Variety == S.variety() &&
- (Scope.empty() || Scope == S.nameSpace())))
- OS << " .Case(\"" << S.name() << "\", " << Test << ")\n";
- }
- OS << " .Default(false);\n";
-}
-
-// Emits the list of spellings for attributes.
-void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
- emitSourceFileHeader("Code to implement the __has_attribute logic", OS);
-
- // Separate all of the attributes out into four group: generic, C++11, GNU,
- // and declspecs. Then generate a big switch statement for each of them.
- std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
- std::vector<Record *> Declspec, GNU;
- std::map<std::string, std::vector<Record *>> CXX;
-
- // Walk over the list of all attributes, and split them out based on the
- // spelling variety.
- for (auto *R : Attrs) {
- std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
- for (const auto &SI : Spellings) {
- std::string Variety = SI.variety();
- if (Variety == "GNU")
- GNU.push_back(R);
- else if (Variety == "Declspec")
- Declspec.push_back(R);
- else if (Variety == "CXX11") {
- CXX[SI.nameSpace()].push_back(R);
- }
- }
- }
-
- OS << "switch (Syntax) {\n";
- OS << "case AttrSyntax::Generic:\n";
- OS << " return llvm::StringSwitch<bool>(Name)\n";
- GenerateHasAttrSpellingStringSwitch(Attrs, OS);
- OS << "case AttrSyntax::GNU:\n";
- OS << " return llvm::StringSwitch<bool>(Name)\n";
- GenerateHasAttrSpellingStringSwitch(GNU, OS, "GNU");
- OS << "case AttrSyntax::Declspec:\n";
- OS << " return llvm::StringSwitch<bool>(Name)\n";
- GenerateHasAttrSpellingStringSwitch(Declspec, OS, "Declspec");
- OS << "case AttrSyntax::CXX: {\n";
- // C++11-style attributes are further split out based on the Scope.
- for (std::map<std::string, std::vector<Record *>>::iterator I = CXX.begin(),
- E = CXX.end();
- I != E; ++I) {
- if (I != CXX.begin())
- OS << " else ";
- if (I->first.empty())
- OS << "if (!Scope || Scope->getName() == \"\") {\n";
- else
- OS << "if (Scope->getName() == \"" << I->first << "\") {\n";
- OS << " return llvm::StringSwitch<bool>(Name)\n";
- GenerateHasAttrSpellingStringSwitch(I->second, OS, "CXX11", I->first);
- OS << "}";
+ OS << ".Case(\"" << S.name() << "\", " << Test << ")\n";
}
- OS << "\n}\n";
- OS << "}\n";
}
void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
GenClangAttrList,
GenClangAttrPCHRead,
GenClangAttrPCHWrite,
- GenClangAttrHasAttributeImpl,
+ GenClangAttrSpellingList,
GenClangAttrSpellingListIndex,
GenClangAttrASTVisitor,
GenClangAttrTemplateInstantiate,
"Generate clang PCH attribute reader"),
clEnumValN(GenClangAttrPCHWrite, "gen-clang-attr-pch-write",
"Generate clang PCH attribute writer"),
- clEnumValN(GenClangAttrHasAttributeImpl,
- "gen-clang-attr-has-attribute-impl",
+ clEnumValN(GenClangAttrSpellingList, "gen-clang-attr-spelling-list",
"Generate a clang attribute spelling list"),
clEnumValN(GenClangAttrSpellingListIndex,
"gen-clang-attr-spelling-index",
case GenClangAttrPCHWrite:
EmitClangAttrPCHWrite(Records, OS);
break;
- case GenClangAttrHasAttributeImpl:
- EmitClangAttrHasAttrImpl(Records, OS);
+ case GenClangAttrSpellingList:
+ EmitClangAttrSpellingList(Records, OS);
break;
case GenClangAttrSpellingListIndex:
EmitClangAttrSpellingListIndex(Records, OS);
void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS);
void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS);
void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS);
-void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS);
+void EmitClangAttrSpellingList(RecordKeeper &Records, raw_ostream &OS);
void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS);
void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS);
void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS);