This is an archive of the discontinued LLVM Phabricator instance.

Differential D43628

[Sema][NFC] Split Function MultiVersioning decl semantic analysis into its own .cpp file.
AbandonedPublic

Authored by erichkeane on Feb 22 2018, 9:20 AM.

Details

Reviewers
rnk
echristo
aaron.ballman
rsmith
Summary

I'm currently working on the cpu_dispatch and cpu_specific multiversion
support, which is making this functionality require a significant amount
of functions. It seems that it would be easier to refactor this and add
additional mechanisms if unencumbered by the rest of SemaDecl (which itself
is getting quite large).

Diff Detail

Event Timeline

erichkeane created this revision.Feb 22 2018, 9:20 AM
Herald added subscribers: mgrang, mgorny. · View Herald TranscriptFeb 22 2018, 9:20 AM
erichkeane abandoned this revision.May 23 2018, 7:38 AM

Revision Contents

PathSize
include/
clang/
Sema/
4 lines
lib/
Sema/
1 line
337 lines
353 lines

Diff 135442

include/clang/Sema/Sema.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,527 Lines • ▼ Show 20 Lines void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
emit(DB, llvm::index_sequence_for<Ts...>()); emit(DB, llvm::index_sequence_for<Ts...>());
DB << T; DB << T;
} }
}; };
private: private:
bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T, bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
TypeDiagnoser *Diagnoser); TypeDiagnoser *Diagnoser);
bool CheckMultiVersionFunction(FunctionDecl *NewFD, bool &Redeclaration,
NamedDecl *&OldDecl,
bool &MergeTypeWithPrevious,
LookupResult &Previous);
struct ModuleScope { struct ModuleScope {
clang::Module *Module = nullptr; clang::Module *Module = nullptr;
bool ModuleInterface = false; bool ModuleInterface = false;
VisibleModuleSet OuterVisibleModules; VisibleModuleSet OuterVisibleModules;
}; };
/// The modules we're currently parsing. /// The modules we're currently parsing.
llvm::SmallVector<ModuleScope, 16> ModuleScopes; llvm::SmallVector<ModuleScope, 16> ModuleScopes;
▲ Show 20 Lines • Show All 9,226 Lines • Show Last 20 Lines

lib/Sema/CMakeLists.txt

