1 | //===--- SemaCast.cpp - Semantic Analysis for Casts -----------------------===// |
---|---|
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | // This file implements semantic analysis for cast expressions, including |
10 | // 1) C-style casts like '(int) x' |
11 | // 2) C++ functional casts like 'int(x)' |
12 | // 3) C++ named casts like 'static_cast<int>(x)' |
13 | // |
14 | //===----------------------------------------------------------------------===// |
15 | |
16 | #include "clang/AST/ASTContext.h" |
17 | #include "clang/AST/ASTStructuralEquivalence.h" |
18 | #include "clang/AST/CXXInheritance.h" |
19 | #include "clang/AST/ExprCXX.h" |
20 | #include "clang/AST/ExprObjC.h" |
21 | #include "clang/AST/RecordLayout.h" |
22 | #include "clang/Basic/PartialDiagnostic.h" |
23 | #include "clang/Basic/TargetInfo.h" |
24 | #include "clang/Lex/Preprocessor.h" |
25 | #include "clang/Sema/Initialization.h" |
26 | #include "clang/Sema/SemaHLSL.h" |
27 | #include "clang/Sema/SemaObjC.h" |
28 | #include "clang/Sema/SemaRISCV.h" |
29 | #include "llvm/ADT/SmallVector.h" |
30 | #include "llvm/ADT/StringExtras.h" |
31 | #include <set> |
32 | using namespace clang; |
33 | |
34 | |
35 | |
36 | enum TryCastResult { |
37 | TC_NotApplicable, ///< The cast method is not applicable. |
38 | TC_Success, ///< The cast method is appropriate and successful. |
39 | TC_Extension, ///< The cast method is appropriate and accepted as a |
40 | ///< language extension. |
41 | TC_Failed ///< The cast method is appropriate, but failed. A |
42 | ///< diagnostic has been emitted. |
43 | }; |
44 | |
45 | static bool isValidCast(TryCastResult TCR) { |
46 | return TCR == TC_Success || TCR == TC_Extension; |
47 | } |
48 | |
49 | enum CastType { |
50 | CT_Const, ///< const_cast |
51 | CT_Static, ///< static_cast |
52 | CT_Reinterpret, ///< reinterpret_cast |
53 | CT_Dynamic, ///< dynamic_cast |
54 | CT_CStyle, ///< (Type)expr |
55 | CT_Functional, ///< Type(expr) |
56 | CT_Addrspace ///< addrspace_cast |
57 | }; |
58 | |
59 | namespace { |
60 | struct CastOperation { |
61 | CastOperation(Sema &S, QualType destType, ExprResult src) |
62 | : Self(S), SrcExpr(src), DestType(destType), |
63 | ResultType(destType.getNonLValueExprType(S.Context)), |
64 | ValueKind(Expr::getValueKindForType(T: destType)), |
65 | Kind(CK_Dependent), IsARCUnbridgedCast(false) { |
66 | |
67 | // C++ [expr.type]/8.2.2: |
68 | // If a pr-value initially has the type cv-T, where T is a |
69 | // cv-unqualified non-class, non-array type, the type of the |
70 | // expression is adjusted to T prior to any further analysis. |
71 | // C23 6.5.4p6: |
72 | // Preceding an expression by a parenthesized type name converts the |
73 | // value of the expression to the unqualified, non-atomic version of |
74 | // the named type. |
75 | // Don't drop __ptrauth qualifiers. We want to treat casting to a |
76 | // __ptrauth-qualified type as an error instead of implicitly ignoring |
77 | // the qualifier. |
78 | if (!S.Context.getLangOpts().ObjC && !DestType->isRecordType() && |
79 | !DestType->isArrayType() && !DestType.getPointerAuth()) { |
80 | DestType = DestType.getAtomicUnqualifiedType(); |
81 | } |
82 | |
83 | if (const BuiltinType *placeholder = |
84 | src.get()->getType()->getAsPlaceholderType()) { |
85 | PlaceholderKind = placeholder->getKind(); |
86 | } else { |
87 | PlaceholderKind = (BuiltinType::Kind) 0; |
88 | } |
89 | } |
90 | |
91 | Sema &Self; |
92 | ExprResult SrcExpr; |
93 | QualType DestType; |
94 | QualType ResultType; |
95 | ExprValueKind ValueKind; |
96 | CastKind Kind; |
97 | BuiltinType::Kind PlaceholderKind; |
98 | CXXCastPath BasePath; |
99 | bool IsARCUnbridgedCast; |
100 | |
101 | SourceRange OpRange; |
102 | SourceRange DestRange; |
103 | |
104 | // Top-level semantics-checking routines. |
105 | void CheckConstCast(); |
106 | void CheckReinterpretCast(); |
107 | void CheckStaticCast(); |
108 | void CheckDynamicCast(); |
109 | void CheckCXXCStyleCast(bool FunctionalCast, bool ListInitialization); |
110 | bool CheckHLSLCStyleCast(CheckedConversionKind CCK); |
111 | void CheckCStyleCast(); |
112 | void CheckBuiltinBitCast(); |
113 | void CheckAddrspaceCast(); |
114 | |
115 | void updatePartOfExplicitCastFlags(CastExpr *CE) { |
116 | // Walk down from the CE to the OrigSrcExpr, and mark all immediate |
117 | // ImplicitCastExpr's as being part of ExplicitCastExpr. The original CE |
118 | // (which is a ExplicitCastExpr), and the OrigSrcExpr are not touched. |
119 | for (; auto *ICE = dyn_cast<ImplicitCastExpr>(Val: CE->getSubExpr()); CE = ICE) |
120 | ICE->setIsPartOfExplicitCast(true); |
121 | } |
122 | |
123 | /// Complete an apparently-successful cast operation that yields |
124 | /// the given expression. |
125 | ExprResult complete(CastExpr *castExpr) { |
126 | // If this is an unbridged cast, wrap the result in an implicit |
127 | // cast that yields the unbridged-cast placeholder type. |
128 | if (IsARCUnbridgedCast) { |
129 | castExpr = ImplicitCastExpr::Create( |
130 | Context: Self.Context, T: Self.Context.ARCUnbridgedCastTy, Kind: CK_Dependent, |
131 | Operand: castExpr, BasePath: nullptr, Cat: castExpr->getValueKind(), |
132 | FPO: Self.CurFPFeatureOverrides()); |
133 | } |
134 | updatePartOfExplicitCastFlags(CE: castExpr); |
135 | return castExpr; |
136 | } |
137 | |
138 | // Internal convenience methods. |
139 | |
140 | /// Try to handle the given placeholder expression kind. Return |
141 | /// true if the source expression has the appropriate placeholder |
142 | /// kind. A placeholder can only be claimed once. |
143 | bool claimPlaceholder(BuiltinType::Kind K) { |
144 | if (PlaceholderKind != K) return false; |
145 | |
146 | PlaceholderKind = (BuiltinType::Kind) 0; |
147 | return true; |
148 | } |
149 | |
150 | bool isPlaceholder() const { |
151 | return PlaceholderKind != 0; |
152 | } |
153 | bool isPlaceholder(BuiltinType::Kind K) const { |
154 | return PlaceholderKind == K; |
155 | } |
156 | |
157 | // Language specific cast restrictions for address spaces. |
158 | void checkAddressSpaceCast(QualType SrcType, QualType DestType); |
159 | |
160 | void checkCastAlign() { |
161 | Self.CheckCastAlign(SrcExpr.get(), DestType, OpRange); |
162 | } |
163 | |
164 | void checkObjCConversion(CheckedConversionKind CCK) { |
165 | assert(Self.getLangOpts().allowsNonTrivialObjCLifetimeQualifiers()); |
166 | |
167 | Expr *src = SrcExpr.get(); |
168 | if (Self.ObjC().CheckObjCConversion(OpRange, DestType, src, CCK) == |
169 | SemaObjC::ACR_unbridged) |
170 | IsARCUnbridgedCast = true; |
171 | SrcExpr = src; |
172 | } |
173 | |
174 | void checkQualifiedDestType() { |
175 | // Destination type may not be qualified with __ptrauth. |
176 | if (DestType.getPointerAuth()) { |
177 | Self.Diag(DestRange.getBegin(), diag::err_ptrauth_qualifier_cast) |
178 | << DestType << DestRange; |
179 | } |
180 | } |
181 | |
182 | /// Check for and handle non-overload placeholder expressions. |
183 | void checkNonOverloadPlaceholders() { |
184 | if (!isPlaceholder() || isPlaceholder(K: BuiltinType::Overload)) |
185 | return; |
186 | |
187 | SrcExpr = Self.CheckPlaceholderExpr(E: SrcExpr.get()); |
188 | if (SrcExpr.isInvalid()) |
189 | return; |
190 | PlaceholderKind = (BuiltinType::Kind) 0; |
191 | } |
192 | }; |
193 | |
194 | void CheckNoDeref(Sema &S, const QualType FromType, const QualType ToType, |
195 | SourceLocation OpLoc) { |
196 | if (const auto *PtrType = dyn_cast<PointerType>(Val: FromType)) { |
197 | if (PtrType->getPointeeType()->hasAttr(attr::NoDeref)) { |
198 | if (const auto *DestType = dyn_cast<PointerType>(Val: ToType)) { |
199 | if (!DestType->getPointeeType()->hasAttr(attr::NoDeref)) { |
200 | S.Diag(OpLoc, diag::warn_noderef_to_dereferenceable_pointer); |
201 | } |
202 | } |
203 | } |
204 | } |
205 | } |
206 | |
207 | struct CheckNoDerefRAII { |
208 | CheckNoDerefRAII(CastOperation &Op) : Op(Op) {} |
209 | ~CheckNoDerefRAII() { |
210 | if (!Op.SrcExpr.isInvalid()) |
211 | CheckNoDeref(Op.Self, Op.SrcExpr.get()->getType(), Op.ResultType, |
212 | Op.OpRange.getBegin()); |
213 | } |
214 | |
215 | CastOperation &Op; |
216 | }; |
217 | } |
218 | |
219 | static void DiagnoseCastQual(Sema &Self, const ExprResult &SrcExpr, |
220 | QualType DestType); |
221 | |
222 | // The Try functions attempt a specific way of casting. If they succeed, they |
223 | // return TC_Success. If their way of casting is not appropriate for the given |
224 | // arguments, they return TC_NotApplicable and *may* set diag to a diagnostic |
225 | // to emit if no other way succeeds. If their way of casting is appropriate but |
226 | // fails, they return TC_Failed and *must* set diag; they can set it to 0 if |
227 | // they emit a specialized diagnostic. |
228 | // All diagnostics returned by these functions must expect the same three |
229 | // arguments: |
230 | // %0: Cast Type (a value from the CastType enumeration) |
231 | // %1: Source Type |
232 | // %2: Destination Type |
233 | static TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, |
234 | QualType DestType, bool CStyle, |
235 | CastKind &Kind, |
236 | CXXCastPath &BasePath, |
237 | unsigned &msg); |
238 | static TryCastResult TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, |
239 | QualType DestType, bool CStyle, |
240 | SourceRange OpRange, |
241 | unsigned &msg, |
242 | CastKind &Kind, |
243 | CXXCastPath &BasePath); |
244 | static TryCastResult TryStaticPointerDowncast(Sema &Self, QualType SrcType, |
245 | QualType DestType, bool CStyle, |
246 | SourceRange OpRange, |
247 | unsigned &msg, |
248 | CastKind &Kind, |
249 | CXXCastPath &BasePath); |
250 | static TryCastResult TryStaticDowncast(Sema &Self, CanQualType SrcType, |
251 | CanQualType DestType, bool CStyle, |
252 | SourceRange OpRange, |
253 | QualType OrigSrcType, |
254 | QualType OrigDestType, unsigned &msg, |
255 | CastKind &Kind, |
256 | CXXCastPath &BasePath); |
257 | static TryCastResult TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, |
258 | QualType SrcType, |
259 | QualType DestType,bool CStyle, |
260 | SourceRange OpRange, |
261 | unsigned &msg, |
262 | CastKind &Kind, |
263 | CXXCastPath &BasePath); |
264 | |
265 | static TryCastResult |
266 | TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, |
267 | CheckedConversionKind CCK, SourceRange OpRange, |
268 | unsigned &msg, CastKind &Kind, bool ListInitialization); |
269 | static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr, |
270 | QualType DestType, CheckedConversionKind CCK, |
271 | SourceRange OpRange, unsigned &msg, |
272 | CastKind &Kind, CXXCastPath &BasePath, |
273 | bool ListInitialization); |
274 | static TryCastResult TryConstCast(Sema &Self, ExprResult &SrcExpr, |
275 | QualType DestType, bool CStyle, |
276 | unsigned &msg); |
277 | static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr, |
278 | QualType DestType, bool CStyle, |
279 | SourceRange OpRange, unsigned &msg, |
280 | CastKind &Kind); |
281 | static TryCastResult TryAddressSpaceCast(Sema &Self, ExprResult &SrcExpr, |
282 | QualType DestType, bool CStyle, |
283 | unsigned &msg, CastKind &Kind); |
284 | |
285 | ExprResult |
286 | Sema::ActOnCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, |
287 | SourceLocation LAngleBracketLoc, Declarator &D, |
288 | SourceLocation RAngleBracketLoc, |
289 | SourceLocation LParenLoc, Expr *E, |
290 | SourceLocation RParenLoc) { |
291 | |
292 | assert(!D.isInvalidType()); |
293 | |
294 | TypeSourceInfo *TInfo = GetTypeForDeclaratorCast(D, FromTy: E->getType()); |
295 | if (D.isInvalidType()) |
296 | return ExprError(); |
297 | |
298 | if (getLangOpts().CPlusPlus) { |
299 | // Check that there are no default arguments (C++ only). |
300 | CheckExtraCXXDefaultArguments(D); |
301 | } |
302 | |
303 | return BuildCXXNamedCast(OpLoc, Kind, Ty: TInfo, E, |
304 | AngleBrackets: SourceRange(LAngleBracketLoc, RAngleBracketLoc), |
305 | Parens: SourceRange(LParenLoc, RParenLoc)); |
306 | } |
307 | |
308 | ExprResult |
309 | Sema::BuildCXXNamedCast(SourceLocation OpLoc, tok::TokenKind Kind, |
310 | TypeSourceInfo *DestTInfo, Expr *E, |
311 | SourceRange AngleBrackets, SourceRange Parens) { |
312 | ExprResult Ex = E; |
313 | QualType DestType = DestTInfo->getType(); |
314 | |
315 | // If the type is dependent, we won't do the semantic analysis now. |
316 | bool TypeDependent = |
317 | DestType->isDependentType() || Ex.get()->isTypeDependent(); |
318 | |
319 | CastOperation Op(*this, DestType, E); |
320 | Op.OpRange = SourceRange(OpLoc, Parens.getEnd()); |
321 | Op.DestRange = AngleBrackets; |
322 | |
323 | Op.checkQualifiedDestType(); |
324 | |
325 | switch (Kind) { |
326 | default: llvm_unreachable("Unknown C++ cast!"); |
327 | |
328 | case tok::kw_addrspace_cast: |
329 | if (!TypeDependent) { |
330 | Op.CheckAddrspaceCast(); |
331 | if (Op.SrcExpr.isInvalid()) |
332 | return ExprError(); |
333 | } |
334 | return Op.complete(castExpr: CXXAddrspaceCastExpr::Create( |
335 | Context, T: Op.ResultType, VK: Op.ValueKind, Kind: Op.Kind, Op: Op.SrcExpr.get(), |
336 | WrittenTy: DestTInfo, L: OpLoc, RParenLoc: Parens.getEnd(), AngleBrackets)); |
337 | |
338 | case tok::kw_const_cast: |
339 | if (!TypeDependent) { |
340 | Op.CheckConstCast(); |
341 | if (Op.SrcExpr.isInvalid()) |
342 | return ExprError(); |
343 | DiscardMisalignedMemberAddress(T: DestType.getTypePtr(), E); |
344 | } |
345 | return Op.complete(castExpr: CXXConstCastExpr::Create(Context, T: Op.ResultType, |
346 | VK: Op.ValueKind, Op: Op.SrcExpr.get(), WrittenTy: DestTInfo, |
347 | L: OpLoc, RParenLoc: Parens.getEnd(), |
348 | AngleBrackets)); |
349 | |
350 | case tok::kw_dynamic_cast: { |
351 | // dynamic_cast is not supported in C++ for OpenCL. |
352 | if (getLangOpts().OpenCLCPlusPlus) { |
353 | return ExprError(Diag(OpLoc, diag::err_openclcxx_not_supported) |
354 | << "dynamic_cast"); |
355 | } |
356 | |
357 | if (!TypeDependent) { |
358 | Op.CheckDynamicCast(); |
359 | if (Op.SrcExpr.isInvalid()) |
360 | return ExprError(); |
361 | } |
362 | return Op.complete(castExpr: CXXDynamicCastExpr::Create(Context, T: Op.ResultType, |
363 | VK: Op.ValueKind, Kind: Op.Kind, Op: Op.SrcExpr.get(), |
364 | Path: &Op.BasePath, Written: DestTInfo, |
365 | L: OpLoc, RParenLoc: Parens.getEnd(), |
366 | AngleBrackets)); |
367 | } |
368 | case tok::kw_reinterpret_cast: { |
369 | if (!TypeDependent) { |
370 | Op.CheckReinterpretCast(); |
371 | if (Op.SrcExpr.isInvalid()) |
372 | return ExprError(); |
373 | DiscardMisalignedMemberAddress(T: DestType.getTypePtr(), E); |
374 | } |
375 | return Op.complete(castExpr: CXXReinterpretCastExpr::Create(Context, T: Op.ResultType, |
376 | VK: Op.ValueKind, Kind: Op.Kind, Op: Op.SrcExpr.get(), |
377 | Path: nullptr, WrittenTy: DestTInfo, L: OpLoc, |
378 | RParenLoc: Parens.getEnd(), |
379 | AngleBrackets)); |
380 | } |
381 | case tok::kw_static_cast: { |
382 | if (!TypeDependent) { |
383 | Op.CheckStaticCast(); |
384 | if (Op.SrcExpr.isInvalid()) |
385 | return ExprError(); |
386 | DiscardMisalignedMemberAddress(T: DestType.getTypePtr(), E); |
387 | } |
388 | |
389 | return Op.complete(castExpr: CXXStaticCastExpr::Create( |
390 | Context, T: Op.ResultType, VK: Op.ValueKind, K: Op.Kind, Op: Op.SrcExpr.get(), |
391 | Path: &Op.BasePath, Written: DestTInfo, FPO: CurFPFeatureOverrides(), L: OpLoc, |
392 | RParenLoc: Parens.getEnd(), AngleBrackets)); |
393 | } |
394 | } |
395 | } |
396 | |
397 | ExprResult Sema::ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &D, |
398 | ExprResult Operand, |
399 | SourceLocation RParenLoc) { |
400 | assert(!D.isInvalidType()); |
401 | |
402 | TypeSourceInfo *TInfo = GetTypeForDeclaratorCast(D, FromTy: Operand.get()->getType()); |
403 | if (D.isInvalidType()) |
404 | return ExprError(); |
405 | |
406 | return BuildBuiltinBitCastExpr(KWLoc, TSI: TInfo, Operand: Operand.get(), RParenLoc); |
407 | } |
408 | |
409 | ExprResult Sema::BuildBuiltinBitCastExpr(SourceLocation KWLoc, |
410 | TypeSourceInfo *TSI, Expr *Operand, |
411 | SourceLocation RParenLoc) { |
412 | CastOperation Op(*this, TSI->getType(), Operand); |
413 | Op.OpRange = SourceRange(KWLoc, RParenLoc); |
414 | TypeLoc TL = TSI->getTypeLoc(); |
415 | Op.DestRange = SourceRange(TL.getBeginLoc(), TL.getEndLoc()); |
416 | |
417 | if (!Operand->isTypeDependent() && !TSI->getType()->isDependentType()) { |
418 | Op.CheckBuiltinBitCast(); |
419 | if (Op.SrcExpr.isInvalid()) |
420 | return ExprError(); |
421 | } |
422 | |
423 | BuiltinBitCastExpr *BCE = |
424 | new (Context) BuiltinBitCastExpr(Op.ResultType, Op.ValueKind, Op.Kind, |
425 | Op.SrcExpr.get(), TSI, KWLoc, RParenLoc); |
426 | return Op.complete(BCE); |
427 | } |
428 | |
429 | /// Try to diagnose a failed overloaded cast. Returns true if |
430 | /// diagnostics were emitted. |
431 | static bool tryDiagnoseOverloadedCast(Sema &S, CastType CT, |
432 | SourceRange range, Expr *src, |
433 | QualType destType, |
434 | bool listInitialization) { |
435 | switch (CT) { |
436 | // These cast kinds don't consider user-defined conversions. |
437 | case CT_Const: |
438 | case CT_Reinterpret: |
439 | case CT_Dynamic: |
440 | case CT_Addrspace: |
441 | return false; |
442 | |
443 | // These do. |
444 | case CT_Static: |
445 | case CT_CStyle: |
446 | case CT_Functional: |
447 | break; |
448 | } |
449 | |
450 | QualType srcType = src->getType(); |
451 | if (!destType->isRecordType() && !srcType->isRecordType()) |
452 | return false; |
453 | |
454 | InitializedEntity entity = InitializedEntity::InitializeTemporary(Type: destType); |
455 | InitializationKind initKind |
456 | = (CT == CT_CStyle)? InitializationKind::CreateCStyleCast(StartLoc: range.getBegin(), |
457 | TypeRange: range, InitList: listInitialization) |
458 | : (CT == CT_Functional)? InitializationKind::CreateFunctionalCast(TypeRange: range, |
459 | InitList: listInitialization) |
460 | : InitializationKind::CreateCast(/*type range?*/ TypeRange: range); |
461 | InitializationSequence sequence(S, entity, initKind, src); |
462 | |
463 | // It could happen that a constructor failed to be used because |
464 | // it requires a temporary of a broken type. Still, it will be found when |
465 | // looking for a match. |
466 | if (!sequence.Failed()) |
467 | return false; |
468 | |
469 | switch (sequence.getFailureKind()) { |
470 | default: return false; |
471 | |
472 | case InitializationSequence::FK_ParenthesizedListInitFailed: |
473 | // In C++20, if the underlying destination type is a RecordType, Clang |
474 | // attempts to perform parentesized aggregate initialization if constructor |
475 | // overload fails: |
476 | // |
477 | // C++20 [expr.static.cast]p4: |
478 | // An expression E can be explicitly converted to a type T...if overload |
479 | // resolution for a direct-initialization...would find at least one viable |
480 | // function ([over.match.viable]), or if T is an aggregate type having a |
481 | // first element X and there is an implicit conversion sequence from E to |
482 | // the type of X. |
483 | // |
484 | // If that fails, then we'll generate the diagnostics from the failed |
485 | // previous constructor overload attempt. Array initialization, however, is |
486 | // not done after attempting constructor overloading, so we exit as there |
487 | // won't be a failed overload result. |
488 | if (destType->isArrayType()) |
489 | return false; |
490 | break; |
491 | case InitializationSequence::FK_ConstructorOverloadFailed: |
492 | case InitializationSequence::FK_UserConversionOverloadFailed: |
493 | break; |
494 | } |
495 | |
496 | OverloadCandidateSet &candidates = sequence.getFailedCandidateSet(); |
497 | |
498 | unsigned msg = 0; |
499 | OverloadCandidateDisplayKind howManyCandidates = OCD_AllCandidates; |
500 | |
501 | switch (sequence.getFailedOverloadResult()) { |
502 | case OR_Success: llvm_unreachable("successful failed overload"); |
503 | case OR_No_Viable_Function: |
504 | if (candidates.empty()) |
505 | msg = diag::err_ovl_no_conversion_in_cast; |
506 | else |
507 | msg = diag::err_ovl_no_viable_conversion_in_cast; |
508 | howManyCandidates = OCD_AllCandidates; |
509 | break; |
510 | |
511 | case OR_Ambiguous: |
512 | msg = diag::err_ovl_ambiguous_conversion_in_cast; |
513 | howManyCandidates = OCD_AmbiguousCandidates; |
514 | break; |
515 | |
516 | case OR_Deleted: { |
517 | OverloadCandidateSet::iterator Best; |
518 | [[maybe_unused]] OverloadingResult Res = |
519 | candidates.BestViableFunction(S, Loc: range.getBegin(), Best); |
520 | assert(Res == OR_Deleted && "Inconsistent overload resolution"); |
521 | |
522 | StringLiteral *Msg = Best->Function->getDeletedMessage(); |
523 | candidates.NoteCandidates( |
524 | PartialDiagnosticAt(range.getBegin(), |
525 | S.PDiag(diag::err_ovl_deleted_conversion_in_cast) |
526 | << CT << srcType << destType << (Msg != nullptr) |
527 | << (Msg ? Msg->getString() : StringRef()) |
528 | << range << src->getSourceRange()), |
529 | S, OCD_ViableCandidates, src); |
530 | return true; |
531 | } |
532 | } |
533 | |
534 | candidates.NoteCandidates( |
535 | PA: PartialDiagnosticAt(range.getBegin(), |
536 | S.PDiag(msg) << CT << srcType << destType << range |
537 | << src->getSourceRange()), |
538 | S, OCD: howManyCandidates, Args: src); |
539 | |
540 | return true; |
541 | } |
542 | |
543 | /// Diagnose a failed cast. |
544 | static void diagnoseBadCast(Sema &S, unsigned msg, CastType castType, |
545 | SourceRange opRange, Expr *src, QualType destType, |
546 | bool listInitialization) { |
547 | if (msg == diag::err_bad_cxx_cast_generic && |
548 | tryDiagnoseOverloadedCast(S, castType, opRange, src, destType, |
549 | listInitialization)) |
550 | return; |
551 | |
552 | S.Diag(opRange.getBegin(), msg) << castType |
553 | << src->getType() << destType << opRange << src->getSourceRange(); |
554 | |
555 | // Detect if both types are (ptr to) class, and note any incompleteness. |
556 | int DifferentPtrness = 0; |
557 | QualType From = destType; |
558 | if (auto Ptr = From->getAs<PointerType>()) { |
559 | From = Ptr->getPointeeType(); |
560 | DifferentPtrness++; |
561 | } |
562 | QualType To = src->getType(); |
563 | if (auto Ptr = To->getAs<PointerType>()) { |
564 | To = Ptr->getPointeeType(); |
565 | DifferentPtrness--; |
566 | } |
567 | if (!DifferentPtrness) { |
568 | auto RecFrom = From->getAs<RecordType>(); |
569 | auto RecTo = To->getAs<RecordType>(); |
570 | if (RecFrom && RecTo) { |
571 | auto DeclFrom = RecFrom->getAsCXXRecordDecl(); |
572 | if (!DeclFrom->isCompleteDefinition()) |
573 | S.Diag(DeclFrom->getLocation(), diag::note_type_incomplete) << DeclFrom; |
574 | auto DeclTo = RecTo->getAsCXXRecordDecl(); |
575 | if (!DeclTo->isCompleteDefinition()) |
576 | S.Diag(DeclTo->getLocation(), diag::note_type_incomplete) << DeclTo; |
577 | } |
578 | } |
579 | } |
580 | |
581 | namespace { |
582 | /// The kind of unwrapping we did when determining whether a conversion casts |
583 | /// away constness. |
584 | enum CastAwayConstnessKind { |
585 | /// The conversion does not cast away constness. |
586 | CACK_None = 0, |
587 | /// We unwrapped similar types. |
588 | CACK_Similar = 1, |
589 | /// We unwrapped dissimilar types with similar representations (eg, a pointer |
590 | /// versus an Objective-C object pointer). |
591 | CACK_SimilarKind = 2, |
592 | /// We unwrapped representationally-unrelated types, such as a pointer versus |
593 | /// a pointer-to-member. |
594 | CACK_Incoherent = 3, |
595 | }; |
596 | } |
597 | |
598 | /// Unwrap one level of types for CastsAwayConstness. |
599 | /// |
600 | /// Like Sema::UnwrapSimilarTypes, this removes one level of indirection from |
601 | /// both types, provided that they're both pointer-like or array-like. Unlike |
602 | /// the Sema function, doesn't care if the unwrapped pieces are related. |
603 | /// |
604 | /// This function may remove additional levels as necessary for correctness: |
605 | /// the resulting T1 is unwrapped sufficiently that it is never an array type, |
606 | /// so that its qualifiers can be directly compared to those of T2 (which will |
607 | /// have the combined set of qualifiers from all indermediate levels of T2), |
608 | /// as (effectively) required by [expr.const.cast]p7 replacing T1's qualifiers |
609 | /// with those from T2. |
610 | static CastAwayConstnessKind |
611 | unwrapCastAwayConstnessLevel(ASTContext &Context, QualType &T1, QualType &T2) { |
612 | enum { None, Ptr, MemPtr, BlockPtr, Array }; |
613 | auto Classify = [](QualType T) { |
614 | if (T->isAnyPointerType()) return Ptr; |
615 | if (T->isMemberPointerType()) return MemPtr; |
616 | if (T->isBlockPointerType()) return BlockPtr; |
617 | // We somewhat-arbitrarily don't look through VLA types here. This is at |
618 | // least consistent with the behavior of UnwrapSimilarTypes. |
619 | if (T->isConstantArrayType() || T->isIncompleteArrayType()) return Array; |
620 | return None; |
621 | }; |
622 | |
623 | auto Unwrap = [&](QualType T) { |
624 | if (auto *AT = Context.getAsArrayType(T)) |
625 | return AT->getElementType(); |
626 | return T->getPointeeType(); |
627 | }; |
628 | |
629 | CastAwayConstnessKind Kind; |
630 | |
631 | if (T2->isReferenceType()) { |
632 | // Special case: if the destination type is a reference type, unwrap it as |
633 | // the first level. (The source will have been an lvalue expression in this |
634 | // case, so there is no corresponding "reference to" in T1 to remove.) This |
635 | // simulates removing a "pointer to" from both sides. |
636 | T2 = T2->getPointeeType(); |
637 | Kind = CastAwayConstnessKind::CACK_Similar; |
638 | } else if (Context.UnwrapSimilarTypes(T1, T2)) { |
639 | Kind = CastAwayConstnessKind::CACK_Similar; |
640 | } else { |
641 | // Try unwrapping mismatching levels. |
642 | int T1Class = Classify(T1); |
643 | if (T1Class == None) |
644 | return CastAwayConstnessKind::CACK_None; |
645 | |
646 | int T2Class = Classify(T2); |
647 | if (T2Class == None) |
648 | return CastAwayConstnessKind::CACK_None; |
649 | |
650 | T1 = Unwrap(T1); |
651 | T2 = Unwrap(T2); |
652 | Kind = T1Class == T2Class ? CastAwayConstnessKind::CACK_SimilarKind |
653 | : CastAwayConstnessKind::CACK_Incoherent; |
654 | } |
655 | |
656 | // We've unwrapped at least one level. If the resulting T1 is a (possibly |
657 | // multidimensional) array type, any qualifier on any matching layer of |
658 | // T2 is considered to correspond to T1. Decompose down to the element |
659 | // type of T1 so that we can compare properly. |
660 | while (true) { |
661 | Context.UnwrapSimilarArrayTypes(T1, T2); |
662 | |
663 | if (Classify(T1) != Array) |
664 | break; |
665 | |
666 | auto T2Class = Classify(T2); |
667 | if (T2Class == None) |
668 | break; |
669 | |
670 | if (T2Class != Array) |
671 | Kind = CastAwayConstnessKind::CACK_Incoherent; |
672 | else if (Kind != CastAwayConstnessKind::CACK_Incoherent) |
673 | Kind = CastAwayConstnessKind::CACK_SimilarKind; |
674 | |
675 | T1 = Unwrap(T1); |
676 | T2 = Unwrap(T2).withCVRQualifiers(CVR: T2.getCVRQualifiers()); |
677 | } |
678 | |
679 | return Kind; |
680 | } |
681 | |
682 | /// Check if the pointer conversion from SrcType to DestType casts away |
683 | /// constness as defined in C++ [expr.const.cast]. This is used by the cast |
684 | /// checkers. Both arguments must denote pointer (possibly to member) types. |
685 | /// |
686 | /// \param CheckCVR Whether to check for const/volatile/restrict qualifiers. |
687 | /// \param CheckObjCLifetime Whether to check Objective-C lifetime qualifiers. |
688 | static CastAwayConstnessKind |
689 | CastsAwayConstness(Sema &Self, QualType SrcType, QualType DestType, |
690 | bool CheckCVR, bool CheckObjCLifetime, |
691 | QualType *TheOffendingSrcType = nullptr, |
692 | QualType *TheOffendingDestType = nullptr, |
693 | Qualifiers *CastAwayQualifiers = nullptr) { |
694 | // If the only checking we care about is for Objective-C lifetime qualifiers, |
695 | // and we're not in ObjC mode, there's nothing to check. |
696 | if (!CheckCVR && CheckObjCLifetime && !Self.Context.getLangOpts().ObjC) |
697 | return CastAwayConstnessKind::CACK_None; |
698 | |
699 | if (!DestType->isReferenceType()) { |
700 | assert((SrcType->isAnyPointerType() || SrcType->isMemberPointerType() || |
701 | SrcType->isBlockPointerType()) && |
702 | "Source type is not pointer or pointer to member."); |
703 | assert((DestType->isAnyPointerType() || DestType->isMemberPointerType() || |
704 | DestType->isBlockPointerType()) && |
705 | "Destination type is not pointer or pointer to member."); |
706 | } |
707 | |
708 | QualType UnwrappedSrcType = Self.Context.getCanonicalType(T: SrcType), |
709 | UnwrappedDestType = Self.Context.getCanonicalType(T: DestType); |
710 | |
711 | // Find the qualifiers. We only care about cvr-qualifiers for the |
712 | // purpose of this check, because other qualifiers (address spaces, |
713 | // Objective-C GC, etc.) are part of the type's identity. |
714 | QualType PrevUnwrappedSrcType = UnwrappedSrcType; |
715 | QualType PrevUnwrappedDestType = UnwrappedDestType; |
716 | auto WorstKind = CastAwayConstnessKind::CACK_Similar; |
717 | bool AllConstSoFar = true; |
718 | while (auto Kind = unwrapCastAwayConstnessLevel( |
719 | Context&: Self.Context, T1&: UnwrappedSrcType, T2&: UnwrappedDestType)) { |
720 | // Track the worst kind of unwrap we needed to do before we found a |
721 | // problem. |
722 | if (Kind > WorstKind) |
723 | WorstKind = Kind; |
724 | |
725 | // Determine the relevant qualifiers at this level. |
726 | Qualifiers SrcQuals, DestQuals; |
727 | Self.Context.getUnqualifiedArrayType(T: UnwrappedSrcType, Quals&: SrcQuals); |
728 | Self.Context.getUnqualifiedArrayType(T: UnwrappedDestType, Quals&: DestQuals); |
729 | |
730 | // We do not meaningfully track object const-ness of Objective-C object |
731 | // types. Remove const from the source type if either the source or |
732 | // the destination is an Objective-C object type. |
733 | if (UnwrappedSrcType->isObjCObjectType() || |
734 | UnwrappedDestType->isObjCObjectType()) |
735 | SrcQuals.removeConst(); |
736 | |
737 | if (CheckCVR) { |
738 | Qualifiers SrcCvrQuals = |
739 | Qualifiers::fromCVRMask(CVR: SrcQuals.getCVRQualifiers()); |
740 | Qualifiers DestCvrQuals = |
741 | Qualifiers::fromCVRMask(CVR: DestQuals.getCVRQualifiers()); |
742 | |
743 | if (SrcCvrQuals != DestCvrQuals) { |
744 | if (CastAwayQualifiers) |
745 | *CastAwayQualifiers = SrcCvrQuals - DestCvrQuals; |
746 | |
747 | // If we removed a cvr-qualifier, this is casting away 'constness'. |
748 | if (!DestCvrQuals.compatiblyIncludes(other: SrcCvrQuals, |
749 | Ctx: Self.getASTContext())) { |
750 | if (TheOffendingSrcType) |
751 | *TheOffendingSrcType = PrevUnwrappedSrcType; |
752 | if (TheOffendingDestType) |
753 | *TheOffendingDestType = PrevUnwrappedDestType; |
754 | return WorstKind; |
755 | } |
756 | |
757 | // If any prior level was not 'const', this is also casting away |
758 | // 'constness'. We noted the outermost type missing a 'const' already. |
759 | if (!AllConstSoFar) |
760 | return WorstKind; |
761 | } |
762 | } |
763 | |
764 | if (CheckObjCLifetime && |
765 | !DestQuals.compatiblyIncludesObjCLifetime(other: SrcQuals)) |
766 | return WorstKind; |
767 | |
768 | // If we found our first non-const-qualified type, this may be the place |
769 | // where things start to go wrong. |
770 | if (AllConstSoFar && !DestQuals.hasConst()) { |
771 | AllConstSoFar = false; |
772 | if (TheOffendingSrcType) |
773 | *TheOffendingSrcType = PrevUnwrappedSrcType; |
774 | if (TheOffendingDestType) |
775 | *TheOffendingDestType = PrevUnwrappedDestType; |
776 | } |
777 | |
778 | PrevUnwrappedSrcType = UnwrappedSrcType; |
779 | PrevUnwrappedDestType = UnwrappedDestType; |
780 | } |
781 | |
782 | return CastAwayConstnessKind::CACK_None; |
783 | } |
784 | |
785 | static TryCastResult getCastAwayConstnessCastKind(CastAwayConstnessKind CACK, |
786 | unsigned &DiagID) { |
787 | switch (CACK) { |
788 | case CastAwayConstnessKind::CACK_None: |
789 | llvm_unreachable("did not cast away constness"); |
790 | |
791 | case CastAwayConstnessKind::CACK_Similar: |
792 | // FIXME: Accept these as an extension too? |
793 | case CastAwayConstnessKind::CACK_SimilarKind: |
794 | DiagID = diag::err_bad_cxx_cast_qualifiers_away; |
795 | return TC_Failed; |
796 | |
797 | case CastAwayConstnessKind::CACK_Incoherent: |
798 | DiagID = diag::ext_bad_cxx_cast_qualifiers_away_incoherent; |
799 | return TC_Extension; |
800 | } |
801 | |
802 | llvm_unreachable("unexpected cast away constness kind"); |
803 | } |
804 | |
805 | /// CheckDynamicCast - Check that a dynamic_cast\<DestType\>(SrcExpr) is valid. |
806 | /// Refer to C++ 5.2.7 for details. Dynamic casts are used mostly for runtime- |
807 | /// checked downcasts in class hierarchies. |
808 | void CastOperation::CheckDynamicCast() { |
809 | CheckNoDerefRAII NoderefCheck(*this); |
810 | |
811 | if (ValueKind == VK_PRValue) |
812 | SrcExpr = Self.DefaultFunctionArrayLvalueConversion(E: SrcExpr.get()); |
813 | else if (isPlaceholder()) |
814 | SrcExpr = Self.CheckPlaceholderExpr(E: SrcExpr.get()); |
815 | if (SrcExpr.isInvalid()) // if conversion failed, don't report another error |
816 | return; |
817 | |
818 | QualType OrigSrcType = SrcExpr.get()->getType(); |
819 | QualType DestType = Self.Context.getCanonicalType(this->DestType); |
820 | |
821 | // C++ 5.2.7p1: T shall be a pointer or reference to a complete class type, |
822 | // or "pointer to cv void". |
823 | |
824 | QualType DestPointee; |
825 | const PointerType *DestPointer = DestType->getAs<PointerType>(); |
826 | const ReferenceType *DestReference = nullptr; |
827 | if (DestPointer) { |
828 | DestPointee = DestPointer->getPointeeType(); |
829 | } else if ((DestReference = DestType->getAs<ReferenceType>())) { |
830 | DestPointee = DestReference->getPointeeType(); |
831 | } else { |
832 | Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ref_or_ptr) |
833 | << this->DestType << DestRange; |
834 | SrcExpr = ExprError(); |
835 | return; |
836 | } |
837 | |
838 | const RecordType *DestRecord = DestPointee->getAs<RecordType>(); |
839 | if (DestPointee->isVoidType()) { |
840 | assert(DestPointer && "Reference to void is not possible"); |
841 | } else if (DestRecord) { |
842 | if (Self.RequireCompleteType(OpRange.getBegin(), DestPointee, |
843 | diag::err_bad_cast_incomplete, |
844 | DestRange)) { |
845 | SrcExpr = ExprError(); |
846 | return; |
847 | } |
848 | } else { |
849 | Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class) |
850 | << DestPointee.getUnqualifiedType() << DestRange; |
851 | SrcExpr = ExprError(); |
852 | return; |
853 | } |
854 | |
855 | // C++0x 5.2.7p2: If T is a pointer type, v shall be an rvalue of a pointer to |
856 | // complete class type, [...]. If T is an lvalue reference type, v shall be |
857 | // an lvalue of a complete class type, [...]. If T is an rvalue reference |
858 | // type, v shall be an expression having a complete class type, [...] |
859 | QualType SrcType = Self.Context.getCanonicalType(T: OrigSrcType); |
860 | QualType SrcPointee; |
861 | if (DestPointer) { |
862 | if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) { |
863 | SrcPointee = SrcPointer->getPointeeType(); |
864 | } else { |
865 | Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_ptr) |
866 | << OrigSrcType << this->DestType << SrcExpr.get()->getSourceRange(); |
867 | SrcExpr = ExprError(); |
868 | return; |
869 | } |
870 | } else if (DestReference->isLValueReferenceType()) { |
871 | if (!SrcExpr.get()->isLValue()) { |
872 | Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_rvalue) |
873 | << CT_Dynamic << OrigSrcType << this->DestType << OpRange; |
874 | } |
875 | SrcPointee = SrcType; |
876 | } else { |
877 | // If we're dynamic_casting from a prvalue to an rvalue reference, we need |
878 | // to materialize the prvalue before we bind the reference to it. |
879 | if (SrcExpr.get()->isPRValue()) |
880 | SrcExpr = Self.CreateMaterializeTemporaryExpr( |
881 | T: SrcType, Temporary: SrcExpr.get(), /*IsLValueReference*/ BoundToLvalueReference: false); |
882 | SrcPointee = SrcType; |
883 | } |
884 | |
885 | const RecordType *SrcRecord = SrcPointee->getAs<RecordType>(); |
886 | if (SrcRecord) { |
887 | if (Self.RequireCompleteType(OpRange.getBegin(), SrcPointee, |
888 | diag::err_bad_cast_incomplete, |
889 | SrcExpr.get())) { |
890 | SrcExpr = ExprError(); |
891 | return; |
892 | } |
893 | } else { |
894 | Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_class) |
895 | << SrcPointee.getUnqualifiedType() << SrcExpr.get()->getSourceRange(); |
896 | SrcExpr = ExprError(); |
897 | return; |
898 | } |
899 | |
900 | assert((DestPointer || DestReference) && |
901 | "Bad destination non-ptr/ref slipped through."); |
902 | assert((DestRecord || DestPointee->isVoidType()) && |
903 | "Bad destination pointee slipped through."); |
904 | assert(SrcRecord && "Bad source pointee slipped through."); |
905 | |
906 | // C++ 5.2.7p1: The dynamic_cast operator shall not cast away constness. |
907 | if (!DestPointee.isAtLeastAsQualifiedAs(other: SrcPointee, Ctx: Self.getASTContext())) { |
908 | Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_qualifiers_away) |
909 | << CT_Dynamic << OrigSrcType << this->DestType << OpRange; |
910 | SrcExpr = ExprError(); |
911 | return; |
912 | } |
913 | |
914 | // C++ 5.2.7p3: If the type of v is the same as the required result type, |
915 | // [except for cv]. |
916 | if (DestRecord == SrcRecord) { |
917 | Kind = CK_NoOp; |
918 | return; |
919 | } |
920 | |
921 | // C++ 5.2.7p5 |
922 | // Upcasts are resolved statically. |
923 | if (DestRecord && |
924 | Self.IsDerivedFrom(Loc: OpRange.getBegin(), Derived: SrcPointee, Base: DestPointee)) { |
925 | if (Self.CheckDerivedToBaseConversion(Derived: SrcPointee, Base: DestPointee, |
926 | Loc: OpRange.getBegin(), Range: OpRange, |
927 | BasePath: &BasePath)) { |
928 | SrcExpr = ExprError(); |
929 | return; |
930 | } |
931 | |
932 | Kind = CK_DerivedToBase; |
933 | return; |
934 | } |
935 | |
936 | // C++ 5.2.7p6: Otherwise, v shall be [polymorphic]. |
937 | const RecordDecl *SrcDecl = SrcRecord->getDecl()->getDefinition(); |
938 | assert(SrcDecl && "Definition missing"); |
939 | if (!cast<CXXRecordDecl>(Val: SrcDecl)->isPolymorphic()) { |
940 | Self.Diag(OpRange.getBegin(), diag::err_bad_dynamic_cast_not_polymorphic) |
941 | << SrcPointee.getUnqualifiedType() << SrcExpr.get()->getSourceRange(); |
942 | SrcExpr = ExprError(); |
943 | } |
944 | |
945 | // dynamic_cast is not available with -fno-rtti. |
946 | // As an exception, dynamic_cast to void* is available because it doesn't |
947 | // use RTTI. |
948 | if (!Self.getLangOpts().RTTI && !DestPointee->isVoidType()) { |
949 | Self.Diag(OpRange.getBegin(), diag::err_no_dynamic_cast_with_fno_rtti); |
950 | SrcExpr = ExprError(); |
951 | return; |
952 | } |
953 | |
954 | // Warns when dynamic_cast is used with RTTI data disabled. |
955 | if (!Self.getLangOpts().RTTIData) { |
956 | bool MicrosoftABI = |
957 | Self.getASTContext().getTargetInfo().getCXXABI().isMicrosoft(); |
958 | bool isClangCL = Self.getDiagnostics().getDiagnosticOptions().getFormat() == |
959 | DiagnosticOptions::MSVC; |
960 | if (MicrosoftABI || !DestPointee->isVoidType()) |
961 | Self.Diag(OpRange.getBegin(), |
962 | diag::warn_no_dynamic_cast_with_rtti_disabled) |
963 | << isClangCL; |
964 | } |
965 | |
966 | // For a dynamic_cast to a final type, IR generation might emit a reference |
967 | // to the vtable. |
968 | if (DestRecord) { |
969 | auto *DestDecl = DestRecord->getAsCXXRecordDecl(); |
970 | if (DestDecl->isEffectivelyFinal()) |
971 | Self.MarkVTableUsed(Loc: OpRange.getBegin(), Class: DestDecl); |
972 | } |
973 | |
974 | // Done. Everything else is run-time checks. |
975 | Kind = CK_Dynamic; |
976 | } |
977 | |
978 | /// CheckConstCast - Check that a const_cast\<DestType\>(SrcExpr) is valid. |
979 | /// Refer to C++ 5.2.11 for details. const_cast is typically used in code |
980 | /// like this: |
981 | /// const char *str = "literal"; |
982 | /// legacy_function(const_cast\<char*\>(str)); |
983 | void CastOperation::CheckConstCast() { |
984 | CheckNoDerefRAII NoderefCheck(*this); |
985 | |
986 | if (ValueKind == VK_PRValue) |
987 | SrcExpr = Self.DefaultFunctionArrayLvalueConversion(E: SrcExpr.get()); |
988 | else if (isPlaceholder()) |
989 | SrcExpr = Self.CheckPlaceholderExpr(E: SrcExpr.get()); |
990 | if (SrcExpr.isInvalid()) // if conversion failed, don't report another error |
991 | return; |
992 | |
993 | unsigned msg = diag::err_bad_cxx_cast_generic; |
994 | auto TCR = TryConstCast(Self, SrcExpr, DestType, /*CStyle*/ false, msg); |
995 | if (TCR != TC_Success && msg != 0) { |
996 | Self.Diag(OpRange.getBegin(), msg) << CT_Const |
997 | << SrcExpr.get()->getType() << DestType << OpRange; |
998 | } |
999 | if (!isValidCast(TCR)) |
1000 | SrcExpr = ExprError(); |
1001 | } |
1002 | |
1003 | void CastOperation::CheckAddrspaceCast() { |
1004 | unsigned msg = diag::err_bad_cxx_cast_generic; |
1005 | auto TCR = |
1006 | TryAddressSpaceCast(Self, SrcExpr, DestType, /*CStyle*/ false, msg, Kind); |
1007 | if (TCR != TC_Success && msg != 0) { |
1008 | Self.Diag(OpRange.getBegin(), msg) |
1009 | << CT_Addrspace << SrcExpr.get()->getType() << DestType << OpRange; |
1010 | } |
1011 | if (!isValidCast(TCR)) |
1012 | SrcExpr = ExprError(); |
1013 | } |
1014 | |
1015 | /// Check that a reinterpret_cast\<DestType\>(SrcExpr) is not used as upcast |
1016 | /// or downcast between respective pointers or references. |
1017 | static void DiagnoseReinterpretUpDownCast(Sema &Self, const Expr *SrcExpr, |
1018 | QualType DestType, |
1019 | SourceRange OpRange) { |
1020 | QualType SrcType = SrcExpr->getType(); |
1021 | // When casting from pointer or reference, get pointee type; use original |
1022 | // type otherwise. |
1023 | const CXXRecordDecl *SrcPointeeRD = SrcType->getPointeeCXXRecordDecl(); |
1024 | const CXXRecordDecl *SrcRD = |
1025 | SrcPointeeRD ? SrcPointeeRD : SrcType->getAsCXXRecordDecl(); |
1026 | |
1027 | // Examining subobjects for records is only possible if the complete and |
1028 | // valid definition is available. Also, template instantiation is not |
1029 | // allowed here. |
1030 | if (!SrcRD || !SrcRD->isCompleteDefinition() || SrcRD->isInvalidDecl()) |
1031 | return; |
1032 | |
1033 | const CXXRecordDecl *DestRD = DestType->getPointeeCXXRecordDecl(); |
1034 | |
1035 | if (!DestRD || !DestRD->isCompleteDefinition() || DestRD->isInvalidDecl()) |
1036 | return; |
1037 | |
1038 | enum { |
1039 | ReinterpretUpcast, |
1040 | ReinterpretDowncast |
1041 | } ReinterpretKind; |
1042 | |
1043 | CXXBasePaths BasePaths; |
1044 | |
1045 | if (SrcRD->isDerivedFrom(Base: DestRD, Paths&: BasePaths)) |
1046 | ReinterpretKind = ReinterpretUpcast; |
1047 | else if (DestRD->isDerivedFrom(Base: SrcRD, Paths&: BasePaths)) |
1048 | ReinterpretKind = ReinterpretDowncast; |
1049 | else |
1050 | return; |
1051 | |
1052 | bool VirtualBase = true; |
1053 | bool NonZeroOffset = false; |
1054 | for (CXXBasePaths::const_paths_iterator I = BasePaths.begin(), |
1055 | E = BasePaths.end(); |
1056 | I != E; ++I) { |
1057 | const CXXBasePath &Path = *I; |
1058 | CharUnits Offset = CharUnits::Zero(); |
1059 | bool IsVirtual = false; |
1060 | for (CXXBasePath::const_iterator IElem = Path.begin(), EElem = Path.end(); |
1061 | IElem != EElem; ++IElem) { |
1062 | IsVirtual = IElem->Base->isVirtual(); |
1063 | if (IsVirtual) |
1064 | break; |
1065 | const CXXRecordDecl *BaseRD = IElem->Base->getType()->getAsCXXRecordDecl(); |
1066 | assert(BaseRD && "Base type should be a valid unqualified class type"); |
1067 | // Don't check if any base has invalid declaration or has no definition |
1068 | // since it has no layout info. |
1069 | const CXXRecordDecl *Class = IElem->Class, |
1070 | *ClassDefinition = Class->getDefinition(); |
1071 | if (Class->isInvalidDecl() || !ClassDefinition || |
1072 | !ClassDefinition->isCompleteDefinition()) |
1073 | return; |
1074 | |
1075 | const ASTRecordLayout &DerivedLayout = |
1076 | Self.Context.getASTRecordLayout(Class); |
1077 | Offset += DerivedLayout.getBaseClassOffset(Base: BaseRD); |
1078 | } |
1079 | if (!IsVirtual) { |
1080 | // Don't warn if any path is a non-virtually derived base at offset zero. |
1081 | if (Offset.isZero()) |
1082 | return; |
1083 | // Offset makes sense only for non-virtual bases. |
1084 | else |
1085 | NonZeroOffset = true; |
1086 | } |
1087 | VirtualBase = VirtualBase && IsVirtual; |
1088 | } |
1089 | |
1090 | (void) NonZeroOffset; // Silence set but not used warning. |
1091 | assert((VirtualBase || NonZeroOffset) && |
1092 | "Should have returned if has non-virtual base with zero offset"); |
1093 | |
1094 | QualType BaseType = |
1095 | ReinterpretKind == ReinterpretUpcast? DestType : SrcType; |
1096 | QualType DerivedType = |
1097 | ReinterpretKind == ReinterpretUpcast? SrcType : DestType; |
1098 | |
1099 | SourceLocation BeginLoc = OpRange.getBegin(); |
1100 | Self.Diag(BeginLoc, diag::warn_reinterpret_different_from_static) |
1101 | << DerivedType << BaseType << !VirtualBase << int(ReinterpretKind) |
1102 | << OpRange; |
1103 | Self.Diag(BeginLoc, diag::note_reinterpret_updowncast_use_static) |
1104 | << int(ReinterpretKind) |
1105 | << FixItHint::CreateReplacement(BeginLoc, "static_cast"); |
1106 | } |
1107 | |
1108 | static bool argTypeIsABIEquivalent(QualType SrcType, QualType DestType, |
1109 | ASTContext &Context) { |
1110 | if (SrcType->isPointerType() && DestType->isPointerType()) |
1111 | return true; |
1112 | |
1113 | // Allow integral type mismatch if their size are equal. |
1114 | if ((SrcType->isIntegralType(Ctx: Context) || SrcType->isEnumeralType()) && |
1115 | (DestType->isIntegralType(Ctx: Context) || DestType->isEnumeralType())) |
1116 | if (Context.getTypeSizeInChars(T: SrcType) == |
1117 | Context.getTypeSizeInChars(T: DestType)) |
1118 | return true; |
1119 | |
1120 | return Context.hasSameUnqualifiedType(T1: SrcType, T2: DestType); |
1121 | } |
1122 | |
1123 | static unsigned int checkCastFunctionType(Sema &Self, const ExprResult &SrcExpr, |
1124 | QualType DestType) { |
1125 | unsigned int DiagID = 0; |
1126 | const unsigned int DiagList[] = {diag::warn_cast_function_type_strict, |
1127 | diag::warn_cast_function_type}; |
1128 | for (auto ID : DiagList) { |
1129 | if (!Self.Diags.isIgnored(ID, SrcExpr.get()->getExprLoc())) { |
1130 | DiagID = ID; |
1131 | break; |
1132 | } |
1133 | } |
1134 | if (!DiagID) |
1135 | return 0; |
1136 | |
1137 | QualType SrcType = SrcExpr.get()->getType(); |
1138 | const FunctionType *SrcFTy = nullptr; |
1139 | const FunctionType *DstFTy = nullptr; |
1140 | if (((SrcType->isBlockPointerType() || SrcType->isFunctionPointerType()) && |
1141 | DestType->isFunctionPointerType()) || |
1142 | (SrcType->isMemberFunctionPointerType() && |
1143 | DestType->isMemberFunctionPointerType())) { |
1144 | SrcFTy = SrcType->getPointeeType()->castAs<FunctionType>(); |
1145 | DstFTy = DestType->getPointeeType()->castAs<FunctionType>(); |
1146 | } else if (SrcType->isFunctionType() && DestType->isFunctionReferenceType()) { |
1147 | SrcFTy = SrcType->castAs<FunctionType>(); |
1148 | DstFTy = DestType.getNonReferenceType()->castAs<FunctionType>(); |
1149 | } else { |
1150 | return 0; |
1151 | } |
1152 | assert(SrcFTy && DstFTy); |
1153 | |
1154 | if (Self.Context.hasSameType(SrcFTy, DstFTy)) |
1155 | return 0; |
1156 | |
1157 | // For strict checks, ensure we have an exact match. |
1158 | if (DiagID == diag::warn_cast_function_type_strict) |
1159 | return DiagID; |
1160 | |
1161 | auto IsVoidVoid = [](const FunctionType *T) { |
1162 | if (!T->getReturnType()->isVoidType()) |
1163 | return false; |
1164 | if (const auto *PT = T->getAs<FunctionProtoType>()) |
1165 | return !PT->isVariadic() && PT->getNumParams() == 0; |
1166 | return false; |
1167 | }; |
1168 | |
1169 | auto IsFarProc = [](const FunctionType *T) { |
1170 | // The definition of FARPROC depends on the platform in terms of its return |
1171 | // type, which could be int, or long long, etc. We'll look for a source |
1172 | // signature for: <integer type> (*)() and call that "close enough" to |
1173 | // FARPROC to be sufficient to silence the diagnostic. This is similar to |
1174 | // how we allow casts between function pointers and void * for supporting |
1175 | // dlsym. |
1176 | // Note: we could check for __stdcall on the function pointer as well, but |
1177 | // that seems like splitting hairs. |
1178 | if (!T->getReturnType()->isIntegerType()) |
1179 | return false; |
1180 | if (const auto *PT = T->getAs<FunctionProtoType>()) |
1181 | return !PT->isVariadic() && PT->getNumParams() == 0; |
1182 | return true; |
1183 | }; |
1184 | |
1185 | // Skip if either function type is void(*)(void) |
1186 | if (IsVoidVoid(SrcFTy) || IsVoidVoid(DstFTy)) |
1187 | return 0; |
1188 | |
1189 | // On Windows, GetProcAddress() returns a FARPROC, which is a typedef for a |
1190 | // function pointer type (with no prototype, in C). We don't want to diagnose |
1191 | // this case so we don't diagnose idiomatic code on Windows. |
1192 | if (Self.getASTContext().getTargetInfo().getTriple().isOSWindows() && |
1193 | IsFarProc(SrcFTy)) |
1194 | return 0; |
1195 | |
1196 | // Check return type. |
1197 | if (!argTypeIsABIEquivalent(SrcType: SrcFTy->getReturnType(), DestType: DstFTy->getReturnType(), |
1198 | Context&: Self.Context)) |
1199 | return DiagID; |
1200 | |
1201 | // Check if either has unspecified number of parameters |
1202 | if (SrcFTy->isFunctionNoProtoType() || DstFTy->isFunctionNoProtoType()) |
1203 | return 0; |
1204 | |
1205 | // Check parameter types. |
1206 | |
1207 | const auto *SrcFPTy = cast<FunctionProtoType>(Val: SrcFTy); |
1208 | const auto *DstFPTy = cast<FunctionProtoType>(Val: DstFTy); |
1209 | |
1210 | // In a cast involving function types with a variable argument list only the |
1211 | // types of initial arguments that are provided are considered. |
1212 | unsigned NumParams = SrcFPTy->getNumParams(); |
1213 | unsigned DstNumParams = DstFPTy->getNumParams(); |
1214 | if (NumParams > DstNumParams) { |
1215 | if (!DstFPTy->isVariadic()) |
1216 | return DiagID; |
1217 | NumParams = DstNumParams; |
1218 | } else if (NumParams < DstNumParams) { |
1219 | if (!SrcFPTy->isVariadic()) |
1220 | return DiagID; |
1221 | } |
1222 | |
1223 | for (unsigned i = 0; i < NumParams; ++i) |
1224 | if (!argTypeIsABIEquivalent(SrcType: SrcFPTy->getParamType(i), |
1225 | DestType: DstFPTy->getParamType(i), Context&: Self.Context)) |
1226 | return DiagID; |
1227 | |
1228 | return 0; |
1229 | } |
1230 | |
1231 | /// CheckReinterpretCast - Check that a reinterpret_cast\<DestType\>(SrcExpr) is |
1232 | /// valid. |
1233 | /// Refer to C++ 5.2.10 for details. reinterpret_cast is typically used in code |
1234 | /// like this: |
1235 | /// char *bytes = reinterpret_cast\<char*\>(int_ptr); |
1236 | void CastOperation::CheckReinterpretCast() { |
1237 | if (ValueKind == VK_PRValue && !isPlaceholder(K: BuiltinType::Overload)) |
1238 | SrcExpr = Self.DefaultFunctionArrayLvalueConversion(E: SrcExpr.get()); |
1239 | else |
1240 | checkNonOverloadPlaceholders(); |
1241 | if (SrcExpr.isInvalid()) // if conversion failed, don't report another error |
1242 | return; |
1243 | |
1244 | unsigned msg = diag::err_bad_cxx_cast_generic; |
1245 | TryCastResult tcr = |
1246 | TryReinterpretCast(Self, SrcExpr, DestType, |
1247 | /*CStyle*/false, OpRange, msg, Kind); |
1248 | if (tcr != TC_Success && msg != 0) { |
1249 | if (SrcExpr.isInvalid()) // if conversion failed, don't report another error |
1250 | return; |
1251 | if (SrcExpr.get()->getType() == Self.Context.OverloadTy) { |
1252 | //FIXME: &f<int>; is overloaded and resolvable |
1253 | Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_overload) |
1254 | << OverloadExpr::find(SrcExpr.get()).Expression->getName() |
1255 | << DestType << OpRange; |
1256 | Self.NoteAllOverloadCandidates(E: SrcExpr.get()); |
1257 | |
1258 | } else { |
1259 | diagnoseBadCast(Self, msg, CT_Reinterpret, OpRange, SrcExpr.get(), |
1260 | DestType, /*listInitialization=*/false); |
1261 | } |
1262 | } |
1263 | |
1264 | if (isValidCast(TCR: tcr)) { |
1265 | if (Self.getLangOpts().allowsNonTrivialObjCLifetimeQualifiers()) |
1266 | checkObjCConversion(CCK: CheckedConversionKind::OtherCast); |
1267 | DiagnoseReinterpretUpDownCast(Self, SrcExpr.get(), DestType, OpRange); |
1268 | |
1269 | if (unsigned DiagID = checkCastFunctionType(Self, SrcExpr, DestType)) |
1270 | Self.Diag(OpRange.getBegin(), DiagID) |
1271 | << SrcExpr.get()->getType() << DestType << OpRange; |
1272 | } else { |
1273 | SrcExpr = ExprError(); |
1274 | } |
1275 | } |
1276 | |
1277 | |
1278 | /// CheckStaticCast - Check that a static_cast\<DestType\>(SrcExpr) is valid. |
1279 | /// Refer to C++ 5.2.9 for details. Static casts are mostly used for making |
1280 | /// implicit conversions explicit and getting rid of data loss warnings. |
1281 | void CastOperation::CheckStaticCast() { |
1282 | CheckNoDerefRAII NoderefCheck(*this); |
1283 | |
1284 | if (isPlaceholder()) { |
1285 | checkNonOverloadPlaceholders(); |
1286 | if (SrcExpr.isInvalid()) |
1287 | return; |
1288 | } |
1289 | |
1290 | // This test is outside everything else because it's the only case where |
1291 | // a non-lvalue-reference target type does not lead to decay. |
1292 | // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void". |
1293 | if (DestType->isVoidType()) { |
1294 | Kind = CK_ToVoid; |
1295 | |
1296 | if (claimPlaceholder(K: BuiltinType::Overload)) { |
1297 | Self.ResolveAndFixSingleFunctionTemplateSpecialization(SrcExpr, |
1298 | false, // Decay Function to ptr |
1299 | true, // Complain |
1300 | OpRange, DestType, diag::err_bad_static_cast_overload); |
1301 | if (SrcExpr.isInvalid()) |
1302 | return; |
1303 | } |
1304 | |
1305 | SrcExpr = Self.IgnoredValueConversions(E: SrcExpr.get()); |
1306 | return; |
1307 | } |
1308 | |
1309 | if (ValueKind == VK_PRValue && !DestType->isRecordType() && |
1310 | !isPlaceholder(BuiltinType::Overload)) { |
1311 | SrcExpr = Self.DefaultFunctionArrayLvalueConversion(E: SrcExpr.get()); |
1312 | if (SrcExpr.isInvalid()) // if conversion failed, don't report another error |
1313 | return; |
1314 | } |
1315 | |
1316 | unsigned msg = diag::err_bad_cxx_cast_generic; |
1317 | TryCastResult tcr = |
1318 | TryStaticCast(Self, SrcExpr, DestType, CheckedConversionKind::OtherCast, |
1319 | OpRange, msg, Kind, BasePath, /*ListInitialization=*/false); |
1320 | if (tcr != TC_Success && msg != 0) { |
1321 | if (SrcExpr.isInvalid()) |
1322 | return; |
1323 | if (SrcExpr.get()->getType() == Self.Context.OverloadTy) { |
1324 | OverloadExpr* oe = OverloadExpr::find(E: SrcExpr.get()).Expression; |
1325 | Self.Diag(OpRange.getBegin(), diag::err_bad_static_cast_overload) |
1326 | << oe->getName() << DestType << OpRange |
1327 | << oe->getQualifierLoc().getSourceRange(); |
1328 | Self.NoteAllOverloadCandidates(E: SrcExpr.get()); |
1329 | } else { |
1330 | diagnoseBadCast(Self, msg, CT_Static, OpRange, SrcExpr.get(), DestType, |
1331 | /*listInitialization=*/false); |
1332 | } |
1333 | } |
1334 | |
1335 | if (isValidCast(TCR: tcr)) { |
1336 | if (Kind == CK_BitCast) |
1337 | checkCastAlign(); |
1338 | if (Self.getLangOpts().allowsNonTrivialObjCLifetimeQualifiers()) |
1339 | checkObjCConversion(CCK: CheckedConversionKind::OtherCast); |
1340 | } else { |
1341 | SrcExpr = ExprError(); |
1342 | } |
1343 | } |
1344 | |
1345 | static bool IsAddressSpaceConversion(QualType SrcType, QualType DestType) { |
1346 | auto *SrcPtrType = SrcType->getAs<PointerType>(); |
1347 | if (!SrcPtrType) |
1348 | return false; |
1349 | auto *DestPtrType = DestType->getAs<PointerType>(); |
1350 | if (!DestPtrType) |
1351 | return false; |
1352 | return SrcPtrType->getPointeeType().getAddressSpace() != |
1353 | DestPtrType->getPointeeType().getAddressSpace(); |
1354 | } |
1355 | |
1356 | /// TryStaticCast - Check if a static cast can be performed, and do so if |
1357 | /// possible. If @p CStyle, ignore access restrictions on hierarchy casting |
1358 | /// and casting away constness. |
1359 | static TryCastResult TryStaticCast(Sema &Self, ExprResult &SrcExpr, |
1360 | QualType DestType, CheckedConversionKind CCK, |
1361 | SourceRange OpRange, unsigned &msg, |
1362 | CastKind &Kind, CXXCastPath &BasePath, |
1363 | bool ListInitialization) { |
1364 | // Determine whether we have the semantics of a C-style cast. |
1365 | bool CStyle = (CCK == CheckedConversionKind::CStyleCast || |
1366 | CCK == CheckedConversionKind::FunctionalCast); |
1367 | |
1368 | // The order the tests is not entirely arbitrary. There is one conversion |
1369 | // that can be handled in two different ways. Given: |
1370 | // struct A {}; |
1371 | // struct B : public A { |
1372 | // B(); B(const A&); |
1373 | // }; |
1374 | // const A &a = B(); |
1375 | // the cast static_cast<const B&>(a) could be seen as either a static |
1376 | // reference downcast, or an explicit invocation of the user-defined |
1377 | // conversion using B's conversion constructor. |
1378 | // DR 427 specifies that the downcast is to be applied here. |
1379 | |
1380 | // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void". |
1381 | // Done outside this function. |
1382 | |
1383 | TryCastResult tcr; |
1384 | |
1385 | // C++ 5.2.9p5, reference downcast. |
1386 | // See the function for details. |
1387 | // DR 427 specifies that this is to be applied before paragraph 2. |
1388 | tcr = TryStaticReferenceDowncast(Self, SrcExpr: SrcExpr.get(), DestType, CStyle, |
1389 | OpRange, msg, Kind, BasePath); |
1390 | if (tcr != TC_NotApplicable) |
1391 | return tcr; |
1392 | |
1393 | // C++11 [expr.static.cast]p3: |
1394 | // A glvalue of type "cv1 T1" can be cast to type "rvalue reference to cv2 |
1395 | // T2" if "cv2 T2" is reference-compatible with "cv1 T1". |
1396 | tcr = TryLValueToRValueCast(Self, SrcExpr: SrcExpr.get(), DestType, CStyle, Kind, |
1397 | BasePath, msg); |
1398 | if (tcr != TC_NotApplicable) |
1399 | return tcr; |
1400 | |
1401 | // C++ 5.2.9p2: An expression e can be explicitly converted to a type T |
1402 | // [...] if the declaration "T t(e);" is well-formed, [...]. |
1403 | tcr = TryStaticImplicitCast(Self, SrcExpr, DestType, CCK, OpRange, msg, |
1404 | Kind, ListInitialization); |
1405 | if (SrcExpr.isInvalid()) |
1406 | return TC_Failed; |
1407 | if (tcr != TC_NotApplicable) |
1408 | return tcr; |
1409 | |
1410 | // C++ 5.2.9p6: May apply the reverse of any standard conversion, except |
1411 | // lvalue-to-rvalue, array-to-pointer, function-to-pointer, and boolean |
1412 | // conversions, subject to further restrictions. |
1413 | // Also, C++ 5.2.9p1 forbids casting away constness, which makes reversal |
1414 | // of qualification conversions impossible. (In C++20, adding an array bound |
1415 | // would be the reverse of a qualification conversion, but adding permission |
1416 | // to add an array bound in a static_cast is a wording oversight.) |
1417 | // In the CStyle case, the earlier attempt to const_cast should have taken |
1418 | // care of reverse qualification conversions. |
1419 | |
1420 | QualType SrcType = Self.Context.getCanonicalType(T: SrcExpr.get()->getType()); |
1421 | |
1422 | // C++0x 5.2.9p9: A value of a scoped enumeration type can be explicitly |
1423 | // converted to an integral type. [...] A value of a scoped enumeration type |
1424 | // can also be explicitly converted to a floating-point type [...]. |
1425 | if (const EnumType *Enum = SrcType->getAs<EnumType>()) { |
1426 | if (Enum->getDecl()->isScoped()) { |
1427 | if (DestType->isBooleanType()) { |
1428 | Kind = CK_IntegralToBoolean; |
1429 | return TC_Success; |
1430 | } else if (DestType->isIntegralType(Ctx: Self.Context)) { |
1431 | Kind = CK_IntegralCast; |
1432 | return TC_Success; |
1433 | } else if (DestType->isRealFloatingType()) { |
1434 | Kind = CK_IntegralToFloating; |
1435 | return TC_Success; |
1436 | } |
1437 | } |
1438 | } |
1439 | |
1440 | // Reverse integral promotion/conversion. All such conversions are themselves |
1441 | // again integral promotions or conversions and are thus already handled by |
1442 | // p2 (TryDirectInitialization above). |
1443 | // (Note: any data loss warnings should be suppressed.) |
1444 | // The exception is the reverse of enum->integer, i.e. integer->enum (and |
1445 | // enum->enum). See also C++ 5.2.9p7. |
1446 | // The same goes for reverse floating point promotion/conversion and |
1447 | // floating-integral conversions. Again, only floating->enum is relevant. |
1448 | if (DestType->isEnumeralType()) { |
1449 | if (Self.RequireCompleteType(OpRange.getBegin(), DestType, |
1450 | diag::err_bad_cast_incomplete)) { |
1451 | SrcExpr = ExprError(); |
1452 | return TC_Failed; |
1453 | } |
1454 | if (SrcType->isIntegralOrEnumerationType()) { |
1455 | // [expr.static.cast]p10 If the enumeration type has a fixed underlying |
1456 | // type, the value is first converted to that type by integral conversion |
1457 | const EnumType *Enum = DestType->castAs<EnumType>(); |
1458 | Kind = Enum->getDecl()->isFixed() && |
1459 | Enum->getDecl()->getIntegerType()->isBooleanType() |
1460 | ? CK_IntegralToBoolean |
1461 | : CK_IntegralCast; |
1462 | return TC_Success; |
1463 | } else if (SrcType->isRealFloatingType()) { |
1464 | Kind = CK_FloatingToIntegral; |
1465 | return TC_Success; |
1466 | } |
1467 | } |
1468 | |
1469 | // Reverse pointer upcast. C++ 4.10p3 specifies pointer upcast. |
1470 | // C++ 5.2.9p8 additionally disallows a cast path through virtual inheritance. |
1471 | tcr = TryStaticPointerDowncast(Self, SrcType, DestType, CStyle, OpRange, msg, |
1472 | Kind, BasePath); |
1473 | if (tcr != TC_NotApplicable) |
1474 | return tcr; |
1475 | |
1476 | // Reverse member pointer conversion. C++ 4.11 specifies member pointer |
1477 | // conversion. C++ 5.2.9p9 has additional information. |
1478 | // DR54's access restrictions apply here also. |
1479 | tcr = TryStaticMemberPointerUpcast(Self, SrcExpr, SrcType, DestType, CStyle, |
1480 | OpRange, msg, Kind, BasePath); |
1481 | if (tcr != TC_NotApplicable) |
1482 | return tcr; |
1483 | |
1484 | // Reverse pointer conversion to void*. C++ 4.10.p2 specifies conversion to |
1485 | // void*. C++ 5.2.9p10 specifies additional restrictions, which really is |
1486 | // just the usual constness stuff. |
1487 | if (const PointerType *SrcPointer = SrcType->getAs<PointerType>()) { |
1488 | QualType SrcPointee = SrcPointer->getPointeeType(); |
1489 | if (SrcPointee->isVoidType()) { |
1490 | if (const PointerType *DestPointer = DestType->getAs<PointerType>()) { |
1491 | QualType DestPointee = DestPointer->getPointeeType(); |
1492 | if (DestPointee->isIncompleteOrObjectType()) { |
1493 | // This is definitely the intended conversion, but it might fail due |
1494 | // to a qualifier violation. Note that we permit Objective-C lifetime |
1495 | // and GC qualifier mismatches here. |
1496 | if (!CStyle) { |
1497 | Qualifiers DestPointeeQuals = DestPointee.getQualifiers(); |
1498 | Qualifiers SrcPointeeQuals = SrcPointee.getQualifiers(); |
1499 | DestPointeeQuals.removeObjCGCAttr(); |
1500 | DestPointeeQuals.removeObjCLifetime(); |
1501 | SrcPointeeQuals.removeObjCGCAttr(); |
1502 | SrcPointeeQuals.removeObjCLifetime(); |
1503 | if (DestPointeeQuals != SrcPointeeQuals && |
1504 | !DestPointeeQuals.compatiblyIncludes(other: SrcPointeeQuals, |
1505 | Ctx: Self.getASTContext())) { |
1506 | msg = diag::err_bad_cxx_cast_qualifiers_away; |
1507 | return TC_Failed; |
1508 | } |
1509 | } |
1510 | Kind = IsAddressSpaceConversion(SrcType, DestType) |
1511 | ? CK_AddressSpaceConversion |
1512 | : CK_BitCast; |
1513 | return TC_Success; |
1514 | } |
1515 | |
1516 | // Microsoft permits static_cast from 'pointer-to-void' to |
1517 | // 'pointer-to-function'. |
1518 | if (!CStyle && Self.getLangOpts().MSVCCompat && |
1519 | DestPointee->isFunctionType()) { |
1520 | Self.Diag(OpRange.getBegin(), diag::ext_ms_cast_fn_obj) << OpRange; |
1521 | Kind = CK_BitCast; |
1522 | return TC_Success; |
1523 | } |
1524 | } |
1525 | else if (DestType->isObjCObjectPointerType()) { |
1526 | // allow both c-style cast and static_cast of objective-c pointers as |
1527 | // they are pervasive. |
1528 | Kind = CK_CPointerToObjCPointerCast; |
1529 | return TC_Success; |
1530 | } |
1531 | else if (CStyle && DestType->isBlockPointerType()) { |
1532 | // allow c-style cast of void * to block pointers. |
1533 | Kind = CK_AnyPointerToBlockPointerCast; |
1534 | return TC_Success; |
1535 | } |
1536 | } |
1537 | } |
1538 | // Allow arbitrary objective-c pointer conversion with static casts. |
1539 | if (SrcType->isObjCObjectPointerType() && |
1540 | DestType->isObjCObjectPointerType()) { |
1541 | Kind = CK_BitCast; |
1542 | return TC_Success; |
1543 | } |
1544 | // Allow ns-pointer to cf-pointer conversion in either direction |
1545 | // with static casts. |
1546 | if (!CStyle && |
1547 | Self.ObjC().CheckTollFreeBridgeStaticCast(castType: DestType, castExpr: SrcExpr.get(), Kind)) |
1548 | return TC_Success; |
1549 | |
1550 | // See if it looks like the user is trying to convert between |
1551 | // related record types, and select a better diagnostic if so. |
1552 | if (auto SrcPointer = SrcType->getAs<PointerType>()) |
1553 | if (auto DestPointer = DestType->getAs<PointerType>()) |
1554 | if (SrcPointer->getPointeeType()->getAs<RecordType>() && |
1555 | DestPointer->getPointeeType()->getAs<RecordType>()) |
1556 | msg = diag::err_bad_cxx_cast_unrelated_class; |
1557 | |
1558 | if (SrcType->isMatrixType() && DestType->isMatrixType()) { |
1559 | if (Self.CheckMatrixCast(R: OpRange, DestTy: DestType, SrcTy: SrcType, Kind)) { |
1560 | SrcExpr = ExprError(); |
1561 | return TC_Failed; |
1562 | } |
1563 | return TC_Success; |
1564 | } |
1565 | |
1566 | // We tried everything. Everything! Nothing works! :-( |
1567 | return TC_NotApplicable; |
1568 | } |
1569 | |
1570 | /// Tests whether a conversion according to N2844 is valid. |
1571 | TryCastResult TryLValueToRValueCast(Sema &Self, Expr *SrcExpr, |
1572 | QualType DestType, bool CStyle, |
1573 | CastKind &Kind, CXXCastPath &BasePath, |
1574 | unsigned &msg) { |
1575 | // C++11 [expr.static.cast]p3: |
1576 | // A glvalue of type "cv1 T1" can be cast to type "rvalue reference to |
1577 | // cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1". |
1578 | const RValueReferenceType *R = DestType->getAs<RValueReferenceType>(); |
1579 | if (!R) |
1580 | return TC_NotApplicable; |
1581 | |
1582 | if (!SrcExpr->isGLValue()) |
1583 | return TC_NotApplicable; |
1584 | |
1585 | // Because we try the reference downcast before this function, from now on |
1586 | // this is the only cast possibility, so we issue an error if we fail now. |
1587 | // FIXME: Should allow casting away constness if CStyle. |
1588 | QualType FromType = SrcExpr->getType(); |
1589 | QualType ToType = R->getPointeeType(); |
1590 | if (CStyle) { |
1591 | FromType = FromType.getUnqualifiedType(); |
1592 | ToType = ToType.getUnqualifiedType(); |
1593 | } |
1594 | |
1595 | Sema::ReferenceConversions RefConv; |
1596 | Sema::ReferenceCompareResult RefResult = Self.CompareReferenceRelationship( |
1597 | Loc: SrcExpr->getBeginLoc(), T1: ToType, T2: FromType, Conv: &RefConv); |
1598 | if (RefResult != Sema::Ref_Compatible) { |
1599 | if (CStyle || RefResult == Sema::Ref_Incompatible) |
1600 | return TC_NotApplicable; |
1601 | // Diagnose types which are reference-related but not compatible here since |
1602 | // we can provide better diagnostics. In these cases forwarding to |
1603 | // [expr.static.cast]p4 should never result in a well-formed cast. |
1604 | msg = SrcExpr->isLValue() ? diag::err_bad_lvalue_to_rvalue_cast |
1605 | : diag::err_bad_rvalue_to_rvalue_cast; |
1606 | return TC_Failed; |
1607 | } |
1608 | |
1609 | if (RefConv & Sema::ReferenceConversions::DerivedToBase) { |
1610 | Kind = CK_DerivedToBase; |
1611 | CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, |
1612 | /*DetectVirtual=*/true); |
1613 | if (!Self.IsDerivedFrom(SrcExpr->getBeginLoc(), SrcExpr->getType(), |
1614 | R->getPointeeType(), Paths)) |
1615 | return TC_NotApplicable; |
1616 | |
1617 | Self.BuildBasePathArray(Paths, BasePath); |
1618 | } else |
1619 | Kind = CK_NoOp; |
1620 | |
1621 | return TC_Success; |
1622 | } |
1623 | |
1624 | /// Tests whether a conversion according to C++ 5.2.9p5 is valid. |
1625 | TryCastResult |
1626 | TryStaticReferenceDowncast(Sema &Self, Expr *SrcExpr, QualType DestType, |
1627 | bool CStyle, SourceRange OpRange, |
1628 | unsigned &msg, CastKind &Kind, |
1629 | CXXCastPath &BasePath) { |
1630 | // C++ 5.2.9p5: An lvalue of type "cv1 B", where B is a class type, can be |
1631 | // cast to type "reference to cv2 D", where D is a class derived from B, |
1632 | // if a valid standard conversion from "pointer to D" to "pointer to B" |
1633 | // exists, cv2 >= cv1, and B is not a virtual base class of D. |
1634 | // In addition, DR54 clarifies that the base must be accessible in the |
1635 | // current context. Although the wording of DR54 only applies to the pointer |
1636 | // variant of this rule, the intent is clearly for it to apply to the this |
1637 | // conversion as well. |
1638 | |
1639 | const ReferenceType *DestReference = DestType->getAs<ReferenceType>(); |
1640 | if (!DestReference) { |
1641 | return TC_NotApplicable; |
1642 | } |
1643 | bool RValueRef = DestReference->isRValueReferenceType(); |
1644 | if (!RValueRef && !SrcExpr->isLValue()) { |
1645 | // We know the left side is an lvalue reference, so we can suggest a reason. |
1646 | msg = diag::err_bad_cxx_cast_rvalue; |
1647 | return TC_NotApplicable; |
1648 | } |
1649 | |
1650 | QualType DestPointee = DestReference->getPointeeType(); |
1651 | |
1652 | // FIXME: If the source is a prvalue, we should issue a warning (because the |
1653 | // cast always has undefined behavior), and for AST consistency, we should |
1654 | // materialize a temporary. |
1655 | return TryStaticDowncast(Self, |
1656 | SrcType: Self.Context.getCanonicalType(T: SrcExpr->getType()), |
1657 | DestType: Self.Context.getCanonicalType(T: DestPointee), CStyle, |
1658 | OpRange, OrigSrcType: SrcExpr->getType(), OrigDestType: DestType, msg, Kind, |
1659 | BasePath); |
1660 | } |
1661 | |
1662 | /// Tests whether a conversion according to C++ 5.2.9p8 is valid. |
1663 | TryCastResult |
1664 | TryStaticPointerDowncast(Sema &Self, QualType SrcType, QualType DestType, |
1665 | bool CStyle, SourceRange OpRange, |
1666 | unsigned &msg, CastKind &Kind, |
1667 | CXXCastPath &BasePath) { |
1668 | // C++ 5.2.9p8: An rvalue of type "pointer to cv1 B", where B is a class |
1669 | // type, can be converted to an rvalue of type "pointer to cv2 D", where D |
1670 | // is a class derived from B, if a valid standard conversion from "pointer |
1671 | // to D" to "pointer to B" exists, cv2 >= cv1, and B is not a virtual base |
1672 | // class of D. |
1673 | // In addition, DR54 clarifies that the base must be accessible in the |
1674 | // current context. |
1675 | |
1676 | const PointerType *DestPointer = DestType->getAs<PointerType>(); |
1677 | if (!DestPointer) { |
1678 | return TC_NotApplicable; |
1679 | } |
1680 | |
1681 | const PointerType *SrcPointer = SrcType->getAs<PointerType>(); |
1682 | if (!SrcPointer) { |
1683 | msg = diag::err_bad_static_cast_pointer_nonpointer; |
1684 | return TC_NotApplicable; |
1685 | } |
1686 | |
1687 | return TryStaticDowncast(Self, |
1688 | SrcType: Self.Context.getCanonicalType(T: SrcPointer->getPointeeType()), |
1689 | DestType: Self.Context.getCanonicalType(T: DestPointer->getPointeeType()), |
1690 | CStyle, OpRange, OrigSrcType: SrcType, OrigDestType: DestType, msg, Kind, |
1691 | BasePath); |
1692 | } |
1693 | |
1694 | /// TryStaticDowncast - Common functionality of TryStaticReferenceDowncast and |
1695 | /// TryStaticPointerDowncast. Tests whether a static downcast from SrcType to |
1696 | /// DestType is possible and allowed. |
1697 | TryCastResult |
1698 | TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType, |
1699 | bool CStyle, SourceRange OpRange, QualType OrigSrcType, |
1700 | QualType OrigDestType, unsigned &msg, |
1701 | CastKind &Kind, CXXCastPath &BasePath) { |
1702 | // We can only work with complete types. But don't complain if it doesn't work |
1703 | if (!Self.isCompleteType(Loc: OpRange.getBegin(), T: SrcType) || |
1704 | !Self.isCompleteType(Loc: OpRange.getBegin(), T: DestType)) |
1705 | return TC_NotApplicable; |
1706 | |
1707 | // Downcast can only happen in class hierarchies, so we need classes. |
1708 | if (!DestType->getAs<RecordType>() || !SrcType->getAs<RecordType>()) { |
1709 | return TC_NotApplicable; |
1710 | } |
1711 | |
1712 | CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, |
1713 | /*DetectVirtual=*/true); |
1714 | if (!Self.IsDerivedFrom(Loc: OpRange.getBegin(), Derived: DestType, Base: SrcType, Paths)) { |
1715 | return TC_NotApplicable; |
1716 | } |
1717 | |
1718 | // Target type does derive from source type. Now we're serious. If an error |
1719 | // appears now, it's not ignored. |
1720 | // This may not be entirely in line with the standard. Take for example: |
1721 | // struct A {}; |
1722 | // struct B : virtual A { |
1723 | // B(A&); |
1724 | // }; |
1725 | // |
1726 | // void f() |
1727 | // { |
1728 | // (void)static_cast<const B&>(*((A*)0)); |
1729 | // } |
1730 | // As far as the standard is concerned, p5 does not apply (A is virtual), so |
1731 | // p2 should be used instead - "const B& t(*((A*)0));" is perfectly valid. |
1732 | // However, both GCC and Comeau reject this example, and accepting it would |
1733 | // mean more complex code if we're to preserve the nice error message. |
1734 | // FIXME: Being 100% compliant here would be nice to have. |
1735 | |
1736 | // Must preserve cv, as always, unless we're in C-style mode. |
1737 | if (!CStyle && |
1738 | !DestType.isAtLeastAsQualifiedAs(Other: SrcType, Ctx: Self.getASTContext())) { |
1739 | msg = diag::err_bad_cxx_cast_qualifiers_away; |
1740 | return TC_Failed; |
1741 | } |
1742 | |
1743 | if (Paths.isAmbiguous(BaseType: SrcType.getUnqualifiedType())) { |
1744 | // This code is analoguous to that in CheckDerivedToBaseConversion, except |
1745 | // that it builds the paths in reverse order. |
1746 | // To sum up: record all paths to the base and build a nice string from |
1747 | // them. Use it to spice up the error message. |
1748 | if (!Paths.isRecordingPaths()) { |
1749 | Paths.clear(); |
1750 | Paths.setRecordingPaths(true); |
1751 | Self.IsDerivedFrom(Loc: OpRange.getBegin(), Derived: DestType, Base: SrcType, Paths); |
1752 | } |
1753 | std::string PathDisplayStr; |
1754 | std::set<unsigned> DisplayedPaths; |
1755 | for (clang::CXXBasePath &Path : Paths) { |
1756 | if (DisplayedPaths.insert(x: Path.back().SubobjectNumber).second) { |
1757 | // We haven't displayed a path to this particular base |
1758 | // class subobject yet. |
1759 | PathDisplayStr += "\n "; |
1760 | for (CXXBasePathElement &PE : llvm::reverse(C&: Path)) |
1761 | PathDisplayStr += PE.Base->getType().getAsString() + " -> "; |
1762 | PathDisplayStr += QualType(DestType).getAsString(); |
1763 | } |
1764 | } |
1765 | |
1766 | Self.Diag(OpRange.getBegin(), diag::err_ambiguous_base_to_derived_cast) |
1767 | << QualType(SrcType).getUnqualifiedType() |
1768 | << QualType(DestType).getUnqualifiedType() |
1769 | << PathDisplayStr << OpRange; |
1770 | msg = 0; |
1771 | return TC_Failed; |
1772 | } |
1773 | |
1774 | if (Paths.getDetectedVirtual() != nullptr) { |
1775 | QualType VirtualBase(Paths.getDetectedVirtual(), 0); |
1776 | Self.Diag(OpRange.getBegin(), diag::err_static_downcast_via_virtual) |
1777 | << OrigSrcType << OrigDestType << VirtualBase << OpRange; |
1778 | msg = 0; |
1779 | return TC_Failed; |
1780 | } |
1781 | |
1782 | if (!CStyle) { |
1783 | switch (Self.CheckBaseClassAccess(OpRange.getBegin(), |
1784 | SrcType, DestType, |
1785 | Paths.front(), |
1786 | diag::err_downcast_from_inaccessible_base)) { |
1787 | case Sema::AR_accessible: |
1788 | case Sema::AR_delayed: // be optimistic |
1789 | case Sema::AR_dependent: // be optimistic |
1790 | break; |
1791 | |
1792 | case Sema::AR_inaccessible: |
1793 | msg = 0; |
1794 | return TC_Failed; |
1795 | } |
1796 | } |
1797 | |
1798 | Self.BuildBasePathArray(Paths, BasePath); |
1799 | Kind = CK_BaseToDerived; |
1800 | return TC_Success; |
1801 | } |
1802 | |
1803 | /// TryStaticMemberPointerUpcast - Tests whether a conversion according to |
1804 | /// C++ 5.2.9p9 is valid: |
1805 | /// |
1806 | /// An rvalue of type "pointer to member of D of type cv1 T" can be |
1807 | /// converted to an rvalue of type "pointer to member of B of type cv2 T", |
1808 | /// where B is a base class of D [...]. |
1809 | /// |
1810 | TryCastResult |
1811 | TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType, |
1812 | QualType DestType, bool CStyle, |
1813 | SourceRange OpRange, |
1814 | unsigned &msg, CastKind &Kind, |
1815 | CXXCastPath &BasePath) { |
1816 | const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>(); |
1817 | if (!DestMemPtr) |
1818 | return TC_NotApplicable; |
1819 | |
1820 | bool WasOverloadedFunction = false; |
1821 | DeclAccessPair FoundOverload; |
1822 | if (SrcExpr.get()->getType() == Self.Context.OverloadTy) { |
1823 | if (FunctionDecl *Fn |
1824 | = Self.ResolveAddressOfOverloadedFunction(AddressOfExpr: SrcExpr.get(), TargetType: DestType, Complain: false, |
1825 | Found&: FoundOverload)) { |
1826 | CXXMethodDecl *M = cast<CXXMethodDecl>(Val: Fn); |
1827 | SrcType = Self.Context.getMemberPointerType( |
1828 | T: Fn->getType(), /*Qualifier=*/nullptr, Cls: M->getParent()); |
1829 | WasOverloadedFunction = true; |
1830 | } |
1831 | } |
1832 | |
1833 | switch (Self.CheckMemberPointerConversion( |
1834 | FromType: SrcType, ToPtrType: DestMemPtr, Kind, BasePath, CheckLoc: OpRange.getBegin(), OpRange, IgnoreBaseAccess: CStyle, |
1835 | Direction: Sema::MemberPointerConversionDirection::Upcast)) { |
1836 | case Sema::MemberPointerConversionResult::Success: |
1837 | if (Kind == CK_NullToMemberPointer) { |
1838 | msg = diag::err_bad_static_cast_member_pointer_nonmp; |
1839 | return TC_NotApplicable; |
1840 | } |
1841 | break; |
1842 | case Sema::MemberPointerConversionResult::DifferentPointee: |
1843 | case Sema::MemberPointerConversionResult::NotDerived: |
1844 | return TC_NotApplicable; |
1845 | case Sema::MemberPointerConversionResult::Ambiguous: |
1846 | case Sema::MemberPointerConversionResult::Virtual: |
1847 | case Sema::MemberPointerConversionResult::Inaccessible: |
1848 | msg = 0; |
1849 | return TC_Failed; |
1850 | } |
1851 | |
1852 | if (WasOverloadedFunction) { |
1853 | // Resolve the address of the overloaded function again, this time |
1854 | // allowing complaints if something goes wrong. |
1855 | FunctionDecl *Fn = Self.ResolveAddressOfOverloadedFunction(AddressOfExpr: SrcExpr.get(), |
1856 | TargetType: DestType, |
1857 | Complain: true, |
1858 | Found&: FoundOverload); |
1859 | if (!Fn) { |
1860 | msg = 0; |
1861 | return TC_Failed; |
1862 | } |
1863 | |
1864 | SrcExpr = Self.FixOverloadedFunctionReference(SrcExpr, FoundDecl: FoundOverload, Fn); |
1865 | if (!SrcExpr.isUsable()) { |
1866 | msg = 0; |
1867 | return TC_Failed; |
1868 | } |
1869 | } |
1870 | return TC_Success; |
1871 | } |
1872 | |
1873 | /// TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2 |
1874 | /// is valid: |
1875 | /// |
1876 | /// An expression e can be explicitly converted to a type T using a |
1877 | /// @c static_cast if the declaration "T t(e);" is well-formed [...]. |
1878 | TryCastResult TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, |
1879 | QualType DestType, |
1880 | CheckedConversionKind CCK, |
1881 | SourceRange OpRange, unsigned &msg, |
1882 | CastKind &Kind, bool ListInitialization) { |
1883 | if (DestType->isRecordType()) { |
1884 | if (Self.RequireCompleteType(OpRange.getBegin(), DestType, |
1885 | diag::err_bad_cast_incomplete) || |
1886 | Self.RequireNonAbstractType(OpRange.getBegin(), DestType, |
1887 | diag::err_allocation_of_abstract_type)) { |
1888 | msg = 0; |
1889 | return TC_Failed; |
1890 | } |
1891 | } |
1892 | |
1893 | InitializedEntity Entity = InitializedEntity::InitializeTemporary(Type: DestType); |
1894 | InitializationKind InitKind = |
1895 | (CCK == CheckedConversionKind::CStyleCast) |
1896 | ? InitializationKind::CreateCStyleCast(StartLoc: OpRange.getBegin(), TypeRange: OpRange, |
1897 | InitList: ListInitialization) |
1898 | : (CCK == CheckedConversionKind::FunctionalCast) |
1899 | ? InitializationKind::CreateFunctionalCast(TypeRange: OpRange, |
1900 | InitList: ListInitialization) |
1901 | : InitializationKind::CreateCast(TypeRange: OpRange); |
1902 | Expr *SrcExprRaw = SrcExpr.get(); |
1903 | // FIXME: Per DR242, we should check for an implicit conversion sequence |
1904 | // or for a constructor that could be invoked by direct-initialization |
1905 | // here, not for an initialization sequence. |
1906 | InitializationSequence InitSeq(Self, Entity, InitKind, SrcExprRaw); |
1907 | |
1908 | // At this point of CheckStaticCast, if the destination is a reference, |
1909 | // or the expression is an overload expression this has to work. |
1910 | // There is no other way that works. |
1911 | // On the other hand, if we're checking a C-style cast, we've still got |
1912 | // the reinterpret_cast way. |
1913 | bool CStyle = (CCK == CheckedConversionKind::CStyleCast || |
1914 | CCK == CheckedConversionKind::FunctionalCast); |
1915 | if (InitSeq.Failed() && (CStyle || !DestType->isReferenceType())) |
1916 | return TC_NotApplicable; |
1917 | |
1918 | ExprResult Result = InitSeq.Perform(S&: Self, Entity, Kind: InitKind, Args: SrcExprRaw); |
1919 | if (Result.isInvalid()) { |
1920 | msg = 0; |
1921 | return TC_Failed; |
1922 | } |
1923 | |
1924 | if (InitSeq.isConstructorInitialization()) |
1925 | Kind = CK_ConstructorConversion; |
1926 | else |
1927 | Kind = CK_NoOp; |
1928 | |
1929 | SrcExpr = Result; |
1930 | return TC_Success; |
1931 | } |
1932 | |
1933 | /// TryConstCast - See if a const_cast from source to destination is allowed, |
1934 | /// and perform it if it is. |
1935 | static TryCastResult TryConstCast(Sema &Self, ExprResult &SrcExpr, |
1936 | QualType DestType, bool CStyle, |
1937 | unsigned &msg) { |
1938 | DestType = Self.Context.getCanonicalType(T: DestType); |
1939 | QualType SrcType = SrcExpr.get()->getType(); |
1940 | bool NeedToMaterializeTemporary = false; |
1941 | |
1942 | if (const ReferenceType *DestTypeTmp =DestType->getAs<ReferenceType>()) { |
1943 | // C++11 5.2.11p4: |
1944 | // if a pointer to T1 can be explicitly converted to the type "pointer to |
1945 | // T2" using a const_cast, then the following conversions can also be |
1946 | // made: |
1947 | // -- an lvalue of type T1 can be explicitly converted to an lvalue of |
1948 | // type T2 using the cast const_cast<T2&>; |
1949 | // -- a glvalue of type T1 can be explicitly converted to an xvalue of |
1950 | // type T2 using the cast const_cast<T2&&>; and |
1951 | // -- if T1 is a class type, a prvalue of type T1 can be explicitly |
1952 | // converted to an xvalue of type T2 using the cast const_cast<T2&&>. |
1953 | |
1954 | if (isa<LValueReferenceType>(Val: DestTypeTmp) && !SrcExpr.get()->isLValue()) { |
1955 | // Cannot const_cast non-lvalue to lvalue reference type. But if this |
1956 | // is C-style, static_cast might find a way, so we simply suggest a |
1957 | // message and tell the parent to keep searching. |
1958 | msg = diag::err_bad_cxx_cast_rvalue; |
1959 | return TC_NotApplicable; |
1960 | } |
1961 | |
1962 | if (isa<RValueReferenceType>(Val: DestTypeTmp) && SrcExpr.get()->isPRValue()) { |
1963 | if (!SrcType->isRecordType()) { |
1964 | // Cannot const_cast non-class prvalue to rvalue reference type. But if |
1965 | // this is C-style, static_cast can do this. |
1966 | msg = diag::err_bad_cxx_cast_rvalue; |
1967 | return TC_NotApplicable; |
1968 | } |
1969 | |
1970 | // Materialize the class prvalue so that the const_cast can bind a |
1971 | // reference to it. |
1972 | NeedToMaterializeTemporary = true; |
1973 | } |
1974 | |
1975 | // It's not completely clear under the standard whether we can |
1976 | // const_cast bit-field gl-values. Doing so would not be |
1977 | // intrinsically complicated, but for now, we say no for |
1978 | // consistency with other compilers and await the word of the |
1979 | // committee. |
1980 | if (SrcExpr.get()->refersToBitField()) { |
1981 | msg = diag::err_bad_cxx_cast_bitfield; |
1982 | return TC_NotApplicable; |
1983 | } |
1984 | |
1985 | DestType = Self.Context.getPointerType(T: DestTypeTmp->getPointeeType()); |
1986 | SrcType = Self.Context.getPointerType(T: SrcType); |
1987 | } |
1988 | |
1989 | // C++ 5.2.11p5: For a const_cast involving pointers to data members [...] |
1990 | // the rules for const_cast are the same as those used for pointers. |
1991 | |
1992 | if (!DestType->isPointerType() && |
1993 | !DestType->isMemberPointerType() && |
1994 | !DestType->isObjCObjectPointerType()) { |
1995 | // Cannot cast to non-pointer, non-reference type. Note that, if DestType |
1996 | // was a reference type, we converted it to a pointer above. |
1997 | // The status of rvalue references isn't entirely clear, but it looks like |
1998 | // conversion to them is simply invalid. |
1999 | // C++ 5.2.11p3: For two pointer types [...] |
2000 | if (!CStyle) |
2001 | msg = diag::err_bad_const_cast_dest; |
2002 | return TC_NotApplicable; |
2003 | } |
2004 | if (DestType->isFunctionPointerType() || |
2005 | DestType->isMemberFunctionPointerType()) { |
2006 | // Cannot cast direct function pointers. |
2007 | // C++ 5.2.11p2: [...] where T is any object type or the void type [...] |
2008 | // T is the ultimate pointee of source and target type. |
2009 | if (!CStyle) |
2010 | msg = diag::err_bad_const_cast_dest; |
2011 | return TC_NotApplicable; |
2012 | } |
2013 | |
2014 | // C++ [expr.const.cast]p3: |
2015 | // "For two similar types T1 and T2, [...]" |
2016 | // |
2017 | // We only allow a const_cast to change cvr-qualifiers, not other kinds of |
2018 | // type qualifiers. (Likewise, we ignore other changes when determining |
2019 | // whether a cast casts away constness.) |
2020 | if (!Self.Context.hasCvrSimilarType(T1: SrcType, T2: DestType)) |
2021 | return TC_NotApplicable; |
2022 | |
2023 | if (NeedToMaterializeTemporary) |
2024 | // This is a const_cast from a class prvalue to an rvalue reference type. |
2025 | // Materialize a temporary to store the result of the conversion. |
2026 | SrcExpr = Self.CreateMaterializeTemporaryExpr(T: SrcExpr.get()->getType(), |
2027 | Temporary: SrcExpr.get(), |
2028 | /*IsLValueReference*/ BoundToLvalueReference: false); |
2029 | |
2030 | return TC_Success; |
2031 | } |
2032 | |
2033 | // Checks for undefined behavior in reinterpret_cast. |
2034 | // The cases that is checked for is: |
2035 | // *reinterpret_cast<T*>(&a) |
2036 | // reinterpret_cast<T&>(a) |
2037 | // where accessing 'a' as type 'T' will result in undefined behavior. |
2038 | void Sema::CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType, |
2039 | bool IsDereference, |
2040 | SourceRange Range) { |
2041 | unsigned DiagID = IsDereference ? |
2042 | diag::warn_pointer_indirection_from_incompatible_type : |
2043 | diag::warn_undefined_reinterpret_cast; |
2044 | |
2045 | if (Diags.isIgnored(DiagID, Loc: Range.getBegin())) |
2046 | return; |
2047 | |
2048 | QualType SrcTy, DestTy; |
2049 | if (IsDereference) { |
2050 | if (!SrcType->getAs<PointerType>() || !DestType->getAs<PointerType>()) { |
2051 | return; |
2052 | } |
2053 | SrcTy = SrcType->getPointeeType(); |
2054 | DestTy = DestType->getPointeeType(); |
2055 | } else { |
2056 | if (!DestType->getAs<ReferenceType>()) { |
2057 | return; |
2058 | } |
2059 | SrcTy = SrcType; |
2060 | DestTy = DestType->getPointeeType(); |
2061 | } |
2062 | |
2063 | // Cast is compatible if the types are the same. |
2064 | if (Context.hasSameUnqualifiedType(T1: DestTy, T2: SrcTy)) { |
2065 | return; |
2066 | } |
2067 | // or one of the types is a char or void type |
2068 | if (DestTy->isAnyCharacterType() || DestTy->isVoidType() || |
2069 | SrcTy->isAnyCharacterType() || SrcTy->isVoidType()) { |
2070 | return; |
2071 | } |
2072 | // or one of the types is a tag type. |
2073 | if (SrcTy->getAs<TagType>() || DestTy->getAs<TagType>()) { |
2074 | return; |
2075 | } |
2076 | |
2077 | // FIXME: Scoped enums? |
2078 | if ((SrcTy->isUnsignedIntegerType() && DestTy->isSignedIntegerType()) || |
2079 | (SrcTy->isSignedIntegerType() && DestTy->isUnsignedIntegerType())) { |
2080 | if (Context.getTypeSize(T: DestTy) == Context.getTypeSize(T: SrcTy)) { |
2081 | return; |
2082 | } |
2083 | } |
2084 | |
2085 | if (SrcTy->isDependentType() || DestTy->isDependentType()) { |
2086 | return; |
2087 | } |
2088 | |
2089 | Diag(Range.getBegin(), DiagID) << SrcType << DestType << Range; |
2090 | } |
2091 | |
2092 | static void DiagnoseCastOfObjCSEL(Sema &Self, const ExprResult &SrcExpr, |
2093 | QualType DestType) { |
2094 | QualType SrcType = SrcExpr.get()->getType(); |
2095 | if (Self.Context.hasSameType(T1: SrcType, T2: DestType)) |
2096 | return; |
2097 | if (const PointerType *SrcPtrTy = SrcType->getAs<PointerType>()) |
2098 | if (SrcPtrTy->isObjCSelType()) { |
2099 | QualType DT = DestType; |
2100 | if (isa<PointerType>(Val: DestType)) |
2101 | DT = DestType->getPointeeType(); |
2102 | if (!DT.getUnqualifiedType()->isVoidType()) |
2103 | Self.Diag(SrcExpr.get()->getExprLoc(), |
2104 | diag::warn_cast_pointer_from_sel) |
2105 | << SrcType << DestType << SrcExpr.get()->getSourceRange(); |
2106 | } |
2107 | } |
2108 | |
2109 | /// Diagnose casts that change the calling convention of a pointer to a function |
2110 | /// defined in the current TU. |
2111 | static void DiagnoseCallingConvCast(Sema &Self, const ExprResult &SrcExpr, |
2112 | QualType DstType, SourceRange OpRange) { |
2113 | // Check if this cast would change the calling convention of a function |
2114 | // pointer type. |
2115 | QualType SrcType = SrcExpr.get()->getType(); |
2116 | if (Self.Context.hasSameType(T1: SrcType, T2: DstType) || |
2117 | !SrcType->isFunctionPointerType() || !DstType->isFunctionPointerType()) |
2118 | return; |
2119 | const auto *SrcFTy = |
2120 | SrcType->castAs<PointerType>()->getPointeeType()->castAs<FunctionType>(); |
2121 | const auto *DstFTy = |
2122 | DstType->castAs<PointerType>()->getPointeeType()->castAs<FunctionType>(); |
2123 | CallingConv SrcCC = SrcFTy->getCallConv(); |
2124 | CallingConv DstCC = DstFTy->getCallConv(); |
2125 | if (SrcCC == DstCC) |
2126 | return; |
2127 | |
2128 | // We have a calling convention cast. Check if the source is a pointer to a |
2129 | // known, specific function that has already been defined. |
2130 | Expr *Src = SrcExpr.get()->IgnoreParenImpCasts(); |
2131 | if (auto *UO = dyn_cast<UnaryOperator>(Val: Src)) |
2132 | if (UO->getOpcode() == UO_AddrOf) |
2133 | Src = UO->getSubExpr()->IgnoreParenImpCasts(); |
2134 | auto *DRE = dyn_cast<DeclRefExpr>(Val: Src); |
2135 | if (!DRE) |
2136 | return; |
2137 | auto *FD = dyn_cast<FunctionDecl>(Val: DRE->getDecl()); |
2138 | if (!FD) |
2139 | return; |
2140 | |
2141 | // Only warn if we are casting from the default convention to a non-default |
2142 | // convention. This can happen when the programmer forgot to apply the calling |
2143 | // convention to the function declaration and then inserted this cast to |
2144 | // satisfy the type system. |
2145 | CallingConv DefaultCC = Self.getASTContext().getDefaultCallingConvention( |
2146 | IsVariadic: FD->isVariadic(), IsCXXMethod: FD->isCXXInstanceMember()); |
2147 | if (DstCC == DefaultCC || SrcCC != DefaultCC) |
2148 | return; |
2149 | |
2150 | // Diagnose this cast, as it is probably bad. |
2151 | StringRef SrcCCName = FunctionType::getNameForCallConv(CC: SrcCC); |
2152 | StringRef DstCCName = FunctionType::getNameForCallConv(CC: DstCC); |
2153 | Self.Diag(OpRange.getBegin(), diag::warn_cast_calling_conv) |
2154 | << SrcCCName << DstCCName << OpRange; |
2155 | |
2156 | // The checks above are cheaper than checking if the diagnostic is enabled. |
2157 | // However, it's worth checking if the warning is enabled before we construct |
2158 | // a fixit. |
2159 | if (Self.Diags.isIgnored(diag::warn_cast_calling_conv, OpRange.getBegin())) |
2160 | return; |
2161 | |
2162 | // Try to suggest a fixit to change the calling convention of the function |
2163 | // whose address was taken. Try to use the latest macro for the convention. |
2164 | // For example, users probably want to write "WINAPI" instead of "__stdcall" |
2165 | // to match the Windows header declarations. |
2166 | SourceLocation NameLoc = FD->getFirstDecl()->getNameInfo().getLoc(); |
2167 | Preprocessor &PP = Self.getPreprocessor(); |
2168 | SmallVector<TokenValue, 6> AttrTokens; |
2169 | SmallString<64> CCAttrText; |
2170 | llvm::raw_svector_ostream OS(CCAttrText); |
2171 | if (Self.getLangOpts().MicrosoftExt) { |
2172 | // __stdcall or __vectorcall |
2173 | OS << "__"<< DstCCName; |
2174 | IdentifierInfo *II = PP.getIdentifierInfo(Name: OS.str()); |
2175 | AttrTokens.push_back(Elt: II->isKeyword(LangOpts: Self.getLangOpts()) |
2176 | ? TokenValue(II->getTokenID()) |
2177 | : TokenValue(II)); |
2178 | } else { |
2179 | // __attribute__((stdcall)) or __attribute__((vectorcall)) |
2180 | OS << "__attribute__(("<< DstCCName << "))"; |
2181 | AttrTokens.push_back(Elt: tok::kw___attribute); |
2182 | AttrTokens.push_back(Elt: tok::l_paren); |
2183 | AttrTokens.push_back(Elt: tok::l_paren); |
2184 | IdentifierInfo *II = PP.getIdentifierInfo(Name: DstCCName); |
2185 | AttrTokens.push_back(Elt: II->isKeyword(LangOpts: Self.getLangOpts()) |
2186 | ? TokenValue(II->getTokenID()) |
2187 | : TokenValue(II)); |
2188 | AttrTokens.push_back(Elt: tok::r_paren); |
2189 | AttrTokens.push_back(Elt: tok::r_paren); |
2190 | } |
2191 | StringRef AttrSpelling = PP.getLastMacroWithSpelling(Loc: NameLoc, Tokens: AttrTokens); |
2192 | if (!AttrSpelling.empty()) |
2193 | CCAttrText = AttrSpelling; |
2194 | OS << ' '; |
2195 | Self.Diag(NameLoc, diag::note_change_calling_conv_fixit) |
2196 | << FD << DstCCName << FixItHint::CreateInsertion(NameLoc, CCAttrText); |
2197 | } |
2198 | |
2199 | static void checkIntToPointerCast(bool CStyle, const SourceRange &OpRange, |
2200 | const Expr *SrcExpr, QualType DestType, |
2201 | Sema &Self) { |
2202 | QualType SrcType = SrcExpr->getType(); |
2203 | |
2204 | // Not warning on reinterpret_cast, boolean, constant expressions, etc |
2205 | // are not explicit design choices, but consistent with GCC's behavior. |
2206 | // Feel free to modify them if you've reason/evidence for an alternative. |
2207 | if (CStyle && SrcType->isIntegralType(Ctx: Self.Context) |
2208 | && !SrcType->isBooleanType() |
2209 | && !SrcType->isEnumeralType() |
2210 | && !SrcExpr->isIntegerConstantExpr(Ctx: Self.Context) |
2211 | && Self.Context.getTypeSize(T: DestType) > |
2212 | Self.Context.getTypeSize(T: SrcType)) { |
2213 | // Separate between casts to void* and non-void* pointers. |
2214 | // Some APIs use (abuse) void* for something like a user context, |
2215 | // and often that value is an integer even if it isn't a pointer itself. |
2216 | // Having a separate warning flag allows users to control the warning |
2217 | // for their workflow. |
2218 | unsigned Diag = DestType->isVoidPointerType() ? |
2219 | diag::warn_int_to_void_pointer_cast |
2220 | : diag::warn_int_to_pointer_cast; |
2221 | Self.Diag(OpRange.getBegin(), Diag) << SrcType << DestType << OpRange; |
2222 | } |
2223 | } |
2224 | |
2225 | static bool fixOverloadedReinterpretCastExpr(Sema &Self, QualType DestType, |
2226 | ExprResult &Result) { |
2227 | // We can only fix an overloaded reinterpret_cast if |
2228 | // - it is a template with explicit arguments that resolves to an lvalue |
2229 | // unambiguously, or |
2230 | // - it is the only function in an overload set that may have its address |
2231 | // taken. |
2232 | |
2233 | Expr *E = Result.get(); |
2234 | // TODO: what if this fails because of DiagnoseUseOfDecl or something |
2235 | // like it? |
2236 | if (Self.ResolveAndFixSingleFunctionTemplateSpecialization( |
2237 | SrcExpr&: Result, |
2238 | DoFunctionPointerConversion: Expr::getValueKindForType(T: DestType) == |
2239 | VK_PRValue // Convert Fun to Ptr |
2240 | ) && |
2241 | Result.isUsable()) |
2242 | return true; |
2243 | |
2244 | // No guarantees that ResolveAndFixSingleFunctionTemplateSpecialization |
2245 | // preserves Result. |
2246 | Result = E; |
2247 | if (!Self.resolveAndFixAddressOfSingleOverloadCandidate( |
2248 | SrcExpr&: Result, /*DoFunctionPointerConversion=*/true)) |
2249 | return false; |
2250 | return Result.isUsable(); |
2251 | } |
2252 | |
2253 | static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr, |
2254 | QualType DestType, bool CStyle, |
2255 | SourceRange OpRange, |
2256 | unsigned &msg, |
2257 | CastKind &Kind) { |
2258 | bool IsLValueCast = false; |
2259 | |
2260 | DestType = Self.Context.getCanonicalType(T: DestType); |
2261 | QualType SrcType = SrcExpr.get()->getType(); |
2262 | |
2263 | // Is the source an overloaded name? (i.e. &foo) |
2264 | // If so, reinterpret_cast generally can not help us here (13.4, p1, bullet 5) |
2265 | if (SrcType == Self.Context.OverloadTy) { |
2266 | ExprResult FixedExpr = SrcExpr; |
2267 | if (!fixOverloadedReinterpretCastExpr(Self, DestType, Result&: FixedExpr)) |
2268 | return TC_NotApplicable; |
2269 | |
2270 | assert(FixedExpr.isUsable() && "Invalid result fixing overloaded expr"); |
2271 | SrcExpr = FixedExpr; |
2272 | SrcType = SrcExpr.get()->getType(); |
2273 | } |
2274 | |
2275 | if (const ReferenceType *DestTypeTmp = DestType->getAs<ReferenceType>()) { |
2276 | if (!SrcExpr.get()->isGLValue()) { |
2277 | // Cannot cast non-glvalue to (lvalue or rvalue) reference type. See the |
2278 | // similar comment in const_cast. |
2279 | msg = diag::err_bad_cxx_cast_rvalue; |
2280 | return TC_NotApplicable; |
2281 | } |
2282 | |
2283 | if (!CStyle) { |
2284 | Self.CheckCompatibleReinterpretCast(SrcType, DestType, |
2285 | /*IsDereference=*/false, Range: OpRange); |
2286 | } |
2287 | |
2288 | // C++ 5.2.10p10: [...] a reference cast reinterpret_cast<T&>(x) has the |
2289 | // same effect as the conversion *reinterpret_cast<T*>(&x) with the |
2290 | // built-in & and * operators. |
2291 | |
2292 | const char *inappropriate = nullptr; |
2293 | switch (SrcExpr.get()->getObjectKind()) { |
2294 | case OK_Ordinary: |
2295 | break; |
2296 | case OK_BitField: |
2297 | msg = diag::err_bad_cxx_cast_bitfield; |
2298 | return TC_NotApplicable; |
2299 | // FIXME: Use a specific diagnostic for the rest of these cases. |
2300 | case OK_VectorComponent: inappropriate = "vector element"; break; |
2301 | case OK_MatrixComponent: |
2302 | inappropriate = "matrix element"; |
2303 | break; |
2304 | case OK_ObjCProperty: inappropriate = "property expression"; break; |
2305 | case OK_ObjCSubscript: inappropriate = "container subscripting expression"; |
2306 | break; |
2307 | } |
2308 | if (inappropriate) { |
2309 | Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_reference) |
2310 | << inappropriate << DestType |
2311 | << OpRange << SrcExpr.get()->getSourceRange(); |
2312 | msg = 0; SrcExpr = ExprError(); |
2313 | return TC_NotApplicable; |
2314 | } |
2315 | |
2316 | // This code does this transformation for the checked types. |
2317 | DestType = Self.Context.getPointerType(T: DestTypeTmp->getPointeeType()); |
2318 | SrcType = Self.Context.getPointerType(T: SrcType); |
2319 | |
2320 | IsLValueCast = true; |
2321 | } |
2322 | |
2323 | // Canonicalize source for comparison. |
2324 | SrcType = Self.Context.getCanonicalType(T: SrcType); |
2325 | |
2326 | const MemberPointerType *DestMemPtr = DestType->getAs<MemberPointerType>(), |
2327 | *SrcMemPtr = SrcType->getAs<MemberPointerType>(); |
2328 | if (DestMemPtr && SrcMemPtr) { |
2329 | // C++ 5.2.10p9: An rvalue of type "pointer to member of X of type T1" |
2330 | // can be explicitly converted to an rvalue of type "pointer to member |
2331 | // of Y of type T2" if T1 and T2 are both function types or both object |
2332 | // types. |
2333 | if (DestMemPtr->isMemberFunctionPointer() != |
2334 | SrcMemPtr->isMemberFunctionPointer()) |
2335 | return TC_NotApplicable; |
2336 | |
2337 | if (Self.Context.getTargetInfo().getCXXABI().isMicrosoft()) { |
2338 | // We need to determine the inheritance model that the class will use if |
2339 | // haven't yet. |
2340 | (void)Self.isCompleteType(Loc: OpRange.getBegin(), T: SrcType); |
2341 | (void)Self.isCompleteType(Loc: OpRange.getBegin(), T: DestType); |
2342 | } |
2343 | |
2344 | // Don't allow casting between member pointers of different sizes. |
2345 | if (Self.Context.getTypeSize(DestMemPtr) != |
2346 | Self.Context.getTypeSize(SrcMemPtr)) { |
2347 | msg = diag::err_bad_cxx_cast_member_pointer_size; |
2348 | return TC_Failed; |
2349 | } |
2350 | |
2351 | // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away |
2352 | // constness. |
2353 | // A reinterpret_cast followed by a const_cast can, though, so in C-style, |
2354 | // we accept it. |
2355 | if (auto CACK = |
2356 | CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle, |
2357 | /*CheckObjCLifetime=*/CStyle)) |
2358 | return getCastAwayConstnessCastKind(CACK, DiagID&: msg); |
2359 | |
2360 | // A valid member pointer cast. |
2361 | assert(!IsLValueCast); |
2362 | Kind = CK_ReinterpretMemberPointer; |
2363 | return TC_Success; |
2364 | } |
2365 | |
2366 | // See below for the enumeral issue. |
2367 | if (SrcType->isNullPtrType() && DestType->isIntegralType(Ctx: Self.Context)) { |
2368 | // C++0x 5.2.10p4: A pointer can be explicitly converted to any integral |
2369 | // type large enough to hold it. A value of std::nullptr_t can be |
2370 | // converted to an integral type; the conversion has the same meaning |
2371 | // and validity as a conversion of (void*)0 to the integral type. |
2372 | if (Self.Context.getTypeSize(T: SrcType) > |
2373 | Self.Context.getTypeSize(T: DestType)) { |
2374 | msg = diag::err_bad_reinterpret_cast_small_int; |
2375 | return TC_Failed; |
2376 | } |
2377 | Kind = CK_PointerToIntegral; |
2378 | return TC_Success; |
2379 | } |
2380 | |
2381 | // Allow reinterpret_casts between vectors of the same size and |
2382 | // between vectors and integers of the same size. |
2383 | bool destIsVector = DestType->isVectorType(); |
2384 | bool srcIsVector = SrcType->isVectorType(); |
2385 | if (srcIsVector || destIsVector) { |
2386 | // Allow bitcasting between SVE VLATs and VLSTs, and vice-versa. |
2387 | if (Self.isValidSveBitcast(srcType: SrcType, destType: DestType)) { |
2388 | Kind = CK_BitCast; |
2389 | return TC_Success; |
2390 | } |
2391 | |
2392 | // Allow bitcasting between SVE VLATs and VLSTs, and vice-versa. |
2393 | if (Self.RISCV().isValidRVVBitcast(srcType: SrcType, destType: DestType)) { |
2394 | Kind = CK_BitCast; |
2395 | return TC_Success; |
2396 | } |
2397 | |
2398 | // The non-vector type, if any, must have integral type. This is |
2399 | // the same rule that C vector casts use; note, however, that enum |
2400 | // types are not integral in C++. |
2401 | if ((!destIsVector && !DestType->isIntegralType(Ctx: Self.Context)) || |
2402 | (!srcIsVector && !SrcType->isIntegralType(Ctx: Self.Context))) |
2403 | return TC_NotApplicable; |
2404 | |
2405 | // The size we want to consider is eltCount * eltSize. |
2406 | // That's exactly what the lax-conversion rules will check. |
2407 | if (Self.areLaxCompatibleVectorTypes(srcType: SrcType, destType: DestType)) { |
2408 | Kind = CK_BitCast; |
2409 | return TC_Success; |
2410 | } |
2411 | |
2412 | if (Self.LangOpts.OpenCL && !CStyle) { |
2413 | if (DestType->isExtVectorType() || SrcType->isExtVectorType()) { |
2414 | // FIXME: Allow for reinterpret cast between 3 and 4 element vectors |
2415 | if (Self.areVectorTypesSameSize(srcType: SrcType, destType: DestType)) { |
2416 | Kind = CK_BitCast; |
2417 | return TC_Success; |
2418 | } |
2419 | } |
2420 | } |
2421 | |
2422 | // Otherwise, pick a reasonable diagnostic. |
2423 | if (!destIsVector) |
2424 | msg = diag::err_bad_cxx_cast_vector_to_scalar_different_size; |
2425 | else if (!srcIsVector) |
2426 | msg = diag::err_bad_cxx_cast_scalar_to_vector_different_size; |
2427 | else |
2428 | msg = diag::err_bad_cxx_cast_vector_to_vector_different_size; |
2429 | |
2430 | return TC_Failed; |
2431 | } |
2432 | |
2433 | if (SrcType == DestType) { |
2434 | // C++ 5.2.10p2 has a note that mentions that, subject to all other |
2435 | // restrictions, a cast to the same type is allowed so long as it does not |
2436 | // cast away constness. In C++98, the intent was not entirely clear here, |
2437 | // since all other paragraphs explicitly forbid casts to the same type. |
2438 | // C++11 clarifies this case with p2. |
2439 | // |
2440 | // The only allowed types are: integral, enumeration, pointer, or |
2441 | // pointer-to-member types. We also won't restrict Obj-C pointers either. |
2442 | Kind = CK_NoOp; |
2443 | TryCastResult Result = TC_NotApplicable; |
2444 | if (SrcType->isIntegralOrEnumerationType() || |
2445 | SrcType->isAnyPointerType() || |
2446 | SrcType->isMemberPointerType() || |
2447 | SrcType->isBlockPointerType()) { |
2448 | Result = TC_Success; |
2449 | } |
2450 | return Result; |
2451 | } |
2452 | |
2453 | bool destIsPtr = DestType->isAnyPointerType() || |
2454 | DestType->isBlockPointerType(); |
2455 | bool srcIsPtr = SrcType->isAnyPointerType() || |
2456 | SrcType->isBlockPointerType(); |
2457 | if (!destIsPtr && !srcIsPtr) { |
2458 | // Except for std::nullptr_t->integer and lvalue->reference, which are |
2459 | // handled above, at least one of the two arguments must be a pointer. |
2460 | return TC_NotApplicable; |
2461 | } |
2462 | |
2463 | if (DestType->isIntegralType(Ctx: Self.Context)) { |
2464 | assert(srcIsPtr && "One type must be a pointer"); |
2465 | // C++ 5.2.10p4: A pointer can be explicitly converted to any integral |
2466 | // type large enough to hold it; except in Microsoft mode, where the |
2467 | // integral type size doesn't matter (except we don't allow bool). |
2468 | if ((Self.Context.getTypeSize(T: SrcType) > |
2469 | Self.Context.getTypeSize(T: DestType))) { |
2470 | bool MicrosoftException = |
2471 | Self.getLangOpts().MicrosoftExt && !DestType->isBooleanType(); |
2472 | if (MicrosoftException) { |
2473 | unsigned Diag = SrcType->isVoidPointerType() |
2474 | ? diag::warn_void_pointer_to_int_cast |
2475 | : diag::warn_pointer_to_int_cast; |
2476 | Self.Diag(OpRange.getBegin(), Diag) << SrcType << DestType << OpRange; |
2477 | } else { |
2478 | msg = diag::err_bad_reinterpret_cast_small_int; |
2479 | return TC_Failed; |
2480 | } |
2481 | } |
2482 | Kind = CK_PointerToIntegral; |
2483 | return TC_Success; |
2484 | } |
2485 | |
2486 | if (SrcType->isIntegralOrEnumerationType()) { |
2487 | assert(destIsPtr && "One type must be a pointer"); |
2488 | checkIntToPointerCast(CStyle, OpRange, SrcExpr: SrcExpr.get(), DestType, Self); |
2489 | // C++ 5.2.10p5: A value of integral or enumeration type can be explicitly |
2490 | // converted to a pointer. |
2491 | // C++ 5.2.10p9: [Note: ...a null pointer constant of integral type is not |
2492 | // necessarily converted to a null pointer value.] |
2493 | Kind = CK_IntegralToPointer; |
2494 | return TC_Success; |
2495 | } |
2496 | |
2497 | if (!destIsPtr || !srcIsPtr) { |
2498 | // With the valid non-pointer conversions out of the way, we can be even |
2499 | // more stringent. |
2500 | return TC_NotApplicable; |
2501 | } |
2502 | |
2503 | // Cannot convert between block pointers and Objective-C object pointers. |
2504 | if ((SrcType->isBlockPointerType() && DestType->isObjCObjectPointerType()) || |
2505 | (DestType->isBlockPointerType() && SrcType->isObjCObjectPointerType())) |
2506 | return TC_NotApplicable; |
2507 | |
2508 | // C++ 5.2.10p2: The reinterpret_cast operator shall not cast away constness. |
2509 | // The C-style cast operator can. |
2510 | TryCastResult SuccessResult = TC_Success; |
2511 | if (auto CACK = |
2512 | CastsAwayConstness(Self, SrcType, DestType, /*CheckCVR=*/!CStyle, |
2513 | /*CheckObjCLifetime=*/CStyle)) |
2514 | SuccessResult = getCastAwayConstnessCastKind(CACK, DiagID&: msg); |
2515 | |
2516 | if (IsAddressSpaceConversion(SrcType, DestType)) { |
2517 | Kind = CK_AddressSpaceConversion; |
2518 | assert(SrcType->isPointerType() && DestType->isPointerType()); |
2519 | if (!CStyle && |
2520 | !DestType->getPointeeType().getQualifiers().isAddressSpaceSupersetOf( |
2521 | other: SrcType->getPointeeType().getQualifiers(), Ctx: Self.getASTContext())) { |
2522 | SuccessResult = TC_Failed; |
2523 | } |
2524 | } else if (IsLValueCast) { |
2525 | Kind = CK_LValueBitCast; |
2526 | } else if (DestType->isObjCObjectPointerType()) { |
2527 | Kind = Self.ObjC().PrepareCastToObjCObjectPointer(E&: SrcExpr); |
2528 | } else if (DestType->isBlockPointerType()) { |
2529 | if (!SrcType->isBlockPointerType()) { |
2530 | Kind = CK_AnyPointerToBlockPointerCast; |
2531 | } else { |
2532 | Kind = CK_BitCast; |
2533 | } |
2534 | } else { |
2535 | Kind = CK_BitCast; |
2536 | } |
2537 | |
2538 | // Any pointer can be cast to an Objective-C pointer type with a C-style |
2539 | // cast. |
2540 | if (CStyle && DestType->isObjCObjectPointerType()) { |
2541 | return SuccessResult; |
2542 | } |
2543 | if (CStyle) |
2544 | DiagnoseCastOfObjCSEL(Self, SrcExpr, DestType); |
2545 | |
2546 | DiagnoseCallingConvCast(Self, SrcExpr, DstType: DestType, OpRange); |
2547 | |
2548 | // Not casting away constness, so the only remaining check is for compatible |
2549 | // pointer categories. |
2550 | |
2551 | if (SrcType->isFunctionPointerType()) { |
2552 | if (DestType->isFunctionPointerType()) { |
2553 | // C++ 5.2.10p6: A pointer to a function can be explicitly converted to |
2554 | // a pointer to a function of a different type. |
2555 | return SuccessResult; |
2556 | } |
2557 | |
2558 | // C++0x 5.2.10p8: Converting a pointer to a function into a pointer to |
2559 | // an object type or vice versa is conditionally-supported. |
2560 | // Compilers support it in C++03 too, though, because it's necessary for |
2561 | // casting the return value of dlsym() and GetProcAddress(). |
2562 | // FIXME: Conditionally-supported behavior should be configurable in the |
2563 | // TargetInfo or similar. |
2564 | Self.Diag(OpRange.getBegin(), |
2565 | Self.getLangOpts().CPlusPlus11 ? |
2566 | diag::warn_cxx98_compat_cast_fn_obj : diag::ext_cast_fn_obj) |
2567 | << OpRange; |
2568 | return SuccessResult; |
2569 | } |
2570 | |
2571 | if (DestType->isFunctionPointerType()) { |
2572 | // See above. |
2573 | Self.Diag(OpRange.getBegin(), |
2574 | Self.getLangOpts().CPlusPlus11 ? |
2575 | diag::warn_cxx98_compat_cast_fn_obj : diag::ext_cast_fn_obj) |
2576 | << OpRange; |
2577 | return SuccessResult; |
2578 | } |
2579 | |
2580 | // Diagnose address space conversion in nested pointers. |
2581 | QualType DestPtee = DestType->getPointeeType().isNull() |
2582 | ? DestType->getPointeeType() |
2583 | : DestType->getPointeeType()->getPointeeType(); |
2584 | QualType SrcPtee = SrcType->getPointeeType().isNull() |
2585 | ? SrcType->getPointeeType() |
2586 | : SrcType->getPointeeType()->getPointeeType(); |
2587 | while (!DestPtee.isNull() && !SrcPtee.isNull()) { |
2588 | if (DestPtee.getAddressSpace() != SrcPtee.getAddressSpace()) { |
2589 | Self.Diag(OpRange.getBegin(), |
2590 | diag::warn_bad_cxx_cast_nested_pointer_addr_space) |
2591 | << CStyle << SrcType << DestType << SrcExpr.get()->getSourceRange(); |
2592 | break; |
2593 | } |
2594 | DestPtee = DestPtee->getPointeeType(); |
2595 | SrcPtee = SrcPtee->getPointeeType(); |
2596 | } |
2597 | |
2598 | // C++ 5.2.10p7: A pointer to an object can be explicitly converted to |
2599 | // a pointer to an object of different type. |
2600 | // Void pointers are not specified, but supported by every compiler out there. |
2601 | // So we finish by allowing everything that remains - it's got to be two |
2602 | // object pointers. |
2603 | return SuccessResult; |
2604 | } |
2605 | |
2606 | static TryCastResult TryAddressSpaceCast(Sema &Self, ExprResult &SrcExpr, |
2607 | QualType DestType, bool CStyle, |
2608 | unsigned &msg, CastKind &Kind) { |
2609 | if (!Self.getLangOpts().OpenCL && !Self.getLangOpts().SYCLIsDevice) |
2610 | // FIXME: As compiler doesn't have any information about overlapping addr |
2611 | // spaces at the moment we have to be permissive here. |
2612 | return TC_NotApplicable; |
2613 | // Even though the logic below is general enough and can be applied to |
2614 | // non-OpenCL mode too, we fast-path above because no other languages |
2615 | // define overlapping address spaces currently. |
2616 | auto SrcType = SrcExpr.get()->getType(); |
2617 | // FIXME: Should this be generalized to references? The reference parameter |
2618 | // however becomes a reference pointee type here and therefore rejected. |
2619 | // Perhaps this is the right behavior though according to C++. |
2620 | auto SrcPtrType = SrcType->getAs<PointerType>(); |
2621 | if (!SrcPtrType) |
2622 | return TC_NotApplicable; |
2623 | auto DestPtrType = DestType->getAs<PointerType>(); |
2624 | if (!DestPtrType) |
2625 | return TC_NotApplicable; |
2626 | auto SrcPointeeType = SrcPtrType->getPointeeType(); |
2627 | auto DestPointeeType = DestPtrType->getPointeeType(); |
2628 | if (!DestPointeeType.isAddressSpaceOverlapping(T: SrcPointeeType, |
2629 | Ctx: Self.getASTContext())) { |
2630 | msg = diag::err_bad_cxx_cast_addr_space_mismatch; |
2631 | return TC_Failed; |
2632 | } |
2633 | auto SrcPointeeTypeWithoutAS = |
2634 | Self.Context.removeAddrSpaceQualType(T: SrcPointeeType.getCanonicalType()); |
2635 | auto DestPointeeTypeWithoutAS = |
2636 | Self.Context.removeAddrSpaceQualType(T: DestPointeeType.getCanonicalType()); |
2637 | if (Self.Context.hasSameType(T1: SrcPointeeTypeWithoutAS, |
2638 | T2: DestPointeeTypeWithoutAS)) { |
2639 | Kind = SrcPointeeType.getAddressSpace() == DestPointeeType.getAddressSpace() |
2640 | ? CK_NoOp |
2641 | : CK_AddressSpaceConversion; |
2642 | return TC_Success; |
2643 | } else { |
2644 | return TC_NotApplicable; |
2645 | } |
2646 | } |
2647 | |
2648 | void CastOperation::checkAddressSpaceCast(QualType SrcType, QualType DestType) { |
2649 | // In OpenCL only conversions between pointers to objects in overlapping |
2650 | // addr spaces are allowed. v2.0 s6.5.5 - Generic addr space overlaps |
2651 | // with any named one, except for constant. |
2652 | |
2653 | // Converting the top level pointee addrspace is permitted for compatible |
2654 | // addrspaces (such as 'generic int *' to 'local int *' or vice versa), but |
2655 | // if any of the nested pointee addrspaces differ, we emit a warning |
2656 | // regardless of addrspace compatibility. This makes |
2657 | // local int ** p; |
2658 | // return (generic int **) p; |
2659 | // warn even though local -> generic is permitted. |
2660 | if (Self.getLangOpts().OpenCL) { |
2661 | const Type *DestPtr, *SrcPtr; |
2662 | bool Nested = false; |
2663 | unsigned DiagID = diag::err_typecheck_incompatible_address_space; |
2664 | DestPtr = Self.getASTContext().getCanonicalType(T: DestType.getTypePtr()), |
2665 | SrcPtr = Self.getASTContext().getCanonicalType(T: SrcType.getTypePtr()); |
2666 | |
2667 | while (isa<PointerType>(Val: DestPtr) && isa<PointerType>(Val: SrcPtr)) { |
2668 | const PointerType *DestPPtr = cast<PointerType>(Val: DestPtr); |
2669 | const PointerType *SrcPPtr = cast<PointerType>(Val: SrcPtr); |
2670 | QualType DestPPointee = DestPPtr->getPointeeType(); |
2671 | QualType SrcPPointee = SrcPPtr->getPointeeType(); |
2672 | if (Nested |
2673 | ? DestPPointee.getAddressSpace() != SrcPPointee.getAddressSpace() |
2674 | : !DestPPointee.isAddressSpaceOverlapping(T: SrcPPointee, |
2675 | Ctx: Self.getASTContext())) { |
2676 | Self.Diag(OpRange.getBegin(), DiagID) |
2677 | << SrcType << DestType << AssignmentAction::Casting |
2678 | << SrcExpr.get()->getSourceRange(); |
2679 | if (!Nested) |
2680 | SrcExpr = ExprError(); |
2681 | return; |
2682 | } |
2683 | |
2684 | DestPtr = DestPPtr->getPointeeType().getTypePtr(); |
2685 | SrcPtr = SrcPPtr->getPointeeType().getTypePtr(); |
2686 | Nested = true; |
2687 | DiagID = diag::ext_nested_pointer_qualifier_mismatch; |
2688 | } |
2689 | } |
2690 | } |
2691 | |
2692 | bool Sema::ShouldSplatAltivecScalarInCast(const VectorType *VecTy) { |
2693 | bool SrcCompatXL = this->getLangOpts().getAltivecSrcCompat() == |
2694 | LangOptions::AltivecSrcCompatKind::XL; |
2695 | VectorKind VKind = VecTy->getVectorKind(); |
2696 | |
2697 | if ((VKind == VectorKind::AltiVecVector) || |
2698 | (SrcCompatXL && ((VKind == VectorKind::AltiVecBool) || |
2699 | (VKind == VectorKind::AltiVecPixel)))) { |
2700 | return true; |
2701 | } |
2702 | return false; |
2703 | } |
2704 | |
2705 | bool Sema::CheckAltivecInitFromScalar(SourceRange R, QualType VecTy, |
2706 | QualType SrcTy) { |
2707 | bool SrcCompatGCC = this->getLangOpts().getAltivecSrcCompat() == |
2708 | LangOptions::AltivecSrcCompatKind::GCC; |
2709 | if (this->getLangOpts().AltiVec && SrcCompatGCC) { |
2710 | this->Diag(R.getBegin(), |
2711 | diag::err_invalid_conversion_between_vector_and_integer) |
2712 | << VecTy << SrcTy << R; |
2713 | return true; |
2714 | } |
2715 | return false; |
2716 | } |
2717 | |
2718 | void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle, |
2719 | bool ListInitialization) { |
2720 | assert(Self.getLangOpts().CPlusPlus); |
2721 | |
2722 | // Handle placeholders. |
2723 | if (isPlaceholder()) { |
2724 | // C-style casts can resolve __unknown_any types. |
2725 | if (claimPlaceholder(K: BuiltinType::UnknownAny)) { |
2726 | SrcExpr = Self.checkUnknownAnyCast(DestRange, DestType, |
2727 | SrcExpr.get(), Kind, |
2728 | ValueKind, BasePath); |
2729 | return; |
2730 | } |
2731 | |
2732 | checkNonOverloadPlaceholders(); |
2733 | if (SrcExpr.isInvalid()) |
2734 | return; |
2735 | } |
2736 | |
2737 | // C++ 5.2.9p4: Any expression can be explicitly converted to type "cv void". |
2738 | // This test is outside everything else because it's the only case where |
2739 | // a non-lvalue-reference target type does not lead to decay. |
2740 | if (DestType->isVoidType()) { |
2741 | Kind = CK_ToVoid; |
2742 | |
2743 | if (claimPlaceholder(K: BuiltinType::Overload)) { |
2744 | Self.ResolveAndFixSingleFunctionTemplateSpecialization( |
2745 | SrcExpr, /* Decay Function to ptr */ false, |
2746 | /* Complain */ true, DestRange, DestType, |
2747 | diag::err_bad_cstyle_cast_overload); |
2748 | if (SrcExpr.isInvalid()) |
2749 | return; |
2750 | } |
2751 | |
2752 | SrcExpr = Self.IgnoredValueConversions(E: SrcExpr.get()); |
2753 | return; |
2754 | } |
2755 | |
2756 | // If the type is dependent, we won't do any other semantic analysis now. |
2757 | if (DestType->isDependentType() || SrcExpr.get()->isTypeDependent() || |
2758 | SrcExpr.get()->isValueDependent()) { |
2759 | assert(Kind == CK_Dependent); |
2760 | return; |
2761 | } |
2762 | |
2763 | CheckedConversionKind CCK = FunctionalStyle |
2764 | ? CheckedConversionKind::FunctionalCast |
2765 | : CheckedConversionKind::CStyleCast; |
2766 | if (Self.getLangOpts().HLSL) { |
2767 | if (CheckHLSLCStyleCast(CCK)) |
2768 | return; |
2769 | } |
2770 | |
2771 | if (ValueKind == VK_PRValue && !DestType->isRecordType() && |
2772 | !isPlaceholder(BuiltinType::Overload)) { |
2773 | SrcExpr = Self.DefaultFunctionArrayLvalueConversion(E: SrcExpr.get()); |
2774 | if (SrcExpr.isInvalid()) |
2775 | return; |
2776 | } |
2777 | |
2778 | // AltiVec vector initialization with a single literal. |
2779 | if (const VectorType *vecTy = DestType->getAs<VectorType>()) { |
2780 | if (Self.CheckAltivecInitFromScalar(OpRange, DestType, |
2781 | SrcExpr.get()->getType())) { |
2782 | SrcExpr = ExprError(); |
2783 | return; |
2784 | } |
2785 | if (Self.ShouldSplatAltivecScalarInCast(VecTy: vecTy) && |
2786 | (SrcExpr.get()->getType()->isIntegerType() || |
2787 | SrcExpr.get()->getType()->isFloatingType())) { |
2788 | Kind = CK_VectorSplat; |
2789 | SrcExpr = Self.prepareVectorSplat(DestType, SrcExpr.get()); |
2790 | return; |
2791 | } |
2792 | } |
2793 | |
2794 | // WebAssembly tables cannot be cast. |
2795 | QualType SrcType = SrcExpr.get()->getType(); |
2796 | if (SrcType->isWebAssemblyTableType()) { |
2797 | Self.Diag(OpRange.getBegin(), diag::err_wasm_cast_table) |
2798 | << 1 << SrcExpr.get()->getSourceRange(); |
2799 | SrcExpr = ExprError(); |
2800 | return; |
2801 | } |
2802 | |
2803 | // C++ [expr.cast]p5: The conversions performed by |
2804 | // - a const_cast, |
2805 | // - a static_cast, |
2806 | // - a static_cast followed by a const_cast, |
2807 | // - a reinterpret_cast, or |
2808 | // - a reinterpret_cast followed by a const_cast, |
2809 | // can be performed using the cast notation of explicit type conversion. |
2810 | // [...] If a conversion can be interpreted in more than one of the ways |
2811 | // listed above, the interpretation that appears first in the list is used, |
2812 | // even if a cast resulting from that interpretation is ill-formed. |
2813 | // In plain language, this means trying a const_cast ... |
2814 | // Note that for address space we check compatibility after const_cast. |
2815 | unsigned msg = diag::err_bad_cxx_cast_generic; |
2816 | TryCastResult tcr = TryConstCast(Self, SrcExpr, DestType, |
2817 | /*CStyle*/ true, msg); |
2818 | if (SrcExpr.isInvalid()) |
2819 | return; |
2820 | if (isValidCast(TCR: tcr)) |
2821 | Kind = CK_NoOp; |
2822 | |
2823 | if (tcr == TC_NotApplicable) { |
2824 | tcr = TryAddressSpaceCast(Self, SrcExpr, DestType, /*CStyle*/ true, msg, |
2825 | Kind); |
2826 | if (SrcExpr.isInvalid()) |
2827 | return; |
2828 | |
2829 | if (tcr == TC_NotApplicable) { |
2830 | // ... or if that is not possible, a static_cast, ignoring const and |
2831 | // addr space, ... |
2832 | tcr = TryStaticCast(Self, SrcExpr, DestType, CCK, OpRange, msg, Kind, |
2833 | BasePath, ListInitialization); |
2834 | if (SrcExpr.isInvalid()) |
2835 | return; |
2836 | |
2837 | if (tcr == TC_NotApplicable) { |
2838 | // ... and finally a reinterpret_cast, ignoring const and addr space. |
2839 | tcr = TryReinterpretCast(Self, SrcExpr, DestType, /*CStyle*/ true, |
2840 | OpRange, msg, Kind); |
2841 | if (SrcExpr.isInvalid()) |
2842 | return; |
2843 | } |
2844 | } |
2845 | } |
2846 | |
2847 | if (Self.getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() && |
2848 | isValidCast(TCR: tcr)) |
2849 | checkObjCConversion(CCK); |
2850 | |
2851 | if (tcr != TC_Success && msg != 0) { |
2852 | if (SrcExpr.get()->getType() == Self.Context.OverloadTy) { |
2853 | DeclAccessPair Found; |
2854 | FunctionDecl *Fn = Self.ResolveAddressOfOverloadedFunction(SrcExpr.get(), |
2855 | DestType, |
2856 | /*Complain*/ true, |
2857 | Found); |
2858 | if (Fn) { |
2859 | // If DestType is a function type (not to be confused with the function |
2860 | // pointer type), it will be possible to resolve the function address, |
2861 | // but the type cast should be considered as failure. |
2862 | OverloadExpr *OE = OverloadExpr::find(E: SrcExpr.get()).Expression; |
2863 | Self.Diag(OpRange.getBegin(), diag::err_bad_cstyle_cast_overload) |
2864 | << OE->getName() << DestType << OpRange |
2865 | << OE->getQualifierLoc().getSourceRange(); |
2866 | Self.NoteAllOverloadCandidates(E: SrcExpr.get()); |
2867 | } |
2868 | } else { |
2869 | diagnoseBadCast(Self, msg, (FunctionalStyle ? CT_Functional : CT_CStyle), |
2870 | OpRange, SrcExpr.get(), DestType, ListInitialization); |
2871 | } |
2872 | } |
2873 | |
2874 | if (isValidCast(TCR: tcr)) { |
2875 | if (Kind == CK_BitCast) |
2876 | checkCastAlign(); |
2877 | |
2878 | if (unsigned DiagID = checkCastFunctionType(Self, SrcExpr, DestType)) |
2879 | Self.Diag(OpRange.getBegin(), DiagID) |
2880 | << SrcExpr.get()->getType() << DestType << OpRange; |
2881 | |
2882 | } else { |
2883 | SrcExpr = ExprError(); |
2884 | } |
2885 | } |
2886 | |
2887 | // CheckHLSLCStyleCast - Returns `true` ihe cast is handled or errored as an |
2888 | // HLSL-specific cast. Returns false if the cast should be checked as a CXX |
2889 | // C-Style cast. |
2890 | bool CastOperation::CheckHLSLCStyleCast(CheckedConversionKind CCK) { |
2891 | assert(Self.getLangOpts().HLSL && "Must be HLSL!"); |
2892 | QualType SrcTy = SrcExpr.get()->getType(); |
2893 | // HLSL has several unique forms of C-style casts which support aggregate to |
2894 | // aggregate casting. |
2895 | // This case should not trigger on regular vector cast, vector truncation |
2896 | if (Self.HLSL().CanPerformElementwiseCast(SrcExpr.get(), DestType)) { |
2897 | if (SrcTy->isConstantArrayType()) |
2898 | SrcExpr = Self.ImpCastExprToType( |
2899 | E: SrcExpr.get(), Type: Self.Context.getArrayParameterType(Ty: SrcTy), |
2900 | CK: CK_HLSLArrayRValue, VK: VK_PRValue, BasePath: nullptr, CCK); |
2901 | Kind = CK_HLSLElementwiseCast; |
2902 | return true; |
2903 | } |
2904 | |
2905 | // This case should not trigger on regular vector splat |
2906 | // If the relative order of this and the HLSLElementWise cast checks |
2907 | // are changed, it might change which cast handles what in a few cases |
2908 | if (Self.HLSL().CanPerformAggregateSplatCast(SrcExpr.get(), DestType)) { |
2909 | const VectorType *VT = SrcTy->getAs<VectorType>(); |
2910 | // change splat from vec1 case to splat from scalar |
2911 | if (VT && VT->getNumElements() == 1) |
2912 | SrcExpr = Self.ImpCastExprToType( |
2913 | E: SrcExpr.get(), Type: VT->getElementType(), CK: CK_HLSLVectorTruncation, |
2914 | VK: SrcExpr.get()->getValueKind(), BasePath: nullptr, CCK); |
2915 | // Inserting a scalar cast here allows for a simplified codegen in |
2916 | // the case the destTy is a vector |
2917 | if (const VectorType *DVT = DestType->getAs<VectorType>()) |
2918 | SrcExpr = Self.ImpCastExprToType( |
2919 | E: SrcExpr.get(), Type: DVT->getElementType(), |
2920 | CK: Self.PrepareScalarCast(src&: SrcExpr, destType: DVT->getElementType()), |
2921 | VK: SrcExpr.get()->getValueKind(), BasePath: nullptr, CCK); |
2922 | Kind = CK_HLSLAggregateSplatCast; |
2923 | return true; |
2924 | } |
2925 | |
2926 | // If the destination is an array, we've exhausted the valid HLSL casts, so we |
2927 | // should emit a dignostic and stop processing. |
2928 | if (DestType->isArrayType()) { |
2929 | Self.Diag(OpRange.getBegin(), diag::err_bad_cxx_cast_generic) |
2930 | << 4 << SrcTy << DestType; |
2931 | SrcExpr = ExprError(); |
2932 | return true; |
2933 | } |
2934 | return false; |
2935 | } |
2936 | |
2937 | /// DiagnoseBadFunctionCast - Warn whenever a function call is cast to a |
2938 | /// non-matching type. Such as enum function call to int, int call to |
2939 | /// pointer; etc. Cast to 'void' is an exception. |
2940 | static void DiagnoseBadFunctionCast(Sema &Self, const ExprResult &SrcExpr, |
2941 | QualType DestType) { |
2942 | if (Self.Diags.isIgnored(diag::warn_bad_function_cast, |
2943 | SrcExpr.get()->getExprLoc())) |
2944 | return; |
2945 | |
2946 | if (!isa<CallExpr>(Val: SrcExpr.get())) |
2947 | return; |
2948 | |
2949 | QualType SrcType = SrcExpr.get()->getType(); |
2950 | if (DestType.getUnqualifiedType()->isVoidType()) |
2951 | return; |
2952 | if ((SrcType->isAnyPointerType() || SrcType->isBlockPointerType()) |
2953 | && (DestType->isAnyPointerType() || DestType->isBlockPointerType())) |
2954 | return; |
2955 | if (SrcType->isIntegerType() && DestType->isIntegerType() && |
2956 | (SrcType->isBooleanType() == DestType->isBooleanType()) && |
2957 | (SrcType->isEnumeralType() == DestType->isEnumeralType())) |
2958 | return; |
2959 | if (SrcType->isRealFloatingType() && DestType->isRealFloatingType()) |
2960 | return; |
2961 | if (SrcType->isEnumeralType() && DestType->isEnumeralType()) |
2962 | return; |
2963 | if (SrcType->isComplexType() && DestType->isComplexType()) |
2964 | return; |
2965 | if (SrcType->isComplexIntegerType() && DestType->isComplexIntegerType()) |
2966 | return; |
2967 | if (SrcType->isFixedPointType() && DestType->isFixedPointType()) |
2968 | return; |
2969 | |
2970 | Self.Diag(SrcExpr.get()->getExprLoc(), |
2971 | diag::warn_bad_function_cast) |
2972 | << SrcType << DestType << SrcExpr.get()->getSourceRange(); |
2973 | } |
2974 | |
2975 | /// Check the semantics of a C-style cast operation, in C. |
2976 | void CastOperation::CheckCStyleCast() { |
2977 | assert(!Self.getLangOpts().CPlusPlus); |
2978 | |
2979 | // C-style casts can resolve __unknown_any types. |
2980 | if (claimPlaceholder(K: BuiltinType::UnknownAny)) { |
2981 | SrcExpr = Self.checkUnknownAnyCast(DestRange, DestType, |
2982 | SrcExpr.get(), Kind, |
2983 | ValueKind, BasePath); |
2984 | return; |
2985 | } |
2986 | |
2987 | // C99 6.5.4p2: the cast type needs to be void or scalar and the expression |
2988 | // type needs to be scalar. |
2989 | if (DestType->isVoidType()) { |
2990 | // We don't necessarily do lvalue-to-rvalue conversions on this. |
2991 | SrcExpr = Self.IgnoredValueConversions(E: SrcExpr.get()); |
2992 | if (SrcExpr.isInvalid()) |
2993 | return; |
2994 | |
2995 | // Cast to void allows any expr type. |
2996 | Kind = CK_ToVoid; |
2997 | return; |
2998 | } |
2999 | |
3000 | // If the type is dependent, we won't do any other semantic analysis now. |
3001 | if (Self.getASTContext().isDependenceAllowed() && |
3002 | (DestType->isDependentType() || SrcExpr.get()->isTypeDependent() || |
3003 | SrcExpr.get()->isValueDependent())) { |
3004 | assert((DestType->containsErrors() || SrcExpr.get()->containsErrors() || |
3005 | SrcExpr.get()->containsErrors()) && |
3006 | "should only occur in error-recovery path."); |
3007 | assert(Kind == CK_Dependent); |
3008 | return; |
3009 | } |
3010 | |
3011 | // Overloads are allowed with C extensions, so we need to support them. |
3012 | if (SrcExpr.get()->getType() == Self.Context.OverloadTy) { |
3013 | DeclAccessPair DAP; |
3014 | if (FunctionDecl *FD = Self.ResolveAddressOfOverloadedFunction( |
3015 | SrcExpr.get(), DestType, /*Complain=*/true, DAP)) |
3016 | SrcExpr = Self.FixOverloadedFunctionReference(E: SrcExpr.get(), FoundDecl: DAP, Fn: FD); |
3017 | else |
3018 | return; |
3019 | assert(SrcExpr.isUsable()); |
3020 | } |
3021 | SrcExpr = Self.DefaultFunctionArrayLvalueConversion(E: SrcExpr.get()); |
3022 | if (SrcExpr.isInvalid()) |
3023 | return; |
3024 | QualType SrcType = SrcExpr.get()->getType(); |
3025 | |
3026 | if (SrcType->isWebAssemblyTableType()) { |
3027 | Self.Diag(OpRange.getBegin(), diag::err_wasm_cast_table) |
3028 | << 1 << SrcExpr.get()->getSourceRange(); |
3029 | SrcExpr = ExprError(); |
3030 | return; |
3031 | } |
3032 | |
3033 | assert(!SrcType->isPlaceholderType()); |
3034 | |
3035 | checkAddressSpaceCast(SrcType, DestType); |
3036 | if (SrcExpr.isInvalid()) |
3037 | return; |
3038 | |
3039 | if (Self.RequireCompleteType(OpRange.getBegin(), DestType, |
3040 | diag::err_typecheck_cast_to_incomplete)) { |
3041 | SrcExpr = ExprError(); |
3042 | return; |
3043 | } |
3044 | |
3045 | // Allow casting a sizeless built-in type to itself. |
3046 | if (DestType->isSizelessBuiltinType() && |
3047 | Self.Context.hasSameUnqualifiedType(DestType, SrcType)) { |
3048 | Kind = CK_NoOp; |
3049 | return; |
3050 | } |
3051 | |
3052 | // Allow bitcasting between compatible SVE vector types. |
3053 | if ((SrcType->isVectorType() || DestType->isVectorType()) && |
3054 | Self.isValidSveBitcast(SrcType, DestType)) { |
3055 | Kind = CK_BitCast; |
3056 | return; |
3057 | } |
3058 | |
3059 | // Allow bitcasting between compatible RVV vector types. |
3060 | if ((SrcType->isVectorType() || DestType->isVectorType()) && |
3061 | Self.RISCV().isValidRVVBitcast(SrcType, DestType)) { |
3062 | Kind = CK_BitCast; |
3063 | return; |
3064 | } |
3065 | |
3066 | if (!DestType->isScalarType() && !DestType->isVectorType() && |
3067 | !DestType->isMatrixType()) { |
3068 | const RecordType *DestRecordTy = DestType->getAs<RecordType>(); |
3069 | |
3070 | if (DestRecordTy && Self.Context.hasSameUnqualifiedType(DestType, SrcType)){ |
3071 | // GCC struct/union extension: allow cast to self. |
3072 | Self.Diag(OpRange.getBegin(), diag::ext_typecheck_cast_nonscalar) |
3073 | << DestType << SrcExpr.get()->getSourceRange(); |
3074 | Kind = CK_NoOp; |
3075 | return; |
3076 | } |
3077 | |
3078 | // GCC's cast to union extension. |
3079 | if (DestRecordTy && DestRecordTy->getDecl()->isUnion()) { |
3080 | RecordDecl *RD = DestRecordTy->getDecl(); |
3081 | if (CastExpr::getTargetFieldForToUnionCast(RD, opType: SrcType)) { |
3082 | Self.Diag(OpRange.getBegin(), diag::ext_typecheck_cast_to_union) |
3083 | << SrcExpr.get()->getSourceRange(); |
3084 | Kind = CK_ToUnion; |
3085 | return; |
3086 | } else { |
3087 | Self.Diag(OpRange.getBegin(), diag::err_typecheck_cast_to_union_no_type) |
3088 | << SrcType << SrcExpr.get()->getSourceRange(); |
3089 | SrcExpr = ExprError(); |
3090 | return; |
3091 | } |
3092 | } |
3093 | |
3094 | // OpenCL v2.0 s6.13.10 - Allow casts from '0' to event_t type. |
3095 | if (Self.getLangOpts().OpenCL && DestType->isEventT()) { |
3096 | Expr::EvalResult Result; |
3097 | if (SrcExpr.get()->EvaluateAsInt(Result, Ctx: Self.Context)) { |
3098 | llvm::APSInt CastInt = Result.Val.getInt(); |
3099 | if (0 == CastInt) { |
3100 | Kind = CK_ZeroToOCLOpaqueType; |
3101 | return; |
3102 | } |
3103 | Self.Diag(OpRange.getBegin(), |
3104 | diag::err_opencl_cast_non_zero_to_event_t) |
3105 | << toString(CastInt, 10) << SrcExpr.get()->getSourceRange(); |
3106 | SrcExpr = ExprError(); |
3107 | return; |
3108 | } |
3109 | } |
3110 | |
3111 | // Reject any other conversions to non-scalar types. |
3112 | Self.Diag(OpRange.getBegin(), diag::err_typecheck_cond_expect_scalar) |
3113 | << DestType << SrcExpr.get()->getSourceRange(); |
3114 | SrcExpr = ExprError(); |
3115 | return; |
3116 | } |
3117 | |
3118 | // The type we're casting to is known to be a scalar, a vector, or a matrix. |
3119 | |
3120 | // Require the operand to be a scalar, a vector, or a matrix. |
3121 | if (!SrcType->isScalarType() && !SrcType->isVectorType() && |
3122 | !SrcType->isMatrixType()) { |
3123 | Self.Diag(SrcExpr.get()->getExprLoc(), |
3124 | diag::err_typecheck_expect_scalar_operand) |
3125 | << SrcType << SrcExpr.get()->getSourceRange(); |
3126 | SrcExpr = ExprError(); |
3127 | return; |
3128 | } |
3129 | |
3130 | // C23 6.5.5p4: |
3131 | // ... The type nullptr_t shall not be converted to any type other than |
3132 | // void, bool or a pointer type.If the target type is nullptr_t, the cast |
3133 | // expression shall be a null pointer constant or have type nullptr_t. |
3134 | if (SrcType->isNullPtrType()) { |
3135 | // FIXME: 6.3.2.4p2 says that nullptr_t can be converted to itself, but |
3136 | // 6.5.4p4 is a constraint check and nullptr_t is not void, bool, or a |
3137 | // pointer type. We're not going to diagnose that as a constraint violation. |
3138 | if (!DestType->isVoidType() && !DestType->isBooleanType() && |
3139 | !DestType->isPointerType() && !DestType->isNullPtrType()) { |
3140 | Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_nullptr_cast) |
3141 | << /*nullptr to type*/ 0 << DestType; |
3142 | SrcExpr = ExprError(); |
3143 | return; |
3144 | } |
3145 | if (!DestType->isNullPtrType()) { |
3146 | // Implicitly cast from the null pointer type to the type of the |
3147 | // destination. |
3148 | CastKind CK = DestType->isPointerType() ? CK_NullToPointer : CK_BitCast; |
3149 | SrcExpr = ImplicitCastExpr::Create(Self.Context, DestType, CK, |
3150 | SrcExpr.get(), nullptr, VK_PRValue, |
3151 | Self.CurFPFeatureOverrides()); |
3152 | } |
3153 | } |
3154 | |
3155 | if (DestType->isNullPtrType() && !SrcType->isNullPtrType()) { |
3156 | if (!SrcExpr.get()->isNullPointerConstant(Ctx&: Self.Context, |
3157 | NPC: Expr::NPC_NeverValueDependent)) { |
3158 | Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_nullptr_cast) |
3159 | << /*type to nullptr*/ 1 << SrcType; |
3160 | SrcExpr = ExprError(); |
3161 | return; |
3162 | } |
3163 | // Need to convert the source from whatever its type is to a null pointer |
3164 | // type first. |
3165 | SrcExpr = ImplicitCastExpr::Create(Self.Context, DestType, CK_NullToPointer, |
3166 | SrcExpr.get(), nullptr, VK_PRValue, |
3167 | Self.CurFPFeatureOverrides()); |
3168 | } |
3169 | |
3170 | if (DestType->isExtVectorType()) { |
3171 | SrcExpr = Self.CheckExtVectorCast(OpRange, DestType, SrcExpr.get(), Kind); |
3172 | return; |
3173 | } |
3174 | |
3175 | if (DestType->getAs<MatrixType>() || SrcType->getAs<MatrixType>()) { |
3176 | if (Self.CheckMatrixCast(OpRange, DestType, SrcType, Kind)) |
3177 | SrcExpr = ExprError(); |
3178 | return; |
3179 | } |
3180 | |
3181 | if (const VectorType *DestVecTy = DestType->getAs<VectorType>()) { |
3182 | if (Self.CheckAltivecInitFromScalar(OpRange, DestType, SrcType)) { |
3183 | SrcExpr = ExprError(); |
3184 | return; |
3185 | } |
3186 | if (Self.ShouldSplatAltivecScalarInCast(VecTy: DestVecTy) && |
3187 | (SrcType->isIntegerType() || SrcType->isFloatingType())) { |
3188 | Kind = CK_VectorSplat; |
3189 | SrcExpr = Self.prepareVectorSplat(DestType, SrcExpr.get()); |
3190 | } else if (Self.CheckVectorCast(OpRange, DestType, SrcType, Kind)) { |
3191 | SrcExpr = ExprError(); |
3192 | } |
3193 | return; |
3194 | } |
3195 | |
3196 | if (SrcType->isVectorType()) { |
3197 | if (Self.CheckVectorCast(OpRange, SrcType, DestType, Kind)) |
3198 | SrcExpr = ExprError(); |
3199 | return; |
3200 | } |
3201 | |
3202 | // The source and target types are both scalars, i.e. |
3203 | // - arithmetic types (fundamental, enum, and complex) |
3204 | // - all kinds of pointers |
3205 | // Note that member pointers were filtered out with C++, above. |
3206 | |
3207 | if (isa<ObjCSelectorExpr>(Val: SrcExpr.get())) { |
3208 | Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_cast_selector_expr); |
3209 | SrcExpr = ExprError(); |
3210 | return; |
3211 | } |
3212 | |
3213 | // If either type is a pointer, the other type has to be either an |
3214 | // integer or a pointer. |
3215 | if (!DestType->isArithmeticType()) { |
3216 | if (!SrcType->isIntegralType(Ctx: Self.Context) && SrcType->isArithmeticType()) { |
3217 | Self.Diag(SrcExpr.get()->getExprLoc(), |
3218 | diag::err_cast_pointer_from_non_pointer_int) |
3219 | << SrcType << SrcExpr.get()->getSourceRange(); |
3220 | SrcExpr = ExprError(); |
3221 | return; |
3222 | } |
3223 | checkIntToPointerCast(/* CStyle */ true, OpRange, SrcExpr.get(), DestType, |
3224 | Self); |
3225 | } else if (!SrcType->isArithmeticType()) { |
3226 | if (!DestType->isIntegralType(Self.Context) && |
3227 | DestType->isArithmeticType()) { |
3228 | Self.Diag(SrcExpr.get()->getBeginLoc(), |
3229 | diag::err_cast_pointer_to_non_pointer_int) |
3230 | << DestType << SrcExpr.get()->getSourceRange(); |
3231 | SrcExpr = ExprError(); |
3232 | return; |
3233 | } |
3234 | |
3235 | if ((Self.Context.getTypeSize(SrcType) > |
3236 | Self.Context.getTypeSize(DestType)) && |
3237 | !DestType->isBooleanType()) { |
3238 | // C 6.3.2.3p6: Any pointer type may be converted to an integer type. |
3239 | // Except as previously specified, the result is implementation-defined. |
3240 | // If the result cannot be represented in the integer type, the behavior |
3241 | // is undefined. The result need not be in the range of values of any |
3242 | // integer type. |
3243 | unsigned Diag; |
3244 | if (SrcType->isVoidPointerType()) |
3245 | Diag = DestType->isEnumeralType() ? diag::warn_void_pointer_to_enum_cast |
3246 | : diag::warn_void_pointer_to_int_cast; |
3247 | else if (DestType->isEnumeralType()) |
3248 | Diag = diag::warn_pointer_to_enum_cast; |
3249 | else |
3250 | Diag = diag::warn_pointer_to_int_cast; |
3251 | Self.Diag(OpRange.getBegin(), Diag) << SrcType << DestType << OpRange; |
3252 | } |
3253 | } |
3254 | |
3255 | if (Self.getLangOpts().OpenCL && !Self.getOpenCLOptions().isAvailableOption( |
3256 | Ext: "cl_khr_fp16", LO: Self.getLangOpts())) { |
3257 | if (DestType->isHalfType()) { |
3258 | Self.Diag(SrcExpr.get()->getBeginLoc(), diag::err_opencl_cast_to_half) |
3259 | << DestType << SrcExpr.get()->getSourceRange(); |
3260 | SrcExpr = ExprError(); |
3261 | return; |
3262 | } |
3263 | } |
3264 | |
3265 | // ARC imposes extra restrictions on casts. |
3266 | if (Self.getLangOpts().allowsNonTrivialObjCLifetimeQualifiers()) { |
3267 | checkObjCConversion(CCK: CheckedConversionKind::CStyleCast); |
3268 | if (SrcExpr.isInvalid()) |
3269 | return; |
3270 | |
3271 | const PointerType *CastPtr = DestType->getAs<PointerType>(); |
3272 | if (Self.getLangOpts().ObjCAutoRefCount && CastPtr) { |
3273 | if (const PointerType *ExprPtr = SrcType->getAs<PointerType>()) { |
3274 | Qualifiers CastQuals = CastPtr->getPointeeType().getQualifiers(); |
3275 | Qualifiers ExprQuals = ExprPtr->getPointeeType().getQualifiers(); |
3276 | if (CastPtr->getPointeeType()->isObjCLifetimeType() && |
3277 | ExprPtr->getPointeeType()->isObjCLifetimeType() && |
3278 | !CastQuals.compatiblyIncludesObjCLifetime(other: ExprQuals)) { |
3279 | Self.Diag(SrcExpr.get()->getBeginLoc(), |
3280 | diag::err_typecheck_incompatible_ownership) |
3281 | << SrcType << DestType << AssignmentAction::Casting |
3282 | << SrcExpr.get()->getSourceRange(); |
3283 | return; |
3284 | } |
3285 | } |
3286 | } else if (!Self.ObjC().CheckObjCARCUnavailableWeakConversion(DestType, |
3287 | SrcType)) { |
3288 | Self.Diag(SrcExpr.get()->getBeginLoc(), |
3289 | diag::err_arc_convesion_of_weak_unavailable) |
3290 | << 1 << SrcType << DestType << SrcExpr.get()->getSourceRange(); |
3291 | SrcExpr = ExprError(); |
3292 | return; |
3293 | } |
3294 | } |
3295 | |
3296 | if (unsigned DiagID = checkCastFunctionType(Self, SrcExpr, DestType)) |
3297 | Self.Diag(OpRange.getBegin(), DiagID) << SrcType << DestType << OpRange; |
3298 | |
3299 | if (isa<PointerType>(SrcType) && isa<PointerType>(DestType)) { |
3300 | QualType SrcTy = cast<PointerType>(Val&: SrcType)->getPointeeType(); |
3301 | QualType DestTy = cast<PointerType>(DestType)->getPointeeType(); |
3302 | |
3303 | const RecordDecl *SrcRD = SrcTy->getAsRecordDecl(); |
3304 | const RecordDecl *DestRD = DestTy->getAsRecordDecl(); |
3305 | |
3306 | if (SrcRD && DestRD && SrcRD->hasAttr<RandomizeLayoutAttr>() && |
3307 | SrcRD != DestRD) { |
3308 | // The struct we are casting the pointer from was randomized. |
3309 | Self.Diag(OpRange.getBegin(), diag::err_cast_from_randomized_struct) |
3310 | << SrcType << DestType; |
3311 | SrcExpr = ExprError(); |
3312 | return; |
3313 | } |
3314 | } |
3315 | |
3316 | DiagnoseCastOfObjCSEL(Self, SrcExpr, DestType); |
3317 | DiagnoseCallingConvCast(Self, SrcExpr, DestType, OpRange); |
3318 | DiagnoseBadFunctionCast(Self, SrcExpr, DestType); |
3319 | Kind = Self.PrepareScalarCast(SrcExpr, DestType); |
3320 | if (SrcExpr.isInvalid()) |
3321 | return; |
3322 | |
3323 | if (Kind == CK_BitCast) |
3324 | checkCastAlign(); |
3325 | } |
3326 | |
3327 | void CastOperation::CheckBuiltinBitCast() { |
3328 | QualType SrcType = SrcExpr.get()->getType(); |
3329 | |
3330 | if (Self.RequireCompleteType(OpRange.getBegin(), DestType, |
3331 | diag::err_typecheck_cast_to_incomplete) || |
3332 | Self.RequireCompleteType(OpRange.getBegin(), SrcType, |
3333 | diag::err_incomplete_type)) { |
3334 | SrcExpr = ExprError(); |
3335 | return; |
3336 | } |
3337 | |
3338 | if (SrcExpr.get()->isPRValue()) |
3339 | SrcExpr = Self.CreateMaterializeTemporaryExpr(T: SrcType, Temporary: SrcExpr.get(), |
3340 | /*IsLValueReference=*/BoundToLvalueReference: false); |
3341 | |
3342 | CharUnits DestSize = Self.Context.getTypeSizeInChars(DestType); |
3343 | CharUnits SourceSize = Self.Context.getTypeSizeInChars(T: SrcType); |
3344 | if (DestSize != SourceSize) { |
3345 | Self.Diag(OpRange.getBegin(), diag::err_bit_cast_type_size_mismatch) |
3346 | << SrcType << DestType << (int)SourceSize.getQuantity() |
3347 | << (int)DestSize.getQuantity(); |
3348 | SrcExpr = ExprError(); |
3349 | return; |
3350 | } |
3351 | |
3352 | if (!DestType.isTriviallyCopyableType(Self.Context)) { |
3353 | Self.Diag(OpRange.getBegin(), diag::err_bit_cast_non_trivially_copyable) |
3354 | << 1; |
3355 | SrcExpr = ExprError(); |
3356 | return; |
3357 | } |
3358 | |
3359 | if (!SrcType.isTriviallyCopyableType(Context: Self.Context)) { |
3360 | Self.Diag(OpRange.getBegin(), diag::err_bit_cast_non_trivially_copyable) |
3361 | << 0; |
3362 | SrcExpr = ExprError(); |
3363 | return; |
3364 | } |
3365 | |
3366 | Kind = CK_LValueToRValueBitCast; |
3367 | } |
3368 | |
3369 | /// DiagnoseCastQual - Warn whenever casts discards a qualifiers, be it either |
3370 | /// const, volatile or both. |
3371 | static void DiagnoseCastQual(Sema &Self, const ExprResult &SrcExpr, |
3372 | QualType DestType) { |
3373 | if (SrcExpr.isInvalid()) |
3374 | return; |
3375 | |
3376 | QualType SrcType = SrcExpr.get()->getType(); |
3377 | if (!((SrcType->isAnyPointerType() && DestType->isAnyPointerType()) || |
3378 | DestType->isLValueReferenceType())) |
3379 | return; |
3380 | |
3381 | QualType TheOffendingSrcType, TheOffendingDestType; |
3382 | Qualifiers CastAwayQualifiers; |
3383 | if (CastsAwayConstness(Self, SrcType, DestType, CheckCVR: true, CheckObjCLifetime: false, |
3384 | TheOffendingSrcType: &TheOffendingSrcType, TheOffendingDestType: &TheOffendingDestType, |
3385 | CastAwayQualifiers: &CastAwayQualifiers) != |
3386 | CastAwayConstnessKind::CACK_Similar) |
3387 | return; |
3388 | |
3389 | // FIXME: 'restrict' is not properly handled here. |
3390 | int qualifiers = -1; |
3391 | if (CastAwayQualifiers.hasConst() && CastAwayQualifiers.hasVolatile()) { |
3392 | qualifiers = 0; |
3393 | } else if (CastAwayQualifiers.hasConst()) { |
3394 | qualifiers = 1; |
3395 | } else if (CastAwayQualifiers.hasVolatile()) { |
3396 | qualifiers = 2; |
3397 | } |
3398 | // This is a variant of int **x; const int **y = (const int **)x; |
3399 | if (qualifiers == -1) |
3400 | Self.Diag(SrcExpr.get()->getBeginLoc(), diag::warn_cast_qual2) |
3401 | << SrcType << DestType; |
3402 | else |
3403 | Self.Diag(SrcExpr.get()->getBeginLoc(), diag::warn_cast_qual) |
3404 | << TheOffendingSrcType << TheOffendingDestType << qualifiers; |
3405 | } |
3406 | |
3407 | ExprResult Sema::BuildCStyleCastExpr(SourceLocation LPLoc, |
3408 | TypeSourceInfo *CastTypeInfo, |
3409 | SourceLocation RPLoc, |
3410 | Expr *CastExpr) { |
3411 | CastOperation Op(*this, CastTypeInfo->getType(), CastExpr); |
3412 | Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange(); |
3413 | Op.OpRange = SourceRange(LPLoc, CastExpr->getEndLoc()); |
3414 | |
3415 | if (getLangOpts().CPlusPlus) { |
3416 | Op.CheckCXXCStyleCast(/*FunctionalCast=*/ FunctionalStyle: false, |
3417 | ListInitialization: isa<InitListExpr>(Val: CastExpr)); |
3418 | } else { |
3419 | Op.CheckCStyleCast(); |
3420 | } |
3421 | |
3422 | if (Op.SrcExpr.isInvalid()) |
3423 | return ExprError(); |
3424 | |
3425 | // -Wcast-qual |
3426 | DiagnoseCastQual(Op.Self, Op.SrcExpr, Op.DestType); |
3427 | |
3428 | Op.checkQualifiedDestType(); |
3429 | |
3430 | return Op.complete(castExpr: CStyleCastExpr::Create( |
3431 | Context, T: Op.ResultType, VK: Op.ValueKind, K: Op.Kind, Op: Op.SrcExpr.get(), |
3432 | BasePath: &Op.BasePath, FPO: CurFPFeatureOverrides(), WrittenTy: CastTypeInfo, L: LPLoc, R: RPLoc)); |
3433 | } |
3434 | |
3435 | ExprResult Sema::BuildCXXFunctionalCastExpr(TypeSourceInfo *CastTypeInfo, |
3436 | QualType Type, |
3437 | SourceLocation LPLoc, |
3438 | Expr *CastExpr, |
3439 | SourceLocation RPLoc) { |
3440 | assert(LPLoc.isValid() && "List-initialization shouldn't get here."); |
3441 | CastOperation Op(*this, Type, CastExpr); |
3442 | Op.DestRange = CastTypeInfo->getTypeLoc().getSourceRange(); |
3443 | Op.OpRange = SourceRange(Op.DestRange.getBegin(), RPLoc); |
3444 | |
3445 | Op.CheckCXXCStyleCast(/*FunctionalCast=*/FunctionalStyle: true, /*ListInit=*/ListInitialization: false); |
3446 | if (Op.SrcExpr.isInvalid()) |
3447 | return ExprError(); |
3448 | |
3449 | Op.checkQualifiedDestType(); |
3450 | |
3451 | auto *SubExpr = Op.SrcExpr.get(); |
3452 | if (auto *BindExpr = dyn_cast<CXXBindTemporaryExpr>(Val: SubExpr)) |
3453 | SubExpr = BindExpr->getSubExpr(); |
3454 | if (auto *ConstructExpr = dyn_cast<CXXConstructExpr>(Val: SubExpr)) |
3455 | ConstructExpr->setParenOrBraceRange(SourceRange(LPLoc, RPLoc)); |
3456 | |
3457 | // -Wcast-qual |
3458 | DiagnoseCastQual(Op.Self, Op.SrcExpr, Op.DestType); |
3459 | |
3460 | return Op.complete(castExpr: CXXFunctionalCastExpr::Create( |
3461 | Context, T: Op.ResultType, VK: Op.ValueKind, Written: CastTypeInfo, Kind: Op.Kind, |
3462 | Op: Op.SrcExpr.get(), Path: &Op.BasePath, FPO: CurFPFeatureOverrides(), LPLoc, RPLoc)); |
3463 | } |
3464 |
Definitions
- TryCastResult
- isValidCast
- CastType
- CastOperation
- CastOperation
- updatePartOfExplicitCastFlags
- complete
- claimPlaceholder
- isPlaceholder
- isPlaceholder
- checkCastAlign
- checkObjCConversion
- checkQualifiedDestType
- checkNonOverloadPlaceholders
- CheckNoDeref
- CheckNoDerefRAII
- CheckNoDerefRAII
- ~CheckNoDerefRAII
- ActOnCXXNamedCast
- BuildCXXNamedCast
- ActOnBuiltinBitCastExpr
- BuildBuiltinBitCastExpr
- tryDiagnoseOverloadedCast
- diagnoseBadCast
- CastAwayConstnessKind
- unwrapCastAwayConstnessLevel
- CastsAwayConstness
- getCastAwayConstnessCastKind
- CheckDynamicCast
- CheckConstCast
- CheckAddrspaceCast
- DiagnoseReinterpretUpDownCast
- argTypeIsABIEquivalent
- checkCastFunctionType
- CheckReinterpretCast
- CheckStaticCast
- IsAddressSpaceConversion
- TryStaticCast
- TryLValueToRValueCast
- TryStaticReferenceDowncast
- TryStaticPointerDowncast
- TryStaticDowncast
- TryStaticMemberPointerUpcast
- TryStaticImplicitCast
- TryConstCast
- CheckCompatibleReinterpretCast
- DiagnoseCastOfObjCSEL
- DiagnoseCallingConvCast
- checkIntToPointerCast
- fixOverloadedReinterpretCastExpr
- TryReinterpretCast
- TryAddressSpaceCast
- checkAddressSpaceCast
- ShouldSplatAltivecScalarInCast
- CheckAltivecInitFromScalar
- CheckCXXCStyleCast
- CheckHLSLCStyleCast
- DiagnoseBadFunctionCast
- CheckCStyleCast
- CheckBuiltinBitCast
- DiagnoseCastQual
- BuildCStyleCastExpr
Improve your Profiling and Debugging skills
Find out more