Skip to content

Commit 0683c0e

Browse files
EricWFEricWF
committedMay 7, 2018
[C++2a] Implement operator<=> CodeGen and ExprConstant
Summary: This patch tackles long hanging fruit for the builtin operator<=> expressions. It is currently needs some cleanup before landing, but I want to get some initial feedback. The main changes are: * Lookup, build, and store the required standard library types and expressions in `ASTContext`. By storing them in ASTContext we don't need to store (and duplicate) the required expressions in the BinaryOperator AST nodes. * Implement [expr.spaceship] checking, including diagnosing narrowing conversions. * Implement `ExprConstant` for builtin spaceship operators. * Implement builitin operator<=> support in `CodeGenAgg`. Initially I emitted the required comparisons using `ScalarExprEmitter::VisitBinaryOperator`, but this caused the operand expressions to be emitted once for every required cmp. * Implement [builtin.over] with modifications to support the intent of P0946R0. See the note on `BuiltinOperatorOverloadBuilder::addThreeWayArithmeticOverloads` for more information about the workaround. Reviewers: rsmith, aaron.ballman, majnemer, rnk, compnerd, rjmccall Reviewed By: rjmccall Subscribers: rjmccall, rsmith, aaron.ballman, junbuml, mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D45476 llvm-svn: 331677
·
llvmorg-21-initllvmorg-7.0.0-rc1
1 parent f53d9ab commit 0683c0e

24 files changed

+3548
-392
lines changed
 

‎clang/include/clang/AST/ASTContext.h

+5
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@
1818
#include "clang/AST/ASTTypeTraits.h"
1919
#include "clang/AST/CanonicalType.h"
2020
#include "clang/AST/CommentCommandTraits.h"
21+
#include "clang/AST/ComparisonCategories.h"
2122
#include "clang/AST/Decl.h"
2223
#include "clang/AST/DeclBase.h"
2324
#include "clang/AST/DeclarationName.h"
@@ -1978,6 +1979,10 @@ class ASTContext : public RefCountedBase<ASTContext> {
19781979
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error,
19791980
unsigned *IntegerConstantArgs = nullptr) const;
19801981

1982+
/// \brief Types and expressions required to build C++2a three-way comparisons
1983+
/// using operator<=>, including the values return by builtin <=> operators.
1984+
ComparisonCategories CompCategories;
1985+
19811986
private:
19821987
CanQualType getFromTargetType(unsigned Type) const;
19831988
TypeInfo getTypeInfoImpl(const Type *T) const;

‎clang/include/clang/AST/ComparisonCategories.h