Show All 25 Linesadd_clang_library(clangSema
SemaChecking.cpp SemaChecking.cpp
SemaCodeComplete.cpp SemaCodeComplete.cpp
SemaConsumer.cpp SemaConsumer.cpp
SemaCoroutine.cpp SemaCoroutine.cpp
SemaCUDA.cpp SemaCUDA.cpp
SemaDecl.cpp SemaDecl.cpp
SemaDeclAttr.cpp SemaDeclAttr.cpp
SemaDeclCXX.cpp SemaDeclCXX.cpp
SemaDeclMultiVersion.cpp
SemaDeclObjC.cpp SemaDeclObjC.cpp
SemaExceptionSpec.cpp SemaExceptionSpec.cpp
SemaExpr.cpp SemaExpr.cpp
SemaExprCXX.cpp SemaExprCXX.cpp
SemaExprMember.cpp SemaExprMember.cpp
SemaExprObjC.cpp SemaExprObjC.cpp
SemaFixItUtils.cpp SemaFixItUtils.cpp
SemaInit.cpp SemaInit.cpp
Show All 24 Lines

lib/Sema/SemaDecl.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 9,153 Lines • ▼ Show 20 Linesbool Sema::shouldLinkDependentDeclWithPrevious(Decl *D, Decl *PrevDecl) {
// template<typename T> class C2 { friend void func() { } }; // template<typename T> class C2 { friend void func() { } };
// //
// This code snippet is a valid code unless both templates are instantiated. // This code snippet is a valid code unless both templates are instantiated.
return !(D->getLexicalDeclContext()->isDependentContext() && return !(D->getLexicalDeclContext()->isDependentContext() &&
D->getDeclContext()->isFileContext() && D->getDeclContext()->isFileContext() &&
D->getFriendObjectKind() != Decl::FOK_None); D->getFriendObjectKind() != Decl::FOK_None);
} }
/// \brief Check the target attribute of the function for MultiVersion
/// validity.
///
/// Returns true if there was an error, false otherwise.
static bool CheckMultiVersionValue(Sema &S, const FunctionDecl *FD) {
const auto *TA = FD->getAttr<TargetAttr>();
assert(TA && "MultiVersion Candidate requires a target attribute");
TargetAttr::ParsedTargetAttr ParseInfo = TA->parse();
const TargetInfo &TargetInfo = S.Context.getTargetInfo();
enum ErrType { Feature = 0, Architecture = 1 };
if (!ParseInfo.Architecture.empty() &&
!TargetInfo.validateCpuIs(ParseInfo.Architecture)) {
S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
<< Architecture << ParseInfo.Architecture;
return true;
}
for (const auto &Feat : ParseInfo.Features) {
auto BareFeat = StringRef{Feat}.substr(1);
if (Feat[0] == '-') {
S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
<< Feature << ("no-" + BareFeat).str();
return true;
}
if (!TargetInfo.validateCpuSupports(BareFeat) ||
!TargetInfo.isValidFeatureName(BareFeat)) {
S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
<< Feature << BareFeat;
return true;
}
}
return false;
}
static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD,
const FunctionDecl *NewFD,
bool CausesMV) {
enum DoesntSupport {
FuncTemplates = 0,
VirtFuncs = 1,
DeducedReturn = 2,
Constructors = 3,
Destructors = 4,
DeletedFuncs = 5,
DefaultedFuncs = 6
};
enum Different {
CallingConv = 0,
ReturnType = 1,
ConstexprSpec = 2,
InlineSpec = 3,
StorageClass = 4,
Linkage = 5
};
// For now, disallow all other attributes. These should be opt-in, but
// an analysis of all of them is a future FIXME.
if (CausesMV && OldFD &&
std::distance(OldFD->attr_begin(), OldFD->attr_end()) != 1) {
S.Diag(OldFD->getLocation(), diag::err_multiversion_no_other_attrs);
S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
return true;
}
if (std::distance(NewFD->attr_begin(), NewFD->attr_end()) != 1)
return S.Diag(NewFD->getLocation(), diag::err_multiversion_no_other_attrs);
if (NewFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
<< FuncTemplates;
if (const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
if (NewCXXFD->isVirtual())
return S.Diag(NewCXXFD->getLocation(),
diag::err_multiversion_doesnt_support)
<< VirtFuncs;
if (const auto *NewCXXCtor = dyn_cast<CXXConstructorDecl>(NewFD))
return S.Diag(NewCXXCtor->getLocation(),
diag::err_multiversion_doesnt_support)
<< Constructors;
if (const auto *NewCXXDtor = dyn_cast<CXXDestructorDecl>(NewFD))
return S.Diag(NewCXXDtor->getLocation(),
diag::err_multiversion_doesnt_support)
<< Destructors;
}
if (NewFD->isDeleted())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
<< DeletedFuncs;
if (NewFD->isDefaulted())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
<< DefaultedFuncs;
QualType NewQType = S.getASTContext().getCanonicalType(NewFD->getType());
const auto *NewType = cast<FunctionType>(NewQType);
QualType NewReturnType = NewType->getReturnType();
if (NewReturnType->isUndeducedType())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
<< DeducedReturn;
// Only allow transition to MultiVersion if it hasn't been used.
if (OldFD && CausesMV && OldFD->isUsed(false))
return S.Diag(NewFD->getLocation(), diag::err_multiversion_after_used);
// Ensure the return type is identical.
if (OldFD) {
QualType OldQType = S.getASTContext().getCanonicalType(OldFD->getType());
const auto *OldType = cast<FunctionType>(OldQType);
FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
if (OldTypeInfo.getCC() != NewTypeInfo.getCC())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< CallingConv;
QualType OldReturnType = OldType->getReturnType();
if (OldReturnType != NewReturnType)
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< ReturnType;
if (OldFD->isConstexpr() != NewFD->isConstexpr())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< ConstexprSpec;
if (OldFD->isInlineSpecified() != NewFD->isInlineSpecified())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< InlineSpec;
if (OldFD->getStorageClass() != NewFD->getStorageClass())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< StorageClass;
if (OldFD->isExternC() != NewFD->isExternC())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< Linkage;
if (S.CheckEquivalentExceptionSpec(
OldFD->getType()->getAs<FunctionProtoType>(), OldFD->getLocation(),
NewFD->getType()->getAs<FunctionProtoType>(), NewFD->getLocation()))
return true;
}
return false;
}
/// \brief Check the validity of a mulitversion function declaration.
/// Also sets the multiversion'ness' of the function itself.
///
/// This sets NewFD->isInvalidDecl() to true if there was an error.
///
/// Returns true if there was an error, false otherwise.
static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD,
bool &Redeclaration, NamedDecl *&OldDecl,
bool &MergeTypeWithPrevious,
LookupResult &Previous) {
const auto *NewTA = NewFD->getAttr<TargetAttr>();
if (NewFD->isMain()) {
if (NewTA && NewTA->isDefaultVersion()) {
S.Diag(NewFD->getLocation(), diag::err_multiversion_not_allowed_on_main);
NewFD->setInvalidDecl();
return true;
}
return false;
}
// If there is no matching previous decl, only 'default' can
// cause MultiVersioning.
if (!OldDecl) {
if (NewTA && NewTA->isDefaultVersion()) {
if (!NewFD->getType()->getAs<FunctionProtoType>()) {
S.Diag(NewFD->getLocation(), diag::err_multiversion_noproto);
NewFD->setInvalidDecl();
return true;
}
if (CheckMultiVersionAdditionalRules(S, nullptr, NewFD, true)) {
NewFD->setInvalidDecl();
return true;
}
if (!S.getASTContext().getTargetInfo().supportsMultiVersioning()) {
S.Diag(NewFD->getLocation(), diag::err_multiversion_not_supported);
NewFD->setInvalidDecl();
return true;
}
NewFD->setIsMultiVersion();
}
return false;
}
if (OldDecl->getDeclContext()->getRedeclContext() !=
NewFD->getDeclContext()->getRedeclContext())
return false;
FunctionDecl *OldFD = OldDecl->getAsFunction();
// Unresolved 'using' statements (the other way OldDecl can be not a function)
// likely cannot cause a problem here.
if (!OldFD)
return false;
if (!OldFD->isMultiVersion() && !NewTA)
return false;
if (OldFD->isMultiVersion() && !NewTA) {
S.Diag(NewFD->getLocation(), diag::err_target_required_in_redecl);
NewFD->setInvalidDecl();
return true;
}
TargetAttr::ParsedTargetAttr NewParsed = NewTA->parse();
// Sort order doesn't matter, it just needs to be consistent.
std::sort(NewParsed.Features.begin(), NewParsed.Features.end());
const auto *OldTA = OldFD->getAttr<TargetAttr>();
if (!OldFD->isMultiVersion()) {
// If the old decl is NOT MultiVersioned yet, and we don't cause that
// to change, this is a simple redeclaration.
if (!OldTA || OldTA->getFeaturesStr() == NewTA->getFeaturesStr())
return false;
// Otherwise, this decl causes MultiVersioning.
if (!S.getASTContext().getTargetInfo().supportsMultiVersioning()) {
S.Diag(NewFD->getLocation(), diag::err_multiversion_not_supported);
S.Diag(OldFD->getLocation(), diag::note_previous_declaration);
NewFD->setInvalidDecl();
return true;
}
if (!OldFD->getType()->getAs<FunctionProtoType>()) {
S.Diag(OldFD->getLocation(), diag::err_multiversion_noproto);
S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
NewFD->setInvalidDecl();
return true;
}
if (CheckMultiVersionValue(S, NewFD)) {
NewFD->setInvalidDecl();
return true;
}
if (CheckMultiVersionValue(S, OldFD)) {
S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
NewFD->setInvalidDecl();
return true;
}
TargetAttr::ParsedTargetAttr OldParsed =
OldTA->parse(std::less<std::string>());
if (OldParsed == NewParsed) {
S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
S.Diag(OldFD->getLocation(), diag::note_previous_declaration);
NewFD->setInvalidDecl();
return true;
}
for (const auto *FD : OldFD->redecls()) {
const auto *CurTA = FD->getAttr<TargetAttr>();
if (!CurTA || CurTA->isInherited()) {
S.Diag(FD->getLocation(), diag::err_target_required_in_redecl);
S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
NewFD->setInvalidDecl();
return true;
}
}
if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD, true)) {
NewFD->setInvalidDecl();
return true;
}
OldFD->setIsMultiVersion();
NewFD->setIsMultiVersion();
Redeclaration = false;
MergeTypeWithPrevious = false;
OldDecl = nullptr;
Previous.clear();
return false;
}
bool UseMemberUsingDeclRules =
S.CurContext->isRecord() && !NewFD->getFriendObjectKind();
// Next, check ALL non-overloads to see if this is a redeclaration of a
// previous member of the MultiVersion set.
for (NamedDecl *ND : Previous) {
FunctionDecl *CurFD = ND->getAsFunction();
if (!CurFD)
continue;
if (S.IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
continue;
const auto *CurTA = CurFD->getAttr<TargetAttr>();
if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) {
NewFD->setIsMultiVersion();
Redeclaration = true;
OldDecl = ND;
return false;
}
TargetAttr::ParsedTargetAttr CurParsed =
CurTA->parse(std::less<std::string>());
if (CurParsed == NewParsed) {
S.Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
S.Diag(CurFD->getLocation(), diag::note_previous_declaration);
NewFD->setInvalidDecl();
return true;
}
}
// Else, this is simply a non-redecl case.
if (CheckMultiVersionValue(S, NewFD)) {
NewFD->setInvalidDecl();
return true;
}
if (CheckMultiVersionAdditionalRules(S, OldFD, NewFD, false)) {
NewFD->setInvalidDecl();
return true;
}
NewFD->setIsMultiVersion();
Redeclaration = false;
MergeTypeWithPrevious = false;
OldDecl = nullptr;
Previous.clear();
return false;
}
/// \brief Perform semantic checking of a new function declaration. /// \brief Perform semantic checking of a new function declaration.
/// ///
/// Performs semantic analysis of the new function declaration /// Performs semantic analysis of the new function declaration
/// NewFD. This routine performs all semantic checking that does not /// NewFD. This routine performs all semantic checking that does not
/// require the actual declarator involved in the declaration, and is /// require the actual declarator involved in the declaration, and is
/// used both for the declaration of functions as they are parsed /// used both for the declaration of functions as they are parsed
/// (called via ActOnDeclarator) and for the declaration of functions /// (called via ActOnDeclarator) and for the declaration of functions
/// that have been instantiated via C++ template instantiation (called /// that have been instantiated via C++ template instantiation (called
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines if (!Previous.empty()) {
MayNeedOverloadableChecks = true; MayNeedOverloadableChecks = true;
Redeclaration = false; Redeclaration = false;
OldDecl = nullptr; OldDecl = nullptr;
} }
} }
} }
} }
if (CheckMultiVersionFunction(*this, NewFD, Redeclaration, OldDecl, if (CheckMultiVersionFunction(NewFD, Redeclaration, OldDecl,
MergeTypeWithPrevious, Previous)) MergeTypeWithPrevious, Previous))
return Redeclaration; return Redeclaration;
// C++11 [dcl.constexpr]p8: // C++11 [dcl.constexpr]p8:
// A constexpr specifier for a non-static member function that is not // A constexpr specifier for a non-static member function that is not
// a constructor declares that member function to be const. // a constructor declares that member function to be const.
// //
// This needs to be delayed until we know whether this is an out-of-line // This needs to be delayed until we know whether this is an out-of-line
▲ Show 20 Lines • Show All 7,201 Lines • Show Last 20 Lines

