Skip to content

Commit adde9cb

Browse files
labrinealabrinea
committed
changes from last revision
Renamed variables, added constness to types and reorder SemaARM code
1 parent 889e7b8 commit adde9cb

File tree

8 files changed

+108
-98
lines changed

8 files changed

+108
-98
lines changed

‎clang/include/clang/Sema/Sema.h‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -834,6 +834,13 @@ enum class CCEKind {
834834
///< message.
835835
};
836836

837+
/// Enums for the diagnostics of target, target_version and target_clones.
838+
namespace DiagAttrParams {
839+
enum DiagType { Unsupported, Duplicate, Unknown };
840+
enum Specifier { None, CPU, Tune };
841+
enum AttrName { Target, TargetClones, TargetVersion };
842+
} // end namespace DiagAttrParams
843+
837844
void inferNoReturnAttr(Sema &S, const Decl *D);
838845

839846
/// Sema - This implements semantic analysis and AST building for C.

‎clang/include/clang/Sema/SemaARM.h‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -92,10 +92,10 @@ class SemaARM : public SemaBase {
9292
/// false otherwise.
9393
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType);
9494

95-
bool checkTargetVersionAttr(StringRef Str, SourceLocation Loc);
96-
bool checkTargetClonesAttr(SmallVectorImpl<StringRef> &Strs,
95+
bool checkTargetVersionAttr(const StringRef Str, const SourceLocation Loc);
96+
bool checkTargetClonesAttr(SmallVectorImpl<StringRef> &Params,
9797
SmallVectorImpl<SourceLocation> &Locs,
98-
SmallVectorImpl<SmallString<64>> &Buffer);
98+
SmallVectorImpl<SmallString<64>> &NewParams);
9999
};
100100

101101
SemaARM::ArmStreamingType getArmStreamingFnType(const FunctionDecl *FD);

‎clang/include/clang/Sema/SemaRISCV.h‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -56,10 +56,10 @@ class SemaRISCV : public SemaBase {
5656

5757
std::unique_ptr<sema::RISCVIntrinsicManager> IntrinsicManager;
5858

59-
bool checkTargetVersionAttr(StringRef Str, SourceLocation Loc);
60-
bool checkTargetClonesAttr(SmallVectorImpl<StringRef> &Strs,
59+
bool checkTargetVersionAttr(const StringRef Param, const SourceLocation Loc);
60+
bool checkTargetClonesAttr(SmallVectorImpl<StringRef> &Params,
6161
SmallVectorImpl<SourceLocation> &Locs,
62-
SmallVectorImpl<SmallString<64>> &Buffer);
62+
SmallVectorImpl<SmallString<64>> &NewParams);
6363
};
6464

6565
std::unique_ptr<sema::RISCVIntrinsicManager>

‎clang/include/clang/Sema/SemaX86.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -38,9 +38,9 @@ class SemaX86 : public SemaBase {
3838
void handleAnyInterruptAttr(Decl *D, const ParsedAttr &AL);
3939
void handleForceAlignArgPointerAttr(Decl *D, const ParsedAttr &AL);
4040

41-
bool checkTargetClonesAttr(SmallVectorImpl<StringRef> &Strs,
41+
bool checkTargetClonesAttr(SmallVectorImpl<StringRef> &Params,
4242
SmallVectorImpl<SourceLocation> &Locs,
43-
SmallVectorImpl<SmallString<64>> &Buffer);
43+
SmallVectorImpl<SmallString<64>> &NewParams);
4444
};
4545
} // namespace clang
4646

‎clang/lib/Sema/SemaARM.cpp‎

Lines changed: 36 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -1535,13 +1535,12 @@ bool SemaARM::areLaxCompatibleSveTypes(QualType FirstType,
15351535
IsLaxCompatible(SecondType, FirstType);
15361536
}
15371537