+255
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,255 @@
1+
//===- ComparisonCategories.h - Three Way Comparison Data -------*- C++ -*-===//
2+
//
3+
// The LLVM Compiler Infrastructure
4+
//
5+
// This file is distributed under the University of Illinois Open Source
6+
// License. See LICENSE.TXT for details.
7+
//
8+
//===----------------------------------------------------------------------===//
9+
//
10+
// This file defines the Comparison Category enum and data types, which
11+
// store the types and expressions needed to support operator<=>
12+
//
13+
//===----------------------------------------------------------------------===//
14+
15+
#ifndef LLVM_CLANG_AST_COMPARISONCATEGORIES_H
16+
#define LLVM_CLANG_AST_COMPARISONCATEGORIES_H
17+
18+
#include "clang/Basic/LLVM.h"
19+
#include "llvm/ADT/APSInt.h"
20+
#include "llvm/ADT/DenseMap.h"
21+
#include <array>
22+
#include <cassert>
23+
24+
namespace llvm {
25+
class StringRef;
26+
class APSInt;
27+
}
28+
29+
namespace clang {
30+
31+
class ASTContext;
32+
class VarDecl;
33+
class CXXRecordDecl;
34+
class Sema;
35+
class QualType;
36+
class NamespaceDecl;
37+
38+
/// \brief An enumeration representing the different comparison categories
39+
/// types.
40+
///
41+
/// C++2a [cmp.categories.pre] The types weak_equality, strong_equality,
42+
/// partial_ordering, weak_ordering, and strong_ordering are collectively
43+
/// termed the comparison category types.
44+
enum class ComparisonCategoryType : unsigned char {
45+
WeakEquality,
46+
StrongEquality,
47+
PartialOrdering,
48+
WeakOrdering,
49+
StrongOrdering,
50+
First = WeakEquality,
51+
Last = StrongOrdering
52+
};
53+
54+
/// \brief An enumeration representing the possible results of a three-way
55+
/// comparison. These values map onto instances of comparison category types
56+
/// defined in the standard library. i.e. 'std::strong_ordering::less'.
57+
enum class ComparisonCategoryResult : unsigned char {
58+
Equal,
59+
Equivalent,
60+
Nonequivalent,
61+
Nonequal,
62+
Less,
63+
Greater,
64+
Unordered,
65+
Last = Unordered
66+
};
67+
68+
class ComparisonCategoryInfo {
69+
friend class ComparisonCategories;
70+
friend class Sema;
71+
72+
public:
73+
ComparisonCategoryInfo(const ASTContext &Ctx, CXXRecordDecl *RD,
74+
ComparisonCategoryType Kind)
75+
: Ctx(Ctx), Record(RD), Kind(Kind) {}
76+
77+
struct ValueInfo {
78+
ComparisonCategoryResult Kind;
79+
VarDecl *VD;
80+
81+
ValueInfo(ComparisonCategoryResult Kind, VarDecl *VD)
82+
: Kind(Kind), VD(VD), HasValue(false) {}
83+
84+
/// \brief True iff we've successfully evaluated the variable as a constant
85+
/// expression and extracted its integer value.
86+
bool hasValidIntValue() const { return HasValue; }
87+
88+
/// \brief Get the constant integer value used by this variable to represent
89+
/// the comparison category result type.
90+
llvm::APSInt getIntValue() const {
91+
assert(hasValidIntValue());
92+
return IntValue;
93+
}
94+
95+
void setIntValue(llvm::APSInt Val) {
96+
IntValue = Val;
97+
HasValue = true;
98+
}
99+
100+
private:
101+
friend class ComparisonCategoryInfo;
102+
llvm::APSInt IntValue;
103+
bool HasValue : 1;
104+
};
105+
private:
106+
const ASTContext &Ctx;
107+
108+
/// \brief A map containing the comparison category result decls from the
109+
/// standard library. The key is a value of ComparisonCategoryResult.
110+
mutable llvm::SmallVector<
111+
ValueInfo, static_cast<unsigned>(ComparisonCategoryResult::Last) + 1>
112+
Objects;
113+
114+
/// \brief Lookup the ValueInfo struct for the specified ValueKind. If the
115+
/// VarDecl for the value cannot be found, nullptr is returned.
116+
///
117+
/// If the ValueInfo does not have a valid integer value the variable
118+
/// is evaluated as a constant expression to determine that value.
119+
ValueInfo *lookupValueInfo(ComparisonCategoryResult ValueKind) const;
120+
121+
public:
122+
/// \brief The declaration for the comparison category type from the
123+
/// standard library.
124+
// FIXME: Make this const
125+
CXXRecordDecl *Record = nullptr;
126+
127+
/// \brief The Kind of the comparison category type
128+
ComparisonCategoryType Kind;
129+
130+
public:
131+
QualType getType() const;
132+
133+
const ValueInfo *getValueInfo(ComparisonCategoryResult ValueKind) const {
134+
ValueInfo *Info = lookupValueInfo(ValueKind);
135+
assert(Info &&
136+
"comparison category does not contain the specified result kind");
137+
assert(Info->hasValidIntValue() &&
138+
"couldn't determine the integer constant for this value");
139+
return Info;
140+
}
141+
142+
/// \brief True iff the comparison category is an equality comparison.
143+
bool isEquality() const { return !isOrdered(); }
144+
145+
/// \brief True iff the comparison category is a relational comparison.
146+
bool isOrdered() const {
147+
using CCK = ComparisonCategoryType;
148+
return Kind == CCK::PartialOrdering || Kind == CCK::WeakOrdering ||
149+
Kind == CCK::StrongOrdering;
150+
}
151+
152+
/// \brief True iff the comparison is "strong". i.e. it checks equality and
153+
/// not equivalence.
154+
bool isStrong() const {
155+
using CCK = ComparisonCategoryType;
156+
return Kind == CCK::StrongEquality || Kind == CCK::StrongOrdering;
157+
}
158+
159+
/// \brief True iff the comparison is not totally ordered.
160+
bool isPartial() const {
161+
using CCK = ComparisonCategoryType;
162+
return Kind == CCK::PartialOrdering;
163+
}
164+
165+
/// \brief Converts the specified result kind into the the correct result kind
166+
/// for this category. Specifically it lowers strong equality results to
167+
/// weak equivalence if needed.
168+
ComparisonCategoryResult makeWeakResult(ComparisonCategoryResult Res) const {
169+
using CCR = ComparisonCategoryResult;
170+
if (!isStrong()) {
171+
if (Res == CCR::Equal)
172+
return CCR::Equivalent;
173+
if (Res == CCR::Nonequal)
174+
return CCR::Nonequivalent;
175+
}
176+
return Res;
177+
}
178+
179+
const ValueInfo *getEqualOrEquiv() const {
180+
return getValueInfo(makeWeakResult(ComparisonCategoryResult::Equal));
181+
}
182+
const ValueInfo *getNonequalOrNonequiv() const {
183+
assert(isEquality());
184+
return getValueInfo(makeWeakResult(ComparisonCategoryResult::Nonequal));
185+
}
186+
const ValueInfo *getLess() const {
187+
assert(isOrdered());
188+
return getValueInfo(ComparisonCategoryResult::Less);
189+
}
190+
const ValueInfo *getGreater() const {
191+
assert(isOrdered());
192+
return getValueInfo(ComparisonCategoryResult::Greater);
193+
}
194+
const ValueInfo *getUnordered() const {
195+
assert(isPartial());
196+
return getValueInfo(ComparisonCategoryResult::Unordered);
197+
}
198+
};
199+
200+
class ComparisonCategories {
201+
public:
202+
static StringRef getCategoryString(ComparisonCategoryType Kind);
203+
static StringRef getResultString(ComparisonCategoryResult Kind);
204+
205+
/// \brief Return the list of results which are valid for the specified
206+
/// comparison category type.
207+
static std::vector<ComparisonCategoryResult>
208+
getPossibleResultsForType(ComparisonCategoryType Type);
209+
210+
/// \brief Return the comparison category information for the category
211+
/// specified by 'Kind'.
212+
const ComparisonCategoryInfo &getInfo(ComparisonCategoryType Kind) const {
213+
const ComparisonCategoryInfo *Result = lookupInfo(Kind);
214+
assert(Result != nullptr &&
215+
"information for specified comparison category has not been built");
216+
return *Result;
217+
}
218+
219+
/// \brief Return the comparison category information as specified by
220+
/// `getCategoryForType(Ty)`. If the information is not already cached,
221+
/// the declaration is looked up and a cache entry is created.
222+
/// NOTE: Lookup is expected to succeed. Use lookupInfo if failure is possible.
223+
const ComparisonCategoryInfo &getInfoForType(QualType Ty) const;
224+
225+
public:
226+
/// \brief Return the cached comparison category information for the
227+
/// specified 'Kind'. If no cache entry is present the comparison category
228+
/// type is looked up. If lookup fails nullptr is returned. Otherwise, a
229+
/// new cache entry is created and returned
230+
const ComparisonCategoryInfo *lookupInfo(ComparisonCategoryType Kind) const;
231+
232+
ComparisonCategoryInfo *lookupInfo(ComparisonCategoryType Kind) {
233+
const auto &This = *this;
234+
return const_cast<ComparisonCategoryInfo *>(This.lookupInfo(Kind));
235+
}
236+
237+
private:
238+
const ComparisonCategoryInfo *lookupInfoForType(QualType Ty) const;
239+
240+
private:
241+
friend class ASTContext;
242+
243+
explicit ComparisonCategories(const ASTContext &Ctx) : Ctx(Ctx) {}
244+
245+
const ASTContext &Ctx;
246+
247+
/// A map from the ComparisonCategoryType (represented as 'char') to the
248+
/// cached information for the specified category.
249+
mutable llvm::DenseMap<char, ComparisonCategoryInfo> Data;
250+
mutable NamespaceDecl *StdNS = nullptr;
251+
};
252+
253+
} // namespace clang
254+
255+
#endif