lib/Sema/SemaDeclMultiVersion.cpp

//==SemaDeclMultiVersion.cpp - Semantic Analysis for MultiVersion Functions===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements semantic analysis for MultiVersion Function
// Declarations.
//
//===----------------------------------------------------------------------===//
#include "clang/Sema/SemaInternal.h"
using namespace clang;
using namespace sema;
/// \brief Check the target attribute of the function for MultiVersion
/// validity.
///
/// Returns true if there was an error, false otherwise.
static bool CheckMultiVersionValue(Sema &S, const FunctionDecl *FD) {
const auto *TA = FD->getAttr<TargetAttr>();
assert(TA && "MultiVersion Candidate requires a target attribute");
TargetAttr::ParsedTargetAttr ParseInfo = TA->parse();
const TargetInfo &TargetInfo = S.Context.getTargetInfo();
enum ErrType { Feature = 0, Architecture = 1 };
if (!ParseInfo.Architecture.empty() &&
!TargetInfo.validateCpuIs(ParseInfo.Architecture)) {
S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
<< Architecture << ParseInfo.Architecture;
return true;
}
for (const auto &Feat : ParseInfo.Features) {
auto BareFeat = StringRef{Feat}.substr(1);
if (Feat[0] == '-') {
S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
<< Feature << ("no-" + BareFeat).str();
return true;
}
if (!TargetInfo.validateCpuSupports(BareFeat) ||
!TargetInfo.isValidFeatureName(BareFeat)) {
S.Diag(FD->getLocation(), diag::err_bad_multiversion_option)
<< Feature << BareFeat;
return true;
}
}
return false;
}
static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD,
const FunctionDecl *NewFD,
bool CausesMV) {
enum DoesntSupport {
FuncTemplates = 0,
VirtFuncs = 1,
DeducedReturn = 2,
Constructors = 3,
Destructors = 4,
DeletedFuncs = 5,
DefaultedFuncs = 6
};
enum Different {
CallingConv = 0,
ReturnType = 1,
ConstexprSpec = 2,
InlineSpec = 3,
StorageClass = 4,
Linkage = 5
};
// For now, disallow all other attributes. These should be opt-in, but
// an analysis of all of them is a future FIXME.
if (CausesMV && OldFD &&
std::distance(OldFD->attr_begin(), OldFD->attr_end()) != 1) {
S.Diag(OldFD->getLocation(), diag::err_multiversion_no_other_attrs);
S.Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
return true;
}
if (std::distance(NewFD->attr_begin(), NewFD->attr_end()) != 1)
return S.Diag(NewFD->getLocation(), diag::err_multiversion_no_other_attrs);
if (NewFD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
<< FuncTemplates;
if (const auto *NewCXXFD = dyn_cast<CXXMethodDecl>(NewFD)) {
if (NewCXXFD->isVirtual())
return S.Diag(NewCXXFD->getLocation(),
diag::err_multiversion_doesnt_support)
<< VirtFuncs;
if (const auto *NewCXXCtor = dyn_cast<CXXConstructorDecl>(NewFD))
return S.Diag(NewCXXCtor->getLocation(),
diag::err_multiversion_doesnt_support)
<< Constructors;
if (const auto *NewCXXDtor = dyn_cast<CXXDestructorDecl>(NewFD))
return S.Diag(NewCXXDtor->getLocation(),
diag::err_multiversion_doesnt_support)
<< Destructors;
}
if (NewFD->isDeleted())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
<< DeletedFuncs;
if (NewFD->isDefaulted())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
<< DefaultedFuncs;
QualType NewQType = S.getASTContext().getCanonicalType(NewFD->getType());
const auto *NewType = cast<FunctionType>(NewQType);
QualType NewReturnType = NewType->getReturnType();
if (NewReturnType->isUndeducedType())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
<< DeducedReturn;
// Only allow transition to MultiVersion if it hasn't been used.
if (OldFD && CausesMV && OldFD->isUsed(false))
return S.Diag(NewFD->getLocation(), diag::err_multiversion_after_used);
// Ensure the return type is identical.
if (OldFD) {
QualType OldQType = S.getASTContext().getCanonicalType(OldFD->getType());
const auto *OldType = cast<FunctionType>(OldQType);
FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
if (OldTypeInfo.getCC() != NewTypeInfo.getCC())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< CallingConv;
QualType OldReturnType = OldType->getReturnType();
if (OldReturnType != NewReturnType)
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< ReturnType;
if (OldFD->isConstexpr() != NewFD->isConstexpr())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< ConstexprSpec;
if (OldFD->isInlineSpecified() != NewFD->isInlineSpecified())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< InlineSpec;
if (OldFD->getStorageClass() != NewFD->getStorageClass())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< StorageClass;
if (OldFD->isExternC() != NewFD->isExternC())
return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
<< Linkage;
if (S.CheckEquivalentExceptionSpec(
OldFD->getType()->getAs<FunctionProtoType>(), OldFD->getLocation(),
NewFD->getType()->getAs<FunctionProtoType>(), NewFD->getLocation()))
return true;
}
return false;
}
/// \brief Check the validity of a mulitversion function declaration.
/// Also sets the multiversion'ness' of the function itself.
///
/// This sets NewFD->isInvalidDecl() to true if there was an error.
///
/// Returns true if there was an error, false otherwise.
bool Sema::CheckMultiVersionFunction(FunctionDecl *NewFD,
bool &Redeclaration, NamedDecl *&OldDecl,
bool &MergeTypeWithPrevious,
LookupResult &Previous) {
const auto *NewTA = NewFD->getAttr<TargetAttr>();
if (NewFD->isMain()) {
if (NewTA && NewTA->isDefaultVersion()) {
Diag(NewFD->getLocation(), diag::err_multiversion_not_allowed_on_main);
NewFD->setInvalidDecl();
return true;
}
return false;
}
// If there is no matching previous decl, only 'default' can
// cause MultiVersioning.
if (!OldDecl) {
if (NewTA && NewTA->isDefaultVersion()) {
if (!NewFD->getType()->getAs<FunctionProtoType>()) {
Diag(NewFD->getLocation(), diag::err_multiversion_noproto);
NewFD->setInvalidDecl();
return true;
}
if (CheckMultiVersionAdditionalRules(*this, nullptr, NewFD, true)) {
NewFD->setInvalidDecl();
return true;
}
if (!getASTContext().getTargetInfo().supportsMultiVersioning()) {
Diag(NewFD->getLocation(), diag::err_multiversion_not_supported);
NewFD->setInvalidDecl();
return true;
}
NewFD->setIsMultiVersion();
}
return false;
}
if (OldDecl->getDeclContext()->getRedeclContext() !=
NewFD->getDeclContext()->getRedeclContext())
return false;
FunctionDecl *OldFD = OldDecl->getAsFunction();
// Unresolved 'using' statements (the other way OldDecl can be not a function)
// likely cannot cause a problem here.
if (!OldFD)
return false;
if (!OldFD->isMultiVersion() && !NewTA)
return false;
if (OldFD->isMultiVersion() && !NewTA) {
Diag(NewFD->getLocation(), diag::err_target_required_in_redecl);
NewFD->setInvalidDecl();
return true;
}
TargetAttr::ParsedTargetAttr NewParsed = NewTA->parse();
// Sort order doesn't matter, it just needs to be consistent.
std::sort(NewParsed.Features.begin(), NewParsed.Features.end());
const auto *OldTA = OldFD->getAttr<TargetAttr>();
if (!OldFD->isMultiVersion()) {
// If the old decl is NOT MultiVersioned yet, and we don't cause that
// to change, this is a simple redeclaration.
if (!OldTA || OldTA->getFeaturesStr() == NewTA->getFeaturesStr())
return false;
// Otherwise, this decl causes MultiVersioning.
if (!getASTContext().getTargetInfo().supportsMultiVersioning()) {
Diag(NewFD->getLocation(), diag::err_multiversion_not_supported);
Diag(OldFD->getLocation(), diag::note_previous_declaration);
NewFD->setInvalidDecl();
return true;
}
if (!OldFD->getType()->getAs<FunctionProtoType>()) {
Diag(OldFD->getLocation(), diag::err_multiversion_noproto);
Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
NewFD->setInvalidDecl();
return true;
}
if (CheckMultiVersionValue(*this, NewFD)) {
NewFD->setInvalidDecl();
return true;
}
if (CheckMultiVersionValue(*this, OldFD)) {
Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
NewFD->setInvalidDecl();
return true;
}
TargetAttr::ParsedTargetAttr OldParsed =
OldTA->parse(std::less<std::string>());
if (OldParsed == NewParsed) {
Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
Diag(OldFD->getLocation(), diag::note_previous_declaration);
NewFD->setInvalidDecl();
return true;
}
for (const auto *FD : OldFD->redecls()) {
const auto *CurTA = FD->getAttr<TargetAttr>();
if (!CurTA || CurTA->isInherited()) {
Diag(FD->getLocation(), diag::err_target_required_in_redecl);
Diag(NewFD->getLocation(), diag::note_multiversioning_caused_here);
NewFD->setInvalidDecl();
return true;
}
}
if (CheckMultiVersionAdditionalRules(*this, OldFD, NewFD, true)) {
NewFD->setInvalidDecl();
return true;
}
OldFD->setIsMultiVersion();
NewFD->setIsMultiVersion();
Redeclaration = false;
MergeTypeWithPrevious = false;
OldDecl = nullptr;
Previous.clear();
return false;
}
bool UseMemberUsingDeclRules =
CurContext->isRecord() && !NewFD->getFriendObjectKind();
// Next, check ALL non-overloads to see if this is a redeclaration of a
// previous member of the MultiVersion set.
for (NamedDecl *ND : Previous) {
FunctionDecl *CurFD = ND->getAsFunction();
if (!CurFD)
continue;
if (IsOverload(NewFD, CurFD, UseMemberUsingDeclRules))
continue;
const auto *CurTA = CurFD->getAttr<TargetAttr>();
if (CurTA->getFeaturesStr() == NewTA->getFeaturesStr()) {
NewFD->setIsMultiVersion();
Redeclaration = true;
OldDecl = ND;
return false;
}
TargetAttr::ParsedTargetAttr CurParsed =
CurTA->parse(std::less<std::string>());
if (CurParsed == NewParsed) {
Diag(NewFD->getLocation(), diag::err_multiversion_duplicate);
Diag(CurFD->getLocation(), diag::note_previous_declaration);
NewFD->setInvalidDecl();
return true;
}
}
// Else, this is simply a non-redecl case.
if (CheckMultiVersionValue(*this, NewFD)) {
NewFD->setInvalidDecl();
return true;
}
if (CheckMultiVersionAdditionalRules(*this, OldFD, NewFD, false)) {
NewFD->setInvalidDecl();
return true;
}
NewFD->setIsMultiVersion();
Redeclaration = false;
MergeTypeWithPrevious = false;
OldDecl = nullptr;
Previous.clear();
return false;
}