1538-
enum FirstParam { Unsupported, Duplicate, Unknown };
1539-
enum SecondParam { None, CPU, Tune };
1540-
enum ThirdParam { Target, TargetClones, TargetVersion };
1538+
bool SemaARM::checkTargetVersionAttr(const StringRef Param,
1539+
const SourceLocation Loc) {
1540+
using namespace DiagAttrParams;
15411541

1542-
bool SemaARM::checkTargetVersionAttr(StringRef Str, SourceLocation Loc) {
15431542
llvm::SmallVector<StringRef, 8> Features;
1544-
Str.split(Features, '+');
1543+
Param.split(Features, '+');
15451544
for (StringRef Feat : Features) {
15461545
Feat = Feat.trim();
15471546
if (Feat == "default")
@@ -1553,30 +1552,32 @@ bool SemaARM::checkTargetVersionAttr(StringRef Str, SourceLocation Loc) {
15531552
return false;
15541553
}
15551554

1556-
bool SemaARM::checkTargetClonesAttr(SmallVectorImpl<StringRef> &Strs,
1557-
SmallVectorImpl<SourceLocation> &Locs,
1558-
SmallVectorImpl<SmallString<64>> &Buffer) {
1555+
bool SemaARM::checkTargetClonesAttr(
1556+
SmallVectorImpl<StringRef> &Params, SmallVectorImpl<SourceLocation> &Locs,
1557+
SmallVectorImpl<SmallString<64>> &NewParams) {
1558+
using namespace DiagAttrParams;
1559+
15591560
if (!getASTContext().getTargetInfo().hasFeature("fmv"))
15601561
return true;
15611562

1562-
assert(Strs.size() == Locs.size() &&
1563-
"Mismatch between number of strings and locations");
1563+
assert(Params.size() == Locs.size() &&
1564+
"Mismatch between number of string parameters and locations");
15641565

15651566
bool HasDefault = false;
15661567
bool HasNonDefault = false;
1567-
for (unsigned I = 0; I < Strs.size(); ++I) {
1568-
StringRef Str = Strs[I].trim();
1569-
SourceLocation Loc = Locs[I];
1568+
for (unsigned I = 0, E = Params.size(); I < E; ++I) {
1569+
const StringRef Param = Params[I].trim();
1570+
const SourceLocation &Loc = Locs[I];
15701571

1571-
if (Str.empty())
1572+
if (Param.empty())
15721573
return Diag(Loc, diag::warn_unsupported_target_attribute)
15731574
<< Unsupported << None << "" << TargetClones;
15741575

1575-
if (Str == "default") {
1576+
if (Param == "default") {
15761577
if (HasDefault)
15771578
Diag(Loc, diag::warn_target_clone_duplicate_options);
15781579
else {
1579-
Buffer.push_back(Str);
1580+
NewParams.push_back(Param);
15801581
HasDefault = true;
15811582
}
15821583
continue;
@@ -1585,7 +1586,7 @@ bool SemaARM::checkTargetClonesAttr(SmallVectorImpl<StringRef> &Strs,
15851586
bool HasCodeGenImpact = false;
15861587
llvm::SmallVector<StringRef, 8> Features;
15871588
llvm::SmallVector<StringRef, 8> ValidFeatures;
1588-
Str.split(Features, '+');
1589+
Param.split(Features, '+');
15891590
for (StringRef Feat : Features) {
15901591
Feat = Feat.trim();
15911592
if (!getASTContext().getTargetInfo().validateCpuSupports(Feat)) {
@@ -1597,24 +1598,27 @@ bool SemaARM::checkTargetClonesAttr(SmallVectorImpl<StringRef> &Strs,
15971598
HasCodeGenImpact = true;
15981599
ValidFeatures.push_back(Feat);
15991600
}
1600-
// Canonize TargetClones Attributes
1601-
SmallString<64> NewStr;
1602-
llvm::sort(ValidFeatures);
1603-
for (StringRef Feat : ValidFeatures) {
1604-
if (!NewStr.empty())
1605-
NewStr.append("+");
1606-
NewStr.append(Feat);
1601+
1602+
// Ignore features that don't impact code generation.
1603+
if (!HasCodeGenImpact) {
1604+
Diag(Loc, diag::warn_target_clone_no_impact_options);
1605+
continue;
16071606
}
1608-
if (llvm::is_contained(Buffer, NewStr))
1607+
1608+
if (ValidFeatures.empty())
1609+
continue;
1610+
1611+
// Canonicalize attribute parameter.
1612+
llvm::sort(ValidFeatures);
1613+
SmallString<64> NewParam(llvm::join(ValidFeatures, "+"));
1614+
if (llvm::is_contained(NewParams, NewParam)) {
16091615
Diag(Loc, diag::warn_target_clone_duplicate_options);
1610-
else if (!HasCodeGenImpact)
1611-
// Ignore features in target_clone attribute that don't impact
1612-
// code generation
1613-
Diag(Loc, diag::warn_target_clone_no_impact_options);
1614-
else if (!NewStr.empty()) {
1615-
Buffer.push_back(NewStr);
1616-
HasNonDefault = true;
1616+
continue;
16171617
}
1618+
1619+
// Valid non-default argument.
1620+
NewParams.push_back(NewParam);
1621+
HasNonDefault = true;
16181622
}
16191623
if (!HasNonDefault)
16201624
return true;

‎clang/lib/Sema/SemaDeclAttr.cpp‎

Lines changed: 19 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -3254,9 +3254,8 @@ static void handleCodeSegAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
32543254
}
32553255

32563256
bool Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) {
3257-
enum FirstParam { Unsupported, Duplicate, Unknown };
3258-
enum SecondParam { None, CPU, Tune };
3259-
enum ThirdParam { Target, TargetClones };
3257+
using namespace DiagAttrParams;
3258+
32603259
if (AttrStr.contains("fpmath="))
32613260
return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
32623261
<< Unsupported << None << "fpmath=" << Target;
@@ -3332,21 +3331,21 @@ bool Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) {
33323331
}
33333332

33343333
static void handleTargetVersionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3335-
StringRef Str;
3334+
StringRef Param;
33363335
SourceLocation Loc;
3337-
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &Loc))
3336+
if (!S.checkStringLiteralArgumentAttr(AL, 0, Param, &Loc))
33383337
return;
33393338

33403339
if (S.Context.getTargetInfo().getTriple().isAArch64()) {
3341-
if (S.ARM().checkTargetVersionAttr(Str, Loc))
3340+
if (S.ARM().checkTargetVersionAttr(Param, Loc))
33423341
return;
33433342
} else if (S.Context.getTargetInfo().getTriple().isRISCV()) {
3344-
if (S.RISCV().checkTargetVersionAttr(Str, Loc))
3343+
if (S.RISCV().checkTargetVersionAttr(Param, Loc))
33453344
return;
33463345
}
33473346

33483347
TargetVersionAttr *NewAttr =
3349-
::new (S.Context) TargetVersionAttr(S.Context, AL, Str);
3348+
::new (S.Context) TargetVersionAttr(S.Context, AL, Param);
33503349
D->addAttr(NewAttr);
33513350
}
33523351

@@ -3383,34 +3382,34 @@ static void handleTargetClonesAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
33833382
}
33843383
}
33853384

3386-
SmallVector<StringRef, 2> Strings;
3385+
SmallVector<StringRef, 2> Params;
33873386
SmallVector<SourceLocation, 2> Locations;
33883387
for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
3389-
StringRef Str;
3388+
StringRef Param;
33903389
SourceLocation Loc;
3391-
if (!S.checkStringLiteralArgumentAttr(AL, I, Str, &Loc))
3390+
if (!S.checkStringLiteralArgumentAttr(AL, I, Param, &Loc))
33923391
return;
3393-
Strings.push_back(Str);
3392+
Params.push_back(Param);
33943393
Locations.push_back(Loc);
33953394
}
33963395

3397-
SmallVector<SmallString<64>, 2> Buffer;
3396+
SmallVector<SmallString<64>, 2> NewParams;
33983397
if (S.Context.getTargetInfo().getTriple().isAArch64()) {
3399-
if (S.ARM().checkTargetClonesAttr(Strings, Locations, Buffer))
3398+
if (S.ARM().checkTargetClonesAttr(Params, Locations, NewParams))
34003399
return;
34013400
} else if (S.Context.getTargetInfo().getTriple().isRISCV()) {
3402-
if (S.RISCV().checkTargetClonesAttr(Strings, Locations, Buffer))
3401+
if (S.RISCV().checkTargetClonesAttr(Params, Locations, NewParams))
34033402
return;
34043403
} else if (S.Context.getTargetInfo().getTriple().isX86()) {
3405-
if (S.X86().checkTargetClonesAttr(Strings, Locations, Buffer))
3404+
if (S.X86().checkTargetClonesAttr(Params, Locations, NewParams))
34063405
return;
34073406
}
3408-
Strings.clear();
3409-
for (auto &SmallStr : Buffer)
3410-
Strings.push_back(SmallStr.str());
3407+
Params.clear();
3408+
for (auto &SmallStr : NewParams)
3409+
Params.push_back(SmallStr.str());
34113410

34123411
TargetClonesAttr *NewAttr = ::new (S.Context)
3413-
TargetClonesAttr(S.Context, AL, Strings.data(), Strings.size());
3412+
TargetClonesAttr(S.Context, AL, Params.data(), Params.size());
34143413
D->addAttr(NewAttr);
34153414
}
34163415

‎clang/lib/Sema/SemaRISCV.cpp‎

Lines changed: 21 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1635,13 +1635,12 @@ bool SemaRISCV::isValidFMVExtension(StringRef Ext) {
16351635
return -1 != RISCVISAInfo::getRISCVFeaturesBitsInfo(Ext).second;
16361636
}
16371637

1638-
enum FirstParam { Unsupported, Duplicate, Unknown };
1639-
enum SecondParam { None, CPU, Tune };
1640-
enum ThirdParam { Target, TargetClones, TargetVersion };
1638+
bool SemaRISCV::checkTargetVersionAttr(const StringRef Param,
1639+
const SourceLocation Loc) {
1640+
using namespace DiagAttrParams;
16411641

1642-
bool SemaRISCV::checkTargetVersionAttr(StringRef Str, SourceLocation Loc) {
16431642
llvm::SmallVector<StringRef, 8> AttrStrs;
1644-
Str.split(AttrStrs, ';');
1643+
Param.split(AttrStrs, ';');
16451644

16461645
bool HasArch = false;
16471646
bool HasPriority = false;
@@ -1681,24 +1680,26 @@ bool SemaRISCV::checkTargetVersionAttr(StringRef Str, SourceLocation Loc) {
16811680
if (((HasPriority || HasArch) && HasDefault) || DuplicateAttr ||
16821681
(HasPriority && !HasArch))
16831682
return Diag(Loc, diag::warn_unsupported_target_attribute)
1684-
<< Unsupported << None << Str << TargetVersion;
1683+
<< Unsupported << None << Param << TargetVersion;
16851684

16861685
return false;
16871686
}
16881687

16891688
bool SemaRISCV::checkTargetClonesAttr(
1690-
SmallVectorImpl<StringRef> &Strs, SmallVectorImpl<SourceLocation> &Locs,
1691-
SmallVectorImpl<SmallString<64>> &Buffer) {
1692-
assert(Strs.size() == Locs.size() &&
1693-
"Mismatch between number of strings and locations");
1689+
SmallVectorImpl<StringRef> &Params, SmallVectorImpl<SourceLocation> &Locs,
1690+
SmallVectorImpl<SmallString<64>> &NewParams) {
1691+
using namespace DiagAttrParams;
1692+
1693+
assert(Params.size() == Locs.size() &&
1694+
"Mismatch between number of string parameters and locations");
16941695

16951696
bool HasDefault = false;
1696-
for (unsigned I = 0; I < Strs.size(); ++I) {
1697-
StringRef Str = Strs[I].trim();
1698-
SourceLocation Loc = Locs[I];
1697+
for (unsigned I = 0, E = Params.size(); I < E; ++I) {
1698+
const StringRef Param = Params[I].trim();
1699+
const SourceLocation &Loc = Locs[I];
16991700

17001701
llvm::SmallVector<StringRef, 8> AttrStrs;
1701-
Str.split(AttrStrs, ";");
1702+
Param.split(AttrStrs, ';');
17021703

17031704
bool IsPriority = false;
17041705
bool IsDefault = false;
@@ -1714,7 +1715,7 @@ bool SemaRISCV::checkTargetClonesAttr(
17141715
return !isValidFMVExtension(Ext);
17151716
}))
17161717
return Diag(Loc, diag::warn_unsupported_target_attribute)
1717-
<< Unsupported << None << Str << TargetClones;
1718+
<< Unsupported << None << Param << TargetClones;
17181719
} else if (AttrStr == "default") {
17191720
IsDefault = true;
17201721
HasDefault = true;
@@ -1723,20 +1724,20 @@ bool SemaRISCV::checkTargetClonesAttr(
17231724
unsigned Digit;
17241725
if (AttrStr.getAsInteger(0, Digit))
17251726
return Diag(Loc, diag::warn_unsupported_target_attribute)
1726-
<< Unsupported << None << Str << TargetClones;
1727+
<< Unsupported << None << Param << TargetClones;
17271728
} else {
17281729
return Diag(Loc, diag::warn_unsupported_target_attribute)
1729-
<< Unsupported << None << Str << TargetClones;
1730+
<< Unsupported << None << Param << TargetClones;
17301731
}
17311732
}
17321733

17331734
if (IsPriority && IsDefault)
17341735
return Diag(Loc, diag::warn_unsupported_target_attribute)
1735-
<< Unsupported << None << Str << TargetClones;
1736+
<< Unsupported << None << Param << TargetClones;
17361737

1737-
if (llvm::is_contained(Buffer, Str))
1738+
if (llvm::is_contained(NewParams, Param))
17381739
Diag(Loc, diag::warn_target_clone_duplicate_options);
1739-
Buffer.push_back(Str);
1740+
NewParams.push_back(Param);
17401741
}
17411742
if (!HasDefault)
17421743
return Diag(Locs[0], diag::err_target_clone_must_have_default);

0 commit comments

Comments
 (0)