‎clang/include/clang/AST/Expr.h

+3-1
Original file line numberDiff line numberDiff line change
@@ -2778,7 +2778,9 @@ class CastExpr : public Expr {
27782778
public:
27792779
CastKind getCastKind() const { return (CastKind) CastExprBits.Kind; }
27802780
void setCastKind(CastKind K) { CastExprBits.Kind = K; }
2781-
const char *getCastKindName() const;
2781+
2782+
static const char *getCastKindName(CastKind CK);
2783+
const char *getCastKindName() const { return getCastKindName(getCastKind()); }
27822784

27832785
Expr *getSubExpr() { return cast<Expr>(Op); }
27842786
const Expr *getSubExpr() const { return cast<Expr>(Op); }

‎clang/include/clang/Basic/DiagnosticSemaKinds.td

+14
Original file line numberDiff line numberDiff line change
@@ -9424,4 +9424,18 @@ def err_multiversion_not_allowed_on_main : Error<
94249424
def err_multiversion_not_supported : Error<
94259425
"function multiversioning is not supported on the current target">;
94269426

9427+
// three-way comparison operator diagnostics
9428+
def err_implied_comparison_category_type_not_found : Error<
9429+
"cannot deduce return type of 'operator<=>' because type %0 was not found; "
9430+
"include <compare>">;
9431+
def err_spaceship_argument_narrowing : Error<
9432+
"argument to 'operator<=>' "
9433+
"%select{cannot be narrowed from type %1 to %2|"
9434+
"evaluates to %1, which cannot be narrowed to type %2}0">;
9435+
def err_std_compare_type_not_supported : Error<
9436+
"standard library implementation of %0 is not supported; "
9437+
"%select{member '%2' does not have expected form|"
9438+
"member '%2' is missing|"
9439+
"the type is not trivially copyable|"
9440+
"the type does not have the expected form}1">;
94279441
} // end of sema component.

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

+4-3
Original file line numberDiff line numberDiff line change
@@ -330,9 +330,10 @@ class Sema;
330330
}
331331

332332
ImplicitConversionRank getRank() const;
333-
NarrowingKind getNarrowingKind(ASTContext &Context, const Expr *Converted,
334-
APValue &ConstantValue,
335-
QualType &ConstantType) const;
333+
NarrowingKind
334+
getNarrowingKind(ASTContext &Context, const Expr *Converted,
335+
APValue &ConstantValue, QualType &ConstantType,
336+
bool IgnoreFloatToIntegralConversion = false) const;
336337
bool isPointerConversionToBool() const;
337338
bool isPointerConversionToVoidPointer(ASTContext& Context) const;
338339
void dump() const;

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

+21-3
Original file line numberDiff line numberDiff line change
@@ -17,8 +17,9 @@
1717

1818
#include "clang/AST/Attr.h"
1919
#include "clang/AST/Availability.h"
20-
#include "clang/AST/DeclarationName.h"
20+
#include "clang/AST/ComparisonCategories.h"
2121
#include "clang/AST/DeclTemplate.h"
22+
#include "clang/AST/DeclarationName.h"
2223
#include "clang/AST/Expr.h"
2324
#include "clang/AST/ExprObjC.h"
2425
#include "clang/AST/ExternalASTSource.h"
@@ -49,6 +50,7 @@
4950
#include "llvm/ADT/ArrayRef.h"
5051
#include "llvm/ADT/Optional.h"
5152
#include "llvm/ADT/SetVector.h"
53+
#include "llvm/ADT/SmallBitVector.h"
5254
#include "llvm/ADT/SmallPtrSet.h"
5355
#include "llvm/ADT/SmallVector.h"
5456
#include "llvm/ADT/TinyPtrVector.h"
@@ -4545,6 +4547,22 @@ class Sema {
45454547
CXXRecordDecl *getStdBadAlloc() const;
45464548
EnumDecl *getStdAlignValT() const;
45474549

4550+
private:
4551+
// A cache representing if we've fully checked the various comparison category
4552+
// types stored in ASTContext. The bit-index corresponds to the integer value
4553+
// of a ComparisonCategoryType enumerator.
4554+
llvm::SmallBitVector FullyCheckedComparisonCategories;
4555+
4556+
public:
4557+
/// \brief Lookup the specified comparison category types in the standard
4558+
/// library, an check the VarDecls possibly returned by the operator<=>
4559+
/// builtins for that type.
4560+
///
4561+
/// \return The type of the comparison category type corresponding to the
4562+
/// specified Kind, or a null type if an error occurs
4563+
QualType CheckComparisonCategoryType(ComparisonCategoryType Kind,
4564+
SourceLocation Loc);
4565+
45484566
/// \brief Tests whether Ty is an instance of std::initializer_list and, if
45494567
/// it is and Element is not NULL, assigns the element type to Element.
45504568
bool isStdInitializerList(QualType Ty, QualType *Element);
@@ -9574,8 +9592,8 @@ class Sema {
95749592
ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
95759593
BinaryOperatorKind Opc, bool IsCompAssign = false);
95769594
QualType CheckCompareOperands( // C99 6.5.8/9
9577-
ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9578-
BinaryOperatorKind Opc, bool isRelational);
9595+
ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
9596+
BinaryOperatorKind Opc);
95799597
QualType CheckBitwiseOperands( // C99 6.5.[10...12]
95809598
ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
95819599
BinaryOperatorKind Opc);

‎clang/lib/AST/ASTContext.cpp

+2-1
Original file line numberDiff line numberDiff line change
@@ -792,7 +792,8 @@ ASTContext::ASTContext(LangOptions &LOpts, SourceManager &SM,
792792
LangOpts.XRayAttrListFiles, SM)),
793793
PrintingPolicy(LOpts), Idents(idents), Selectors(sels),
794794
BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM),
795-
CommentCommandTraits(BumpAlloc, LOpts.CommentOpts), LastSDM(nullptr, 0) {
795+
CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
796+
CompCategories(this_()), LastSDM(nullptr, 0) {
796797
TUDecl = TranslationUnitDecl::Create(*this);
797798
}
798799

‎clang/lib/AST/CMakeLists.txt

+1
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ add_clang_library(clangAST
2020
CommentLexer.cpp
2121
CommentParser.cpp
2222
CommentSema.cpp
23+
ComparisonCategories.cpp
2324
DataCollection.cpp
2425
Decl.cpp
2526
DeclarationName.cpp

0 commit comments

Comments
 (0)
Please sign in to comment.