SemaExpr.cpp revision 08062aaaa5e32a9a313109a53afc1e13d3689eb5
1//===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements semantic analysis for expressions. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Sema/SemaInternal.h" 15#include "clang/Sema/Initialization.h" 16#include "clang/Sema/Lookup.h" 17#include "clang/Sema/AnalysisBasedWarnings.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/ASTMutationListener.h" 20#include "clang/AST/CXXInheritance.h" 21#include "clang/AST/DeclObjC.h" 22#include "clang/AST/DeclTemplate.h" 23#include "clang/AST/EvaluatedExprVisitor.h" 24#include "clang/AST/Expr.h" 25#include "clang/AST/ExprCXX.h" 26#include "clang/AST/ExprObjC.h" 27#include "clang/AST/RecursiveASTVisitor.h" 28#include "clang/AST/TypeLoc.h" 29#include "clang/Basic/PartialDiagnostic.h" 30#include "clang/Basic/SourceManager.h" 31#include "clang/Basic/TargetInfo.h" 32#include "clang/Lex/LiteralSupport.h" 33#include "clang/Lex/Preprocessor.h" 34#include "clang/Sema/DeclSpec.h" 35#include "clang/Sema/Designator.h" 36#include "clang/Sema/Scope.h" 37#include "clang/Sema/ScopeInfo.h" 38#include "clang/Sema/ParsedTemplate.h" 39#include "clang/Sema/SemaFixItUtils.h" 40#include "clang/Sema/Template.h" 41using namespace clang; 42using namespace sema; 43 44 45/// \brief Determine whether the use of this declaration is valid, and 46/// emit any corresponding diagnostics. 47/// 48/// This routine diagnoses various problems with referencing 49/// declarations that can occur when using a declaration. For example, 50/// it might warn if a deprecated or unavailable declaration is being 51/// used, or produce an error (and return true) if a C++0x deleted 52/// function is being used. 53/// 54/// If IgnoreDeprecated is set to true, this should not warn about deprecated 55/// decls. 56/// 57/// \returns true if there was an error (this declaration cannot be 58/// referenced), false otherwise. 59/// 60bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, 61 const ObjCInterfaceDecl *UnknownObjCClass) { 62 if (getLangOptions().CPlusPlus && isa<FunctionDecl>(D)) { 63 // If there were any diagnostics suppressed by template argument deduction, 64 // emit them now. 65 llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >::iterator 66 Pos = SuppressedDiagnostics.find(D->getCanonicalDecl()); 67 if (Pos != SuppressedDiagnostics.end()) { 68 SmallVectorImpl<PartialDiagnosticAt> &Suppressed = Pos->second; 69 for (unsigned I = 0, N = Suppressed.size(); I != N; ++I) 70 Diag(Suppressed[I].first, Suppressed[I].second); 71 72 // Clear out the list of suppressed diagnostics, so that we don't emit 73 // them again for this specialization. However, we don't obsolete this 74 // entry from the table, because we want to avoid ever emitting these 75 // diagnostics again. 76 Suppressed.clear(); 77 } 78 } 79 80 // See if this is an auto-typed variable whose initializer we are parsing. 81 if (ParsingInitForAutoVars.count(D)) { 82 Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer) 83 << D->getDeclName(); 84 return true; 85 } 86 87 // See if this is a deleted function. 88 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 89 if (FD->isDeleted()) { 90 Diag(Loc, diag::err_deleted_function_use); 91 Diag(D->getLocation(), diag::note_unavailable_here) << 1 << true; 92 return true; 93 } 94 } 95 96 // See if this declaration is unavailable or deprecated. 97 std::string Message; 98 switch (D->getAvailability(&Message)) { 99 case AR_Available: 100 case AR_NotYetIntroduced: 101 break; 102 103 case AR_Deprecated: 104 EmitDeprecationWarning(D, Message, Loc, UnknownObjCClass); 105 break; 106 107 case AR_Unavailable: 108 if (cast<Decl>(CurContext)->getAvailability() != AR_Unavailable) { 109 if (Message.empty()) { 110 if (!UnknownObjCClass) 111 Diag(Loc, diag::err_unavailable) << D->getDeclName(); 112 else 113 Diag(Loc, diag::warn_unavailable_fwdclass_message) 114 << D->getDeclName(); 115 } 116 else 117 Diag(Loc, diag::err_unavailable_message) 118 << D->getDeclName() << Message; 119 Diag(D->getLocation(), diag::note_unavailable_here) 120 << isa<FunctionDecl>(D) << false; 121 } 122 break; 123 } 124 125 // Warn if this is used but marked unused. 126 if (D->hasAttr<UnusedAttr>()) 127 Diag(Loc, diag::warn_used_but_marked_unused) << D->getDeclName(); 128 129 return false; 130} 131 132/// \brief Retrieve the message suffix that should be added to a 133/// diagnostic complaining about the given function being deleted or 134/// unavailable. 135std::string Sema::getDeletedOrUnavailableSuffix(const FunctionDecl *FD) { 136 // FIXME: C++0x implicitly-deleted special member functions could be 137 // detected here so that we could improve diagnostics to say, e.g., 138 // "base class 'A' had a deleted copy constructor". 139 if (FD->isDeleted()) 140 return std::string(); 141 142 std::string Message; 143 if (FD->getAvailability(&Message)) 144 return ": " + Message; 145 146 return std::string(); 147} 148 149/// DiagnoseSentinelCalls - This routine checks on method dispatch calls 150/// (and other functions in future), which have been declared with sentinel 151/// attribute. It warns if call does not have the sentinel argument. 152/// 153void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, 154 Expr **Args, unsigned NumArgs) { 155 const SentinelAttr *attr = D->getAttr<SentinelAttr>(); 156 if (!attr) 157 return; 158 159 int sentinelPos = attr->getSentinel(); 160 int nullPos = attr->getNullPos(); 161 162 unsigned int i = 0; 163 bool warnNotEnoughArgs = false; 164 int isMethod = 0; 165 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 166 // skip over named parameters. 167 ObjCMethodDecl::param_iterator P, E = MD->param_end(); 168 for (P = MD->param_begin(); (P != E && i < NumArgs); ++P) { 169 if (nullPos) 170 --nullPos; 171 else 172 ++i; 173 } 174 warnNotEnoughArgs = (P != E || i >= NumArgs); 175 isMethod = 1; 176 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 177 // skip over named parameters. 178 ObjCMethodDecl::param_iterator P, E = FD->param_end(); 179 for (P = FD->param_begin(); (P != E && i < NumArgs); ++P) { 180 if (nullPos) 181 --nullPos; 182 else 183 ++i; 184 } 185 warnNotEnoughArgs = (P != E || i >= NumArgs); 186 } else if (VarDecl *V = dyn_cast<VarDecl>(D)) { 187 // block or function pointer call. 188 QualType Ty = V->getType(); 189 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) { 190 const FunctionType *FT = Ty->isFunctionPointerType() 191 ? Ty->getAs<PointerType>()->getPointeeType()->getAs<FunctionType>() 192 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>(); 193 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT)) { 194 unsigned NumArgsInProto = Proto->getNumArgs(); 195 unsigned k; 196 for (k = 0; (k != NumArgsInProto && i < NumArgs); k++) { 197 if (nullPos) 198 --nullPos; 199 else 200 ++i; 201 } 202 warnNotEnoughArgs = (k != NumArgsInProto || i >= NumArgs); 203 } 204 if (Ty->isBlockPointerType()) 205 isMethod = 2; 206 } else 207 return; 208 } else 209 return; 210 211 if (warnNotEnoughArgs) { 212 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName(); 213 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod; 214 return; 215 } 216 int sentinel = i; 217 while (sentinelPos > 0 && i < NumArgs-1) { 218 --sentinelPos; 219 ++i; 220 } 221 if (sentinelPos > 0) { 222 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName(); 223 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod; 224 return; 225 } 226 while (i < NumArgs-1) { 227 ++i; 228 ++sentinel; 229 } 230 Expr *sentinelExpr = Args[sentinel]; 231 if (!sentinelExpr) return; 232 if (sentinelExpr->isTypeDependent()) return; 233 if (sentinelExpr->isValueDependent()) return; 234 235 // nullptr_t is always treated as null. 236 if (sentinelExpr->getType()->isNullPtrType()) return; 237 238 if (sentinelExpr->getType()->isAnyPointerType() && 239 sentinelExpr->IgnoreParenCasts()->isNullPointerConstant(Context, 240 Expr::NPC_ValueDependentIsNull)) 241 return; 242 243 // Unfortunately, __null has type 'int'. 244 if (isa<GNUNullExpr>(sentinelExpr)) return; 245 246 SourceLocation MissingNilLoc 247 = PP.getLocForEndOfToken(sentinelExpr->getLocEnd()); 248 std::string NullValue; 249 if (isMethod && PP.getIdentifierInfo("nil")->hasMacroDefinition()) 250 NullValue = "nil"; 251 else if (PP.getIdentifierInfo("NULL")->hasMacroDefinition()) 252 NullValue = "NULL"; 253 else if (Context.getTypeSize(Context.IntTy) 254 == Context.getTypeSize(Context.getSizeType())) 255 NullValue = "0"; 256 else 257 NullValue = "0L"; 258 259 Diag(MissingNilLoc, diag::warn_missing_sentinel) 260 << isMethod 261 << FixItHint::CreateInsertion(MissingNilLoc, ", " + NullValue); 262 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod; 263} 264 265SourceRange Sema::getExprRange(ExprTy *E) const { 266 Expr *Ex = (Expr *)E; 267 return Ex? Ex->getSourceRange() : SourceRange(); 268} 269 270//===----------------------------------------------------------------------===// 271// Standard Promotions and Conversions 272//===----------------------------------------------------------------------===// 273 274/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4). 275ExprResult Sema::DefaultFunctionArrayConversion(Expr *E) { 276 QualType Ty = E->getType(); 277 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type"); 278 279 if (Ty->isFunctionType()) 280 E = ImpCastExprToType(E, Context.getPointerType(Ty), 281 CK_FunctionToPointerDecay).take(); 282 else if (Ty->isArrayType()) { 283 // In C90 mode, arrays only promote to pointers if the array expression is 284 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has 285 // type 'array of type' is converted to an expression that has type 'pointer 286 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression 287 // that has type 'array of type' ...". The relevant change is "an lvalue" 288 // (C90) to "an expression" (C99). 289 // 290 // C++ 4.2p1: 291 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of 292 // T" can be converted to an rvalue of type "pointer to T". 293 // 294 if (getLangOptions().C99 || getLangOptions().CPlusPlus || E->isLValue()) 295 E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty), 296 CK_ArrayToPointerDecay).take(); 297 } 298 return Owned(E); 299} 300 301static void CheckForNullPointerDereference(Sema &S, Expr *E) { 302 // Check to see if we are dereferencing a null pointer. If so, 303 // and if not volatile-qualified, this is undefined behavior that the 304 // optimizer will delete, so warn about it. People sometimes try to use this 305 // to get a deterministic trap and are surprised by clang's behavior. This 306 // only handles the pattern "*null", which is a very syntactic check. 307 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts())) 308 if (UO->getOpcode() == UO_Deref && 309 UO->getSubExpr()->IgnoreParenCasts()-> 310 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) && 311 !UO->getType().isVolatileQualified()) { 312 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 313 S.PDiag(diag::warn_indirection_through_null) 314 << UO->getSubExpr()->getSourceRange()); 315 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 316 S.PDiag(diag::note_indirection_through_null)); 317 } 318} 319 320ExprResult Sema::DefaultLvalueConversion(Expr *E) { 321 // C++ [conv.lval]p1: 322 // A glvalue of a non-function, non-array type T can be 323 // converted to a prvalue. 324 if (!E->isGLValue()) return Owned(E); 325 326 QualType T = E->getType(); 327 assert(!T.isNull() && "r-value conversion on typeless expression?"); 328 329 // Create a load out of an ObjCProperty l-value, if necessary. 330 if (E->getObjectKind() == OK_ObjCProperty) { 331 ExprResult Res = ConvertPropertyForRValue(E); 332 if (Res.isInvalid()) 333 return Owned(E); 334 E = Res.take(); 335 if (!E->isGLValue()) 336 return Owned(E); 337 } 338 339 // We don't want to throw lvalue-to-rvalue casts on top of 340 // expressions of certain types in C++. 341 if (getLangOptions().CPlusPlus && 342 (E->getType() == Context.OverloadTy || 343 T->isDependentType() || 344 T->isRecordType())) 345 return Owned(E); 346 347 // The C standard is actually really unclear on this point, and 348 // DR106 tells us what the result should be but not why. It's 349 // generally best to say that void types just doesn't undergo 350 // lvalue-to-rvalue at all. Note that expressions of unqualified 351 // 'void' type are never l-values, but qualified void can be. 352 if (T->isVoidType()) 353 return Owned(E); 354 355 CheckForNullPointerDereference(*this, E); 356 357 // C++ [conv.lval]p1: 358 // [...] If T is a non-class type, the type of the prvalue is the 359 // cv-unqualified version of T. Otherwise, the type of the 360 // rvalue is T. 361 // 362 // C99 6.3.2.1p2: 363 // If the lvalue has qualified type, the value has the unqualified 364 // version of the type of the lvalue; otherwise, the value has the 365 // type of the lvalue. 366 if (T.hasQualifiers()) 367 T = T.getUnqualifiedType(); 368 369 return Owned(ImplicitCastExpr::Create(Context, T, CK_LValueToRValue, 370 E, 0, VK_RValue)); 371} 372 373ExprResult Sema::DefaultFunctionArrayLvalueConversion(Expr *E) { 374 ExprResult Res = DefaultFunctionArrayConversion(E); 375 if (Res.isInvalid()) 376 return ExprError(); 377 Res = DefaultLvalueConversion(Res.take()); 378 if (Res.isInvalid()) 379 return ExprError(); 380 return move(Res); 381} 382 383 384/// UsualUnaryConversions - Performs various conversions that are common to most 385/// operators (C99 6.3). The conversions of array and function types are 386/// sometimes suppressed. For example, the array->pointer conversion doesn't 387/// apply if the array is an argument to the sizeof or address (&) operators. 388/// In these instances, this routine should *not* be called. 389ExprResult Sema::UsualUnaryConversions(Expr *E) { 390 // First, convert to an r-value. 391 ExprResult Res = DefaultFunctionArrayLvalueConversion(E); 392 if (Res.isInvalid()) 393 return Owned(E); 394 E = Res.take(); 395 396 QualType Ty = E->getType(); 397 assert(!Ty.isNull() && "UsualUnaryConversions - missing type"); 398 399 // Try to perform integral promotions if the object has a theoretically 400 // promotable type. 401 if (Ty->isIntegralOrUnscopedEnumerationType()) { 402 // C99 6.3.1.1p2: 403 // 404 // The following may be used in an expression wherever an int or 405 // unsigned int may be used: 406 // - an object or expression with an integer type whose integer 407 // conversion rank is less than or equal to the rank of int 408 // and unsigned int. 409 // - A bit-field of type _Bool, int, signed int, or unsigned int. 410 // 411 // If an int can represent all values of the original type, the 412 // value is converted to an int; otherwise, it is converted to an 413 // unsigned int. These are called the integer promotions. All 414 // other types are unchanged by the integer promotions. 415 416 QualType PTy = Context.isPromotableBitField(E); 417 if (!PTy.isNull()) { 418 E = ImpCastExprToType(E, PTy, CK_IntegralCast).take(); 419 return Owned(E); 420 } 421 if (Ty->isPromotableIntegerType()) { 422 QualType PT = Context.getPromotedIntegerType(Ty); 423 E = ImpCastExprToType(E, PT, CK_IntegralCast).take(); 424 return Owned(E); 425 } 426 } 427 return Owned(E); 428} 429 430/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that 431/// do not have a prototype. Arguments that have type float are promoted to 432/// double. All other argument types are converted by UsualUnaryConversions(). 433ExprResult Sema::DefaultArgumentPromotion(Expr *E) { 434 QualType Ty = E->getType(); 435 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type"); 436 437 ExprResult Res = UsualUnaryConversions(E); 438 if (Res.isInvalid()) 439 return Owned(E); 440 E = Res.take(); 441 442 // If this is a 'float' (CVR qualified or typedef) promote to double. 443 if (Ty->isSpecificBuiltinType(BuiltinType::Float)) 444 E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).take(); 445 446 // C++ performs lvalue-to-rvalue conversion as a default argument 447 // promotion, even on class types, but note: 448 // C++11 [conv.lval]p2: 449 // When an lvalue-to-rvalue conversion occurs in an unevaluated 450 // operand or a subexpression thereof the value contained in the 451 // referenced object is not accessed. Otherwise, if the glvalue 452 // has a class type, the conversion copy-initializes a temporary 453 // of type T from the glvalue and the result of the conversion 454 // is a prvalue for the temporary. 455 // FIXME: add some way to gate this entire thing for correctness in 456 // potentially potentially evaluated contexts. 457 if (getLangOptions().CPlusPlus && E->isGLValue() && 458 ExprEvalContexts.back().Context != Unevaluated) { 459 ExprResult Temp = PerformCopyInitialization( 460 InitializedEntity::InitializeTemporary(E->getType()), 461 E->getExprLoc(), 462 Owned(E)); 463 if (Temp.isInvalid()) 464 return ExprError(); 465 E = Temp.get(); 466 } 467 468 return Owned(E); 469} 470 471/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but 472/// will warn if the resulting type is not a POD type, and rejects ObjC 473/// interfaces passed by value. 474ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, 475 FunctionDecl *FDecl) { 476 ExprResult ExprRes = CheckPlaceholderExpr(E); 477 if (ExprRes.isInvalid()) 478 return ExprError(); 479 480 ExprRes = DefaultArgumentPromotion(E); 481 if (ExprRes.isInvalid()) 482 return ExprError(); 483 E = ExprRes.take(); 484 485 // Don't allow one to pass an Objective-C interface to a vararg. 486 if (E->getType()->isObjCObjectType() && 487 DiagRuntimeBehavior(E->getLocStart(), 0, 488 PDiag(diag::err_cannot_pass_objc_interface_to_vararg) 489 << E->getType() << CT)) 490 return ExprError(); 491 492 if (!E->getType().isPODType(Context)) { 493 // C++0x [expr.call]p7: 494 // Passing a potentially-evaluated argument of class type (Clause 9) 495 // having a non-trivial copy constructor, a non-trivial move constructor, 496 // or a non-trivial destructor, with no corresponding parameter, 497 // is conditionally-supported with implementation-defined semantics. 498 bool TrivialEnough = false; 499 if (getLangOptions().CPlusPlus0x && !E->getType()->isDependentType()) { 500 if (CXXRecordDecl *Record = E->getType()->getAsCXXRecordDecl()) { 501 if (Record->hasTrivialCopyConstructor() && 502 Record->hasTrivialMoveConstructor() && 503 Record->hasTrivialDestructor()) 504 TrivialEnough = true; 505 } 506 } 507 508 if (!TrivialEnough && 509 getLangOptions().ObjCAutoRefCount && 510 E->getType()->isObjCLifetimeType()) 511 TrivialEnough = true; 512 513 if (TrivialEnough) { 514 // Nothing to diagnose. This is okay. 515 } else if (DiagRuntimeBehavior(E->getLocStart(), 0, 516 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg) 517 << getLangOptions().CPlusPlus0x << E->getType() 518 << CT)) { 519 // Turn this into a trap. 520 CXXScopeSpec SS; 521 UnqualifiedId Name; 522 Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"), 523 E->getLocStart()); 524 ExprResult TrapFn = ActOnIdExpression(TUScope, SS, Name, true, false); 525 if (TrapFn.isInvalid()) 526 return ExprError(); 527 528 ExprResult Call = ActOnCallExpr(TUScope, TrapFn.get(), E->getLocStart(), 529 MultiExprArg(), E->getLocEnd()); 530 if (Call.isInvalid()) 531 return ExprError(); 532 533 ExprResult Comma = ActOnBinOp(TUScope, E->getLocStart(), tok::comma, 534 Call.get(), E); 535 if (Comma.isInvalid()) 536 return ExprError(); 537 E = Comma.get(); 538 } 539 } 540 541 return Owned(E); 542} 543 544/// \brief Converts an integer to complex float type. Helper function of 545/// UsualArithmeticConversions() 546/// 547/// \return false if the integer expression is an integer type and is 548/// successfully converted to the complex type. 549static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &intExpr, 550 ExprResult &complexExpr, 551 QualType intTy, 552 QualType complexTy, 553 bool skipCast) { 554 if (intTy->isComplexType() || intTy->isRealFloatingType()) return true; 555 if (skipCast) return false; 556 if (intTy->isIntegerType()) { 557 QualType fpTy = cast<ComplexType>(complexTy)->getElementType(); 558 intExpr = S.ImpCastExprToType(intExpr.take(), fpTy, CK_IntegralToFloating); 559 intExpr = S.ImpCastExprToType(intExpr.take(), complexTy, 560 CK_FloatingRealToComplex); 561 } else { 562 assert(intTy->isComplexIntegerType()); 563 intExpr = S.ImpCastExprToType(intExpr.take(), complexTy, 564 CK_IntegralComplexToFloatingComplex); 565 } 566 return false; 567} 568 569/// \brief Takes two complex float types and converts them to the same type. 570/// Helper function of UsualArithmeticConversions() 571static QualType 572handleComplexFloatToComplexFloatConverstion(Sema &S, ExprResult &LHS, 573 ExprResult &RHS, QualType LHSType, 574 QualType RHSType, 575 bool isCompAssign) { 576 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 577 578 if (order < 0) { 579 // _Complex float -> _Complex double 580 if (!isCompAssign) 581 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingComplexCast); 582 return RHSType; 583 } 584 if (order > 0) 585 // _Complex float -> _Complex double 586 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingComplexCast); 587 return LHSType; 588} 589 590/// \brief Converts otherExpr to complex float and promotes complexExpr if 591/// necessary. Helper function of UsualArithmeticConversions() 592static QualType handleOtherComplexFloatConversion(Sema &S, 593 ExprResult &complexExpr, 594 ExprResult &otherExpr, 595 QualType complexTy, 596 QualType otherTy, 597 bool convertComplexExpr, 598 bool convertOtherExpr) { 599 int order = S.Context.getFloatingTypeOrder(complexTy, otherTy); 600 601 // If just the complexExpr is complex, the otherExpr needs to be converted, 602 // and the complexExpr might need to be promoted. 603 if (order > 0) { // complexExpr is wider 604 // float -> _Complex double 605 if (convertOtherExpr) { 606 QualType fp = cast<ComplexType>(complexTy)->getElementType(); 607 otherExpr = S.ImpCastExprToType(otherExpr.take(), fp, CK_FloatingCast); 608 otherExpr = S.ImpCastExprToType(otherExpr.take(), complexTy, 609 CK_FloatingRealToComplex); 610 } 611 return complexTy; 612 } 613 614 // otherTy is at least as wide. Find its corresponding complex type. 615 QualType result = (order == 0 ? complexTy : 616 S.Context.getComplexType(otherTy)); 617 618 // double -> _Complex double 619 if (convertOtherExpr) 620 otherExpr = S.ImpCastExprToType(otherExpr.take(), result, 621 CK_FloatingRealToComplex); 622 623 // _Complex float -> _Complex double 624 if (convertComplexExpr && order < 0) 625 complexExpr = S.ImpCastExprToType(complexExpr.take(), result, 626 CK_FloatingComplexCast); 627 628 return result; 629} 630 631/// \brief Handle arithmetic conversion with complex types. Helper function of 632/// UsualArithmeticConversions() 633static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS, 634 ExprResult &RHS, QualType LHSType, 635 QualType RHSType, 636 bool isCompAssign) { 637 // if we have an integer operand, the result is the complex type. 638 if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType, 639 /*skipCast*/false)) 640 return LHSType; 641 if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType, 642 /*skipCast*/isCompAssign)) 643 return RHSType; 644 645 // This handles complex/complex, complex/float, or float/complex. 646 // When both operands are complex, the shorter operand is converted to the 647 // type of the longer, and that is the type of the result. This corresponds 648 // to what is done when combining two real floating-point operands. 649 // The fun begins when size promotion occur across type domains. 650 // From H&S 6.3.4: When one operand is complex and the other is a real 651 // floating-point type, the less precise type is converted, within it's 652 // real or complex domain, to the precision of the other type. For example, 653 // when combining a "long double" with a "double _Complex", the 654 // "double _Complex" is promoted to "long double _Complex". 655 656 bool LHSComplexFloat = LHSType->isComplexType(); 657 bool RHSComplexFloat = RHSType->isComplexType(); 658 659 // If both are complex, just cast to the more precise type. 660 if (LHSComplexFloat && RHSComplexFloat) 661 return handleComplexFloatToComplexFloatConverstion(S, LHS, RHS, 662 LHSType, RHSType, 663 isCompAssign); 664 665 // If only one operand is complex, promote it if necessary and convert the 666 // other operand to complex. 667 if (LHSComplexFloat) 668 return handleOtherComplexFloatConversion( 669 S, LHS, RHS, LHSType, RHSType, /*convertComplexExpr*/!isCompAssign, 670 /*convertOtherExpr*/ true); 671 672 assert(RHSComplexFloat); 673 return handleOtherComplexFloatConversion( 674 S, RHS, LHS, RHSType, LHSType, /*convertComplexExpr*/true, 675 /*convertOtherExpr*/ !isCompAssign); 676} 677 678/// \brief Hande arithmetic conversion from integer to float. Helper function 679/// of UsualArithmeticConversions() 680static QualType handleIntToFloatConversion(Sema &S, ExprResult &floatExpr, 681 ExprResult &intExpr, 682 QualType floatTy, QualType intTy, 683 bool convertFloat, bool convertInt) { 684 if (intTy->isIntegerType()) { 685 if (convertInt) 686 // Convert intExpr to the lhs floating point type. 687 intExpr = S.ImpCastExprToType(intExpr.take(), floatTy, 688 CK_IntegralToFloating); 689 return floatTy; 690 } 691 692 // Convert both sides to the appropriate complex float. 693 assert(intTy->isComplexIntegerType()); 694 QualType result = S.Context.getComplexType(floatTy); 695 696 // _Complex int -> _Complex float 697 if (convertInt) 698 intExpr = S.ImpCastExprToType(intExpr.take(), result, 699 CK_IntegralComplexToFloatingComplex); 700 701 // float -> _Complex float 702 if (convertFloat) 703 floatExpr = S.ImpCastExprToType(floatExpr.take(), result, 704 CK_FloatingRealToComplex); 705 706 return result; 707} 708 709/// \brief Handle arithmethic conversion with floating point types. Helper 710/// function of UsualArithmeticConversions() 711static QualType handleFloatConversion(Sema &S, ExprResult &LHS, 712 ExprResult &RHS, QualType LHSType, 713 QualType RHSType, bool isCompAssign) { 714 bool LHSFloat = LHSType->isRealFloatingType(); 715 bool RHSFloat = RHSType->isRealFloatingType(); 716 717 // If we have two real floating types, convert the smaller operand 718 // to the bigger result. 719 if (LHSFloat && RHSFloat) { 720 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 721 if (order > 0) { 722 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingCast); 723 return LHSType; 724 } 725 726 assert(order < 0 && "illegal float comparison"); 727 if (!isCompAssign) 728 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingCast); 729 return RHSType; 730 } 731 732 if (LHSFloat) 733 return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType, 734 /*convertFloat=*/!isCompAssign, 735 /*convertInt=*/ true); 736 assert(RHSFloat); 737 return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType, 738 /*convertInt=*/ true, 739 /*convertFloat=*/!isCompAssign); 740} 741 742/// \brief Handle conversions with GCC complex int extension. Helper function 743/// of UsualArithmeticConversions() 744// FIXME: if the operands are (int, _Complex long), we currently 745// don't promote the complex. Also, signedness? 746static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS, 747 ExprResult &RHS, QualType LHSType, 748 QualType RHSType, 749 bool isCompAssign) { 750 const ComplexType *LHSComplexInt = LHSType->getAsComplexIntegerType(); 751 const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType(); 752 753 if (LHSComplexInt && RHSComplexInt) { 754 int order = S.Context.getIntegerTypeOrder(LHSComplexInt->getElementType(), 755 RHSComplexInt->getElementType()); 756 assert(order && "inequal types with equal element ordering"); 757 if (order > 0) { 758 // _Complex int -> _Complex long 759 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralComplexCast); 760 return LHSType; 761 } 762 763 if (!isCompAssign) 764 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralComplexCast); 765 return RHSType; 766 } 767 768 if (LHSComplexInt) { 769 // int -> _Complex int 770 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralRealToComplex); 771 return LHSType; 772 } 773 774 assert(RHSComplexInt); 775 // int -> _Complex int 776 if (!isCompAssign) 777 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralRealToComplex); 778 return RHSType; 779} 780 781/// \brief Handle integer arithmetic conversions. Helper function of 782/// UsualArithmeticConversions() 783static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, 784 ExprResult &RHS, QualType LHSType, 785 QualType RHSType, bool isCompAssign) { 786 // The rules for this case are in C99 6.3.1.8 787 int order = S.Context.getIntegerTypeOrder(LHSType, RHSType); 788 bool LHSSigned = LHSType->hasSignedIntegerRepresentation(); 789 bool RHSSigned = RHSType->hasSignedIntegerRepresentation(); 790 if (LHSSigned == RHSSigned) { 791 // Same signedness; use the higher-ranked type 792 if (order >= 0) { 793 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 794 return LHSType; 795 } else if (!isCompAssign) 796 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 797 return RHSType; 798 } else if (order != (LHSSigned ? 1 : -1)) { 799 // The unsigned type has greater than or equal rank to the 800 // signed type, so use the unsigned type 801 if (RHSSigned) { 802 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 803 return LHSType; 804 } else if (!isCompAssign) 805 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 806 return RHSType; 807 } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) { 808 // The two types are different widths; if we are here, that 809 // means the signed type is larger than the unsigned type, so 810 // use the signed type. 811 if (LHSSigned) { 812 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 813 return LHSType; 814 } else if (!isCompAssign) 815 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 816 return RHSType; 817 } else { 818 // The signed type is higher-ranked than the unsigned type, 819 // but isn't actually any bigger (like unsigned int and long 820 // on most 32-bit systems). Use the unsigned type corresponding 821 // to the signed type. 822 QualType result = 823 S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType); 824 RHS = S.ImpCastExprToType(RHS.take(), result, CK_IntegralCast); 825 if (!isCompAssign) 826 LHS = S.ImpCastExprToType(LHS.take(), result, CK_IntegralCast); 827 return result; 828 } 829} 830 831/// UsualArithmeticConversions - Performs various conversions that are common to 832/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this 833/// routine returns the first non-arithmetic type found. The client is 834/// responsible for emitting appropriate error diagnostics. 835/// FIXME: verify the conversion rules for "complex int" are consistent with 836/// GCC. 837QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, 838 bool isCompAssign) { 839 if (!isCompAssign) { 840 LHS = UsualUnaryConversions(LHS.take()); 841 if (LHS.isInvalid()) 842 return QualType(); 843 } 844 845 RHS = UsualUnaryConversions(RHS.take()); 846 if (RHS.isInvalid()) 847 return QualType(); 848 849 // For conversion purposes, we ignore any qualifiers. 850 // For example, "const float" and "float" are equivalent. 851 QualType LHSType = 852 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType(); 853 QualType RHSType = 854 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType(); 855 856 // If both types are identical, no conversion is needed. 857 if (LHSType == RHSType) 858 return LHSType; 859 860 // If either side is a non-arithmetic type (e.g. a pointer), we are done. 861 // The caller can deal with this (e.g. pointer + int). 862 if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType()) 863 return LHSType; 864 865 // Apply unary and bitfield promotions to the LHS's type. 866 QualType LHSUnpromotedType = LHSType; 867 if (LHSType->isPromotableIntegerType()) 868 LHSType = Context.getPromotedIntegerType(LHSType); 869 QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get()); 870 if (!LHSBitfieldPromoteTy.isNull()) 871 LHSType = LHSBitfieldPromoteTy; 872 if (LHSType != LHSUnpromotedType && !isCompAssign) 873 LHS = ImpCastExprToType(LHS.take(), LHSType, CK_IntegralCast); 874 875 // If both types are identical, no conversion is needed. 876 if (LHSType == RHSType) 877 return LHSType; 878 879 // At this point, we have two different arithmetic types. 880 881 // Handle complex types first (C99 6.3.1.8p1). 882 if (LHSType->isComplexType() || RHSType->isComplexType()) 883 return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType, 884 isCompAssign); 885 886 // Now handle "real" floating types (i.e. float, double, long double). 887 if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType()) 888 return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType, 889 isCompAssign); 890 891 // Handle GCC complex int extension. 892 if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType()) 893 return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType, 894 isCompAssign); 895 896 // Finally, we have two differing integer types. 897 return handleIntegerConversion(*this, LHS, RHS, LHSType, RHSType, 898 isCompAssign); 899} 900 901//===----------------------------------------------------------------------===// 902// Semantic Analysis for various Expression Types 903//===----------------------------------------------------------------------===// 904 905 906ExprResult 907Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc, 908 SourceLocation DefaultLoc, 909 SourceLocation RParenLoc, 910 Expr *ControllingExpr, 911 MultiTypeArg types, 912 MultiExprArg exprs) { 913 unsigned NumAssocs = types.size(); 914 assert(NumAssocs == exprs.size()); 915 916 ParsedType *ParsedTypes = types.release(); 917 Expr **Exprs = exprs.release(); 918 919 TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs]; 920 for (unsigned i = 0; i < NumAssocs; ++i) { 921 if (ParsedTypes[i]) 922 (void) GetTypeFromParser(ParsedTypes[i], &Types[i]); 923 else 924 Types[i] = 0; 925 } 926 927 ExprResult ER = CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, 928 ControllingExpr, Types, Exprs, 929 NumAssocs); 930 delete [] Types; 931 return ER; 932} 933 934ExprResult 935Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc, 936 SourceLocation DefaultLoc, 937 SourceLocation RParenLoc, 938 Expr *ControllingExpr, 939 TypeSourceInfo **Types, 940 Expr **Exprs, 941 unsigned NumAssocs) { 942 bool TypeErrorFound = false, 943 IsResultDependent = ControllingExpr->isTypeDependent(), 944 ContainsUnexpandedParameterPack 945 = ControllingExpr->containsUnexpandedParameterPack(); 946 947 for (unsigned i = 0; i < NumAssocs; ++i) { 948 if (Exprs[i]->containsUnexpandedParameterPack()) 949 ContainsUnexpandedParameterPack = true; 950 951 if (Types[i]) { 952 if (Types[i]->getType()->containsUnexpandedParameterPack()) 953 ContainsUnexpandedParameterPack = true; 954 955 if (Types[i]->getType()->isDependentType()) { 956 IsResultDependent = true; 957 } else { 958 // C1X 6.5.1.1p2 "The type name in a generic association shall specify a 959 // complete object type other than a variably modified type." 960 unsigned D = 0; 961 if (Types[i]->getType()->isIncompleteType()) 962 D = diag::err_assoc_type_incomplete; 963 else if (!Types[i]->getType()->isObjectType()) 964 D = diag::err_assoc_type_nonobject; 965 else if (Types[i]->getType()->isVariablyModifiedType()) 966 D = diag::err_assoc_type_variably_modified; 967 968 if (D != 0) { 969 Diag(Types[i]->getTypeLoc().getBeginLoc(), D) 970 << Types[i]->getTypeLoc().getSourceRange() 971 << Types[i]->getType(); 972 TypeErrorFound = true; 973 } 974 975 // C1X 6.5.1.1p2 "No two generic associations in the same generic 976 // selection shall specify compatible types." 977 for (unsigned j = i+1; j < NumAssocs; ++j) 978 if (Types[j] && !Types[j]->getType()->isDependentType() && 979 Context.typesAreCompatible(Types[i]->getType(), 980 Types[j]->getType())) { 981 Diag(Types[j]->getTypeLoc().getBeginLoc(), 982 diag::err_assoc_compatible_types) 983 << Types[j]->getTypeLoc().getSourceRange() 984 << Types[j]->getType() 985 << Types[i]->getType(); 986 Diag(Types[i]->getTypeLoc().getBeginLoc(), 987 diag::note_compat_assoc) 988 << Types[i]->getTypeLoc().getSourceRange() 989 << Types[i]->getType(); 990 TypeErrorFound = true; 991 } 992 } 993 } 994 } 995 if (TypeErrorFound) 996 return ExprError(); 997 998 // If we determined that the generic selection is result-dependent, don't 999 // try to compute the result expression. 1000 if (IsResultDependent) 1001 return Owned(new (Context) GenericSelectionExpr( 1002 Context, KeyLoc, ControllingExpr, 1003 Types, Exprs, NumAssocs, DefaultLoc, 1004 RParenLoc, ContainsUnexpandedParameterPack)); 1005 1006 SmallVector<unsigned, 1> CompatIndices; 1007 unsigned DefaultIndex = -1U; 1008 for (unsigned i = 0; i < NumAssocs; ++i) { 1009 if (!Types[i]) 1010 DefaultIndex = i; 1011 else if (Context.typesAreCompatible(ControllingExpr->getType(), 1012 Types[i]->getType())) 1013 CompatIndices.push_back(i); 1014 } 1015 1016 // C1X 6.5.1.1p2 "The controlling expression of a generic selection shall have 1017 // type compatible with at most one of the types named in its generic 1018 // association list." 1019 if (CompatIndices.size() > 1) { 1020 // We strip parens here because the controlling expression is typically 1021 // parenthesized in macro definitions. 1022 ControllingExpr = ControllingExpr->IgnoreParens(); 1023 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_multi_match) 1024 << ControllingExpr->getSourceRange() << ControllingExpr->getType() 1025 << (unsigned) CompatIndices.size(); 1026 for (SmallVector<unsigned, 1>::iterator I = CompatIndices.begin(), 1027 E = CompatIndices.end(); I != E; ++I) { 1028 Diag(Types[*I]->getTypeLoc().getBeginLoc(), 1029 diag::note_compat_assoc) 1030 << Types[*I]->getTypeLoc().getSourceRange() 1031 << Types[*I]->getType(); 1032 } 1033 return ExprError(); 1034 } 1035 1036 // C1X 6.5.1.1p2 "If a generic selection has no default generic association, 1037 // its controlling expression shall have type compatible with exactly one of 1038 // the types named in its generic association list." 1039 if (DefaultIndex == -1U && CompatIndices.size() == 0) { 1040 // We strip parens here because the controlling expression is typically 1041 // parenthesized in macro definitions. 1042 ControllingExpr = ControllingExpr->IgnoreParens(); 1043 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_no_match) 1044 << ControllingExpr->getSourceRange() << ControllingExpr->getType(); 1045 return ExprError(); 1046 } 1047 1048 // C1X 6.5.1.1p3 "If a generic selection has a generic association with a 1049 // type name that is compatible with the type of the controlling expression, 1050 // then the result expression of the generic selection is the expression 1051 // in that generic association. Otherwise, the result expression of the 1052 // generic selection is the expression in the default generic association." 1053 unsigned ResultIndex = 1054 CompatIndices.size() ? CompatIndices[0] : DefaultIndex; 1055 1056 return Owned(new (Context) GenericSelectionExpr( 1057 Context, KeyLoc, ControllingExpr, 1058 Types, Exprs, NumAssocs, DefaultLoc, 1059 RParenLoc, ContainsUnexpandedParameterPack, 1060 ResultIndex)); 1061} 1062 1063/// ActOnStringLiteral - The specified tokens were lexed as pasted string 1064/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string 1065/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from 1066/// multiple tokens. However, the common case is that StringToks points to one 1067/// string. 1068/// 1069ExprResult 1070Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks) { 1071 assert(NumStringToks && "Must have at least one string!"); 1072 1073 StringLiteralParser Literal(StringToks, NumStringToks, PP); 1074 if (Literal.hadError) 1075 return ExprError(); 1076 1077 SmallVector<SourceLocation, 4> StringTokLocs; 1078 for (unsigned i = 0; i != NumStringToks; ++i) 1079 StringTokLocs.push_back(StringToks[i].getLocation()); 1080 1081 QualType StrTy = Context.CharTy; 1082 if (Literal.isWide()) 1083 StrTy = Context.getWCharType(); 1084 else if (Literal.isUTF16()) 1085 StrTy = Context.Char16Ty; 1086 else if (Literal.isUTF32()) 1087 StrTy = Context.Char32Ty; 1088 else if (Literal.Pascal) 1089 StrTy = Context.UnsignedCharTy; 1090 1091 StringLiteral::StringKind Kind = StringLiteral::Ascii; 1092 if (Literal.isWide()) 1093 Kind = StringLiteral::Wide; 1094 else if (Literal.isUTF8()) 1095 Kind = StringLiteral::UTF8; 1096 else if (Literal.isUTF16()) 1097 Kind = StringLiteral::UTF16; 1098 else if (Literal.isUTF32()) 1099 Kind = StringLiteral::UTF32; 1100 1101 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1). 1102 if (getLangOptions().CPlusPlus || getLangOptions().ConstStrings) 1103 StrTy.addConst(); 1104 1105 // Get an array type for the string, according to C99 6.4.5. This includes 1106 // the nul terminator character as well as the string length for pascal 1107 // strings. 1108 StrTy = Context.getConstantArrayType(StrTy, 1109 llvm::APInt(32, Literal.GetNumStringChars()+1), 1110 ArrayType::Normal, 0); 1111 1112 // Pass &StringTokLocs[0], StringTokLocs.size() to factory! 1113 return Owned(StringLiteral::Create(Context, Literal.GetString(), 1114 Kind, Literal.Pascal, StrTy, 1115 &StringTokLocs[0], 1116 StringTokLocs.size())); 1117} 1118 1119enum CaptureResult { 1120 /// No capture is required. 1121 CR_NoCapture, 1122 1123 /// A capture is required. 1124 CR_Capture, 1125 1126 /// A by-ref capture is required. 1127 CR_CaptureByRef, 1128 1129 /// An error occurred when trying to capture the given variable. 1130 CR_Error 1131}; 1132 1133/// Diagnose an uncapturable value reference. 1134/// 1135/// \param var - the variable referenced 1136/// \param DC - the context which we couldn't capture through 1137static CaptureResult 1138diagnoseUncapturableValueReference(Sema &S, SourceLocation loc, 1139 VarDecl *var, DeclContext *DC) { 1140 switch (S.ExprEvalContexts.back().Context) { 1141 case Sema::Unevaluated: 1142 // The argument will never be evaluated, so don't complain. 1143 return CR_NoCapture; 1144 1145 case Sema::PotentiallyEvaluated: 1146 case Sema::PotentiallyEvaluatedIfUsed: 1147 break; 1148 1149 case Sema::PotentiallyPotentiallyEvaluated: 1150 // FIXME: delay these! 1151 break; 1152 } 1153 1154 // Don't diagnose about capture if we're not actually in code right 1155 // now; in general, there are more appropriate places that will 1156 // diagnose this. 1157 if (!S.CurContext->isFunctionOrMethod()) return CR_NoCapture; 1158 1159 // Certain madnesses can happen with parameter declarations, which 1160 // we want to ignore. 1161 if (isa<ParmVarDecl>(var)) { 1162 // - If the parameter still belongs to the translation unit, then 1163 // we're actually just using one parameter in the declaration of 1164 // the next. This is useful in e.g. VLAs. 1165 if (isa<TranslationUnitDecl>(var->getDeclContext())) 1166 return CR_NoCapture; 1167 1168 // - This particular madness can happen in ill-formed default 1169 // arguments; claim it's okay and let downstream code handle it. 1170 if (S.CurContext == var->getDeclContext()->getParent()) 1171 return CR_NoCapture; 1172 } 1173 1174 DeclarationName functionName; 1175 if (FunctionDecl *fn = dyn_cast<FunctionDecl>(var->getDeclContext())) 1176 functionName = fn->getDeclName(); 1177 // FIXME: variable from enclosing block that we couldn't capture from! 1178 1179 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_function) 1180 << var->getIdentifier() << functionName; 1181 S.Diag(var->getLocation(), diag::note_local_variable_declared_here) 1182 << var->getIdentifier(); 1183 1184 return CR_Error; 1185} 1186 1187/// There is a well-formed capture at a particular scope level; 1188/// propagate it through all the nested blocks. 1189static CaptureResult propagateCapture(Sema &S, unsigned validScopeIndex, 1190 const BlockDecl::Capture &capture) { 1191 VarDecl *var = capture.getVariable(); 1192 1193 // Update all the inner blocks with the capture information. 1194 for (unsigned i = validScopeIndex + 1, e = S.FunctionScopes.size(); 1195 i != e; ++i) { 1196 BlockScopeInfo *innerBlock = cast<BlockScopeInfo>(S.FunctionScopes[i]); 1197 innerBlock->Captures.push_back( 1198 BlockDecl::Capture(capture.getVariable(), capture.isByRef(), 1199 /*nested*/ true, capture.getCopyExpr())); 1200 innerBlock->CaptureMap[var] = innerBlock->Captures.size(); // +1 1201 } 1202 1203 return capture.isByRef() ? CR_CaptureByRef : CR_Capture; 1204} 1205 1206/// shouldCaptureValueReference - Determine if a reference to the 1207/// given value in the current context requires a variable capture. 1208/// 1209/// This also keeps the captures set in the BlockScopeInfo records 1210/// up-to-date. 1211static CaptureResult shouldCaptureValueReference(Sema &S, SourceLocation loc, 1212 ValueDecl *value) { 1213 // Only variables ever require capture. 1214 VarDecl *var = dyn_cast<VarDecl>(value); 1215 if (!var) return CR_NoCapture; 1216 1217 // Fast path: variables from the current context never require capture. 1218 DeclContext *DC = S.CurContext; 1219 if (var->getDeclContext() == DC) return CR_NoCapture; 1220 1221 // Only variables with local storage require capture. 1222 // FIXME: What about 'const' variables in C++? 1223 if (!var->hasLocalStorage()) return CR_NoCapture; 1224 1225 // Otherwise, we need to capture. 1226 1227 unsigned functionScopesIndex = S.FunctionScopes.size() - 1; 1228 do { 1229 // Only blocks (and eventually C++0x closures) can capture; other 1230 // scopes don't work. 1231 if (!isa<BlockDecl>(DC)) 1232 return diagnoseUncapturableValueReference(S, loc, var, DC); 1233 1234 BlockScopeInfo *blockScope = 1235 cast<BlockScopeInfo>(S.FunctionScopes[functionScopesIndex]); 1236 assert(blockScope->TheDecl == static_cast<BlockDecl*>(DC)); 1237 1238 // Check whether we've already captured it in this block. If so, 1239 // we're done. 1240 if (unsigned indexPlus1 = blockScope->CaptureMap[var]) 1241 return propagateCapture(S, functionScopesIndex, 1242 blockScope->Captures[indexPlus1 - 1]); 1243 1244 functionScopesIndex--; 1245 DC = cast<BlockDecl>(DC)->getDeclContext(); 1246 } while (var->getDeclContext() != DC); 1247 1248 // Okay, we descended all the way to the block that defines the variable. 1249 // Actually try to capture it. 1250 QualType type = var->getType(); 1251 1252 // Prohibit variably-modified types. 1253 if (type->isVariablyModifiedType()) { 1254 S.Diag(loc, diag::err_ref_vm_type); 1255 S.Diag(var->getLocation(), diag::note_declared_at); 1256 return CR_Error; 1257 } 1258 1259 // Prohibit arrays, even in __block variables, but not references to 1260 // them. 1261 if (type->isArrayType()) { 1262 S.Diag(loc, diag::err_ref_array_type); 1263 S.Diag(var->getLocation(), diag::note_declared_at); 1264 return CR_Error; 1265 } 1266 1267 S.MarkDeclarationReferenced(loc, var); 1268 1269 // The BlocksAttr indicates the variable is bound by-reference. 1270 bool byRef = var->hasAttr<BlocksAttr>(); 1271 1272 // Build a copy expression. 1273 Expr *copyExpr = 0; 1274 const RecordType *rtype; 1275 if (!byRef && S.getLangOptions().CPlusPlus && !type->isDependentType() && 1276 (rtype = type->getAs<RecordType>())) { 1277 1278 // The capture logic needs the destructor, so make sure we mark it. 1279 // Usually this is unnecessary because most local variables have 1280 // their destructors marked at declaration time, but parameters are 1281 // an exception because it's technically only the call site that 1282 // actually requires the destructor. 1283 if (isa<ParmVarDecl>(var)) 1284 S.FinalizeVarWithDestructor(var, rtype); 1285 1286 // According to the blocks spec, the capture of a variable from 1287 // the stack requires a const copy constructor. This is not true 1288 // of the copy/move done to move a __block variable to the heap. 1289 type.addConst(); 1290 1291 Expr *declRef = new (S.Context) DeclRefExpr(var, type, VK_LValue, loc); 1292 ExprResult result = 1293 S.PerformCopyInitialization( 1294 InitializedEntity::InitializeBlock(var->getLocation(), 1295 type, false), 1296 loc, S.Owned(declRef)); 1297 1298 // Build a full-expression copy expression if initialization 1299 // succeeded and used a non-trivial constructor. Recover from 1300 // errors by pretending that the copy isn't necessary. 1301 if (!result.isInvalid() && 1302 !cast<CXXConstructExpr>(result.get())->getConstructor()->isTrivial()) { 1303 result = S.MaybeCreateExprWithCleanups(result); 1304 copyExpr = result.take(); 1305 } 1306 } 1307 1308 // We're currently at the declarer; go back to the closure. 1309 functionScopesIndex++; 1310 BlockScopeInfo *blockScope = 1311 cast<BlockScopeInfo>(S.FunctionScopes[functionScopesIndex]); 1312 1313 // Build a valid capture in this scope. 1314 blockScope->Captures.push_back( 1315 BlockDecl::Capture(var, byRef, /*nested*/ false, copyExpr)); 1316 blockScope->CaptureMap[var] = blockScope->Captures.size(); // +1 1317 1318 // Propagate that to inner captures if necessary. 1319 return propagateCapture(S, functionScopesIndex, 1320 blockScope->Captures.back()); 1321} 1322 1323static ExprResult BuildBlockDeclRefExpr(Sema &S, ValueDecl *vd, 1324 const DeclarationNameInfo &NameInfo, 1325 bool byRef) { 1326 assert(isa<VarDecl>(vd) && "capturing non-variable"); 1327 1328 VarDecl *var = cast<VarDecl>(vd); 1329 assert(var->hasLocalStorage() && "capturing non-local"); 1330 assert(byRef == var->hasAttr<BlocksAttr>() && "byref set wrong"); 1331 1332 QualType exprType = var->getType().getNonReferenceType(); 1333 1334 BlockDeclRefExpr *BDRE; 1335 if (!byRef) { 1336 // The variable will be bound by copy; make it const within the 1337 // closure, but record that this was done in the expression. 1338 bool constAdded = !exprType.isConstQualified(); 1339 exprType.addConst(); 1340 1341 BDRE = new (S.Context) BlockDeclRefExpr(var, exprType, VK_LValue, 1342 NameInfo.getLoc(), false, 1343 constAdded); 1344 } else { 1345 BDRE = new (S.Context) BlockDeclRefExpr(var, exprType, VK_LValue, 1346 NameInfo.getLoc(), true); 1347 } 1348 1349 return S.Owned(BDRE); 1350} 1351 1352ExprResult 1353Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1354 SourceLocation Loc, 1355 const CXXScopeSpec *SS) { 1356 DeclarationNameInfo NameInfo(D->getDeclName(), Loc); 1357 return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS); 1358} 1359 1360/// BuildDeclRefExpr - Build an expression that references a 1361/// declaration that does not require a closure capture. 1362ExprResult 1363Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1364 const DeclarationNameInfo &NameInfo, 1365 const CXXScopeSpec *SS) { 1366 MarkDeclarationReferenced(NameInfo.getLoc(), D); 1367 1368 Expr *E = DeclRefExpr::Create(Context, 1369 SS? SS->getWithLocInContext(Context) 1370 : NestedNameSpecifierLoc(), 1371 D, NameInfo, Ty, VK); 1372 1373 // Just in case we're building an illegal pointer-to-member. 1374 if (isa<FieldDecl>(D) && cast<FieldDecl>(D)->getBitWidth()) 1375 E->setObjectKind(OK_BitField); 1376 1377 return Owned(E); 1378} 1379 1380/// Decomposes the given name into a DeclarationNameInfo, its location, and 1381/// possibly a list of template arguments. 1382/// 1383/// If this produces template arguments, it is permitted to call 1384/// DecomposeTemplateName. 1385/// 1386/// This actually loses a lot of source location information for 1387/// non-standard name kinds; we should consider preserving that in 1388/// some way. 1389void 1390Sema::DecomposeUnqualifiedId(const UnqualifiedId &Id, 1391 TemplateArgumentListInfo &Buffer, 1392 DeclarationNameInfo &NameInfo, 1393 const TemplateArgumentListInfo *&TemplateArgs) { 1394 if (Id.getKind() == UnqualifiedId::IK_TemplateId) { 1395 Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc); 1396 Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc); 1397 1398 ASTTemplateArgsPtr TemplateArgsPtr(*this, 1399 Id.TemplateId->getTemplateArgs(), 1400 Id.TemplateId->NumArgs); 1401 translateTemplateArguments(TemplateArgsPtr, Buffer); 1402 TemplateArgsPtr.release(); 1403 1404 TemplateName TName = Id.TemplateId->Template.get(); 1405 SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc; 1406 NameInfo = Context.getNameForTemplate(TName, TNameLoc); 1407 TemplateArgs = &Buffer; 1408 } else { 1409 NameInfo = GetNameFromUnqualifiedId(Id); 1410 TemplateArgs = 0; 1411 } 1412} 1413 1414/// Diagnose an empty lookup. 1415/// 1416/// \return false if new lookup candidates were found 1417bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, 1418 CorrectTypoContext CTC, 1419 TemplateArgumentListInfo *ExplicitTemplateArgs, 1420 Expr **Args, unsigned NumArgs) { 1421 DeclarationName Name = R.getLookupName(); 1422 1423 unsigned diagnostic = diag::err_undeclared_var_use; 1424 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest; 1425 if (Name.getNameKind() == DeclarationName::CXXOperatorName || 1426 Name.getNameKind() == DeclarationName::CXXLiteralOperatorName || 1427 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 1428 diagnostic = diag::err_undeclared_use; 1429 diagnostic_suggest = diag::err_undeclared_use_suggest; 1430 } 1431 1432 // If the original lookup was an unqualified lookup, fake an 1433 // unqualified lookup. This is useful when (for example) the 1434 // original lookup would not have found something because it was a 1435 // dependent name. 1436 for (DeclContext *DC = SS.isEmpty() ? CurContext : 0; 1437 DC; DC = DC->getParent()) { 1438 if (isa<CXXRecordDecl>(DC)) { 1439 LookupQualifiedName(R, DC); 1440 1441 if (!R.empty()) { 1442 // Don't give errors about ambiguities in this lookup. 1443 R.suppressDiagnostics(); 1444 1445 CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext); 1446 bool isInstance = CurMethod && 1447 CurMethod->isInstance() && 1448 DC == CurMethod->getParent(); 1449 1450 // Give a code modification hint to insert 'this->'. 1451 // TODO: fixit for inserting 'Base<T>::' in the other cases. 1452 // Actually quite difficult! 1453 if (isInstance) { 1454 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>( 1455 CallsUndergoingInstantiation.back()->getCallee()); 1456 CXXMethodDecl *DepMethod = cast_or_null<CXXMethodDecl>( 1457 CurMethod->getInstantiatedFromMemberFunction()); 1458 if (DepMethod) { 1459 Diag(R.getNameLoc(), diagnostic) << Name 1460 << FixItHint::CreateInsertion(R.getNameLoc(), "this->"); 1461 QualType DepThisType = DepMethod->getThisType(Context); 1462 CXXThisExpr *DepThis = new (Context) CXXThisExpr( 1463 R.getNameLoc(), DepThisType, false); 1464 TemplateArgumentListInfo TList; 1465 if (ULE->hasExplicitTemplateArgs()) 1466 ULE->copyTemplateArgumentsInto(TList); 1467 1468 CXXScopeSpec SS; 1469 SS.Adopt(ULE->getQualifierLoc()); 1470 CXXDependentScopeMemberExpr *DepExpr = 1471 CXXDependentScopeMemberExpr::Create( 1472 Context, DepThis, DepThisType, true, SourceLocation(), 1473 SS.getWithLocInContext(Context), NULL, 1474 R.getLookupNameInfo(), 1475 ULE->hasExplicitTemplateArgs() ? &TList : 0); 1476 CallsUndergoingInstantiation.back()->setCallee(DepExpr); 1477 } else { 1478 // FIXME: we should be able to handle this case too. It is correct 1479 // to add this-> here. This is a workaround for PR7947. 1480 Diag(R.getNameLoc(), diagnostic) << Name; 1481 } 1482 } else { 1483 Diag(R.getNameLoc(), diagnostic) << Name; 1484 } 1485 1486 // Do we really want to note all of these? 1487 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) 1488 Diag((*I)->getLocation(), diag::note_dependent_var_use); 1489 1490 // Tell the callee to try to recover. 1491 return false; 1492 } 1493 1494 R.clear(); 1495 } 1496 } 1497 1498 // We didn't find anything, so try to correct for a typo. 1499 TypoCorrection Corrected; 1500 if (S && (Corrected = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), 1501 S, &SS, NULL, false, CTC))) { 1502 std::string CorrectedStr(Corrected.getAsString(getLangOptions())); 1503 std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOptions())); 1504 R.setLookupName(Corrected.getCorrection()); 1505 1506 if (NamedDecl *ND = Corrected.getCorrectionDecl()) { 1507 if (Corrected.isOverloaded()) { 1508 OverloadCandidateSet OCS(R.getNameLoc()); 1509 OverloadCandidateSet::iterator Best; 1510 for (TypoCorrection::decl_iterator CD = Corrected.begin(), 1511 CDEnd = Corrected.end(); 1512 CD != CDEnd; ++CD) { 1513 if (FunctionTemplateDecl *FTD = 1514 dyn_cast<FunctionTemplateDecl>(*CD)) 1515 AddTemplateOverloadCandidate( 1516 FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs, 1517 Args, NumArgs, OCS); 1518 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD)) 1519 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0) 1520 AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), 1521 Args, NumArgs, OCS); 1522 } 1523 switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) { 1524 case OR_Success: 1525 ND = Best->Function; 1526 break; 1527 default: 1528 break; 1529 } 1530 } 1531 R.addDecl(ND); 1532 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) { 1533 if (SS.isEmpty()) 1534 Diag(R.getNameLoc(), diagnostic_suggest) << Name << CorrectedQuotedStr 1535 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr); 1536 else 1537 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1538 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1539 << SS.getRange() 1540 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr); 1541 if (ND) 1542 Diag(ND->getLocation(), diag::note_previous_decl) 1543 << CorrectedQuotedStr; 1544 1545 // Tell the callee to try to recover. 1546 return false; 1547 } 1548 1549 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) { 1550 // FIXME: If we ended up with a typo for a type name or 1551 // Objective-C class name, we're in trouble because the parser 1552 // is in the wrong place to recover. Suggest the typo 1553 // correction, but don't make it a fix-it since we're not going 1554 // to recover well anyway. 1555 if (SS.isEmpty()) 1556 Diag(R.getNameLoc(), diagnostic_suggest) 1557 << Name << CorrectedQuotedStr; 1558 else 1559 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1560 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1561 << SS.getRange(); 1562 1563 // Don't try to recover; it won't work. 1564 return true; 1565 } 1566 } else { 1567 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it 1568 // because we aren't able to recover. 1569 if (SS.isEmpty()) 1570 Diag(R.getNameLoc(), diagnostic_suggest) << Name << CorrectedQuotedStr; 1571 else 1572 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1573 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1574 << SS.getRange(); 1575 return true; 1576 } 1577 } 1578 R.clear(); 1579 1580 // Emit a special diagnostic for failed member lookups. 1581 // FIXME: computing the declaration context might fail here (?) 1582 if (!SS.isEmpty()) { 1583 Diag(R.getNameLoc(), diag::err_no_member) 1584 << Name << computeDeclContext(SS, false) 1585 << SS.getRange(); 1586 return true; 1587 } 1588 1589 // Give up, we can't recover. 1590 Diag(R.getNameLoc(), diagnostic) << Name; 1591 return true; 1592} 1593 1594ExprResult Sema::ActOnIdExpression(Scope *S, 1595 CXXScopeSpec &SS, 1596 UnqualifiedId &Id, 1597 bool HasTrailingLParen, 1598 bool isAddressOfOperand) { 1599 assert(!(isAddressOfOperand && HasTrailingLParen) && 1600 "cannot be direct & operand and have a trailing lparen"); 1601 1602 if (SS.isInvalid()) 1603 return ExprError(); 1604 1605 TemplateArgumentListInfo TemplateArgsBuffer; 1606 1607 // Decompose the UnqualifiedId into the following data. 1608 DeclarationNameInfo NameInfo; 1609 const TemplateArgumentListInfo *TemplateArgs; 1610 DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs); 1611 1612 DeclarationName Name = NameInfo.getName(); 1613 IdentifierInfo *II = Name.getAsIdentifierInfo(); 1614 SourceLocation NameLoc = NameInfo.getLoc(); 1615 1616 // C++ [temp.dep.expr]p3: 1617 // An id-expression is type-dependent if it contains: 1618 // -- an identifier that was declared with a dependent type, 1619 // (note: handled after lookup) 1620 // -- a template-id that is dependent, 1621 // (note: handled in BuildTemplateIdExpr) 1622 // -- a conversion-function-id that specifies a dependent type, 1623 // -- a nested-name-specifier that contains a class-name that 1624 // names a dependent type. 1625 // Determine whether this is a member of an unknown specialization; 1626 // we need to handle these differently. 1627 bool DependentID = false; 1628 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName && 1629 Name.getCXXNameType()->isDependentType()) { 1630 DependentID = true; 1631 } else if (SS.isSet()) { 1632 if (DeclContext *DC = computeDeclContext(SS, false)) { 1633 if (RequireCompleteDeclContext(SS, DC)) 1634 return ExprError(); 1635 } else { 1636 DependentID = true; 1637 } 1638 } 1639 1640 if (DependentID) 1641 return ActOnDependentIdExpression(SS, NameInfo, isAddressOfOperand, 1642 TemplateArgs); 1643 1644 bool IvarLookupFollowUp = false; 1645 // Perform the required lookup. 1646 LookupResult R(*this, NameInfo, 1647 (Id.getKind() == UnqualifiedId::IK_ImplicitSelfParam) 1648 ? LookupObjCImplicitSelfParam : LookupOrdinaryName); 1649 if (TemplateArgs) { 1650 // Lookup the template name again to correctly establish the context in 1651 // which it was found. This is really unfortunate as we already did the 1652 // lookup to determine that it was a template name in the first place. If 1653 // this becomes a performance hit, we can work harder to preserve those 1654 // results until we get here but it's likely not worth it. 1655 bool MemberOfUnknownSpecialization; 1656 LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false, 1657 MemberOfUnknownSpecialization); 1658 1659 if (MemberOfUnknownSpecialization || 1660 (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)) 1661 return ActOnDependentIdExpression(SS, NameInfo, isAddressOfOperand, 1662 TemplateArgs); 1663 } else { 1664 IvarLookupFollowUp = (!SS.isSet() && II && getCurMethodDecl()); 1665 LookupParsedName(R, S, &SS, !IvarLookupFollowUp); 1666 1667 // If the result might be in a dependent base class, this is a dependent 1668 // id-expression. 1669 if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation) 1670 return ActOnDependentIdExpression(SS, NameInfo, isAddressOfOperand, 1671 TemplateArgs); 1672 1673 // If this reference is in an Objective-C method, then we need to do 1674 // some special Objective-C lookup, too. 1675 if (IvarLookupFollowUp) { 1676 ExprResult E(LookupInObjCMethod(R, S, II, true)); 1677 if (E.isInvalid()) 1678 return ExprError(); 1679 1680 if (Expr *Ex = E.takeAs<Expr>()) 1681 return Owned(Ex); 1682 1683 // for further use, this must be set to false if in class method. 1684 IvarLookupFollowUp = getCurMethodDecl()->isInstanceMethod(); 1685 } 1686 } 1687 1688 if (R.isAmbiguous()) 1689 return ExprError(); 1690 1691 // Determine whether this name might be a candidate for 1692 // argument-dependent lookup. 1693 bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen); 1694 1695 if (R.empty() && !ADL) { 1696 // Otherwise, this could be an implicitly declared function reference (legal 1697 // in C90, extension in C99, forbidden in C++). 1698 if (HasTrailingLParen && II && !getLangOptions().CPlusPlus) { 1699 NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S); 1700 if (D) R.addDecl(D); 1701 } 1702 1703 // If this name wasn't predeclared and if this is not a function 1704 // call, diagnose the problem. 1705 if (R.empty()) { 1706 if (DiagnoseEmptyLookup(S, SS, R, CTC_Unknown)) 1707 return ExprError(); 1708 1709 assert(!R.empty() && 1710 "DiagnoseEmptyLookup returned false but added no results"); 1711 1712 // If we found an Objective-C instance variable, let 1713 // LookupInObjCMethod build the appropriate expression to 1714 // reference the ivar. 1715 if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) { 1716 R.clear(); 1717 ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier())); 1718 assert(E.isInvalid() || E.get()); 1719 return move(E); 1720 } 1721 } 1722 } 1723 1724 // This is guaranteed from this point on. 1725 assert(!R.empty() || ADL); 1726 1727 // Check whether this might be a C++ implicit instance member access. 1728 // C++ [class.mfct.non-static]p3: 1729 // When an id-expression that is not part of a class member access 1730 // syntax and not used to form a pointer to member is used in the 1731 // body of a non-static member function of class X, if name lookup 1732 // resolves the name in the id-expression to a non-static non-type 1733 // member of some class C, the id-expression is transformed into a 1734 // class member access expression using (*this) as the 1735 // postfix-expression to the left of the . operator. 1736 // 1737 // But we don't actually need to do this for '&' operands if R 1738 // resolved to a function or overloaded function set, because the 1739 // expression is ill-formed if it actually works out to be a 1740 // non-static member function: 1741 // 1742 // C++ [expr.ref]p4: 1743 // Otherwise, if E1.E2 refers to a non-static member function. . . 1744 // [t]he expression can be used only as the left-hand operand of a 1745 // member function call. 1746 // 1747 // There are other safeguards against such uses, but it's important 1748 // to get this right here so that we don't end up making a 1749 // spuriously dependent expression if we're inside a dependent 1750 // instance method. 1751 if (!R.empty() && (*R.begin())->isCXXClassMember()) { 1752 bool MightBeImplicitMember; 1753 if (!isAddressOfOperand) 1754 MightBeImplicitMember = true; 1755 else if (!SS.isEmpty()) 1756 MightBeImplicitMember = false; 1757 else if (R.isOverloadedResult()) 1758 MightBeImplicitMember = false; 1759 else if (R.isUnresolvableResult()) 1760 MightBeImplicitMember = true; 1761 else 1762 MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) || 1763 isa<IndirectFieldDecl>(R.getFoundDecl()); 1764 1765 if (MightBeImplicitMember) 1766 return BuildPossibleImplicitMemberExpr(SS, R, TemplateArgs); 1767 } 1768 1769 if (TemplateArgs) 1770 return BuildTemplateIdExpr(SS, R, ADL, *TemplateArgs); 1771 1772 return BuildDeclarationNameExpr(SS, R, ADL); 1773} 1774 1775/// BuildQualifiedDeclarationNameExpr - Build a C++ qualified 1776/// declaration name, generally during template instantiation. 1777/// There's a large number of things which don't need to be done along 1778/// this path. 1779ExprResult 1780Sema::BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, 1781 const DeclarationNameInfo &NameInfo) { 1782 DeclContext *DC; 1783 if (!(DC = computeDeclContext(SS, false)) || DC->isDependentContext()) 1784 return BuildDependentDeclRefExpr(SS, NameInfo, 0); 1785 1786 if (RequireCompleteDeclContext(SS, DC)) 1787 return ExprError(); 1788 1789 LookupResult R(*this, NameInfo, LookupOrdinaryName); 1790 LookupQualifiedName(R, DC); 1791 1792 if (R.isAmbiguous()) 1793 return ExprError(); 1794 1795 if (R.empty()) { 1796 Diag(NameInfo.getLoc(), diag::err_no_member) 1797 << NameInfo.getName() << DC << SS.getRange(); 1798 return ExprError(); 1799 } 1800 1801 return BuildDeclarationNameExpr(SS, R, /*ADL*/ false); 1802} 1803 1804/// LookupInObjCMethod - The parser has read a name in, and Sema has 1805/// detected that we're currently inside an ObjC method. Perform some 1806/// additional lookup. 1807/// 1808/// Ideally, most of this would be done by lookup, but there's 1809/// actually quite a lot of extra work involved. 1810/// 1811/// Returns a null sentinel to indicate trivial success. 1812ExprResult 1813Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S, 1814 IdentifierInfo *II, bool AllowBuiltinCreation) { 1815 SourceLocation Loc = Lookup.getNameLoc(); 1816 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 1817 1818 // There are two cases to handle here. 1) scoped lookup could have failed, 1819 // in which case we should look for an ivar. 2) scoped lookup could have 1820 // found a decl, but that decl is outside the current instance method (i.e. 1821 // a global variable). In these two cases, we do a lookup for an ivar with 1822 // this name, if the lookup sucedes, we replace it our current decl. 1823 1824 // If we're in a class method, we don't normally want to look for 1825 // ivars. But if we don't find anything else, and there's an 1826 // ivar, that's an error. 1827 bool IsClassMethod = CurMethod->isClassMethod(); 1828 1829 bool LookForIvars; 1830 if (Lookup.empty()) 1831 LookForIvars = true; 1832 else if (IsClassMethod) 1833 LookForIvars = false; 1834 else 1835 LookForIvars = (Lookup.isSingleResult() && 1836 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()); 1837 ObjCInterfaceDecl *IFace = 0; 1838 if (LookForIvars) { 1839 IFace = CurMethod->getClassInterface(); 1840 ObjCInterfaceDecl *ClassDeclared; 1841 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) { 1842 // Diagnose using an ivar in a class method. 1843 if (IsClassMethod) 1844 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 1845 << IV->getDeclName()); 1846 1847 // If we're referencing an invalid decl, just return this as a silent 1848 // error node. The error diagnostic was already emitted on the decl. 1849 if (IV->isInvalidDecl()) 1850 return ExprError(); 1851 1852 // Check if referencing a field with __attribute__((deprecated)). 1853 if (DiagnoseUseOfDecl(IV, Loc)) 1854 return ExprError(); 1855 1856 // Diagnose the use of an ivar outside of the declaring class. 1857 if (IV->getAccessControl() == ObjCIvarDecl::Private && 1858 ClassDeclared != IFace) 1859 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName(); 1860 1861 // FIXME: This should use a new expr for a direct reference, don't 1862 // turn this into Self->ivar, just return a BareIVarExpr or something. 1863 IdentifierInfo &II = Context.Idents.get("self"); 1864 UnqualifiedId SelfName; 1865 SelfName.setIdentifier(&II, SourceLocation()); 1866 SelfName.setKind(UnqualifiedId::IK_ImplicitSelfParam); 1867 CXXScopeSpec SelfScopeSpec; 1868 ExprResult SelfExpr = ActOnIdExpression(S, SelfScopeSpec, 1869 SelfName, false, false); 1870 if (SelfExpr.isInvalid()) 1871 return ExprError(); 1872 1873 SelfExpr = DefaultLvalueConversion(SelfExpr.take()); 1874 if (SelfExpr.isInvalid()) 1875 return ExprError(); 1876 1877 MarkDeclarationReferenced(Loc, IV); 1878 return Owned(new (Context) 1879 ObjCIvarRefExpr(IV, IV->getType(), Loc, 1880 SelfExpr.take(), true, true)); 1881 } 1882 } else if (CurMethod->isInstanceMethod()) { 1883 // We should warn if a local variable hides an ivar. 1884 ObjCInterfaceDecl *IFace = CurMethod->getClassInterface(); 1885 ObjCInterfaceDecl *ClassDeclared; 1886 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) { 1887 if (IV->getAccessControl() != ObjCIvarDecl::Private || 1888 IFace == ClassDeclared) 1889 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName(); 1890 } 1891 } 1892 1893 if (Lookup.empty() && II && AllowBuiltinCreation) { 1894 // FIXME. Consolidate this with similar code in LookupName. 1895 if (unsigned BuiltinID = II->getBuiltinID()) { 1896 if (!(getLangOptions().CPlusPlus && 1897 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) { 1898 NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID, 1899 S, Lookup.isForRedeclaration(), 1900 Lookup.getNameLoc()); 1901 if (D) Lookup.addDecl(D); 1902 } 1903 } 1904 } 1905 // Sentinel value saying that we didn't do anything special. 1906 return Owned((Expr*) 0); 1907} 1908 1909/// \brief Cast a base object to a member's actual type. 1910/// 1911/// Logically this happens in three phases: 1912/// 1913/// * First we cast from the base type to the naming class. 1914/// The naming class is the class into which we were looking 1915/// when we found the member; it's the qualifier type if a 1916/// qualifier was provided, and otherwise it's the base type. 1917/// 1918/// * Next we cast from the naming class to the declaring class. 1919/// If the member we found was brought into a class's scope by 1920/// a using declaration, this is that class; otherwise it's 1921/// the class declaring the member. 1922/// 1923/// * Finally we cast from the declaring class to the "true" 1924/// declaring class of the member. This conversion does not 1925/// obey access control. 1926ExprResult 1927Sema::PerformObjectMemberConversion(Expr *From, 1928 NestedNameSpecifier *Qualifier, 1929 NamedDecl *FoundDecl, 1930 NamedDecl *Member) { 1931 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext()); 1932 if (!RD) 1933 return Owned(From); 1934 1935 QualType DestRecordType; 1936 QualType DestType; 1937 QualType FromRecordType; 1938 QualType FromType = From->getType(); 1939 bool PointerConversions = false; 1940 if (isa<FieldDecl>(Member)) { 1941 DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD)); 1942 1943 if (FromType->getAs<PointerType>()) { 1944 DestType = Context.getPointerType(DestRecordType); 1945 FromRecordType = FromType->getPointeeType(); 1946 PointerConversions = true; 1947 } else { 1948 DestType = DestRecordType; 1949 FromRecordType = FromType; 1950 } 1951 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) { 1952 if (Method->isStatic()) 1953 return Owned(From); 1954 1955 DestType = Method->getThisType(Context); 1956 DestRecordType = DestType->getPointeeType(); 1957 1958 if (FromType->getAs<PointerType>()) { 1959 FromRecordType = FromType->getPointeeType(); 1960 PointerConversions = true; 1961 } else { 1962 FromRecordType = FromType; 1963 DestType = DestRecordType; 1964 } 1965 } else { 1966 // No conversion necessary. 1967 return Owned(From); 1968 } 1969 1970 if (DestType->isDependentType() || FromType->isDependentType()) 1971 return Owned(From); 1972 1973 // If the unqualified types are the same, no conversion is necessary. 1974 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 1975 return Owned(From); 1976 1977 SourceRange FromRange = From->getSourceRange(); 1978 SourceLocation FromLoc = FromRange.getBegin(); 1979 1980 ExprValueKind VK = CastCategory(From); 1981 1982 // C++ [class.member.lookup]p8: 1983 // [...] Ambiguities can often be resolved by qualifying a name with its 1984 // class name. 1985 // 1986 // If the member was a qualified name and the qualified referred to a 1987 // specific base subobject type, we'll cast to that intermediate type 1988 // first and then to the object in which the member is declared. That allows 1989 // one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as: 1990 // 1991 // class Base { public: int x; }; 1992 // class Derived1 : public Base { }; 1993 // class Derived2 : public Base { }; 1994 // class VeryDerived : public Derived1, public Derived2 { void f(); }; 1995 // 1996 // void VeryDerived::f() { 1997 // x = 17; // error: ambiguous base subobjects 1998 // Derived1::x = 17; // okay, pick the Base subobject of Derived1 1999 // } 2000 if (Qualifier) { 2001 QualType QType = QualType(Qualifier->getAsType(), 0); 2002 assert(!QType.isNull() && "lookup done with dependent qualifier?"); 2003 assert(QType->isRecordType() && "lookup done with non-record type"); 2004 2005 QualType QRecordType = QualType(QType->getAs<RecordType>(), 0); 2006 2007 // In C++98, the qualifier type doesn't actually have to be a base 2008 // type of the object type, in which case we just ignore it. 2009 // Otherwise build the appropriate casts. 2010 if (IsDerivedFrom(FromRecordType, QRecordType)) { 2011 CXXCastPath BasePath; 2012 if (CheckDerivedToBaseConversion(FromRecordType, QRecordType, 2013 FromLoc, FromRange, &BasePath)) 2014 return ExprError(); 2015 2016 if (PointerConversions) 2017 QType = Context.getPointerType(QType); 2018 From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase, 2019 VK, &BasePath).take(); 2020 2021 FromType = QType; 2022 FromRecordType = QRecordType; 2023 2024 // If the qualifier type was the same as the destination type, 2025 // we're done. 2026 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 2027 return Owned(From); 2028 } 2029 } 2030 2031 bool IgnoreAccess = false; 2032 2033 // If we actually found the member through a using declaration, cast 2034 // down to the using declaration's type. 2035 // 2036 // Pointer equality is fine here because only one declaration of a 2037 // class ever has member declarations. 2038 if (FoundDecl->getDeclContext() != Member->getDeclContext()) { 2039 assert(isa<UsingShadowDecl>(FoundDecl)); 2040 QualType URecordType = Context.getTypeDeclType( 2041 cast<CXXRecordDecl>(FoundDecl->getDeclContext())); 2042 2043 // We only need to do this if the naming-class to declaring-class 2044 // conversion is non-trivial. 2045 if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) { 2046 assert(IsDerivedFrom(FromRecordType, URecordType)); 2047 CXXCastPath BasePath; 2048 if (CheckDerivedToBaseConversion(FromRecordType, URecordType, 2049 FromLoc, FromRange, &BasePath)) 2050 return ExprError(); 2051 2052 QualType UType = URecordType; 2053 if (PointerConversions) 2054 UType = Context.getPointerType(UType); 2055 From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase, 2056 VK, &BasePath).take(); 2057 FromType = UType; 2058 FromRecordType = URecordType; 2059 } 2060 2061 // We don't do access control for the conversion from the 2062 // declaring class to the true declaring class. 2063 IgnoreAccess = true; 2064 } 2065 2066 CXXCastPath BasePath; 2067 if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType, 2068 FromLoc, FromRange, &BasePath, 2069 IgnoreAccess)) 2070 return ExprError(); 2071 2072 return ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase, 2073 VK, &BasePath); 2074} 2075 2076bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS, 2077 const LookupResult &R, 2078 bool HasTrailingLParen) { 2079 // Only when used directly as the postfix-expression of a call. 2080 if (!HasTrailingLParen) 2081 return false; 2082 2083 // Never if a scope specifier was provided. 2084 if (SS.isSet()) 2085 return false; 2086 2087 // Only in C++ or ObjC++. 2088 if (!getLangOptions().CPlusPlus) 2089 return false; 2090 2091 // Turn off ADL when we find certain kinds of declarations during 2092 // normal lookup: 2093 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { 2094 NamedDecl *D = *I; 2095 2096 // C++0x [basic.lookup.argdep]p3: 2097 // -- a declaration of a class member 2098 // Since using decls preserve this property, we check this on the 2099 // original decl. 2100 if (D->isCXXClassMember()) 2101 return false; 2102 2103 // C++0x [basic.lookup.argdep]p3: 2104 // -- a block-scope function declaration that is not a 2105 // using-declaration 2106 // NOTE: we also trigger this for function templates (in fact, we 2107 // don't check the decl type at all, since all other decl types 2108 // turn off ADL anyway). 2109 if (isa<UsingShadowDecl>(D)) 2110 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 2111 else if (D->getDeclContext()->isFunctionOrMethod()) 2112 return false; 2113 2114 // C++0x [basic.lookup.argdep]p3: 2115 // -- a declaration that is neither a function or a function 2116 // template 2117 // And also for builtin functions. 2118 if (isa<FunctionDecl>(D)) { 2119 FunctionDecl *FDecl = cast<FunctionDecl>(D); 2120 2121 // But also builtin functions. 2122 if (FDecl->getBuiltinID() && FDecl->isImplicit()) 2123 return false; 2124 } else if (!isa<FunctionTemplateDecl>(D)) 2125 return false; 2126 } 2127 2128 return true; 2129} 2130 2131 2132/// Diagnoses obvious problems with the use of the given declaration 2133/// as an expression. This is only actually called for lookups that 2134/// were not overloaded, and it doesn't promise that the declaration 2135/// will in fact be used. 2136static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) { 2137 if (isa<TypedefNameDecl>(D)) { 2138 S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName(); 2139 return true; 2140 } 2141 2142 if (isa<ObjCInterfaceDecl>(D)) { 2143 S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName(); 2144 return true; 2145 } 2146 2147 if (isa<NamespaceDecl>(D)) { 2148 S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName(); 2149 return true; 2150 } 2151 2152 return false; 2153} 2154 2155ExprResult 2156Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2157 LookupResult &R, 2158 bool NeedsADL) { 2159 // If this is a single, fully-resolved result and we don't need ADL, 2160 // just build an ordinary singleton decl ref. 2161 if (!NeedsADL && R.isSingleResult() && !R.getAsSingle<FunctionTemplateDecl>()) 2162 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), 2163 R.getFoundDecl()); 2164 2165 // We only need to check the declaration if there's exactly one 2166 // result, because in the overloaded case the results can only be 2167 // functions and function templates. 2168 if (R.isSingleResult() && 2169 CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl())) 2170 return ExprError(); 2171 2172 // Otherwise, just build an unresolved lookup expression. Suppress 2173 // any lookup-related diagnostics; we'll hash these out later, when 2174 // we've picked a target. 2175 R.suppressDiagnostics(); 2176 2177 UnresolvedLookupExpr *ULE 2178 = UnresolvedLookupExpr::Create(Context, R.getNamingClass(), 2179 SS.getWithLocInContext(Context), 2180 R.getLookupNameInfo(), 2181 NeedsADL, R.isOverloadedResult(), 2182 R.begin(), R.end()); 2183 2184 return Owned(ULE); 2185} 2186 2187/// \brief Complete semantic analysis for a reference to the given declaration. 2188ExprResult 2189Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2190 const DeclarationNameInfo &NameInfo, 2191 NamedDecl *D) { 2192 assert(D && "Cannot refer to a NULL declaration"); 2193 assert(!isa<FunctionTemplateDecl>(D) && 2194 "Cannot refer unambiguously to a function template"); 2195 2196 SourceLocation Loc = NameInfo.getLoc(); 2197 if (CheckDeclInExpr(*this, Loc, D)) 2198 return ExprError(); 2199 2200 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) { 2201 // Specifically diagnose references to class templates that are missing 2202 // a template argument list. 2203 Diag(Loc, diag::err_template_decl_ref) 2204 << Template << SS.getRange(); 2205 Diag(Template->getLocation(), diag::note_template_decl_here); 2206 return ExprError(); 2207 } 2208 2209 // Make sure that we're referring to a value. 2210 ValueDecl *VD = dyn_cast<ValueDecl>(D); 2211 if (!VD) { 2212 Diag(Loc, diag::err_ref_non_value) 2213 << D << SS.getRange(); 2214 Diag(D->getLocation(), diag::note_declared_at); 2215 return ExprError(); 2216 } 2217 2218 // Check whether this declaration can be used. Note that we suppress 2219 // this check when we're going to perform argument-dependent lookup 2220 // on this function name, because this might not be the function 2221 // that overload resolution actually selects. 2222 if (DiagnoseUseOfDecl(VD, Loc)) 2223 return ExprError(); 2224 2225 // Only create DeclRefExpr's for valid Decl's. 2226 if (VD->isInvalidDecl()) 2227 return ExprError(); 2228 2229 // Handle members of anonymous structs and unions. If we got here, 2230 // and the reference is to a class member indirect field, then this 2231 // must be the subject of a pointer-to-member expression. 2232 if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD)) 2233 if (!indirectField->isCXXClassMember()) 2234 return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(), 2235 indirectField); 2236 2237 // If the identifier reference is inside a block, and it refers to a value 2238 // that is outside the block, create a BlockDeclRefExpr instead of a 2239 // DeclRefExpr. This ensures the value is treated as a copy-in snapshot when 2240 // the block is formed. 2241 // 2242 // We do not do this for things like enum constants, global variables, etc, 2243 // as they do not get snapshotted. 2244 // 2245 switch (shouldCaptureValueReference(*this, NameInfo.getLoc(), VD)) { 2246 case CR_Error: 2247 return ExprError(); 2248 2249 case CR_Capture: 2250 assert(!SS.isSet() && "referenced local variable with scope specifier?"); 2251 return BuildBlockDeclRefExpr(*this, VD, NameInfo, /*byref*/ false); 2252 2253 case CR_CaptureByRef: 2254 assert(!SS.isSet() && "referenced local variable with scope specifier?"); 2255 return BuildBlockDeclRefExpr(*this, VD, NameInfo, /*byref*/ true); 2256 2257 case CR_NoCapture: { 2258 // If this reference is not in a block or if the referenced 2259 // variable is within the block, create a normal DeclRefExpr. 2260 2261 QualType type = VD->getType(); 2262 ExprValueKind valueKind = VK_RValue; 2263 2264 switch (D->getKind()) { 2265 // Ignore all the non-ValueDecl kinds. 2266#define ABSTRACT_DECL(kind) 2267#define VALUE(type, base) 2268#define DECL(type, base) \ 2269 case Decl::type: 2270#include "clang/AST/DeclNodes.inc" 2271 llvm_unreachable("invalid value decl kind"); 2272 return ExprError(); 2273 2274 // These shouldn't make it here. 2275 case Decl::ObjCAtDefsField: 2276 case Decl::ObjCIvar: 2277 llvm_unreachable("forming non-member reference to ivar?"); 2278 return ExprError(); 2279 2280 // Enum constants are always r-values and never references. 2281 // Unresolved using declarations are dependent. 2282 case Decl::EnumConstant: 2283 case Decl::UnresolvedUsingValue: 2284 valueKind = VK_RValue; 2285 break; 2286 2287 // Fields and indirect fields that got here must be for 2288 // pointer-to-member expressions; we just call them l-values for 2289 // internal consistency, because this subexpression doesn't really 2290 // exist in the high-level semantics. 2291 case Decl::Field: 2292 case Decl::IndirectField: 2293 assert(getLangOptions().CPlusPlus && 2294 "building reference to field in C?"); 2295 2296 // These can't have reference type in well-formed programs, but 2297 // for internal consistency we do this anyway. 2298 type = type.getNonReferenceType(); 2299 valueKind = VK_LValue; 2300 break; 2301 2302 // Non-type template parameters are either l-values or r-values 2303 // depending on the type. 2304 case Decl::NonTypeTemplateParm: { 2305 if (const ReferenceType *reftype = type->getAs<ReferenceType>()) { 2306 type = reftype->getPointeeType(); 2307 valueKind = VK_LValue; // even if the parameter is an r-value reference 2308 break; 2309 } 2310 2311 // For non-references, we need to strip qualifiers just in case 2312 // the template parameter was declared as 'const int' or whatever. 2313 valueKind = VK_RValue; 2314 type = type.getUnqualifiedType(); 2315 break; 2316 } 2317 2318 case Decl::Var: 2319 // In C, "extern void blah;" is valid and is an r-value. 2320 if (!getLangOptions().CPlusPlus && 2321 !type.hasQualifiers() && 2322 type->isVoidType()) { 2323 valueKind = VK_RValue; 2324 break; 2325 } 2326 // fallthrough 2327 2328 case Decl::ImplicitParam: 2329 case Decl::ParmVar: 2330 // These are always l-values. 2331 valueKind = VK_LValue; 2332 type = type.getNonReferenceType(); 2333 break; 2334 2335 case Decl::Function: { 2336 const FunctionType *fty = type->castAs<FunctionType>(); 2337 2338 // If we're referring to a function with an __unknown_anytype 2339 // result type, make the entire expression __unknown_anytype. 2340 if (fty->getResultType() == Context.UnknownAnyTy) { 2341 type = Context.UnknownAnyTy; 2342 valueKind = VK_RValue; 2343 break; 2344 } 2345 2346 // Functions are l-values in C++. 2347 if (getLangOptions().CPlusPlus) { 2348 valueKind = VK_LValue; 2349 break; 2350 } 2351 2352 // C99 DR 316 says that, if a function type comes from a 2353 // function definition (without a prototype), that type is only 2354 // used for checking compatibility. Therefore, when referencing 2355 // the function, we pretend that we don't have the full function 2356 // type. 2357 if (!cast<FunctionDecl>(VD)->hasPrototype() && 2358 isa<FunctionProtoType>(fty)) 2359 type = Context.getFunctionNoProtoType(fty->getResultType(), 2360 fty->getExtInfo()); 2361 2362 // Functions are r-values in C. 2363 valueKind = VK_RValue; 2364 break; 2365 } 2366 2367 case Decl::CXXMethod: 2368 // If we're referring to a method with an __unknown_anytype 2369 // result type, make the entire expression __unknown_anytype. 2370 // This should only be possible with a type written directly. 2371 if (const FunctionProtoType *proto 2372 = dyn_cast<FunctionProtoType>(VD->getType())) 2373 if (proto->getResultType() == Context.UnknownAnyTy) { 2374 type = Context.UnknownAnyTy; 2375 valueKind = VK_RValue; 2376 break; 2377 } 2378 2379 // C++ methods are l-values if static, r-values if non-static. 2380 if (cast<CXXMethodDecl>(VD)->isStatic()) { 2381 valueKind = VK_LValue; 2382 break; 2383 } 2384 // fallthrough 2385 2386 case Decl::CXXConversion: 2387 case Decl::CXXDestructor: 2388 case Decl::CXXConstructor: 2389 valueKind = VK_RValue; 2390 break; 2391 } 2392 2393 return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS); 2394 } 2395 2396 } 2397 2398 llvm_unreachable("unknown capture result"); 2399 return ExprError(); 2400} 2401 2402ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) { 2403 PredefinedExpr::IdentType IT; 2404 2405 switch (Kind) { 2406 default: assert(0 && "Unknown simple primary expr!"); 2407 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2] 2408 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break; 2409 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break; 2410 } 2411 2412 // Pre-defined identifiers are of type char[x], where x is the length of the 2413 // string. 2414 2415 Decl *currentDecl = getCurFunctionOrMethodDecl(); 2416 if (!currentDecl && getCurBlock()) 2417 currentDecl = getCurBlock()->TheDecl; 2418 if (!currentDecl) { 2419 Diag(Loc, diag::ext_predef_outside_function); 2420 currentDecl = Context.getTranslationUnitDecl(); 2421 } 2422 2423 QualType ResTy; 2424 if (cast<DeclContext>(currentDecl)->isDependentContext()) { 2425 ResTy = Context.DependentTy; 2426 } else { 2427 unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length(); 2428 2429 llvm::APInt LengthI(32, Length + 1); 2430 ResTy = Context.CharTy.withConst(); 2431 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0); 2432 } 2433 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT)); 2434} 2435 2436ExprResult Sema::ActOnCharacterConstant(const Token &Tok) { 2437 llvm::SmallString<16> CharBuffer; 2438 bool Invalid = false; 2439 StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid); 2440 if (Invalid) 2441 return ExprError(); 2442 2443 CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(), 2444 PP, Tok.getKind()); 2445 if (Literal.hadError()) 2446 return ExprError(); 2447 2448 QualType Ty; 2449 if (!getLangOptions().CPlusPlus) 2450 Ty = Context.IntTy; // 'x' and L'x' -> int in C. 2451 else if (Literal.isWide()) 2452 Ty = Context.WCharTy; // L'x' -> wchar_t in C++. 2453 else if (Literal.isUTF16()) 2454 Ty = Context.Char16Ty; // u'x' -> char16_t in C++0x. 2455 else if (Literal.isUTF32()) 2456 Ty = Context.Char32Ty; // U'x' -> char32_t in C++0x. 2457 else if (Literal.isMultiChar()) 2458 Ty = Context.IntTy; // 'wxyz' -> int in C++. 2459 else 2460 Ty = Context.CharTy; // 'x' -> char in C++ 2461 2462 CharacterLiteral::CharacterKind Kind = CharacterLiteral::Ascii; 2463 if (Literal.isWide()) 2464 Kind = CharacterLiteral::Wide; 2465 else if (Literal.isUTF16()) 2466 Kind = CharacterLiteral::UTF16; 2467 else if (Literal.isUTF32()) 2468 Kind = CharacterLiteral::UTF32; 2469 2470 return Owned(new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty, 2471 Tok.getLocation())); 2472} 2473 2474ExprResult Sema::ActOnNumericConstant(const Token &Tok) { 2475 // Fast path for a single digit (which is quite common). A single digit 2476 // cannot have a trigraph, escaped newline, radix prefix, or type suffix. 2477 if (Tok.getLength() == 1) { 2478 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok); 2479 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 2480 return Owned(IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val-'0'), 2481 Context.IntTy, Tok.getLocation())); 2482 } 2483 2484 llvm::SmallString<512> IntegerBuffer; 2485 // Add padding so that NumericLiteralParser can overread by one character. 2486 IntegerBuffer.resize(Tok.getLength()+1); 2487 const char *ThisTokBegin = &IntegerBuffer[0]; 2488 2489 // Get the spelling of the token, which eliminates trigraphs, etc. 2490 bool Invalid = false; 2491 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid); 2492 if (Invalid) 2493 return ExprError(); 2494 2495 NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength, 2496 Tok.getLocation(), PP); 2497 if (Literal.hadError) 2498 return ExprError(); 2499 2500 Expr *Res; 2501 2502 if (Literal.isFloatingLiteral()) { 2503 QualType Ty; 2504 if (Literal.isFloat) 2505 Ty = Context.FloatTy; 2506 else if (!Literal.isLong) 2507 Ty = Context.DoubleTy; 2508 else 2509 Ty = Context.LongDoubleTy; 2510 2511 const llvm::fltSemantics &Format = Context.getFloatTypeSemantics(Ty); 2512 2513 using llvm::APFloat; 2514 APFloat Val(Format); 2515 2516 APFloat::opStatus result = Literal.GetFloatValue(Val); 2517 2518 // Overflow is always an error, but underflow is only an error if 2519 // we underflowed to zero (APFloat reports denormals as underflow). 2520 if ((result & APFloat::opOverflow) || 2521 ((result & APFloat::opUnderflow) && Val.isZero())) { 2522 unsigned diagnostic; 2523 llvm::SmallString<20> buffer; 2524 if (result & APFloat::opOverflow) { 2525 diagnostic = diag::warn_float_overflow; 2526 APFloat::getLargest(Format).toString(buffer); 2527 } else { 2528 diagnostic = diag::warn_float_underflow; 2529 APFloat::getSmallest(Format).toString(buffer); 2530 } 2531 2532 Diag(Tok.getLocation(), diagnostic) 2533 << Ty 2534 << StringRef(buffer.data(), buffer.size()); 2535 } 2536 2537 bool isExact = (result == APFloat::opOK); 2538 Res = FloatingLiteral::Create(Context, Val, isExact, Ty, Tok.getLocation()); 2539 2540 if (Ty == Context.DoubleTy) { 2541 if (getLangOptions().SinglePrecisionConstants) { 2542 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); 2543 } else if (getLangOptions().OpenCL && !getOpenCLOptions().cl_khr_fp64) { 2544 Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64); 2545 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); 2546 } 2547 } 2548 } else if (!Literal.isIntegerLiteral()) { 2549 return ExprError(); 2550 } else { 2551 QualType Ty; 2552 2553 // long long is a C99 feature. 2554 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x && 2555 Literal.isLongLong) 2556 Diag(Tok.getLocation(), diag::ext_longlong); 2557 2558 // Get the value in the widest-possible width. 2559 llvm::APInt ResultVal(Context.getTargetInfo().getIntMaxTWidth(), 0); 2560 2561 if (Literal.GetIntegerValue(ResultVal)) { 2562 // If this value didn't fit into uintmax_t, warn and force to ull. 2563 Diag(Tok.getLocation(), diag::warn_integer_too_large); 2564 Ty = Context.UnsignedLongLongTy; 2565 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() && 2566 "long long is not intmax_t?"); 2567 } else { 2568 // If this value fits into a ULL, try to figure out what else it fits into 2569 // according to the rules of C99 6.4.4.1p5. 2570 2571 // Octal, Hexadecimal, and integers with a U suffix are allowed to 2572 // be an unsigned int. 2573 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10; 2574 2575 // Check from smallest to largest, picking the smallest type we can. 2576 unsigned Width = 0; 2577 if (!Literal.isLong && !Literal.isLongLong) { 2578 // Are int/unsigned possibilities? 2579 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 2580 2581 // Does it fit in a unsigned int? 2582 if (ResultVal.isIntN(IntSize)) { 2583 // Does it fit in a signed int? 2584 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0) 2585 Ty = Context.IntTy; 2586 else if (AllowUnsigned) 2587 Ty = Context.UnsignedIntTy; 2588 Width = IntSize; 2589 } 2590 } 2591 2592 // Are long/unsigned long possibilities? 2593 if (Ty.isNull() && !Literal.isLongLong) { 2594 unsigned LongSize = Context.getTargetInfo().getLongWidth(); 2595 2596 // Does it fit in a unsigned long? 2597 if (ResultVal.isIntN(LongSize)) { 2598 // Does it fit in a signed long? 2599 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0) 2600 Ty = Context.LongTy; 2601 else if (AllowUnsigned) 2602 Ty = Context.UnsignedLongTy; 2603 Width = LongSize; 2604 } 2605 } 2606 2607 // Finally, check long long if needed. 2608 if (Ty.isNull()) { 2609 unsigned LongLongSize = Context.getTargetInfo().getLongLongWidth(); 2610 2611 // Does it fit in a unsigned long long? 2612 if (ResultVal.isIntN(LongLongSize)) { 2613 // Does it fit in a signed long long? 2614 // To be compatible with MSVC, hex integer literals ending with the 2615 // LL or i64 suffix are always signed in Microsoft mode. 2616 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 || 2617 (getLangOptions().Microsoft && Literal.isLongLong))) 2618 Ty = Context.LongLongTy; 2619 else if (AllowUnsigned) 2620 Ty = Context.UnsignedLongLongTy; 2621 Width = LongLongSize; 2622 } 2623 } 2624 2625 // If we still couldn't decide a type, we probably have something that 2626 // does not fit in a signed long long, but has no U suffix. 2627 if (Ty.isNull()) { 2628 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed); 2629 Ty = Context.UnsignedLongLongTy; 2630 Width = Context.getTargetInfo().getLongLongWidth(); 2631 } 2632 2633 if (ResultVal.getBitWidth() != Width) 2634 ResultVal = ResultVal.trunc(Width); 2635 } 2636 Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation()); 2637 } 2638 2639 // If this is an imaginary literal, create the ImaginaryLiteral wrapper. 2640 if (Literal.isImaginary) 2641 Res = new (Context) ImaginaryLiteral(Res, 2642 Context.getComplexType(Res->getType())); 2643 2644 return Owned(Res); 2645} 2646 2647ExprResult Sema::ActOnParenExpr(SourceLocation L, 2648 SourceLocation R, Expr *E) { 2649 assert((E != 0) && "ActOnParenExpr() missing expr"); 2650 return Owned(new (Context) ParenExpr(L, R, E)); 2651} 2652 2653static bool CheckVecStepTraitOperandType(Sema &S, QualType T, 2654 SourceLocation Loc, 2655 SourceRange ArgRange) { 2656 // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in 2657 // scalar or vector data type argument..." 2658 // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic 2659 // type (C99 6.2.5p18) or void. 2660 if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) { 2661 S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type) 2662 << T << ArgRange; 2663 return true; 2664 } 2665 2666 assert((T->isVoidType() || !T->isIncompleteType()) && 2667 "Scalar types should always be complete"); 2668 return false; 2669} 2670 2671static bool CheckExtensionTraitOperandType(Sema &S, QualType T, 2672 SourceLocation Loc, 2673 SourceRange ArgRange, 2674 UnaryExprOrTypeTrait TraitKind) { 2675 // C99 6.5.3.4p1: 2676 if (T->isFunctionType()) { 2677 // alignof(function) is allowed as an extension. 2678 if (TraitKind == UETT_SizeOf) 2679 S.Diag(Loc, diag::ext_sizeof_function_type) << ArgRange; 2680 return false; 2681 } 2682 2683 // Allow sizeof(void)/alignof(void) as an extension. 2684 if (T->isVoidType()) { 2685 S.Diag(Loc, diag::ext_sizeof_void_type) << TraitKind << ArgRange; 2686 return false; 2687 } 2688 2689 return true; 2690} 2691 2692static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, 2693 SourceLocation Loc, 2694 SourceRange ArgRange, 2695 UnaryExprOrTypeTrait TraitKind) { 2696 // Reject sizeof(interface) and sizeof(interface<proto>) in 64-bit mode. 2697 if (S.LangOpts.ObjCNonFragileABI && T->isObjCObjectType()) { 2698 S.Diag(Loc, diag::err_sizeof_nonfragile_interface) 2699 << T << (TraitKind == UETT_SizeOf) 2700 << ArgRange; 2701 return true; 2702 } 2703 2704 return false; 2705} 2706 2707/// \brief Check the constrains on expression operands to unary type expression 2708/// and type traits. 2709/// 2710/// Completes any types necessary and validates the constraints on the operand 2711/// expression. The logic mostly mirrors the type-based overload, but may modify 2712/// the expression as it completes the type for that expression through template 2713/// instantiation, etc. 2714bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *Op, 2715 UnaryExprOrTypeTrait ExprKind) { 2716 QualType ExprTy = Op->getType(); 2717 2718 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 2719 // the result is the size of the referenced type." 2720 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the 2721 // result shall be the alignment of the referenced type." 2722 if (const ReferenceType *Ref = ExprTy->getAs<ReferenceType>()) 2723 ExprTy = Ref->getPointeeType(); 2724 2725 if (ExprKind == UETT_VecStep) 2726 return CheckVecStepTraitOperandType(*this, ExprTy, Op->getExprLoc(), 2727 Op->getSourceRange()); 2728 2729 // Whitelist some types as extensions 2730 if (!CheckExtensionTraitOperandType(*this, ExprTy, Op->getExprLoc(), 2731 Op->getSourceRange(), ExprKind)) 2732 return false; 2733 2734 if (RequireCompleteExprType(Op, 2735 PDiag(diag::err_sizeof_alignof_incomplete_type) 2736 << ExprKind << Op->getSourceRange(), 2737 std::make_pair(SourceLocation(), PDiag(0)))) 2738 return true; 2739 2740 // Completeing the expression's type may have changed it. 2741 ExprTy = Op->getType(); 2742 if (const ReferenceType *Ref = ExprTy->getAs<ReferenceType>()) 2743 ExprTy = Ref->getPointeeType(); 2744 2745 if (CheckObjCTraitOperandConstraints(*this, ExprTy, Op->getExprLoc(), 2746 Op->getSourceRange(), ExprKind)) 2747 return true; 2748 2749 if (ExprKind == UETT_SizeOf) { 2750 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(Op->IgnoreParens())) { 2751 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) { 2752 QualType OType = PVD->getOriginalType(); 2753 QualType Type = PVD->getType(); 2754 if (Type->isPointerType() && OType->isArrayType()) { 2755 Diag(Op->getExprLoc(), diag::warn_sizeof_array_param) 2756 << Type << OType; 2757 Diag(PVD->getLocation(), diag::note_declared_at); 2758 } 2759 } 2760 } 2761 } 2762 2763 return false; 2764} 2765 2766/// \brief Check the constraints on operands to unary expression and type 2767/// traits. 2768/// 2769/// This will complete any types necessary, and validate the various constraints 2770/// on those operands. 2771/// 2772/// The UsualUnaryConversions() function is *not* called by this routine. 2773/// C99 6.3.2.1p[2-4] all state: 2774/// Except when it is the operand of the sizeof operator ... 2775/// 2776/// C++ [expr.sizeof]p4 2777/// The lvalue-to-rvalue, array-to-pointer, and function-to-pointer 2778/// standard conversions are not applied to the operand of sizeof. 2779/// 2780/// This policy is followed for all of the unary trait expressions. 2781bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType exprType, 2782 SourceLocation OpLoc, 2783 SourceRange ExprRange, 2784 UnaryExprOrTypeTrait ExprKind) { 2785 if (exprType->isDependentType()) 2786 return false; 2787 2788 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 2789 // the result is the size of the referenced type." 2790 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the 2791 // result shall be the alignment of the referenced type." 2792 if (const ReferenceType *Ref = exprType->getAs<ReferenceType>()) 2793 exprType = Ref->getPointeeType(); 2794 2795 if (ExprKind == UETT_VecStep) 2796 return CheckVecStepTraitOperandType(*this, exprType, OpLoc, ExprRange); 2797 2798 // Whitelist some types as extensions 2799 if (!CheckExtensionTraitOperandType(*this, exprType, OpLoc, ExprRange, 2800 ExprKind)) 2801 return false; 2802 2803 if (RequireCompleteType(OpLoc, exprType, 2804 PDiag(diag::err_sizeof_alignof_incomplete_type) 2805 << ExprKind << ExprRange)) 2806 return true; 2807 2808 if (CheckObjCTraitOperandConstraints(*this, exprType, OpLoc, ExprRange, 2809 ExprKind)) 2810 return true; 2811 2812 return false; 2813} 2814 2815static bool CheckAlignOfExpr(Sema &S, Expr *E) { 2816 E = E->IgnoreParens(); 2817 2818 // alignof decl is always ok. 2819 if (isa<DeclRefExpr>(E)) 2820 return false; 2821 2822 // Cannot know anything else if the expression is dependent. 2823 if (E->isTypeDependent()) 2824 return false; 2825 2826 if (E->getBitField()) { 2827 S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) 2828 << 1 << E->getSourceRange(); 2829 return true; 2830 } 2831 2832 // Alignment of a field access is always okay, so long as it isn't a 2833 // bit-field. 2834 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) 2835 if (isa<FieldDecl>(ME->getMemberDecl())) 2836 return false; 2837 2838 return S.CheckUnaryExprOrTypeTraitOperand(E, UETT_AlignOf); 2839} 2840 2841bool Sema::CheckVecStepExpr(Expr *E) { 2842 E = E->IgnoreParens(); 2843 2844 // Cannot know anything else if the expression is dependent. 2845 if (E->isTypeDependent()) 2846 return false; 2847 2848 return CheckUnaryExprOrTypeTraitOperand(E, UETT_VecStep); 2849} 2850 2851/// \brief Build a sizeof or alignof expression given a type operand. 2852ExprResult 2853Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, 2854 SourceLocation OpLoc, 2855 UnaryExprOrTypeTrait ExprKind, 2856 SourceRange R) { 2857 if (!TInfo) 2858 return ExprError(); 2859 2860 QualType T = TInfo->getType(); 2861 2862 if (!T->isDependentType() && 2863 CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind)) 2864 return ExprError(); 2865 2866 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 2867 return Owned(new (Context) UnaryExprOrTypeTraitExpr(ExprKind, TInfo, 2868 Context.getSizeType(), 2869 OpLoc, R.getEnd())); 2870} 2871 2872/// \brief Build a sizeof or alignof expression given an expression 2873/// operand. 2874ExprResult 2875Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc, 2876 UnaryExprOrTypeTrait ExprKind) { 2877 ExprResult PE = CheckPlaceholderExpr(E); 2878 if (PE.isInvalid()) 2879 return ExprError(); 2880 2881 E = PE.get(); 2882 2883 // Verify that the operand is valid. 2884 bool isInvalid = false; 2885 if (E->isTypeDependent()) { 2886 // Delay type-checking for type-dependent expressions. 2887 } else if (ExprKind == UETT_AlignOf) { 2888 isInvalid = CheckAlignOfExpr(*this, E); 2889 } else if (ExprKind == UETT_VecStep) { 2890 isInvalid = CheckVecStepExpr(E); 2891 } else if (E->getBitField()) { // C99 6.5.3.4p1. 2892 Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) << 0; 2893 isInvalid = true; 2894 } else { 2895 isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf); 2896 } 2897 2898 if (isInvalid) 2899 return ExprError(); 2900 2901 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 2902 return Owned(new (Context) UnaryExprOrTypeTraitExpr( 2903 ExprKind, E, Context.getSizeType(), OpLoc, 2904 E->getSourceRange().getEnd())); 2905} 2906 2907/// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c 2908/// expr and the same for @c alignof and @c __alignof 2909/// Note that the ArgRange is invalid if isType is false. 2910ExprResult 2911Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, 2912 UnaryExprOrTypeTrait ExprKind, bool isType, 2913 void *TyOrEx, const SourceRange &ArgRange) { 2914 // If error parsing type, ignore. 2915 if (TyOrEx == 0) return ExprError(); 2916 2917 if (isType) { 2918 TypeSourceInfo *TInfo; 2919 (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo); 2920 return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange); 2921 } 2922 2923 Expr *ArgEx = (Expr *)TyOrEx; 2924 ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind); 2925 return move(Result); 2926} 2927 2928static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, 2929 bool isReal) { 2930 if (V.get()->isTypeDependent()) 2931 return S.Context.DependentTy; 2932 2933 // _Real and _Imag are only l-values for normal l-values. 2934 if (V.get()->getObjectKind() != OK_Ordinary) { 2935 V = S.DefaultLvalueConversion(V.take()); 2936 if (V.isInvalid()) 2937 return QualType(); 2938 } 2939 2940 // These operators return the element type of a complex type. 2941 if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>()) 2942 return CT->getElementType(); 2943 2944 // Otherwise they pass through real integer and floating point types here. 2945 if (V.get()->getType()->isArithmeticType()) 2946 return V.get()->getType(); 2947 2948 // Test for placeholders. 2949 ExprResult PR = S.CheckPlaceholderExpr(V.get()); 2950 if (PR.isInvalid()) return QualType(); 2951 if (PR.get() != V.get()) { 2952 V = move(PR); 2953 return CheckRealImagOperand(S, V, Loc, isReal); 2954 } 2955 2956 // Reject anything else. 2957 S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType() 2958 << (isReal ? "__real" : "__imag"); 2959 return QualType(); 2960} 2961 2962 2963 2964ExprResult 2965Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, 2966 tok::TokenKind Kind, Expr *Input) { 2967 UnaryOperatorKind Opc; 2968 switch (Kind) { 2969 default: assert(0 && "Unknown unary op!"); 2970 case tok::plusplus: Opc = UO_PostInc; break; 2971 case tok::minusminus: Opc = UO_PostDec; break; 2972 } 2973 2974 return BuildUnaryOp(S, OpLoc, Opc, Input); 2975} 2976 2977ExprResult 2978Sema::ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, 2979 Expr *Idx, SourceLocation RLoc) { 2980 // Since this might be a postfix expression, get rid of ParenListExprs. 2981 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); 2982 if (Result.isInvalid()) return ExprError(); 2983 Base = Result.take(); 2984 2985 Expr *LHSExp = Base, *RHSExp = Idx; 2986 2987 if (getLangOptions().CPlusPlus && 2988 (LHSExp->isTypeDependent() || RHSExp->isTypeDependent())) { 2989 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 2990 Context.DependentTy, 2991 VK_LValue, OK_Ordinary, 2992 RLoc)); 2993 } 2994 2995 if (getLangOptions().CPlusPlus && 2996 (LHSExp->getType()->isRecordType() || 2997 LHSExp->getType()->isEnumeralType() || 2998 RHSExp->getType()->isRecordType() || 2999 RHSExp->getType()->isEnumeralType())) { 3000 return CreateOverloadedArraySubscriptExpr(LLoc, RLoc, Base, Idx); 3001 } 3002 3003 return CreateBuiltinArraySubscriptExpr(Base, LLoc, Idx, RLoc); 3004} 3005 3006 3007ExprResult 3008Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, 3009 Expr *Idx, SourceLocation RLoc) { 3010 Expr *LHSExp = Base; 3011 Expr *RHSExp = Idx; 3012 3013 // Perform default conversions. 3014 if (!LHSExp->getType()->getAs<VectorType>()) { 3015 ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp); 3016 if (Result.isInvalid()) 3017 return ExprError(); 3018 LHSExp = Result.take(); 3019 } 3020 ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp); 3021 if (Result.isInvalid()) 3022 return ExprError(); 3023 RHSExp = Result.take(); 3024 3025 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType(); 3026 ExprValueKind VK = VK_LValue; 3027 ExprObjectKind OK = OK_Ordinary; 3028 3029 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent 3030 // to the expression *((e1)+(e2)). This means the array "Base" may actually be 3031 // in the subscript position. As a result, we need to derive the array base 3032 // and index from the expression types. 3033 Expr *BaseExpr, *IndexExpr; 3034 QualType ResultType; 3035 if (LHSTy->isDependentType() || RHSTy->isDependentType()) { 3036 BaseExpr = LHSExp; 3037 IndexExpr = RHSExp; 3038 ResultType = Context.DependentTy; 3039 } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) { 3040 BaseExpr = LHSExp; 3041 IndexExpr = RHSExp; 3042 ResultType = PTy->getPointeeType(); 3043 } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) { 3044 // Handle the uncommon case of "123[Ptr]". 3045 BaseExpr = RHSExp; 3046 IndexExpr = LHSExp; 3047 ResultType = PTy->getPointeeType(); 3048 } else if (const ObjCObjectPointerType *PTy = 3049 LHSTy->getAs<ObjCObjectPointerType>()) { 3050 BaseExpr = LHSExp; 3051 IndexExpr = RHSExp; 3052 ResultType = PTy->getPointeeType(); 3053 } else if (const ObjCObjectPointerType *PTy = 3054 RHSTy->getAs<ObjCObjectPointerType>()) { 3055 // Handle the uncommon case of "123[Ptr]". 3056 BaseExpr = RHSExp; 3057 IndexExpr = LHSExp; 3058 ResultType = PTy->getPointeeType(); 3059 } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) { 3060 BaseExpr = LHSExp; // vectors: V[123] 3061 IndexExpr = RHSExp; 3062 VK = LHSExp->getValueKind(); 3063 if (VK != VK_RValue) 3064 OK = OK_VectorComponent; 3065 3066 // FIXME: need to deal with const... 3067 ResultType = VTy->getElementType(); 3068 } else if (LHSTy->isArrayType()) { 3069 // If we see an array that wasn't promoted by 3070 // DefaultFunctionArrayLvalueConversion, it must be an array that 3071 // wasn't promoted because of the C90 rule that doesn't 3072 // allow promoting non-lvalue arrays. Warn, then 3073 // force the promotion here. 3074 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3075 LHSExp->getSourceRange(); 3076 LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy), 3077 CK_ArrayToPointerDecay).take(); 3078 LHSTy = LHSExp->getType(); 3079 3080 BaseExpr = LHSExp; 3081 IndexExpr = RHSExp; 3082 ResultType = LHSTy->getAs<PointerType>()->getPointeeType(); 3083 } else if (RHSTy->isArrayType()) { 3084 // Same as previous, except for 123[f().a] case 3085 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3086 RHSExp->getSourceRange(); 3087 RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy), 3088 CK_ArrayToPointerDecay).take(); 3089 RHSTy = RHSExp->getType(); 3090 3091 BaseExpr = RHSExp; 3092 IndexExpr = LHSExp; 3093 ResultType = RHSTy->getAs<PointerType>()->getPointeeType(); 3094 } else { 3095 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value) 3096 << LHSExp->getSourceRange() << RHSExp->getSourceRange()); 3097 } 3098 // C99 6.5.2.1p1 3099 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent()) 3100 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer) 3101 << IndexExpr->getSourceRange()); 3102 3103 if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) || 3104 IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U)) 3105 && !IndexExpr->isTypeDependent()) 3106 Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange(); 3107 3108 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly, 3109 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object 3110 // type. Note that Functions are not objects, and that (in C99 parlance) 3111 // incomplete types are not object types. 3112 if (ResultType->isFunctionType()) { 3113 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type) 3114 << ResultType << BaseExpr->getSourceRange(); 3115 return ExprError(); 3116 } 3117 3118 if (ResultType->isVoidType() && !getLangOptions().CPlusPlus) { 3119 // GNU extension: subscripting on pointer to void 3120 Diag(LLoc, diag::ext_gnu_subscript_void_type) 3121 << BaseExpr->getSourceRange(); 3122 3123 // C forbids expressions of unqualified void type from being l-values. 3124 // See IsCForbiddenLValueType. 3125 if (!ResultType.hasQualifiers()) VK = VK_RValue; 3126 } else if (!ResultType->isDependentType() && 3127 RequireCompleteType(LLoc, ResultType, 3128 PDiag(diag::err_subscript_incomplete_type) 3129 << BaseExpr->getSourceRange())) 3130 return ExprError(); 3131 3132 // Diagnose bad cases where we step over interface counts. 3133 if (ResultType->isObjCObjectType() && LangOpts.ObjCNonFragileABI) { 3134 Diag(LLoc, diag::err_subscript_nonfragile_interface) 3135 << ResultType << BaseExpr->getSourceRange(); 3136 return ExprError(); 3137 } 3138 3139 assert(VK == VK_RValue || LangOpts.CPlusPlus || 3140 !ResultType.isCForbiddenLValueType()); 3141 3142 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 3143 ResultType, VK, OK, RLoc)); 3144} 3145 3146ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc, 3147 FunctionDecl *FD, 3148 ParmVarDecl *Param) { 3149 if (Param->hasUnparsedDefaultArg()) { 3150 Diag(CallLoc, 3151 diag::err_use_of_default_argument_to_function_declared_later) << 3152 FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName(); 3153 Diag(UnparsedDefaultArgLocs[Param], 3154 diag::note_default_argument_declared_here); 3155 return ExprError(); 3156 } 3157 3158 if (Param->hasUninstantiatedDefaultArg()) { 3159 Expr *UninstExpr = Param->getUninstantiatedDefaultArg(); 3160 3161 // Instantiate the expression. 3162 MultiLevelTemplateArgumentList ArgList 3163 = getTemplateInstantiationArgs(FD, 0, /*RelativeToPrimary=*/true); 3164 3165 std::pair<const TemplateArgument *, unsigned> Innermost 3166 = ArgList.getInnermost(); 3167 InstantiatingTemplate Inst(*this, CallLoc, Param, Innermost.first, 3168 Innermost.second); 3169 3170 ExprResult Result; 3171 { 3172 // C++ [dcl.fct.default]p5: 3173 // The names in the [default argument] expression are bound, and 3174 // the semantic constraints are checked, at the point where the 3175 // default argument expression appears. 3176 ContextRAII SavedContext(*this, FD); 3177 Result = SubstExpr(UninstExpr, ArgList); 3178 } 3179 if (Result.isInvalid()) 3180 return ExprError(); 3181 3182 // Check the expression as an initializer for the parameter. 3183 InitializedEntity Entity 3184 = InitializedEntity::InitializeParameter(Context, Param); 3185 InitializationKind Kind 3186 = InitializationKind::CreateCopy(Param->getLocation(), 3187 /*FIXME:EqualLoc*/UninstExpr->getSourceRange().getBegin()); 3188 Expr *ResultE = Result.takeAs<Expr>(); 3189 3190 InitializationSequence InitSeq(*this, Entity, Kind, &ResultE, 1); 3191 Result = InitSeq.Perform(*this, Entity, Kind, 3192 MultiExprArg(*this, &ResultE, 1)); 3193 if (Result.isInvalid()) 3194 return ExprError(); 3195 3196 // Build the default argument expression. 3197 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param, 3198 Result.takeAs<Expr>())); 3199 } 3200 3201 // If the default expression creates temporaries, we need to 3202 // push them to the current stack of expression temporaries so they'll 3203 // be properly destroyed. 3204 // FIXME: We should really be rebuilding the default argument with new 3205 // bound temporaries; see the comment in PR5810. 3206 for (unsigned i = 0, e = Param->getNumDefaultArgTemporaries(); i != e; ++i) { 3207 CXXTemporary *Temporary = Param->getDefaultArgTemporary(i); 3208 MarkDeclarationReferenced(Param->getDefaultArg()->getLocStart(), 3209 const_cast<CXXDestructorDecl*>(Temporary->getDestructor())); 3210 ExprTemporaries.push_back(Temporary); 3211 ExprNeedsCleanups = true; 3212 } 3213 3214 // We already type-checked the argument, so we know it works. 3215 // Just mark all of the declarations in this potentially-evaluated expression 3216 // as being "referenced". 3217 MarkDeclarationsReferencedInExpr(Param->getDefaultArg()); 3218 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param)); 3219} 3220 3221/// ConvertArgumentsForCall - Converts the arguments specified in 3222/// Args/NumArgs to the parameter types of the function FDecl with 3223/// function prototype Proto. Call is the call expression itself, and 3224/// Fn is the function expression. For a C++ member function, this 3225/// routine does not attempt to convert the object argument. Returns 3226/// true if the call is ill-formed. 3227bool 3228Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, 3229 FunctionDecl *FDecl, 3230 const FunctionProtoType *Proto, 3231 Expr **Args, unsigned NumArgs, 3232 SourceLocation RParenLoc) { 3233 // Bail out early if calling a builtin with custom typechecking. 3234 // We don't need to do this in the 3235 if (FDecl) 3236 if (unsigned ID = FDecl->getBuiltinID()) 3237 if (Context.BuiltinInfo.hasCustomTypechecking(ID)) 3238 return false; 3239 3240 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by 3241 // assignment, to the types of the corresponding parameter, ... 3242 unsigned NumArgsInProto = Proto->getNumArgs(); 3243 bool Invalid = false; 3244 3245 // If too few arguments are available (and we don't have default 3246 // arguments for the remaining parameters), don't make the call. 3247 if (NumArgs < NumArgsInProto) { 3248 if (!FDecl || NumArgs < FDecl->getMinRequiredArguments()) { 3249 Diag(RParenLoc, diag::err_typecheck_call_too_few_args) 3250 << Fn->getType()->isBlockPointerType() 3251 << NumArgsInProto << NumArgs << Fn->getSourceRange(); 3252 3253 // Emit the location of the prototype. 3254 if (FDecl && !FDecl->getBuiltinID()) 3255 Diag(FDecl->getLocStart(), diag::note_callee_decl) 3256 << FDecl; 3257 3258 return true; 3259 } 3260 Call->setNumArgs(Context, NumArgsInProto); 3261 } 3262 3263 // If too many are passed and not variadic, error on the extras and drop 3264 // them. 3265 if (NumArgs > NumArgsInProto) { 3266 if (!Proto->isVariadic()) { 3267 Diag(Args[NumArgsInProto]->getLocStart(), 3268 diag::err_typecheck_call_too_many_args) 3269 << Fn->getType()->isBlockPointerType() 3270 << NumArgsInProto << NumArgs << Fn->getSourceRange() 3271 << SourceRange(Args[NumArgsInProto]->getLocStart(), 3272 Args[NumArgs-1]->getLocEnd()); 3273 3274 // Emit the location of the prototype. 3275 if (FDecl && !FDecl->getBuiltinID()) 3276 Diag(FDecl->getLocStart(), diag::note_callee_decl) 3277 << FDecl; 3278 3279 // This deletes the extra arguments. 3280 Call->setNumArgs(Context, NumArgsInProto); 3281 return true; 3282 } 3283 } 3284 SmallVector<Expr *, 8> AllArgs; 3285 VariadicCallType CallType = 3286 Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply; 3287 if (Fn->getType()->isBlockPointerType()) 3288 CallType = VariadicBlock; // Block 3289 else if (isa<MemberExpr>(Fn)) 3290 CallType = VariadicMethod; 3291 Invalid = GatherArgumentsForCall(Call->getSourceRange().getBegin(), FDecl, 3292 Proto, 0, Args, NumArgs, AllArgs, CallType); 3293 if (Invalid) 3294 return true; 3295 unsigned TotalNumArgs = AllArgs.size(); 3296 for (unsigned i = 0; i < TotalNumArgs; ++i) 3297 Call->setArg(i, AllArgs[i]); 3298 3299 return false; 3300} 3301 3302bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, 3303 FunctionDecl *FDecl, 3304 const FunctionProtoType *Proto, 3305 unsigned FirstProtoArg, 3306 Expr **Args, unsigned NumArgs, 3307 SmallVector<Expr *, 8> &AllArgs, 3308 VariadicCallType CallType) { 3309 unsigned NumArgsInProto = Proto->getNumArgs(); 3310 unsigned NumArgsToCheck = NumArgs; 3311 bool Invalid = false; 3312 if (NumArgs != NumArgsInProto) 3313 // Use default arguments for missing arguments 3314 NumArgsToCheck = NumArgsInProto; 3315 unsigned ArgIx = 0; 3316 // Continue to check argument types (even if we have too few/many args). 3317 for (unsigned i = FirstProtoArg; i != NumArgsToCheck; i++) { 3318 QualType ProtoArgType = Proto->getArgType(i); 3319 3320 Expr *Arg; 3321 if (ArgIx < NumArgs) { 3322 Arg = Args[ArgIx++]; 3323 3324 if (RequireCompleteType(Arg->getSourceRange().getBegin(), 3325 ProtoArgType, 3326 PDiag(diag::err_call_incomplete_argument) 3327 << Arg->getSourceRange())) 3328 return true; 3329 3330 // Pass the argument 3331 ParmVarDecl *Param = 0; 3332 if (FDecl && i < FDecl->getNumParams()) 3333 Param = FDecl->getParamDecl(i); 3334 3335 InitializedEntity Entity = 3336 Param? InitializedEntity::InitializeParameter(Context, Param) 3337 : InitializedEntity::InitializeParameter(Context, ProtoArgType, 3338 Proto->isArgConsumed(i)); 3339 ExprResult ArgE = PerformCopyInitialization(Entity, 3340 SourceLocation(), 3341 Owned(Arg)); 3342 if (ArgE.isInvalid()) 3343 return true; 3344 3345 Arg = ArgE.takeAs<Expr>(); 3346 } else { 3347 ParmVarDecl *Param = FDecl->getParamDecl(i); 3348 3349 ExprResult ArgExpr = 3350 BuildCXXDefaultArgExpr(CallLoc, FDecl, Param); 3351 if (ArgExpr.isInvalid()) 3352 return true; 3353 3354 Arg = ArgExpr.takeAs<Expr>(); 3355 } 3356 3357 // Check for array bounds violations for each argument to the call. This 3358 // check only triggers warnings when the argument isn't a more complex Expr 3359 // with its own checking, such as a BinaryOperator. 3360 CheckArrayAccess(Arg); 3361 3362 AllArgs.push_back(Arg); 3363 } 3364 3365 // If this is a variadic call, handle args passed through "...". 3366 if (CallType != VariadicDoesNotApply) { 3367 3368 // Assume that extern "C" functions with variadic arguments that 3369 // return __unknown_anytype aren't *really* variadic. 3370 if (Proto->getResultType() == Context.UnknownAnyTy && 3371 FDecl && FDecl->isExternC()) { 3372 for (unsigned i = ArgIx; i != NumArgs; ++i) { 3373 ExprResult arg; 3374 if (isa<ExplicitCastExpr>(Args[i]->IgnoreParens())) 3375 arg = DefaultFunctionArrayLvalueConversion(Args[i]); 3376 else 3377 arg = DefaultVariadicArgumentPromotion(Args[i], CallType, FDecl); 3378 Invalid |= arg.isInvalid(); 3379 AllArgs.push_back(arg.take()); 3380 } 3381 3382 // Otherwise do argument promotion, (C99 6.5.2.2p7). 3383 } else { 3384 for (unsigned i = ArgIx; i != NumArgs; ++i) { 3385 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], CallType, 3386 FDecl); 3387 Invalid |= Arg.isInvalid(); 3388 AllArgs.push_back(Arg.take()); 3389 } 3390 } 3391 } 3392 return Invalid; 3393} 3394 3395/// Given a function expression of unknown-any type, try to rebuild it 3396/// to have a function type. 3397static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn); 3398 3399/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments. 3400/// This provides the location of the left/right parens and a list of comma 3401/// locations. 3402ExprResult 3403Sema::ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, 3404 MultiExprArg args, SourceLocation RParenLoc, 3405 Expr *ExecConfig) { 3406 unsigned NumArgs = args.size(); 3407 3408 // Since this might be a postfix expression, get rid of ParenListExprs. 3409 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn); 3410 if (Result.isInvalid()) return ExprError(); 3411 Fn = Result.take(); 3412 3413 Expr **Args = args.release(); 3414 3415 if (getLangOptions().CPlusPlus) { 3416 // If this is a pseudo-destructor expression, build the call immediately. 3417 if (isa<CXXPseudoDestructorExpr>(Fn)) { 3418 if (NumArgs > 0) { 3419 // Pseudo-destructor calls should not have any arguments. 3420 Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args) 3421 << FixItHint::CreateRemoval( 3422 SourceRange(Args[0]->getLocStart(), 3423 Args[NumArgs-1]->getLocEnd())); 3424 3425 NumArgs = 0; 3426 } 3427 3428 return Owned(new (Context) CallExpr(Context, Fn, 0, 0, Context.VoidTy, 3429 VK_RValue, RParenLoc)); 3430 } 3431 3432 // Determine whether this is a dependent call inside a C++ template, 3433 // in which case we won't do any semantic analysis now. 3434 // FIXME: Will need to cache the results of name lookup (including ADL) in 3435 // Fn. 3436 bool Dependent = false; 3437 if (Fn->isTypeDependent()) 3438 Dependent = true; 3439 else if (Expr::hasAnyTypeDependentArguments(Args, NumArgs)) 3440 Dependent = true; 3441 3442 if (Dependent) { 3443 if (ExecConfig) { 3444 return Owned(new (Context) CUDAKernelCallExpr( 3445 Context, Fn, cast<CallExpr>(ExecConfig), Args, NumArgs, 3446 Context.DependentTy, VK_RValue, RParenLoc)); 3447 } else { 3448 return Owned(new (Context) CallExpr(Context, Fn, Args, NumArgs, 3449 Context.DependentTy, VK_RValue, 3450 RParenLoc)); 3451 } 3452 } 3453 3454 // Determine whether this is a call to an object (C++ [over.call.object]). 3455 if (Fn->getType()->isRecordType()) 3456 return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc, Args, NumArgs, 3457 RParenLoc)); 3458 3459 if (Fn->getType() == Context.UnknownAnyTy) { 3460 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 3461 if (result.isInvalid()) return ExprError(); 3462 Fn = result.take(); 3463 } 3464 3465 if (Fn->getType() == Context.BoundMemberTy) { 3466 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs, 3467 RParenLoc); 3468 } 3469 } 3470 3471 // Check for overloaded calls. This can happen even in C due to extensions. 3472 if (Fn->getType() == Context.OverloadTy) { 3473 OverloadExpr::FindResult find = OverloadExpr::find(Fn); 3474 3475 // We aren't supposed to apply this logic if there's an '&' involved. 3476 if (!find.IsAddressOfOperand) { 3477 OverloadExpr *ovl = find.Expression; 3478 if (isa<UnresolvedLookupExpr>(ovl)) { 3479 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(ovl); 3480 return BuildOverloadedCallExpr(S, Fn, ULE, LParenLoc, Args, NumArgs, 3481 RParenLoc, ExecConfig); 3482 } else { 3483 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs, 3484 RParenLoc); 3485 } 3486 } 3487 } 3488 3489 // If we're directly calling a function, get the appropriate declaration. 3490 3491 Expr *NakedFn = Fn->IgnoreParens(); 3492 3493 NamedDecl *NDecl = 0; 3494 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) 3495 if (UnOp->getOpcode() == UO_AddrOf) 3496 NakedFn = UnOp->getSubExpr()->IgnoreParens(); 3497 3498 if (isa<DeclRefExpr>(NakedFn)) 3499 NDecl = cast<DeclRefExpr>(NakedFn)->getDecl(); 3500 else if (isa<MemberExpr>(NakedFn)) 3501 NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl(); 3502 3503 return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, Args, NumArgs, RParenLoc, 3504 ExecConfig); 3505} 3506 3507ExprResult 3508Sema::ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc, 3509 MultiExprArg execConfig, SourceLocation GGGLoc) { 3510 FunctionDecl *ConfigDecl = Context.getcudaConfigureCallDecl(); 3511 if (!ConfigDecl) 3512 return ExprError(Diag(LLLLoc, diag::err_undeclared_var_use) 3513 << "cudaConfigureCall"); 3514 QualType ConfigQTy = ConfigDecl->getType(); 3515 3516 DeclRefExpr *ConfigDR = new (Context) DeclRefExpr( 3517 ConfigDecl, ConfigQTy, VK_LValue, LLLLoc); 3518 3519 return ActOnCallExpr(S, ConfigDR, LLLLoc, execConfig, GGGLoc, 0); 3520} 3521 3522/// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments. 3523/// 3524/// __builtin_astype( value, dst type ) 3525/// 3526ExprResult Sema::ActOnAsTypeExpr(Expr *expr, ParsedType destty, 3527 SourceLocation BuiltinLoc, 3528 SourceLocation RParenLoc) { 3529 ExprValueKind VK = VK_RValue; 3530 ExprObjectKind OK = OK_Ordinary; 3531 QualType DstTy = GetTypeFromParser(destty); 3532 QualType SrcTy = expr->getType(); 3533 if (Context.getTypeSize(DstTy) != Context.getTypeSize(SrcTy)) 3534 return ExprError(Diag(BuiltinLoc, 3535 diag::err_invalid_astype_of_different_size) 3536 << DstTy 3537 << SrcTy 3538 << expr->getSourceRange()); 3539 return Owned(new (Context) AsTypeExpr(expr, DstTy, VK, OK, BuiltinLoc, 3540 RParenLoc)); 3541} 3542 3543/// BuildResolvedCallExpr - Build a call to a resolved expression, 3544/// i.e. an expression not of \p OverloadTy. The expression should 3545/// unary-convert to an expression of function-pointer or 3546/// block-pointer type. 3547/// 3548/// \param NDecl the declaration being called, if available 3549ExprResult 3550Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, 3551 SourceLocation LParenLoc, 3552 Expr **Args, unsigned NumArgs, 3553 SourceLocation RParenLoc, 3554 Expr *Config) { 3555 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl); 3556 3557 // Promote the function operand. 3558 ExprResult Result = UsualUnaryConversions(Fn); 3559 if (Result.isInvalid()) 3560 return ExprError(); 3561 Fn = Result.take(); 3562 3563 // Make the call expr early, before semantic checks. This guarantees cleanup 3564 // of arguments and function on error. 3565 CallExpr *TheCall; 3566 if (Config) { 3567 TheCall = new (Context) CUDAKernelCallExpr(Context, Fn, 3568 cast<CallExpr>(Config), 3569 Args, NumArgs, 3570 Context.BoolTy, 3571 VK_RValue, 3572 RParenLoc); 3573 } else { 3574 TheCall = new (Context) CallExpr(Context, Fn, 3575 Args, NumArgs, 3576 Context.BoolTy, 3577 VK_RValue, 3578 RParenLoc); 3579 } 3580 3581 unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0); 3582 3583 // Bail out early if calling a builtin with custom typechecking. 3584 if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID)) 3585 return CheckBuiltinFunctionCall(BuiltinID, TheCall); 3586 3587 retry: 3588 const FunctionType *FuncT; 3589 if (const PointerType *PT = Fn->getType()->getAs<PointerType>()) { 3590 // C99 6.5.2.2p1 - "The expression that denotes the called function shall 3591 // have type pointer to function". 3592 FuncT = PT->getPointeeType()->getAs<FunctionType>(); 3593 if (FuncT == 0) 3594 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 3595 << Fn->getType() << Fn->getSourceRange()); 3596 } else if (const BlockPointerType *BPT = 3597 Fn->getType()->getAs<BlockPointerType>()) { 3598 FuncT = BPT->getPointeeType()->castAs<FunctionType>(); 3599 } else { 3600 // Handle calls to expressions of unknown-any type. 3601 if (Fn->getType() == Context.UnknownAnyTy) { 3602 ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn); 3603 if (rewrite.isInvalid()) return ExprError(); 3604 Fn = rewrite.take(); 3605 TheCall->setCallee(Fn); 3606 goto retry; 3607 } 3608 3609 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 3610 << Fn->getType() << Fn->getSourceRange()); 3611 } 3612 3613 if (getLangOptions().CUDA) { 3614 if (Config) { 3615 // CUDA: Kernel calls must be to global functions 3616 if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>()) 3617 return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function) 3618 << FDecl->getName() << Fn->getSourceRange()); 3619 3620 // CUDA: Kernel function must have 'void' return type 3621 if (!FuncT->getResultType()->isVoidType()) 3622 return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return) 3623 << Fn->getType() << Fn->getSourceRange()); 3624 } 3625 } 3626 3627 // Check for a valid return type 3628 if (CheckCallReturnType(FuncT->getResultType(), 3629 Fn->getSourceRange().getBegin(), TheCall, 3630 FDecl)) 3631 return ExprError(); 3632 3633 // We know the result type of the call, set it. 3634 TheCall->setType(FuncT->getCallResultType(Context)); 3635 TheCall->setValueKind(Expr::getValueKindForType(FuncT->getResultType())); 3636 3637 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) { 3638 if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, NumArgs, 3639 RParenLoc)) 3640 return ExprError(); 3641 } else { 3642 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!"); 3643 3644 if (FDecl) { 3645 // Check if we have too few/too many template arguments, based 3646 // on our knowledge of the function definition. 3647 const FunctionDecl *Def = 0; 3648 if (FDecl->hasBody(Def) && NumArgs != Def->param_size()) { 3649 const FunctionProtoType *Proto 3650 = Def->getType()->getAs<FunctionProtoType>(); 3651 if (!Proto || !(Proto->isVariadic() && NumArgs >= Def->param_size())) 3652 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments) 3653 << (NumArgs > Def->param_size()) << FDecl << Fn->getSourceRange(); 3654 } 3655 3656 // If the function we're calling isn't a function prototype, but we have 3657 // a function prototype from a prior declaratiom, use that prototype. 3658 if (!FDecl->hasPrototype()) 3659 Proto = FDecl->getType()->getAs<FunctionProtoType>(); 3660 } 3661 3662 // Promote the arguments (C99 6.5.2.2p6). 3663 for (unsigned i = 0; i != NumArgs; i++) { 3664 Expr *Arg = Args[i]; 3665 3666 if (Proto && i < Proto->getNumArgs()) { 3667 InitializedEntity Entity 3668 = InitializedEntity::InitializeParameter(Context, 3669 Proto->getArgType(i), 3670 Proto->isArgConsumed(i)); 3671 ExprResult ArgE = PerformCopyInitialization(Entity, 3672 SourceLocation(), 3673 Owned(Arg)); 3674 if (ArgE.isInvalid()) 3675 return true; 3676 3677 Arg = ArgE.takeAs<Expr>(); 3678 3679 } else { 3680 ExprResult ArgE = DefaultArgumentPromotion(Arg); 3681 3682 if (ArgE.isInvalid()) 3683 return true; 3684 3685 Arg = ArgE.takeAs<Expr>(); 3686 } 3687 3688 if (RequireCompleteType(Arg->getSourceRange().getBegin(), 3689 Arg->getType(), 3690 PDiag(diag::err_call_incomplete_argument) 3691 << Arg->getSourceRange())) 3692 return ExprError(); 3693 3694 TheCall->setArg(i, Arg); 3695 } 3696 } 3697 3698 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl)) 3699 if (!Method->isStatic()) 3700 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object) 3701 << Fn->getSourceRange()); 3702 3703 // Check for sentinels 3704 if (NDecl) 3705 DiagnoseSentinelCalls(NDecl, LParenLoc, Args, NumArgs); 3706 3707 // Do special checking on direct calls to functions. 3708 if (FDecl) { 3709 if (CheckFunctionCall(FDecl, TheCall)) 3710 return ExprError(); 3711 3712 if (BuiltinID) 3713 return CheckBuiltinFunctionCall(BuiltinID, TheCall); 3714 } else if (NDecl) { 3715 if (CheckBlockCall(NDecl, TheCall)) 3716 return ExprError(); 3717 } 3718 3719 return MaybeBindToTemporary(TheCall); 3720} 3721 3722ExprResult 3723Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, 3724 SourceLocation RParenLoc, Expr *InitExpr) { 3725 assert((Ty != 0) && "ActOnCompoundLiteral(): missing type"); 3726 // FIXME: put back this assert when initializers are worked out. 3727 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression"); 3728 3729 TypeSourceInfo *TInfo; 3730 QualType literalType = GetTypeFromParser(Ty, &TInfo); 3731 if (!TInfo) 3732 TInfo = Context.getTrivialTypeSourceInfo(literalType); 3733 3734 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr); 3735} 3736 3737ExprResult 3738Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, 3739 SourceLocation RParenLoc, Expr *literalExpr) { 3740 QualType literalType = TInfo->getType(); 3741 3742 if (literalType->isArrayType()) { 3743 if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType), 3744 PDiag(diag::err_illegal_decl_array_incomplete_type) 3745 << SourceRange(LParenLoc, 3746 literalExpr->getSourceRange().getEnd()))) 3747 return ExprError(); 3748 if (literalType->isVariableArrayType()) 3749 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init) 3750 << SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd())); 3751 } else if (!literalType->isDependentType() && 3752 RequireCompleteType(LParenLoc, literalType, 3753 PDiag(diag::err_typecheck_decl_incomplete_type) 3754 << SourceRange(LParenLoc, 3755 literalExpr->getSourceRange().getEnd()))) 3756 return ExprError(); 3757 3758 InitializedEntity Entity 3759 = InitializedEntity::InitializeTemporary(literalType); 3760 InitializationKind Kind 3761 = InitializationKind::CreateCStyleCast(LParenLoc, 3762 SourceRange(LParenLoc, RParenLoc)); 3763 InitializationSequence InitSeq(*this, Entity, Kind, &literalExpr, 1); 3764 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, 3765 MultiExprArg(*this, &literalExpr, 1), 3766 &literalType); 3767 if (Result.isInvalid()) 3768 return ExprError(); 3769 literalExpr = Result.get(); 3770 3771 bool isFileScope = getCurFunctionOrMethodDecl() == 0; 3772 if (isFileScope) { // 6.5.2.5p3 3773 if (CheckForConstantInitializer(literalExpr, literalType)) 3774 return ExprError(); 3775 } 3776 3777 // In C, compound literals are l-values for some reason. 3778 ExprValueKind VK = getLangOptions().CPlusPlus ? VK_RValue : VK_LValue; 3779 3780 return MaybeBindToTemporary( 3781 new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType, 3782 VK, literalExpr, isFileScope)); 3783} 3784 3785ExprResult 3786Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg initlist, 3787 SourceLocation RBraceLoc) { 3788 unsigned NumInit = initlist.size(); 3789 Expr **InitList = initlist.release(); 3790 3791 // Semantic analysis for initializers is done by ActOnDeclarator() and 3792 // CheckInitializer() - it requires knowledge of the object being intialized. 3793 3794 InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitList, 3795 NumInit, RBraceLoc); 3796 E->setType(Context.VoidTy); // FIXME: just a place holder for now. 3797 return Owned(E); 3798} 3799 3800/// Prepares for a scalar cast, performing all the necessary stages 3801/// except the final cast and returning the kind required. 3802static CastKind PrepareScalarCast(Sema &S, ExprResult &Src, QualType DestTy) { 3803 // Both Src and Dest are scalar types, i.e. arithmetic or pointer. 3804 // Also, callers should have filtered out the invalid cases with 3805 // pointers. Everything else should be possible. 3806 3807 QualType SrcTy = Src.get()->getType(); 3808 if (S.Context.hasSameUnqualifiedType(SrcTy, DestTy)) 3809 return CK_NoOp; 3810 3811 switch (SrcTy->getScalarTypeKind()) { 3812 case Type::STK_MemberPointer: 3813 llvm_unreachable("member pointer type in C"); 3814 3815 case Type::STK_Pointer: 3816 switch (DestTy->getScalarTypeKind()) { 3817 case Type::STK_Pointer: 3818 return DestTy->isObjCObjectPointerType() ? 3819 CK_AnyPointerToObjCPointerCast : 3820 CK_BitCast; 3821 case Type::STK_Bool: 3822 return CK_PointerToBoolean; 3823 case Type::STK_Integral: 3824 return CK_PointerToIntegral; 3825 case Type::STK_Floating: 3826 case Type::STK_FloatingComplex: 3827 case Type::STK_IntegralComplex: 3828 case Type::STK_MemberPointer: 3829 llvm_unreachable("illegal cast from pointer"); 3830 } 3831 break; 3832 3833 case Type::STK_Bool: // casting from bool is like casting from an integer 3834 case Type::STK_Integral: 3835 switch (DestTy->getScalarTypeKind()) { 3836 case Type::STK_Pointer: 3837 if (Src.get()->isNullPointerConstant(S.Context, 3838 Expr::NPC_ValueDependentIsNull)) 3839 return CK_NullToPointer; 3840 return CK_IntegralToPointer; 3841 case Type::STK_Bool: 3842 return CK_IntegralToBoolean; 3843 case Type::STK_Integral: 3844 return CK_IntegralCast; 3845 case Type::STK_Floating: 3846 return CK_IntegralToFloating; 3847 case Type::STK_IntegralComplex: 3848 Src = S.ImpCastExprToType(Src.take(), 3849 DestTy->getAs<ComplexType>()->getElementType(), 3850 CK_IntegralCast); 3851 return CK_IntegralRealToComplex; 3852 case Type::STK_FloatingComplex: 3853 Src = S.ImpCastExprToType(Src.take(), 3854 DestTy->getAs<ComplexType>()->getElementType(), 3855 CK_IntegralToFloating); 3856 return CK_FloatingRealToComplex; 3857 case Type::STK_MemberPointer: 3858 llvm_unreachable("member pointer type in C"); 3859 } 3860 break; 3861 3862 case Type::STK_Floating: 3863 switch (DestTy->getScalarTypeKind()) { 3864 case Type::STK_Floating: 3865 return CK_FloatingCast; 3866 case Type::STK_Bool: 3867 return CK_FloatingToBoolean; 3868 case Type::STK_Integral: 3869 return CK_FloatingToIntegral; 3870 case Type::STK_FloatingComplex: 3871 Src = S.ImpCastExprToType(Src.take(), 3872 DestTy->getAs<ComplexType>()->getElementType(), 3873 CK_FloatingCast); 3874 return CK_FloatingRealToComplex; 3875 case Type::STK_IntegralComplex: 3876 Src = S.ImpCastExprToType(Src.take(), 3877 DestTy->getAs<ComplexType>()->getElementType(), 3878 CK_FloatingToIntegral); 3879 return CK_IntegralRealToComplex; 3880 case Type::STK_Pointer: 3881 llvm_unreachable("valid float->pointer cast?"); 3882 case Type::STK_MemberPointer: 3883 llvm_unreachable("member pointer type in C"); 3884 } 3885 break; 3886 3887 case Type::STK_FloatingComplex: 3888 switch (DestTy->getScalarTypeKind()) { 3889 case Type::STK_FloatingComplex: 3890 return CK_FloatingComplexCast; 3891 case Type::STK_IntegralComplex: 3892 return CK_FloatingComplexToIntegralComplex; 3893 case Type::STK_Floating: { 3894 QualType ET = SrcTy->getAs<ComplexType>()->getElementType(); 3895 if (S.Context.hasSameType(ET, DestTy)) 3896 return CK_FloatingComplexToReal; 3897 Src = S.ImpCastExprToType(Src.take(), ET, CK_FloatingComplexToReal); 3898 return CK_FloatingCast; 3899 } 3900 case Type::STK_Bool: 3901 return CK_FloatingComplexToBoolean; 3902 case Type::STK_Integral: 3903 Src = S.ImpCastExprToType(Src.take(), 3904 SrcTy->getAs<ComplexType>()->getElementType(), 3905 CK_FloatingComplexToReal); 3906 return CK_FloatingToIntegral; 3907 case Type::STK_Pointer: 3908 llvm_unreachable("valid complex float->pointer cast?"); 3909 case Type::STK_MemberPointer: 3910 llvm_unreachable("member pointer type in C"); 3911 } 3912 break; 3913 3914 case Type::STK_IntegralComplex: 3915 switch (DestTy->getScalarTypeKind()) { 3916 case Type::STK_FloatingComplex: 3917 return CK_IntegralComplexToFloatingComplex; 3918 case Type::STK_IntegralComplex: 3919 return CK_IntegralComplexCast; 3920 case Type::STK_Integral: { 3921 QualType ET = SrcTy->getAs<ComplexType>()->getElementType(); 3922 if (S.Context.hasSameType(ET, DestTy)) 3923 return CK_IntegralComplexToReal; 3924 Src = S.ImpCastExprToType(Src.take(), ET, CK_IntegralComplexToReal); 3925 return CK_IntegralCast; 3926 } 3927 case Type::STK_Bool: 3928 return CK_IntegralComplexToBoolean; 3929 case Type::STK_Floating: 3930 Src = S.ImpCastExprToType(Src.take(), 3931 SrcTy->getAs<ComplexType>()->getElementType(), 3932 CK_IntegralComplexToReal); 3933 return CK_IntegralToFloating; 3934 case Type::STK_Pointer: 3935 llvm_unreachable("valid complex int->pointer cast?"); 3936 case Type::STK_MemberPointer: 3937 llvm_unreachable("member pointer type in C"); 3938 } 3939 break; 3940 } 3941 3942 llvm_unreachable("Unhandled scalar cast"); 3943 return CK_BitCast; 3944} 3945 3946/// CheckCastTypes - Check type constraints for casting between types. 3947ExprResult Sema::CheckCastTypes(SourceLocation CastStartLoc, SourceRange TyR, 3948 QualType castType, Expr *castExpr, 3949 CastKind& Kind, ExprValueKind &VK, 3950 CXXCastPath &BasePath, bool FunctionalStyle) { 3951 if (castExpr->getType() == Context.UnknownAnyTy) 3952 return checkUnknownAnyCast(TyR, castType, castExpr, Kind, VK, BasePath); 3953 3954 if (getLangOptions().CPlusPlus) 3955 return CXXCheckCStyleCast(SourceRange(CastStartLoc, 3956 castExpr->getLocEnd()), 3957 castType, VK, castExpr, Kind, BasePath, 3958 FunctionalStyle); 3959 3960 assert(!castExpr->getType()->isPlaceholderType()); 3961 3962 // We only support r-value casts in C. 3963 VK = VK_RValue; 3964 3965 // C99 6.5.4p2: the cast type needs to be void or scalar and the expression 3966 // type needs to be scalar. 3967 if (castType->isVoidType()) { 3968 // We don't necessarily do lvalue-to-rvalue conversions on this. 3969 ExprResult castExprRes = IgnoredValueConversions(castExpr); 3970 if (castExprRes.isInvalid()) 3971 return ExprError(); 3972 castExpr = castExprRes.take(); 3973 3974 // Cast to void allows any expr type. 3975 Kind = CK_ToVoid; 3976 return Owned(castExpr); 3977 } 3978 3979 ExprResult castExprRes = DefaultFunctionArrayLvalueConversion(castExpr); 3980 if (castExprRes.isInvalid()) 3981 return ExprError(); 3982 castExpr = castExprRes.take(); 3983 3984 if (RequireCompleteType(TyR.getBegin(), castType, 3985 diag::err_typecheck_cast_to_incomplete)) 3986 return ExprError(); 3987 3988 if (!castType->isScalarType() && !castType->isVectorType()) { 3989 if (Context.hasSameUnqualifiedType(castType, castExpr->getType()) && 3990 (castType->isStructureType() || castType->isUnionType())) { 3991 // GCC struct/union extension: allow cast to self. 3992 // FIXME: Check that the cast destination type is complete. 3993 Diag(TyR.getBegin(), diag::ext_typecheck_cast_nonscalar) 3994 << castType << castExpr->getSourceRange(); 3995 Kind = CK_NoOp; 3996 return Owned(castExpr); 3997 } 3998 3999 if (castType->isUnionType()) { 4000 // GCC cast to union extension 4001 RecordDecl *RD = castType->getAs<RecordType>()->getDecl(); 4002 RecordDecl::field_iterator Field, FieldEnd; 4003 for (Field = RD->field_begin(), FieldEnd = RD->field_end(); 4004 Field != FieldEnd; ++Field) { 4005 if (Context.hasSameUnqualifiedType(Field->getType(), 4006 castExpr->getType()) && 4007 !Field->isUnnamedBitfield()) { 4008 Diag(TyR.getBegin(), diag::ext_typecheck_cast_to_union) 4009 << castExpr->getSourceRange(); 4010 break; 4011 } 4012 } 4013 if (Field == FieldEnd) { 4014 Diag(TyR.getBegin(), diag::err_typecheck_cast_to_union_no_type) 4015 << castExpr->getType() << castExpr->getSourceRange(); 4016 return ExprError(); 4017 } 4018 Kind = CK_ToUnion; 4019 return Owned(castExpr); 4020 } 4021 4022 // Reject any other conversions to non-scalar types. 4023 Diag(TyR.getBegin(), diag::err_typecheck_cond_expect_scalar) 4024 << castType << castExpr->getSourceRange(); 4025 return ExprError(); 4026 } 4027 4028 // The type we're casting to is known to be a scalar or vector. 4029 4030 // Require the operand to be a scalar or vector. 4031 if (!castExpr->getType()->isScalarType() && 4032 !castExpr->getType()->isVectorType()) { 4033 Diag(castExpr->getLocStart(), 4034 diag::err_typecheck_expect_scalar_operand) 4035 << castExpr->getType() << castExpr->getSourceRange(); 4036 return ExprError(); 4037 } 4038 4039 if (castType->isExtVectorType()) 4040 return CheckExtVectorCast(TyR, castType, castExpr, Kind); 4041 4042 if (castType->isVectorType()) { 4043 if (castType->getAs<VectorType>()->getVectorKind() == 4044 VectorType::AltiVecVector && 4045 (castExpr->getType()->isIntegerType() || 4046 castExpr->getType()->isFloatingType())) { 4047 Kind = CK_VectorSplat; 4048 return Owned(castExpr); 4049 } else if (CheckVectorCast(TyR, castType, castExpr->getType(), Kind)) { 4050 return ExprError(); 4051 } else 4052 return Owned(castExpr); 4053 } 4054 if (castExpr->getType()->isVectorType()) { 4055 if (CheckVectorCast(TyR, castExpr->getType(), castType, Kind)) 4056 return ExprError(); 4057 else 4058 return Owned(castExpr); 4059 } 4060 4061 // The source and target types are both scalars, i.e. 4062 // - arithmetic types (fundamental, enum, and complex) 4063 // - all kinds of pointers 4064 // Note that member pointers were filtered out with C++, above. 4065 4066 if (isa<ObjCSelectorExpr>(castExpr)) { 4067 Diag(castExpr->getLocStart(), diag::err_cast_selector_expr); 4068 return ExprError(); 4069 } 4070 4071 // If either type is a pointer, the other type has to be either an 4072 // integer or a pointer. 4073 QualType castExprType = castExpr->getType(); 4074 if (!castType->isArithmeticType()) { 4075 if (!castExprType->isIntegralType(Context) && 4076 castExprType->isArithmeticType()) { 4077 Diag(castExpr->getLocStart(), 4078 diag::err_cast_pointer_from_non_pointer_int) 4079 << castExprType << castExpr->getSourceRange(); 4080 return ExprError(); 4081 } 4082 } else if (!castExpr->getType()->isArithmeticType()) { 4083 if (!castType->isIntegralType(Context) && castType->isArithmeticType()) { 4084 Diag(castExpr->getLocStart(), diag::err_cast_pointer_to_non_pointer_int) 4085 << castType << castExpr->getSourceRange(); 4086 return ExprError(); 4087 } 4088 } 4089 4090 if (getLangOptions().ObjCAutoRefCount) { 4091 // Diagnose problems with Objective-C casts involving lifetime qualifiers. 4092 CheckObjCARCConversion(SourceRange(CastStartLoc, castExpr->getLocEnd()), 4093 castType, castExpr, CCK_CStyleCast); 4094 4095 if (const PointerType *CastPtr = castType->getAs<PointerType>()) { 4096 if (const PointerType *ExprPtr = castExprType->getAs<PointerType>()) { 4097 Qualifiers CastQuals = CastPtr->getPointeeType().getQualifiers(); 4098 Qualifiers ExprQuals = ExprPtr->getPointeeType().getQualifiers(); 4099 if (CastPtr->getPointeeType()->isObjCLifetimeType() && 4100 ExprPtr->getPointeeType()->isObjCLifetimeType() && 4101 !CastQuals.compatiblyIncludesObjCLifetime(ExprQuals)) { 4102 Diag(castExpr->getLocStart(), 4103 diag::err_typecheck_incompatible_ownership) 4104 << castExprType << castType << AA_Casting 4105 << castExpr->getSourceRange(); 4106 4107 return ExprError(); 4108 } 4109 } 4110 } 4111 else if (!CheckObjCARCUnavailableWeakConversion(castType, castExprType)) { 4112 Diag(castExpr->getLocStart(), 4113 diag::err_arc_convesion_of_weak_unavailable) << 1 4114 << castExprType << castType 4115 << castExpr->getSourceRange(); 4116 return ExprError(); 4117 } 4118 } 4119 4120 castExprRes = Owned(castExpr); 4121 Kind = PrepareScalarCast(*this, castExprRes, castType); 4122 if (castExprRes.isInvalid()) 4123 return ExprError(); 4124 castExpr = castExprRes.take(); 4125 4126 if (Kind == CK_BitCast) 4127 CheckCastAlign(castExpr, castType, TyR); 4128 4129 return Owned(castExpr); 4130} 4131 4132bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, 4133 CastKind &Kind) { 4134 assert(VectorTy->isVectorType() && "Not a vector type!"); 4135 4136 if (Ty->isVectorType() || Ty->isIntegerType()) { 4137 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty)) 4138 return Diag(R.getBegin(), 4139 Ty->isVectorType() ? 4140 diag::err_invalid_conversion_between_vectors : 4141 diag::err_invalid_conversion_between_vector_and_integer) 4142 << VectorTy << Ty << R; 4143 } else 4144 return Diag(R.getBegin(), 4145 diag::err_invalid_conversion_between_vector_and_scalar) 4146 << VectorTy << Ty << R; 4147 4148 Kind = CK_BitCast; 4149 return false; 4150} 4151 4152ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy, 4153 Expr *CastExpr, CastKind &Kind) { 4154 assert(DestTy->isExtVectorType() && "Not an extended vector type!"); 4155 4156 QualType SrcTy = CastExpr->getType(); 4157 4158 // If SrcTy is a VectorType, the total size must match to explicitly cast to 4159 // an ExtVectorType. 4160 if (SrcTy->isVectorType()) { 4161 if (Context.getTypeSize(DestTy) != Context.getTypeSize(SrcTy)) { 4162 Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors) 4163 << DestTy << SrcTy << R; 4164 return ExprError(); 4165 } 4166 Kind = CK_BitCast; 4167 return Owned(CastExpr); 4168 } 4169 4170 // All non-pointer scalars can be cast to ExtVector type. The appropriate 4171 // conversion will take place first from scalar to elt type, and then 4172 // splat from elt type to vector. 4173 if (SrcTy->isPointerType()) 4174 return Diag(R.getBegin(), 4175 diag::err_invalid_conversion_between_vector_and_scalar) 4176 << DestTy << SrcTy << R; 4177 4178 QualType DestElemTy = DestTy->getAs<ExtVectorType>()->getElementType(); 4179 ExprResult CastExprRes = Owned(CastExpr); 4180 CastKind CK = PrepareScalarCast(*this, CastExprRes, DestElemTy); 4181 if (CastExprRes.isInvalid()) 4182 return ExprError(); 4183 CastExpr = ImpCastExprToType(CastExprRes.take(), DestElemTy, CK).take(); 4184 4185 Kind = CK_VectorSplat; 4186 return Owned(CastExpr); 4187} 4188 4189ExprResult 4190Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, 4191 Declarator &D, ParsedType &Ty, 4192 SourceLocation RParenLoc, Expr *castExpr) { 4193 assert(!D.isInvalidType() && (castExpr != 0) && 4194 "ActOnCastExpr(): missing type or expr"); 4195 4196 TypeSourceInfo *castTInfo = GetTypeForDeclaratorCast(D, castExpr->getType()); 4197 if (D.isInvalidType()) 4198 return ExprError(); 4199 4200 if (getLangOptions().CPlusPlus) { 4201 // Check that there are no default arguments (C++ only). 4202 CheckExtraCXXDefaultArguments(D); 4203 } 4204 4205 QualType castType = castTInfo->getType(); 4206 Ty = CreateParsedType(castType, castTInfo); 4207 4208 bool isVectorLiteral = false; 4209 4210 // Check for an altivec or OpenCL literal, 4211 // i.e. all the elements are integer constants. 4212 ParenExpr *PE = dyn_cast<ParenExpr>(castExpr); 4213 ParenListExpr *PLE = dyn_cast<ParenListExpr>(castExpr); 4214 if (getLangOptions().AltiVec && castType->isVectorType() && (PE || PLE)) { 4215 if (PLE && PLE->getNumExprs() == 0) { 4216 Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer); 4217 return ExprError(); 4218 } 4219 if (PE || PLE->getNumExprs() == 1) { 4220 Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0)); 4221 if (!E->getType()->isVectorType()) 4222 isVectorLiteral = true; 4223 } 4224 else 4225 isVectorLiteral = true; 4226 } 4227 4228 // If this is a vector initializer, '(' type ')' '(' init, ..., init ')' 4229 // then handle it as such. 4230 if (isVectorLiteral) 4231 return BuildVectorLiteral(LParenLoc, RParenLoc, castExpr, castTInfo); 4232 4233 // If the Expr being casted is a ParenListExpr, handle it specially. 4234 // This is not an AltiVec-style cast, so turn the ParenListExpr into a 4235 // sequence of BinOp comma operators. 4236 if (isa<ParenListExpr>(castExpr)) { 4237 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, castExpr); 4238 if (Result.isInvalid()) return ExprError(); 4239 castExpr = Result.take(); 4240 } 4241 4242 return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, castExpr); 4243} 4244 4245ExprResult 4246Sema::BuildCStyleCastExpr(SourceLocation LParenLoc, TypeSourceInfo *Ty, 4247 SourceLocation RParenLoc, Expr *castExpr) { 4248 CastKind Kind = CK_Invalid; 4249 ExprValueKind VK = VK_RValue; 4250 CXXCastPath BasePath; 4251 ExprResult CastResult = 4252 CheckCastTypes(LParenLoc, SourceRange(LParenLoc, RParenLoc), Ty->getType(), 4253 castExpr, Kind, VK, BasePath); 4254 if (CastResult.isInvalid()) 4255 return ExprError(); 4256 castExpr = CastResult.take(); 4257 4258 return Owned(CStyleCastExpr::Create( 4259 Context, Ty->getType().getNonLValueExprType(Context), VK, Kind, castExpr, 4260 &BasePath, Ty, LParenLoc, RParenLoc)); 4261} 4262 4263ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc, 4264 SourceLocation RParenLoc, Expr *E, 4265 TypeSourceInfo *TInfo) { 4266 assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) && 4267 "Expected paren or paren list expression"); 4268 4269 Expr **exprs; 4270 unsigned numExprs; 4271 Expr *subExpr; 4272 if (ParenListExpr *PE = dyn_cast<ParenListExpr>(E)) { 4273 exprs = PE->getExprs(); 4274 numExprs = PE->getNumExprs(); 4275 } else { 4276 subExpr = cast<ParenExpr>(E)->getSubExpr(); 4277 exprs = &subExpr; 4278 numExprs = 1; 4279 } 4280 4281 QualType Ty = TInfo->getType(); 4282 assert(Ty->isVectorType() && "Expected vector type"); 4283 4284 SmallVector<Expr *, 8> initExprs; 4285 const VectorType *VTy = Ty->getAs<VectorType>(); 4286 unsigned numElems = Ty->getAs<VectorType>()->getNumElements(); 4287 4288 // '(...)' form of vector initialization in AltiVec: the number of 4289 // initializers must be one or must match the size of the vector. 4290 // If a single value is specified in the initializer then it will be 4291 // replicated to all the components of the vector 4292 if (VTy->getVectorKind() == VectorType::AltiVecVector) { 4293 // The number of initializers must be one or must match the size of the 4294 // vector. If a single value is specified in the initializer then it will 4295 // be replicated to all the components of the vector 4296 if (numExprs == 1) { 4297 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 4298 ExprResult Literal = Owned(exprs[0]); 4299 Literal = ImpCastExprToType(Literal.take(), ElemTy, 4300 PrepareScalarCast(*this, Literal, ElemTy)); 4301 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take()); 4302 } 4303 else if (numExprs < numElems) { 4304 Diag(E->getExprLoc(), 4305 diag::err_incorrect_number_of_vector_initializers); 4306 return ExprError(); 4307 } 4308 else 4309 for (unsigned i = 0, e = numExprs; i != e; ++i) 4310 initExprs.push_back(exprs[i]); 4311 } 4312 else { 4313 // For OpenCL, when the number of initializers is a single value, 4314 // it will be replicated to all components of the vector. 4315 if (getLangOptions().OpenCL && 4316 VTy->getVectorKind() == VectorType::GenericVector && 4317 numExprs == 1) { 4318 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 4319 ExprResult Literal = Owned(exprs[0]); 4320 Literal = ImpCastExprToType(Literal.take(), ElemTy, 4321 PrepareScalarCast(*this, Literal, ElemTy)); 4322 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take()); 4323 } 4324 4325 for (unsigned i = 0, e = numExprs; i != e; ++i) 4326 initExprs.push_back(exprs[i]); 4327 } 4328 // FIXME: This means that pretty-printing the final AST will produce curly 4329 // braces instead of the original commas. 4330 InitListExpr *initE = new (Context) InitListExpr(Context, LParenLoc, 4331 &initExprs[0], 4332 initExprs.size(), RParenLoc); 4333 initE->setType(Ty); 4334 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE); 4335} 4336 4337/// This is not an AltiVec-style cast, so turn the ParenListExpr into a sequence 4338/// of comma binary operators. 4339ExprResult 4340Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *expr) { 4341 ParenListExpr *E = dyn_cast<ParenListExpr>(expr); 4342 if (!E) 4343 return Owned(expr); 4344 4345 ExprResult Result(E->getExpr(0)); 4346 4347 for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i) 4348 Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(), 4349 E->getExpr(i)); 4350 4351 if (Result.isInvalid()) return ExprError(); 4352 4353 return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get()); 4354} 4355 4356ExprResult Sema::ActOnParenOrParenListExpr(SourceLocation L, 4357 SourceLocation R, 4358 MultiExprArg Val) { 4359 unsigned nexprs = Val.size(); 4360 Expr **exprs = reinterpret_cast<Expr**>(Val.release()); 4361 assert((exprs != 0) && "ActOnParenOrParenListExpr() missing expr list"); 4362 Expr *expr; 4363 if (nexprs == 1) 4364 expr = new (Context) ParenExpr(L, R, exprs[0]); 4365 else 4366 expr = new (Context) ParenListExpr(Context, L, exprs, nexprs, R, 4367 exprs[nexprs-1]->getType()); 4368 return Owned(expr); 4369} 4370 4371/// \brief Emit a specialized diagnostic when one expression is a null pointer 4372/// constant and the other is not a pointer. Returns true if a diagnostic is 4373/// emitted. 4374bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, 4375 SourceLocation QuestionLoc) { 4376 Expr *NullExpr = LHSExpr; 4377 Expr *NonPointerExpr = RHSExpr; 4378 Expr::NullPointerConstantKind NullKind = 4379 NullExpr->isNullPointerConstant(Context, 4380 Expr::NPC_ValueDependentIsNotNull); 4381 4382 if (NullKind == Expr::NPCK_NotNull) { 4383 NullExpr = RHSExpr; 4384 NonPointerExpr = LHSExpr; 4385 NullKind = 4386 NullExpr->isNullPointerConstant(Context, 4387 Expr::NPC_ValueDependentIsNotNull); 4388 } 4389 4390 if (NullKind == Expr::NPCK_NotNull) 4391 return false; 4392 4393 if (NullKind == Expr::NPCK_ZeroInteger) { 4394 // In this case, check to make sure that we got here from a "NULL" 4395 // string in the source code. 4396 NullExpr = NullExpr->IgnoreParenImpCasts(); 4397 SourceLocation loc = NullExpr->getExprLoc(); 4398 if (!findMacroSpelling(loc, "NULL")) 4399 return false; 4400 } 4401 4402 int DiagType = (NullKind == Expr::NPCK_CXX0X_nullptr); 4403 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null) 4404 << NonPointerExpr->getType() << DiagType 4405 << NonPointerExpr->getSourceRange(); 4406 return true; 4407} 4408 4409/// \brief Return false if the condition expression is valid, true otherwise. 4410static bool checkCondition(Sema &S, Expr *Cond) { 4411 QualType CondTy = Cond->getType(); 4412 4413 // C99 6.5.15p2 4414 if (CondTy->isScalarType()) return false; 4415 4416 // OpenCL: Sec 6.3.i says the condition is allowed to be a vector or scalar. 4417 if (S.getLangOptions().OpenCL && CondTy->isVectorType()) 4418 return false; 4419 4420 // Emit the proper error message. 4421 S.Diag(Cond->getLocStart(), S.getLangOptions().OpenCL ? 4422 diag::err_typecheck_cond_expect_scalar : 4423 diag::err_typecheck_cond_expect_scalar_or_vector) 4424 << CondTy; 4425 return true; 4426} 4427 4428/// \brief Return false if the two expressions can be converted to a vector, 4429/// true otherwise 4430static bool checkConditionalConvertScalarsToVectors(Sema &S, ExprResult &LHS, 4431 ExprResult &RHS, 4432 QualType CondTy) { 4433 // Both operands should be of scalar type. 4434 if (!LHS.get()->getType()->isScalarType()) { 4435 S.Diag(LHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 4436 << CondTy; 4437 return true; 4438 } 4439 if (!RHS.get()->getType()->isScalarType()) { 4440 S.Diag(RHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 4441 << CondTy; 4442 return true; 4443 } 4444 4445 // Implicity convert these scalars to the type of the condition. 4446 LHS = S.ImpCastExprToType(LHS.take(), CondTy, CK_IntegralCast); 4447 RHS = S.ImpCastExprToType(RHS.take(), CondTy, CK_IntegralCast); 4448 return false; 4449} 4450 4451/// \brief Handle when one or both operands are void type. 4452static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS, 4453 ExprResult &RHS) { 4454 Expr *LHSExpr = LHS.get(); 4455 Expr *RHSExpr = RHS.get(); 4456 4457 if (!LHSExpr->getType()->isVoidType()) 4458 S.Diag(RHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 4459 << RHSExpr->getSourceRange(); 4460 if (!RHSExpr->getType()->isVoidType()) 4461 S.Diag(LHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 4462 << LHSExpr->getSourceRange(); 4463 LHS = S.ImpCastExprToType(LHS.take(), S.Context.VoidTy, CK_ToVoid); 4464 RHS = S.ImpCastExprToType(RHS.take(), S.Context.VoidTy, CK_ToVoid); 4465 return S.Context.VoidTy; 4466} 4467 4468/// \brief Return false if the NullExpr can be promoted to PointerTy, 4469/// true otherwise. 4470static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, 4471 QualType PointerTy) { 4472 if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) || 4473 !NullExpr.get()->isNullPointerConstant(S.Context, 4474 Expr::NPC_ValueDependentIsNull)) 4475 return true; 4476 4477 NullExpr = S.ImpCastExprToType(NullExpr.take(), PointerTy, CK_NullToPointer); 4478 return false; 4479} 4480 4481/// \brief Checks compatibility between two pointers and return the resulting 4482/// type. 4483static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, 4484 ExprResult &RHS, 4485 SourceLocation Loc) { 4486 QualType LHSTy = LHS.get()->getType(); 4487 QualType RHSTy = RHS.get()->getType(); 4488 4489 if (S.Context.hasSameType(LHSTy, RHSTy)) { 4490 // Two identical pointers types are always compatible. 4491 return LHSTy; 4492 } 4493 4494 QualType lhptee, rhptee; 4495 4496 // Get the pointee types. 4497 if (LHSTy->isBlockPointerType()) { 4498 lhptee = LHSTy->getAs<BlockPointerType>()->getPointeeType(); 4499 rhptee = RHSTy->getAs<BlockPointerType>()->getPointeeType(); 4500 } else { 4501 lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 4502 rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 4503 } 4504 4505 if (!S.Context.typesAreCompatible(lhptee.getUnqualifiedType(), 4506 rhptee.getUnqualifiedType())) { 4507 S.Diag(Loc, diag::warn_typecheck_cond_incompatible_pointers) 4508 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4509 << RHS.get()->getSourceRange(); 4510 // In this situation, we assume void* type. No especially good 4511 // reason, but this is what gcc does, and we do have to pick 4512 // to get a consistent AST. 4513 QualType incompatTy = S.Context.getPointerType(S.Context.VoidTy); 4514 LHS = S.ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); 4515 RHS = S.ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); 4516 return incompatTy; 4517 } 4518 4519 // The pointer types are compatible. 4520 // C99 6.5.15p6: If both operands are pointers to compatible types *or* to 4521 // differently qualified versions of compatible types, the result type is 4522 // a pointer to an appropriately qualified version of the *composite* 4523 // type. 4524 // FIXME: Need to calculate the composite type. 4525 // FIXME: Need to add qualifiers 4526 4527 LHS = S.ImpCastExprToType(LHS.take(), LHSTy, CK_BitCast); 4528 RHS = S.ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 4529 return LHSTy; 4530} 4531 4532/// \brief Return the resulting type when the operands are both block pointers. 4533static QualType checkConditionalBlockPointerCompatibility(Sema &S, 4534 ExprResult &LHS, 4535 ExprResult &RHS, 4536 SourceLocation Loc) { 4537 QualType LHSTy = LHS.get()->getType(); 4538 QualType RHSTy = RHS.get()->getType(); 4539 4540 if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) { 4541 if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) { 4542 QualType destType = S.Context.getPointerType(S.Context.VoidTy); 4543 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast); 4544 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast); 4545 return destType; 4546 } 4547 S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 4548 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4549 << RHS.get()->getSourceRange(); 4550 return QualType(); 4551 } 4552 4553 // We have 2 block pointer types. 4554 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 4555} 4556 4557/// \brief Return the resulting type when the operands are both pointers. 4558static QualType 4559checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, 4560 ExprResult &RHS, 4561 SourceLocation Loc) { 4562 // get the pointer types 4563 QualType LHSTy = LHS.get()->getType(); 4564 QualType RHSTy = RHS.get()->getType(); 4565 4566 // get the "pointed to" types 4567 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 4568 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 4569 4570 // ignore qualifiers on void (C99 6.5.15p3, clause 6) 4571 if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) { 4572 // Figure out necessary qualifiers (C99 6.5.15p6) 4573 QualType destPointee 4574 = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 4575 QualType destType = S.Context.getPointerType(destPointee); 4576 // Add qualifiers if necessary. 4577 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_NoOp); 4578 // Promote to void*. 4579 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast); 4580 return destType; 4581 } 4582 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) { 4583 QualType destPointee 4584 = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 4585 QualType destType = S.Context.getPointerType(destPointee); 4586 // Add qualifiers if necessary. 4587 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_NoOp); 4588 // Promote to void*. 4589 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast); 4590 return destType; 4591 } 4592 4593 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 4594} 4595 4596/// \brief Return false if the first expression is not an integer and the second 4597/// expression is not a pointer, true otherwise. 4598static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, 4599 Expr* PointerExpr, SourceLocation Loc, 4600 bool isIntFirstExpr) { 4601 if (!PointerExpr->getType()->isPointerType() || 4602 !Int.get()->getType()->isIntegerType()) 4603 return false; 4604 4605 Expr *Expr1 = isIntFirstExpr ? Int.get() : PointerExpr; 4606 Expr *Expr2 = isIntFirstExpr ? PointerExpr : Int.get(); 4607 4608 S.Diag(Loc, diag::warn_typecheck_cond_pointer_integer_mismatch) 4609 << Expr1->getType() << Expr2->getType() 4610 << Expr1->getSourceRange() << Expr2->getSourceRange(); 4611 Int = S.ImpCastExprToType(Int.take(), PointerExpr->getType(), 4612 CK_IntegralToPointer); 4613 return true; 4614} 4615 4616/// Note that LHS is not null here, even if this is the gnu "x ?: y" extension. 4617/// In that case, LHS = cond. 4618/// C99 6.5.15 4619QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, 4620 ExprResult &RHS, ExprValueKind &VK, 4621 ExprObjectKind &OK, 4622 SourceLocation QuestionLoc) { 4623 4624 ExprResult LHSResult = CheckPlaceholderExpr(LHS.get()); 4625 if (!LHSResult.isUsable()) return QualType(); 4626 LHS = move(LHSResult); 4627 4628 ExprResult RHSResult = CheckPlaceholderExpr(RHS.get()); 4629 if (!RHSResult.isUsable()) return QualType(); 4630 RHS = move(RHSResult); 4631 4632 // C++ is sufficiently different to merit its own checker. 4633 if (getLangOptions().CPlusPlus) 4634 return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc); 4635 4636 VK = VK_RValue; 4637 OK = OK_Ordinary; 4638 4639 Cond = UsualUnaryConversions(Cond.take()); 4640 if (Cond.isInvalid()) 4641 return QualType(); 4642 LHS = UsualUnaryConversions(LHS.take()); 4643 if (LHS.isInvalid()) 4644 return QualType(); 4645 RHS = UsualUnaryConversions(RHS.take()); 4646 if (RHS.isInvalid()) 4647 return QualType(); 4648 4649 QualType CondTy = Cond.get()->getType(); 4650 QualType LHSTy = LHS.get()->getType(); 4651 QualType RHSTy = RHS.get()->getType(); 4652 4653 // first, check the condition. 4654 if (checkCondition(*this, Cond.get())) 4655 return QualType(); 4656 4657 // Now check the two expressions. 4658 if (LHSTy->isVectorType() || RHSTy->isVectorType()) 4659 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false); 4660 4661 // OpenCL: If the condition is a vector, and both operands are scalar, 4662 // attempt to implicity convert them to the vector type to act like the 4663 // built in select. 4664 if (getLangOptions().OpenCL && CondTy->isVectorType()) 4665 if (checkConditionalConvertScalarsToVectors(*this, LHS, RHS, CondTy)) 4666 return QualType(); 4667 4668 // If both operands have arithmetic type, do the usual arithmetic conversions 4669 // to find a common type: C99 6.5.15p3,5. 4670 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) { 4671 UsualArithmeticConversions(LHS, RHS); 4672 if (LHS.isInvalid() || RHS.isInvalid()) 4673 return QualType(); 4674 return LHS.get()->getType(); 4675 } 4676 4677 // If both operands are the same structure or union type, the result is that 4678 // type. 4679 if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3 4680 if (const RecordType *RHSRT = RHSTy->getAs<RecordType>()) 4681 if (LHSRT->getDecl() == RHSRT->getDecl()) 4682 // "If both the operands have structure or union type, the result has 4683 // that type." This implies that CV qualifiers are dropped. 4684 return LHSTy.getUnqualifiedType(); 4685 // FIXME: Type of conditional expression must be complete in C mode. 4686 } 4687 4688 // C99 6.5.15p5: "If both operands have void type, the result has void type." 4689 // The following || allows only one side to be void (a GCC-ism). 4690 if (LHSTy->isVoidType() || RHSTy->isVoidType()) { 4691 return checkConditionalVoidType(*this, LHS, RHS); 4692 } 4693 4694 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has 4695 // the type of the other operand." 4696 if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy; 4697 if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy; 4698 4699 // All objective-c pointer type analysis is done here. 4700 QualType compositeType = FindCompositeObjCPointerType(LHS, RHS, 4701 QuestionLoc); 4702 if (LHS.isInvalid() || RHS.isInvalid()) 4703 return QualType(); 4704 if (!compositeType.isNull()) 4705 return compositeType; 4706 4707 4708 // Handle block pointer types. 4709 if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) 4710 return checkConditionalBlockPointerCompatibility(*this, LHS, RHS, 4711 QuestionLoc); 4712 4713 // Check constraints for C object pointers types (C99 6.5.15p3,6). 4714 if (LHSTy->isPointerType() && RHSTy->isPointerType()) 4715 return checkConditionalObjectPointersCompatibility(*this, LHS, RHS, 4716 QuestionLoc); 4717 4718 // GCC compatibility: soften pointer/integer mismatch. Note that 4719 // null pointers have been filtered out by this point. 4720 if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc, 4721 /*isIntFirstExpr=*/true)) 4722 return RHSTy; 4723 if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc, 4724 /*isIntFirstExpr=*/false)) 4725 return LHSTy; 4726 4727 // Emit a better diagnostic if one of the expressions is a null pointer 4728 // constant and the other is not a pointer type. In this case, the user most 4729 // likely forgot to take the address of the other expression. 4730 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc)) 4731 return QualType(); 4732 4733 // Otherwise, the operands are not compatible. 4734 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 4735 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4736 << RHS.get()->getSourceRange(); 4737 return QualType(); 4738} 4739 4740/// FindCompositeObjCPointerType - Helper method to find composite type of 4741/// two objective-c pointer types of the two input expressions. 4742QualType Sema::FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, 4743 SourceLocation QuestionLoc) { 4744 QualType LHSTy = LHS.get()->getType(); 4745 QualType RHSTy = RHS.get()->getType(); 4746 4747 // Handle things like Class and struct objc_class*. Here we case the result 4748 // to the pseudo-builtin, because that will be implicitly cast back to the 4749 // redefinition type if an attempt is made to access its fields. 4750 if (LHSTy->isObjCClassType() && 4751 (Context.hasSameType(RHSTy, Context.getObjCClassRedefinitionType()))) { 4752 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 4753 return LHSTy; 4754 } 4755 if (RHSTy->isObjCClassType() && 4756 (Context.hasSameType(LHSTy, Context.getObjCClassRedefinitionType()))) { 4757 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_BitCast); 4758 return RHSTy; 4759 } 4760 // And the same for struct objc_object* / id 4761 if (LHSTy->isObjCIdType() && 4762 (Context.hasSameType(RHSTy, Context.getObjCIdRedefinitionType()))) { 4763 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 4764 return LHSTy; 4765 } 4766 if (RHSTy->isObjCIdType() && 4767 (Context.hasSameType(LHSTy, Context.getObjCIdRedefinitionType()))) { 4768 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_BitCast); 4769 return RHSTy; 4770 } 4771 // And the same for struct objc_selector* / SEL 4772 if (Context.isObjCSelType(LHSTy) && 4773 (Context.hasSameType(RHSTy, Context.getObjCSelRedefinitionType()))) { 4774 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 4775 return LHSTy; 4776 } 4777 if (Context.isObjCSelType(RHSTy) && 4778 (Context.hasSameType(LHSTy, Context.getObjCSelRedefinitionType()))) { 4779 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_BitCast); 4780 return RHSTy; 4781 } 4782 // Check constraints for Objective-C object pointers types. 4783 if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) { 4784 4785 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) { 4786 // Two identical object pointer types are always compatible. 4787 return LHSTy; 4788 } 4789 const ObjCObjectPointerType *LHSOPT = LHSTy->getAs<ObjCObjectPointerType>(); 4790 const ObjCObjectPointerType *RHSOPT = RHSTy->getAs<ObjCObjectPointerType>(); 4791 QualType compositeType = LHSTy; 4792 4793 // If both operands are interfaces and either operand can be 4794 // assigned to the other, use that type as the composite 4795 // type. This allows 4796 // xxx ? (A*) a : (B*) b 4797 // where B is a subclass of A. 4798 // 4799 // Additionally, as for assignment, if either type is 'id' 4800 // allow silent coercion. Finally, if the types are 4801 // incompatible then make sure to use 'id' as the composite 4802 // type so the result is acceptable for sending messages to. 4803 4804 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'. 4805 // It could return the composite type. 4806 if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) { 4807 compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy; 4808 } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) { 4809 compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy; 4810 } else if ((LHSTy->isObjCQualifiedIdType() || 4811 RHSTy->isObjCQualifiedIdType()) && 4812 Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) { 4813 // Need to handle "id<xx>" explicitly. 4814 // GCC allows qualified id and any Objective-C type to devolve to 4815 // id. Currently localizing to here until clear this should be 4816 // part of ObjCQualifiedIdTypesAreCompatible. 4817 compositeType = Context.getObjCIdType(); 4818 } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) { 4819 compositeType = Context.getObjCIdType(); 4820 } else if (!(compositeType = 4821 Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull()) 4822 ; 4823 else { 4824 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands) 4825 << LHSTy << RHSTy 4826 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 4827 QualType incompatTy = Context.getObjCIdType(); 4828 LHS = ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); 4829 RHS = ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); 4830 return incompatTy; 4831 } 4832 // The object pointer types are compatible. 4833 LHS = ImpCastExprToType(LHS.take(), compositeType, CK_BitCast); 4834 RHS = ImpCastExprToType(RHS.take(), compositeType, CK_BitCast); 4835 return compositeType; 4836 } 4837 // Check Objective-C object pointer types and 'void *' 4838 if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) { 4839 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 4840 QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 4841 QualType destPointee 4842 = Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 4843 QualType destType = Context.getPointerType(destPointee); 4844 // Add qualifiers if necessary. 4845 LHS = ImpCastExprToType(LHS.take(), destType, CK_NoOp); 4846 // Promote to void*. 4847 RHS = ImpCastExprToType(RHS.take(), destType, CK_BitCast); 4848 return destType; 4849 } 4850 if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) { 4851 QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 4852 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 4853 QualType destPointee 4854 = Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 4855 QualType destType = Context.getPointerType(destPointee); 4856 // Add qualifiers if necessary. 4857 RHS = ImpCastExprToType(RHS.take(), destType, CK_NoOp); 4858 // Promote to void*. 4859 LHS = ImpCastExprToType(LHS.take(), destType, CK_BitCast); 4860 return destType; 4861 } 4862 return QualType(); 4863} 4864 4865/// SuggestParentheses - Emit a note with a fixit hint that wraps 4866/// ParenRange in parentheses. 4867static void SuggestParentheses(Sema &Self, SourceLocation Loc, 4868 const PartialDiagnostic &Note, 4869 SourceRange ParenRange) { 4870 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(ParenRange.getEnd()); 4871 if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() && 4872 EndLoc.isValid()) { 4873 Self.Diag(Loc, Note) 4874 << FixItHint::CreateInsertion(ParenRange.getBegin(), "(") 4875 << FixItHint::CreateInsertion(EndLoc, ")"); 4876 } else { 4877 // We can't display the parentheses, so just show the bare note. 4878 Self.Diag(Loc, Note) << ParenRange; 4879 } 4880} 4881 4882static bool IsArithmeticOp(BinaryOperatorKind Opc) { 4883 return Opc >= BO_Mul && Opc <= BO_Shr; 4884} 4885 4886/// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary 4887/// expression, either using a built-in or overloaded operator, 4888/// and sets *OpCode to the opcode and *RHSExprs to the right-hand side 4889/// expression. 4890static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode, 4891 Expr **RHSExprs) { 4892 E = E->IgnoreParenImpCasts(); 4893 E = E->IgnoreConversionOperator(); 4894 E = E->IgnoreParenImpCasts(); 4895 4896 // Built-in binary operator. 4897 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) { 4898 if (IsArithmeticOp(OP->getOpcode())) { 4899 *Opcode = OP->getOpcode(); 4900 *RHSExprs = OP->getRHS(); 4901 return true; 4902 } 4903 } 4904 4905 // Overloaded operator. 4906 if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(E)) { 4907 if (Call->getNumArgs() != 2) 4908 return false; 4909 4910 // Make sure this is really a binary operator that is safe to pass into 4911 // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op. 4912 OverloadedOperatorKind OO = Call->getOperator(); 4913 if (OO < OO_Plus || OO > OO_Arrow) 4914 return false; 4915 4916 BinaryOperatorKind OpKind = BinaryOperator::getOverloadedOpcode(OO); 4917 if (IsArithmeticOp(OpKind)) { 4918 *Opcode = OpKind; 4919 *RHSExprs = Call->getArg(1); 4920 return true; 4921 } 4922 } 4923 4924 return false; 4925} 4926 4927static bool IsLogicOp(BinaryOperatorKind Opc) { 4928 return (Opc >= BO_LT && Opc <= BO_NE) || (Opc >= BO_LAnd && Opc <= BO_LOr); 4929} 4930 4931/// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type 4932/// or is a logical expression such as (x==y) which has int type, but is 4933/// commonly interpreted as boolean. 4934static bool ExprLooksBoolean(Expr *E) { 4935 E = E->IgnoreParenImpCasts(); 4936 4937 if (E->getType()->isBooleanType()) 4938 return true; 4939 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) 4940 return IsLogicOp(OP->getOpcode()); 4941 if (UnaryOperator *OP = dyn_cast<UnaryOperator>(E)) 4942 return OP->getOpcode() == UO_LNot; 4943 4944 return false; 4945} 4946 4947/// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator 4948/// and binary operator are mixed in a way that suggests the programmer assumed 4949/// the conditional operator has higher precedence, for example: 4950/// "int x = a + someBinaryCondition ? 1 : 2". 4951static void DiagnoseConditionalPrecedence(Sema &Self, 4952 SourceLocation OpLoc, 4953 Expr *Condition, 4954 Expr *LHSExpr, 4955 Expr *RHSExpr) { 4956 BinaryOperatorKind CondOpcode; 4957 Expr *CondRHS; 4958 4959 if (!IsArithmeticBinaryExpr(Condition, &CondOpcode, &CondRHS)) 4960 return; 4961 if (!ExprLooksBoolean(CondRHS)) 4962 return; 4963 4964 // The condition is an arithmetic binary expression, with a right- 4965 // hand side that looks boolean, so warn. 4966 4967 Self.Diag(OpLoc, diag::warn_precedence_conditional) 4968 << Condition->getSourceRange() 4969 << BinaryOperator::getOpcodeStr(CondOpcode); 4970 4971 SuggestParentheses(Self, OpLoc, 4972 Self.PDiag(diag::note_precedence_conditional_silence) 4973 << BinaryOperator::getOpcodeStr(CondOpcode), 4974 SourceRange(Condition->getLocStart(), Condition->getLocEnd())); 4975 4976 SuggestParentheses(Self, OpLoc, 4977 Self.PDiag(diag::note_precedence_conditional_first), 4978 SourceRange(CondRHS->getLocStart(), RHSExpr->getLocEnd())); 4979} 4980 4981/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null 4982/// in the case of a the GNU conditional expr extension. 4983ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc, 4984 SourceLocation ColonLoc, 4985 Expr *CondExpr, Expr *LHSExpr, 4986 Expr *RHSExpr) { 4987 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS 4988 // was the condition. 4989 OpaqueValueExpr *opaqueValue = 0; 4990 Expr *commonExpr = 0; 4991 if (LHSExpr == 0) { 4992 commonExpr = CondExpr; 4993 4994 // We usually want to apply unary conversions *before* saving, except 4995 // in the special case of a C++ l-value conditional. 4996 if (!(getLangOptions().CPlusPlus 4997 && !commonExpr->isTypeDependent() 4998 && commonExpr->getValueKind() == RHSExpr->getValueKind() 4999 && commonExpr->isGLValue() 5000 && commonExpr->isOrdinaryOrBitFieldObject() 5001 && RHSExpr->isOrdinaryOrBitFieldObject() 5002 && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) { 5003 ExprResult commonRes = UsualUnaryConversions(commonExpr); 5004 if (commonRes.isInvalid()) 5005 return ExprError(); 5006 commonExpr = commonRes.take(); 5007 } 5008 5009 opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(), 5010 commonExpr->getType(), 5011 commonExpr->getValueKind(), 5012 commonExpr->getObjectKind()); 5013 LHSExpr = CondExpr = opaqueValue; 5014 } 5015 5016 ExprValueKind VK = VK_RValue; 5017 ExprObjectKind OK = OK_Ordinary; 5018 ExprResult Cond = Owned(CondExpr), LHS = Owned(LHSExpr), RHS = Owned(RHSExpr); 5019 QualType result = CheckConditionalOperands(Cond, LHS, RHS, 5020 VK, OK, QuestionLoc); 5021 if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() || 5022 RHS.isInvalid()) 5023 return ExprError(); 5024 5025 DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(), 5026 RHS.get()); 5027 5028 if (!commonExpr) 5029 return Owned(new (Context) ConditionalOperator(Cond.take(), QuestionLoc, 5030 LHS.take(), ColonLoc, 5031 RHS.take(), result, VK, OK)); 5032 5033 return Owned(new (Context) 5034 BinaryConditionalOperator(commonExpr, opaqueValue, Cond.take(), LHS.take(), 5035 RHS.take(), QuestionLoc, ColonLoc, result, VK, 5036 OK)); 5037} 5038 5039// checkPointerTypesForAssignment - This is a very tricky routine (despite 5040// being closely modeled after the C99 spec:-). The odd characteristic of this 5041// routine is it effectively iqnores the qualifiers on the top level pointee. 5042// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3]. 5043// FIXME: add a couple examples in this comment. 5044static Sema::AssignConvertType 5045checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) { 5046 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 5047 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 5048 5049 // get the "pointed to" type (ignoring qualifiers at the top level) 5050 const Type *lhptee, *rhptee; 5051 Qualifiers lhq, rhq; 5052 llvm::tie(lhptee, lhq) = cast<PointerType>(LHSType)->getPointeeType().split(); 5053 llvm::tie(rhptee, rhq) = cast<PointerType>(RHSType)->getPointeeType().split(); 5054 5055 Sema::AssignConvertType ConvTy = Sema::Compatible; 5056 5057 // C99 6.5.16.1p1: This following citation is common to constraints 5058 // 3 & 4 (below). ...and the type *pointed to* by the left has all the 5059 // qualifiers of the type *pointed to* by the right; 5060 Qualifiers lq; 5061 5062 // As a special case, 'non-__weak A *' -> 'non-__weak const *' is okay. 5063 if (lhq.getObjCLifetime() != rhq.getObjCLifetime() && 5064 lhq.compatiblyIncludesObjCLifetime(rhq)) { 5065 // Ignore lifetime for further calculation. 5066 lhq.removeObjCLifetime(); 5067 rhq.removeObjCLifetime(); 5068 } 5069 5070 if (!lhq.compatiblyIncludes(rhq)) { 5071 // Treat address-space mismatches as fatal. TODO: address subspaces 5072 if (lhq.getAddressSpace() != rhq.getAddressSpace()) 5073 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 5074 5075 // It's okay to add or remove GC or lifetime qualifiers when converting to 5076 // and from void*. 5077 else if (lhq.withoutObjCGCAttr().withoutObjCGLifetime() 5078 .compatiblyIncludes( 5079 rhq.withoutObjCGCAttr().withoutObjCGLifetime()) 5080 && (lhptee->isVoidType() || rhptee->isVoidType())) 5081 ; // keep old 5082 5083 // Treat lifetime mismatches as fatal. 5084 else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) 5085 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 5086 5087 // For GCC compatibility, other qualifier mismatches are treated 5088 // as still compatible in C. 5089 else ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 5090 } 5091 5092 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or 5093 // incomplete type and the other is a pointer to a qualified or unqualified 5094 // version of void... 5095 if (lhptee->isVoidType()) { 5096 if (rhptee->isIncompleteOrObjectType()) 5097 return ConvTy; 5098 5099 // As an extension, we allow cast to/from void* to function pointer. 5100 assert(rhptee->isFunctionType()); 5101 return Sema::FunctionVoidPointer; 5102 } 5103 5104 if (rhptee->isVoidType()) { 5105 if (lhptee->isIncompleteOrObjectType()) 5106 return ConvTy; 5107 5108 // As an extension, we allow cast to/from void* to function pointer. 5109 assert(lhptee->isFunctionType()); 5110 return Sema::FunctionVoidPointer; 5111 } 5112 5113 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or 5114 // unqualified versions of compatible types, ... 5115 QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0); 5116 if (!S.Context.typesAreCompatible(ltrans, rtrans)) { 5117 // Check if the pointee types are compatible ignoring the sign. 5118 // We explicitly check for char so that we catch "char" vs 5119 // "unsigned char" on systems where "char" is unsigned. 5120 if (lhptee->isCharType()) 5121 ltrans = S.Context.UnsignedCharTy; 5122 else if (lhptee->hasSignedIntegerRepresentation()) 5123 ltrans = S.Context.getCorrespondingUnsignedType(ltrans); 5124 5125 if (rhptee->isCharType()) 5126 rtrans = S.Context.UnsignedCharTy; 5127 else if (rhptee->hasSignedIntegerRepresentation()) 5128 rtrans = S.Context.getCorrespondingUnsignedType(rtrans); 5129 5130 if (ltrans == rtrans) { 5131 // Types are compatible ignoring the sign. Qualifier incompatibility 5132 // takes priority over sign incompatibility because the sign 5133 // warning can be disabled. 5134 if (ConvTy != Sema::Compatible) 5135 return ConvTy; 5136 5137 return Sema::IncompatiblePointerSign; 5138 } 5139 5140 // If we are a multi-level pointer, it's possible that our issue is simply 5141 // one of qualification - e.g. char ** -> const char ** is not allowed. If 5142 // the eventual target type is the same and the pointers have the same 5143 // level of indirection, this must be the issue. 5144 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) { 5145 do { 5146 lhptee = cast<PointerType>(lhptee)->getPointeeType().getTypePtr(); 5147 rhptee = cast<PointerType>(rhptee)->getPointeeType().getTypePtr(); 5148 } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)); 5149 5150 if (lhptee == rhptee) 5151 return Sema::IncompatibleNestedPointerQualifiers; 5152 } 5153 5154 // General pointer incompatibility takes priority over qualifiers. 5155 return Sema::IncompatiblePointer; 5156 } 5157 return ConvTy; 5158} 5159 5160/// checkBlockPointerTypesForAssignment - This routine determines whether two 5161/// block pointer types are compatible or whether a block and normal pointer 5162/// are compatible. It is more restrict than comparing two function pointer 5163// types. 5164static Sema::AssignConvertType 5165checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType, 5166 QualType RHSType) { 5167 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 5168 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 5169 5170 QualType lhptee, rhptee; 5171 5172 // get the "pointed to" type (ignoring qualifiers at the top level) 5173 lhptee = cast<BlockPointerType>(LHSType)->getPointeeType(); 5174 rhptee = cast<BlockPointerType>(RHSType)->getPointeeType(); 5175 5176 // In C++, the types have to match exactly. 5177 if (S.getLangOptions().CPlusPlus) 5178 return Sema::IncompatibleBlockPointer; 5179 5180 Sema::AssignConvertType ConvTy = Sema::Compatible; 5181 5182 // For blocks we enforce that qualifiers are identical. 5183 if (lhptee.getLocalQualifiers() != rhptee.getLocalQualifiers()) 5184 ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 5185 5186 if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType)) 5187 return Sema::IncompatibleBlockPointer; 5188 5189 return ConvTy; 5190} 5191 5192/// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types 5193/// for assignment compatibility. 5194static Sema::AssignConvertType 5195checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType, 5196 QualType RHSType) { 5197 assert(LHSType.isCanonical() && "LHS was not canonicalized!"); 5198 assert(RHSType.isCanonical() && "RHS was not canonicalized!"); 5199 5200 if (LHSType->isObjCBuiltinType()) { 5201 // Class is not compatible with ObjC object pointers. 5202 if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() && 5203 !RHSType->isObjCQualifiedClassType()) 5204 return Sema::IncompatiblePointer; 5205 return Sema::Compatible; 5206 } 5207 if (RHSType->isObjCBuiltinType()) { 5208 // Class is not compatible with ObjC object pointers. 5209 if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() && 5210 !LHSType->isObjCQualifiedClassType()) 5211 return Sema::IncompatiblePointer; 5212 return Sema::Compatible; 5213 } 5214 QualType lhptee = LHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 5215 QualType rhptee = RHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 5216 5217 if (!lhptee.isAtLeastAsQualifiedAs(rhptee)) 5218 return Sema::CompatiblePointerDiscardsQualifiers; 5219 5220 if (S.Context.typesAreCompatible(LHSType, RHSType)) 5221 return Sema::Compatible; 5222 if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType()) 5223 return Sema::IncompatibleObjCQualifiedId; 5224 return Sema::IncompatiblePointer; 5225} 5226 5227Sema::AssignConvertType 5228Sema::CheckAssignmentConstraints(SourceLocation Loc, 5229 QualType LHSType, QualType RHSType) { 5230 // Fake up an opaque expression. We don't actually care about what 5231 // cast operations are required, so if CheckAssignmentConstraints 5232 // adds casts to this they'll be wasted, but fortunately that doesn't 5233 // usually happen on valid code. 5234 OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue); 5235 ExprResult RHSPtr = &RHSExpr; 5236 CastKind K = CK_Invalid; 5237 5238 return CheckAssignmentConstraints(LHSType, RHSPtr, K); 5239} 5240 5241/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently 5242/// has code to accommodate several GCC extensions when type checking 5243/// pointers. Here are some objectionable examples that GCC considers warnings: 5244/// 5245/// int a, *pint; 5246/// short *pshort; 5247/// struct foo *pfoo; 5248/// 5249/// pint = pshort; // warning: assignment from incompatible pointer type 5250/// a = pint; // warning: assignment makes integer from pointer without a cast 5251/// pint = a; // warning: assignment makes pointer from integer without a cast 5252/// pint = pfoo; // warning: assignment from incompatible pointer type 5253/// 5254/// As a result, the code for dealing with pointers is more complex than the 5255/// C99 spec dictates. 5256/// 5257/// Sets 'Kind' for any result kind except Incompatible. 5258Sema::AssignConvertType 5259Sema::CheckAssignmentConstraints(QualType LHSType, ExprResult &RHS, 5260 CastKind &Kind) { 5261 QualType RHSType = RHS.get()->getType(); 5262 QualType OrigLHSType = LHSType; 5263 5264 // Get canonical types. We're not formatting these types, just comparing 5265 // them. 5266 LHSType = Context.getCanonicalType(LHSType).getUnqualifiedType(); 5267 RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType(); 5268 5269 // Common case: no conversion required. 5270 if (LHSType == RHSType) { 5271 Kind = CK_NoOp; 5272 return Compatible; 5273 } 5274 5275 // If the left-hand side is a reference type, then we are in a 5276 // (rare!) case where we've allowed the use of references in C, 5277 // e.g., as a parameter type in a built-in function. In this case, 5278 // just make sure that the type referenced is compatible with the 5279 // right-hand side type. The caller is responsible for adjusting 5280 // LHSType so that the resulting expression does not have reference 5281 // type. 5282 if (const ReferenceType *LHSTypeRef = LHSType->getAs<ReferenceType>()) { 5283 if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) { 5284 Kind = CK_LValueBitCast; 5285 return Compatible; 5286 } 5287 return Incompatible; 5288 } 5289 5290 // Allow scalar to ExtVector assignments, and assignments of an ExtVector type 5291 // to the same ExtVector type. 5292 if (LHSType->isExtVectorType()) { 5293 if (RHSType->isExtVectorType()) 5294 return Incompatible; 5295 if (RHSType->isArithmeticType()) { 5296 // CK_VectorSplat does T -> vector T, so first cast to the 5297 // element type. 5298 QualType elType = cast<ExtVectorType>(LHSType)->getElementType(); 5299 if (elType != RHSType) { 5300 Kind = PrepareScalarCast(*this, RHS, elType); 5301 RHS = ImpCastExprToType(RHS.take(), elType, Kind); 5302 } 5303 Kind = CK_VectorSplat; 5304 return Compatible; 5305 } 5306 } 5307 5308 // Conversions to or from vector type. 5309 if (LHSType->isVectorType() || RHSType->isVectorType()) { 5310 if (LHSType->isVectorType() && RHSType->isVectorType()) { 5311 // Allow assignments of an AltiVec vector type to an equivalent GCC 5312 // vector type and vice versa 5313 if (Context.areCompatibleVectorTypes(LHSType, RHSType)) { 5314 Kind = CK_BitCast; 5315 return Compatible; 5316 } 5317 5318 // If we are allowing lax vector conversions, and LHS and RHS are both 5319 // vectors, the total size only needs to be the same. This is a bitcast; 5320 // no bits are changed but the result type is different. 5321 if (getLangOptions().LaxVectorConversions && 5322 (Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType))) { 5323 Kind = CK_BitCast; 5324 return IncompatibleVectors; 5325 } 5326 } 5327 return Incompatible; 5328 } 5329 5330 // Arithmetic conversions. 5331 if (LHSType->isArithmeticType() && RHSType->isArithmeticType() && 5332 !(getLangOptions().CPlusPlus && LHSType->isEnumeralType())) { 5333 Kind = PrepareScalarCast(*this, RHS, LHSType); 5334 return Compatible; 5335 } 5336 5337 // Conversions to normal pointers. 5338 if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) { 5339 // U* -> T* 5340 if (isa<PointerType>(RHSType)) { 5341 Kind = CK_BitCast; 5342 return checkPointerTypesForAssignment(*this, LHSType, RHSType); 5343 } 5344 5345 // int -> T* 5346 if (RHSType->isIntegerType()) { 5347 Kind = CK_IntegralToPointer; // FIXME: null? 5348 return IntToPointer; 5349 } 5350 5351 // C pointers are not compatible with ObjC object pointers, 5352 // with two exceptions: 5353 if (isa<ObjCObjectPointerType>(RHSType)) { 5354 // - conversions to void* 5355 if (LHSPointer->getPointeeType()->isVoidType()) { 5356 Kind = CK_AnyPointerToObjCPointerCast; 5357 return Compatible; 5358 } 5359 5360 // - conversions from 'Class' to the redefinition type 5361 if (RHSType->isObjCClassType() && 5362 Context.hasSameType(LHSType, 5363 Context.getObjCClassRedefinitionType())) { 5364 Kind = CK_BitCast; 5365 return Compatible; 5366 } 5367 5368 Kind = CK_BitCast; 5369 return IncompatiblePointer; 5370 } 5371 5372 // U^ -> void* 5373 if (RHSType->getAs<BlockPointerType>()) { 5374 if (LHSPointer->getPointeeType()->isVoidType()) { 5375 Kind = CK_BitCast; 5376 return Compatible; 5377 } 5378 } 5379 5380 return Incompatible; 5381 } 5382 5383 // Conversions to block pointers. 5384 if (isa<BlockPointerType>(LHSType)) { 5385 // U^ -> T^ 5386 if (RHSType->isBlockPointerType()) { 5387 Kind = CK_AnyPointerToBlockPointerCast; 5388 return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType); 5389 } 5390 5391 // int or null -> T^ 5392 if (RHSType->isIntegerType()) { 5393 Kind = CK_IntegralToPointer; // FIXME: null 5394 return IntToBlockPointer; 5395 } 5396 5397 // id -> T^ 5398 if (getLangOptions().ObjC1 && RHSType->isObjCIdType()) { 5399 Kind = CK_AnyPointerToBlockPointerCast; 5400 return Compatible; 5401 } 5402 5403 // void* -> T^ 5404 if (const PointerType *RHSPT = RHSType->getAs<PointerType>()) 5405 if (RHSPT->getPointeeType()->isVoidType()) { 5406 Kind = CK_AnyPointerToBlockPointerCast; 5407 return Compatible; 5408 } 5409 5410 return Incompatible; 5411 } 5412 5413 // Conversions to Objective-C pointers. 5414 if (isa<ObjCObjectPointerType>(LHSType)) { 5415 // A* -> B* 5416 if (RHSType->isObjCObjectPointerType()) { 5417 Kind = CK_BitCast; 5418 Sema::AssignConvertType result = 5419 checkObjCPointerTypesForAssignment(*this, LHSType, RHSType); 5420 if (getLangOptions().ObjCAutoRefCount && 5421 result == Compatible && 5422 !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType)) 5423 result = IncompatibleObjCWeakRef; 5424 return result; 5425 } 5426 5427 // int or null -> A* 5428 if (RHSType->isIntegerType()) { 5429 Kind = CK_IntegralToPointer; // FIXME: null 5430 return IntToPointer; 5431 } 5432 5433 // In general, C pointers are not compatible with ObjC object pointers, 5434 // with two exceptions: 5435 if (isa<PointerType>(RHSType)) { 5436 // - conversions from 'void*' 5437 if (RHSType->isVoidPointerType()) { 5438 Kind = CK_AnyPointerToObjCPointerCast; 5439 return Compatible; 5440 } 5441 5442 // - conversions to 'Class' from its redefinition type 5443 if (LHSType->isObjCClassType() && 5444 Context.hasSameType(RHSType, 5445 Context.getObjCClassRedefinitionType())) { 5446 Kind = CK_BitCast; 5447 return Compatible; 5448 } 5449 5450 Kind = CK_AnyPointerToObjCPointerCast; 5451 return IncompatiblePointer; 5452 } 5453 5454 // T^ -> A* 5455 if (RHSType->isBlockPointerType()) { 5456 Kind = CK_AnyPointerToObjCPointerCast; 5457 return Compatible; 5458 } 5459 5460 return Incompatible; 5461 } 5462 5463 // Conversions from pointers that are not covered by the above. 5464 if (isa<PointerType>(RHSType)) { 5465 // T* -> _Bool 5466 if (LHSType == Context.BoolTy) { 5467 Kind = CK_PointerToBoolean; 5468 return Compatible; 5469 } 5470 5471 // T* -> int 5472 if (LHSType->isIntegerType()) { 5473 Kind = CK_PointerToIntegral; 5474 return PointerToInt; 5475 } 5476 5477 return Incompatible; 5478 } 5479 5480 // Conversions from Objective-C pointers that are not covered by the above. 5481 if (isa<ObjCObjectPointerType>(RHSType)) { 5482 // T* -> _Bool 5483 if (LHSType == Context.BoolTy) { 5484 Kind = CK_PointerToBoolean; 5485 return Compatible; 5486 } 5487 5488 // T* -> int 5489 if (LHSType->isIntegerType()) { 5490 Kind = CK_PointerToIntegral; 5491 return PointerToInt; 5492 } 5493 5494 return Incompatible; 5495 } 5496 5497 // struct A -> struct B 5498 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) { 5499 if (Context.typesAreCompatible(LHSType, RHSType)) { 5500 Kind = CK_NoOp; 5501 return Compatible; 5502 } 5503 } 5504 5505 return Incompatible; 5506} 5507 5508/// \brief Constructs a transparent union from an expression that is 5509/// used to initialize the transparent union. 5510static void ConstructTransparentUnion(Sema &S, ASTContext &C, 5511 ExprResult &EResult, QualType UnionType, 5512 FieldDecl *Field) { 5513 // Build an initializer list that designates the appropriate member 5514 // of the transparent union. 5515 Expr *E = EResult.take(); 5516 InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(), 5517 &E, 1, 5518 SourceLocation()); 5519 Initializer->setType(UnionType); 5520 Initializer->setInitializedFieldInUnion(Field); 5521 5522 // Build a compound literal constructing a value of the transparent 5523 // union type from this initializer list. 5524 TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType); 5525 EResult = S.Owned( 5526 new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType, 5527 VK_RValue, Initializer, false)); 5528} 5529 5530Sema::AssignConvertType 5531Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, 5532 ExprResult &RHS) { 5533 QualType RHSType = RHS.get()->getType(); 5534 5535 // If the ArgType is a Union type, we want to handle a potential 5536 // transparent_union GCC extension. 5537 const RecordType *UT = ArgType->getAsUnionType(); 5538 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>()) 5539 return Incompatible; 5540 5541 // The field to initialize within the transparent union. 5542 RecordDecl *UD = UT->getDecl(); 5543 FieldDecl *InitField = 0; 5544 // It's compatible if the expression matches any of the fields. 5545 for (RecordDecl::field_iterator it = UD->field_begin(), 5546 itend = UD->field_end(); 5547 it != itend; ++it) { 5548 if (it->getType()->isPointerType()) { 5549 // If the transparent union contains a pointer type, we allow: 5550 // 1) void pointer 5551 // 2) null pointer constant 5552 if (RHSType->isPointerType()) 5553 if (RHSType->getAs<PointerType>()->getPointeeType()->isVoidType()) { 5554 RHS = ImpCastExprToType(RHS.take(), it->getType(), CK_BitCast); 5555 InitField = *it; 5556 break; 5557 } 5558 5559 if (RHS.get()->isNullPointerConstant(Context, 5560 Expr::NPC_ValueDependentIsNull)) { 5561 RHS = ImpCastExprToType(RHS.take(), it->getType(), 5562 CK_NullToPointer); 5563 InitField = *it; 5564 break; 5565 } 5566 } 5567 5568 CastKind Kind = CK_Invalid; 5569 if (CheckAssignmentConstraints(it->getType(), RHS, Kind) 5570 == Compatible) { 5571 RHS = ImpCastExprToType(RHS.take(), it->getType(), Kind); 5572 InitField = *it; 5573 break; 5574 } 5575 } 5576 5577 if (!InitField) 5578 return Incompatible; 5579 5580 ConstructTransparentUnion(*this, Context, RHS, ArgType, InitField); 5581 return Compatible; 5582} 5583 5584Sema::AssignConvertType 5585Sema::CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS) { 5586 if (getLangOptions().CPlusPlus) { 5587 if (!LHSType->isRecordType()) { 5588 // C++ 5.17p3: If the left operand is not of class type, the 5589 // expression is implicitly converted (C++ 4) to the 5590 // cv-unqualified type of the left operand. 5591 ExprResult Res = PerformImplicitConversion(RHS.get(), 5592 LHSType.getUnqualifiedType(), 5593 AA_Assigning); 5594 if (Res.isInvalid()) 5595 return Incompatible; 5596 Sema::AssignConvertType result = Compatible; 5597 if (getLangOptions().ObjCAutoRefCount && 5598 !CheckObjCARCUnavailableWeakConversion(LHSType, 5599 RHS.get()->getType())) 5600 result = IncompatibleObjCWeakRef; 5601 RHS = move(Res); 5602 return result; 5603 } 5604 5605 // FIXME: Currently, we fall through and treat C++ classes like C 5606 // structures. 5607 } 5608 5609 // C99 6.5.16.1p1: the left operand is a pointer and the right is 5610 // a null pointer constant. 5611 if ((LHSType->isPointerType() || 5612 LHSType->isObjCObjectPointerType() || 5613 LHSType->isBlockPointerType()) 5614 && RHS.get()->isNullPointerConstant(Context, 5615 Expr::NPC_ValueDependentIsNull)) { 5616 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_NullToPointer); 5617 return Compatible; 5618 } 5619 5620 // This check seems unnatural, however it is necessary to ensure the proper 5621 // conversion of functions/arrays. If the conversion were done for all 5622 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary 5623 // expressions that suppress this implicit conversion (&, sizeof). 5624 // 5625 // Suppress this for references: C++ 8.5.3p5. 5626 if (!LHSType->isReferenceType()) { 5627 RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); 5628 if (RHS.isInvalid()) 5629 return Incompatible; 5630 } 5631 5632 CastKind Kind = CK_Invalid; 5633 Sema::AssignConvertType result = 5634 CheckAssignmentConstraints(LHSType, RHS, Kind); 5635 5636 // C99 6.5.16.1p2: The value of the right operand is converted to the 5637 // type of the assignment expression. 5638 // CheckAssignmentConstraints allows the left-hand side to be a reference, 5639 // so that we can use references in built-in functions even in C. 5640 // The getNonReferenceType() call makes sure that the resulting expression 5641 // does not have reference type. 5642 if (result != Incompatible && RHS.get()->getType() != LHSType) 5643 RHS = ImpCastExprToType(RHS.take(), 5644 LHSType.getNonLValueExprType(Context), Kind); 5645 return result; 5646} 5647 5648QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &LHS, 5649 ExprResult &RHS) { 5650 Diag(Loc, diag::err_typecheck_invalid_operands) 5651 << LHS.get()->getType() << RHS.get()->getType() 5652 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5653 return QualType(); 5654} 5655 5656QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, 5657 SourceLocation Loc, bool isCompAssign) { 5658 // For conversion purposes, we ignore any qualifiers. 5659 // For example, "const float" and "float" are equivalent. 5660 QualType LHSType = 5661 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType(); 5662 QualType RHSType = 5663 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType(); 5664 5665 // If the vector types are identical, return. 5666 if (LHSType == RHSType) 5667 return LHSType; 5668 5669 // Handle the case of equivalent AltiVec and GCC vector types 5670 if (LHSType->isVectorType() && RHSType->isVectorType() && 5671 Context.areCompatibleVectorTypes(LHSType, RHSType)) { 5672 if (LHSType->isExtVectorType()) { 5673 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 5674 return LHSType; 5675 } 5676 5677 if (!isCompAssign) 5678 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); 5679 return RHSType; 5680 } 5681 5682 if (getLangOptions().LaxVectorConversions && 5683 Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType)) { 5684 // If we are allowing lax vector conversions, and LHS and RHS are both 5685 // vectors, the total size only needs to be the same. This is a 5686 // bitcast; no bits are changed but the result type is different. 5687 // FIXME: Should we really be allowing this? 5688 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 5689 return LHSType; 5690 } 5691 5692 // Canonicalize the ExtVector to the LHS, remember if we swapped so we can 5693 // swap back (so that we don't reverse the inputs to a subtract, for instance. 5694 bool swapped = false; 5695 if (RHSType->isExtVectorType() && !isCompAssign) { 5696 swapped = true; 5697 std::swap(RHS, LHS); 5698 std::swap(RHSType, LHSType); 5699 } 5700 5701 // Handle the case of an ext vector and scalar. 5702 if (const ExtVectorType *LV = LHSType->getAs<ExtVectorType>()) { 5703 QualType EltTy = LV->getElementType(); 5704 if (EltTy->isIntegralType(Context) && RHSType->isIntegralType(Context)) { 5705 int order = Context.getIntegerTypeOrder(EltTy, RHSType); 5706 if (order > 0) 5707 RHS = ImpCastExprToType(RHS.take(), EltTy, CK_IntegralCast); 5708 if (order >= 0) { 5709 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_VectorSplat); 5710 if (swapped) std::swap(RHS, LHS); 5711 return LHSType; 5712 } 5713 } 5714 if (EltTy->isRealFloatingType() && RHSType->isScalarType() && 5715 RHSType->isRealFloatingType()) { 5716 int order = Context.getFloatingTypeOrder(EltTy, RHSType); 5717 if (order > 0) 5718 RHS = ImpCastExprToType(RHS.take(), EltTy, CK_FloatingCast); 5719 if (order >= 0) { 5720 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_VectorSplat); 5721 if (swapped) std::swap(RHS, LHS); 5722 return LHSType; 5723 } 5724 } 5725 } 5726 5727 // Vectors of different size or scalar and non-ext-vector are errors. 5728 if (swapped) std::swap(RHS, LHS); 5729 Diag(Loc, diag::err_typecheck_vector_not_convertable) 5730 << LHS.get()->getType() << RHS.get()->getType() 5731 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5732 return QualType(); 5733} 5734 5735QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS, 5736 SourceLocation Loc, 5737 bool isCompAssign, bool isDiv) { 5738 if (LHS.get()->getType()->isVectorType() || 5739 RHS.get()->getType()->isVectorType()) 5740 return CheckVectorOperands(LHS, RHS, Loc, isCompAssign); 5741 5742 QualType compType = UsualArithmeticConversions(LHS, RHS, isCompAssign); 5743 if (LHS.isInvalid() || RHS.isInvalid()) 5744 return QualType(); 5745 5746 if (!LHS.get()->getType()->isArithmeticType() || 5747 !RHS.get()->getType()->isArithmeticType()) 5748 return InvalidOperands(Loc, LHS, RHS); 5749 5750 // Check for division by zero. 5751 if (isDiv && 5752 RHS.get()->isNullPointerConstant(Context, 5753 Expr::NPC_ValueDependentIsNotNull)) 5754 DiagRuntimeBehavior(Loc, RHS.get(), PDiag(diag::warn_division_by_zero) 5755 << RHS.get()->getSourceRange()); 5756 5757 return compType; 5758} 5759 5760QualType Sema::CheckRemainderOperands( 5761 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool isCompAssign) { 5762 if (LHS.get()->getType()->isVectorType() || 5763 RHS.get()->getType()->isVectorType()) { 5764 if (LHS.get()->getType()->hasIntegerRepresentation() && 5765 RHS.get()->getType()->hasIntegerRepresentation()) 5766 return CheckVectorOperands(LHS, RHS, Loc, isCompAssign); 5767 return InvalidOperands(Loc, LHS, RHS); 5768 } 5769 5770 QualType compType = UsualArithmeticConversions(LHS, RHS, isCompAssign); 5771 if (LHS.isInvalid() || RHS.isInvalid()) 5772 return QualType(); 5773 5774 if (!LHS.get()->getType()->isIntegerType() || 5775 !RHS.get()->getType()->isIntegerType()) 5776 return InvalidOperands(Loc, LHS, RHS); 5777 5778 // Check for remainder by zero. 5779 if (RHS.get()->isNullPointerConstant(Context, 5780 Expr::NPC_ValueDependentIsNotNull)) 5781 DiagRuntimeBehavior(Loc, RHS.get(), PDiag(diag::warn_remainder_by_zero) 5782 << RHS.get()->getSourceRange()); 5783 5784 return compType; 5785} 5786 5787/// \brief Diagnose invalid arithmetic on two void pointers. 5788static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, 5789 Expr *LHS, Expr *RHS) { 5790 S.Diag(Loc, S.getLangOptions().CPlusPlus 5791 ? diag::err_typecheck_pointer_arith_void_type 5792 : diag::ext_gnu_void_ptr) 5793 << 1 /* two pointers */ << LHS->getSourceRange() << RHS->getSourceRange(); 5794} 5795 5796/// \brief Diagnose invalid arithmetic on a void pointer. 5797static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, 5798 Expr *Pointer) { 5799 S.Diag(Loc, S.getLangOptions().CPlusPlus 5800 ? diag::err_typecheck_pointer_arith_void_type 5801 : diag::ext_gnu_void_ptr) 5802 << 0 /* one pointer */ << Pointer->getSourceRange(); 5803} 5804 5805/// \brief Diagnose invalid arithmetic on two function pointers. 5806static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, 5807 Expr *LHS, Expr *RHS) { 5808 assert(LHS->getType()->isAnyPointerType()); 5809 assert(RHS->getType()->isAnyPointerType()); 5810 S.Diag(Loc, S.getLangOptions().CPlusPlus 5811 ? diag::err_typecheck_pointer_arith_function_type 5812 : diag::ext_gnu_ptr_func_arith) 5813 << 1 /* two pointers */ << LHS->getType()->getPointeeType() 5814 // We only show the second type if it differs from the first. 5815 << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(), 5816 RHS->getType()) 5817 << RHS->getType()->getPointeeType() 5818 << LHS->getSourceRange() << RHS->getSourceRange(); 5819} 5820 5821/// \brief Diagnose invalid arithmetic on a function pointer. 5822static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, 5823 Expr *Pointer) { 5824 assert(Pointer->getType()->isAnyPointerType()); 5825 S.Diag(Loc, S.getLangOptions().CPlusPlus 5826 ? diag::err_typecheck_pointer_arith_function_type 5827 : diag::ext_gnu_ptr_func_arith) 5828 << 0 /* one pointer */ << Pointer->getType()->getPointeeType() 5829 << 0 /* one pointer, so only one type */ 5830 << Pointer->getSourceRange(); 5831} 5832 5833/// \brief Warn if Operand is incomplete pointer type 5834/// 5835/// \returns True if pointer has incomplete type 5836static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, 5837 Expr *Operand) { 5838 if ((Operand->getType()->isPointerType() && 5839 !Operand->getType()->isDependentType()) || 5840 Operand->getType()->isObjCObjectPointerType()) { 5841 QualType PointeeTy = Operand->getType()->getPointeeType(); 5842 if (S.RequireCompleteType( 5843 Loc, PointeeTy, 5844 S.PDiag(diag::err_typecheck_arithmetic_incomplete_type) 5845 << PointeeTy << Operand->getSourceRange())) 5846 return true; 5847 } 5848 return false; 5849} 5850 5851/// \brief Check the validity of an arithmetic pointer operand. 5852/// 5853/// If the operand has pointer type, this code will check for pointer types 5854/// which are invalid in arithmetic operations. These will be diagnosed 5855/// appropriately, including whether or not the use is supported as an 5856/// extension. 5857/// 5858/// \returns True when the operand is valid to use (even if as an extension). 5859static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc, 5860 Expr *Operand) { 5861 if (!Operand->getType()->isAnyPointerType()) return true; 5862 5863 QualType PointeeTy = Operand->getType()->getPointeeType(); 5864 if (PointeeTy->isVoidType()) { 5865 diagnoseArithmeticOnVoidPointer(S, Loc, Operand); 5866 return !S.getLangOptions().CPlusPlus; 5867 } 5868 if (PointeeTy->isFunctionType()) { 5869 diagnoseArithmeticOnFunctionPointer(S, Loc, Operand); 5870 return !S.getLangOptions().CPlusPlus; 5871 } 5872 5873 if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false; 5874 5875 return true; 5876} 5877 5878/// \brief Check the validity of a binary arithmetic operation w.r.t. pointer 5879/// operands. 5880/// 5881/// This routine will diagnose any invalid arithmetic on pointer operands much 5882/// like \see checkArithmeticOpPointerOperand. However, it has special logic 5883/// for emitting a single diagnostic even for operations where both LHS and RHS 5884/// are (potentially problematic) pointers. 5885/// 5886/// \returns True when the operand is valid to use (even if as an extension). 5887static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc, 5888 Expr *LHS, Expr *RHS) { 5889 bool isLHSPointer = LHS->getType()->isAnyPointerType(); 5890 bool isRHSPointer = RHS->getType()->isAnyPointerType(); 5891 if (!isLHSPointer && !isRHSPointer) return true; 5892 5893 QualType LHSPointeeTy, RHSPointeeTy; 5894 if (isLHSPointer) LHSPointeeTy = LHS->getType()->getPointeeType(); 5895 if (isRHSPointer) RHSPointeeTy = RHS->getType()->getPointeeType(); 5896 5897 // Check for arithmetic on pointers to incomplete types. 5898 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType(); 5899 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType(); 5900 if (isLHSVoidPtr || isRHSVoidPtr) { 5901 if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHS); 5902 else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHS); 5903 else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHS, RHS); 5904 5905 return !S.getLangOptions().CPlusPlus; 5906 } 5907 5908 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType(); 5909 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType(); 5910 if (isLHSFuncPtr || isRHSFuncPtr) { 5911 if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHS); 5912 else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, RHS); 5913 else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHS, RHS); 5914 5915 return !S.getLangOptions().CPlusPlus; 5916 } 5917 5918 if (checkArithmeticIncompletePointerType(S, Loc, LHS)) return false; 5919 if (checkArithmeticIncompletePointerType(S, Loc, RHS)) return false; 5920 5921 return true; 5922} 5923 5924/// \brief Check bad cases where we step over interface counts. 5925static bool checkArithmethicPointerOnNonFragileABI(Sema &S, 5926 SourceLocation OpLoc, 5927 Expr *Op) { 5928 assert(Op->getType()->isAnyPointerType()); 5929 QualType PointeeTy = Op->getType()->getPointeeType(); 5930 if (!PointeeTy->isObjCObjectType() || !S.LangOpts.ObjCNonFragileABI) 5931 return true; 5932 5933 S.Diag(OpLoc, diag::err_arithmetic_nonfragile_interface) 5934 << PointeeTy << Op->getSourceRange(); 5935 return false; 5936} 5937 5938/// \brief Warn when two pointers are incompatible. 5939static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, 5940 Expr *LHS, Expr *RHS) { 5941 assert(LHS->getType()->isAnyPointerType()); 5942 assert(RHS->getType()->isAnyPointerType()); 5943 S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible) 5944 << LHS->getType() << RHS->getType() << LHS->getSourceRange() 5945 << RHS->getSourceRange(); 5946} 5947 5948QualType Sema::CheckAdditionOperands( // C99 6.5.6 5949 ExprResult &lex, ExprResult &rex, SourceLocation Loc, QualType* CompLHSTy) { 5950 if (lex.get()->getType()->isVectorType() || 5951 rex.get()->getType()->isVectorType()) { 5952 QualType compType = CheckVectorOperands(lex, rex, Loc, CompLHSTy); 5953 if (CompLHSTy) *CompLHSTy = compType; 5954 return compType; 5955 } 5956 5957 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy); 5958 if (lex.isInvalid() || rex.isInvalid()) 5959 return QualType(); 5960 5961 // handle the common case first (both operands are arithmetic). 5962 if (lex.get()->getType()->isArithmeticType() && 5963 rex.get()->getType()->isArithmeticType()) { 5964 if (CompLHSTy) *CompLHSTy = compType; 5965 return compType; 5966 } 5967 5968 // Put any potential pointer into PExp 5969 Expr* PExp = lex.get(), *IExp = rex.get(); 5970 if (IExp->getType()->isAnyPointerType()) 5971 std::swap(PExp, IExp); 5972 5973 if (PExp->getType()->isAnyPointerType()) { 5974 if (IExp->getType()->isIntegerType()) { 5975 if (!checkArithmeticOpPointerOperand(*this, Loc, PExp)) 5976 return QualType(); 5977 5978 // Diagnose bad cases where we step over interface counts. 5979 if (!checkArithmethicPointerOnNonFragileABI(*this, Loc, PExp)) 5980 return QualType(); 5981 5982 // Check array bounds for pointer arithemtic 5983 CheckArrayAccess(PExp, IExp); 5984 5985 if (CompLHSTy) { 5986 QualType LHSTy = Context.isPromotableBitField(lex.get()); 5987 if (LHSTy.isNull()) { 5988 LHSTy = lex.get()->getType(); 5989 if (LHSTy->isPromotableIntegerType()) 5990 LHSTy = Context.getPromotedIntegerType(LHSTy); 5991 } 5992 *CompLHSTy = LHSTy; 5993 } 5994 return PExp->getType(); 5995 } 5996 } 5997 5998 return InvalidOperands(Loc, lex, rex); 5999} 6000 6001// C99 6.5.6 6002QualType Sema::CheckSubtractionOperands(ExprResult &lex, ExprResult &rex, 6003 SourceLocation Loc, 6004 QualType* CompLHSTy) { 6005 if (lex.get()->getType()->isVectorType() || 6006 rex.get()->getType()->isVectorType()) { 6007 QualType compType = CheckVectorOperands(lex, rex, Loc, CompLHSTy); 6008 if (CompLHSTy) *CompLHSTy = compType; 6009 return compType; 6010 } 6011 6012 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy); 6013 if (lex.isInvalid() || rex.isInvalid()) 6014 return QualType(); 6015 6016 // Enforce type constraints: C99 6.5.6p3. 6017 6018 // Handle the common case first (both operands are arithmetic). 6019 if (lex.get()->getType()->isArithmeticType() && 6020 rex.get()->getType()->isArithmeticType()) { 6021 if (CompLHSTy) *CompLHSTy = compType; 6022 return compType; 6023 } 6024 6025 // Either ptr - int or ptr - ptr. 6026 if (lex.get()->getType()->isAnyPointerType()) { 6027 QualType lpointee = lex.get()->getType()->getPointeeType(); 6028 6029 // Diagnose bad cases where we step over interface counts. 6030 if (!checkArithmethicPointerOnNonFragileABI(*this, Loc, lex.get())) 6031 return QualType(); 6032 6033 // The result type of a pointer-int computation is the pointer type. 6034 if (rex.get()->getType()->isIntegerType()) { 6035 if (!checkArithmeticOpPointerOperand(*this, Loc, lex.get())) 6036 return QualType(); 6037 6038 Expr *IExpr = rex.get()->IgnoreParenCasts(); 6039 UnaryOperator negRex(IExpr, UO_Minus, IExpr->getType(), VK_RValue, 6040 OK_Ordinary, IExpr->getExprLoc()); 6041 // Check array bounds for pointer arithemtic 6042 CheckArrayAccess(lex.get()->IgnoreParenCasts(), &negRex); 6043 6044 if (CompLHSTy) *CompLHSTy = lex.get()->getType(); 6045 return lex.get()->getType(); 6046 } 6047 6048 // Handle pointer-pointer subtractions. 6049 if (const PointerType *RHSPTy 6050 = rex.get()->getType()->getAs<PointerType>()) { 6051 QualType rpointee = RHSPTy->getPointeeType(); 6052 6053 if (getLangOptions().CPlusPlus) { 6054 // Pointee types must be the same: C++ [expr.add] 6055 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) { 6056 diagnosePointerIncompatibility(*this, Loc, lex.get(), rex.get()); 6057 } 6058 } else { 6059 // Pointee types must be compatible C99 6.5.6p3 6060 if (!Context.typesAreCompatible( 6061 Context.getCanonicalType(lpointee).getUnqualifiedType(), 6062 Context.getCanonicalType(rpointee).getUnqualifiedType())) { 6063 diagnosePointerIncompatibility(*this, Loc, lex.get(), rex.get()); 6064 return QualType(); 6065 } 6066 } 6067 6068 if (!checkArithmeticBinOpPointerOperands(*this, Loc, 6069 lex.get(), rex.get())) 6070 return QualType(); 6071 6072 if (CompLHSTy) *CompLHSTy = lex.get()->getType(); 6073 return Context.getPointerDiffType(); 6074 } 6075 } 6076 6077 return InvalidOperands(Loc, lex, rex); 6078} 6079 6080static bool isScopedEnumerationType(QualType T) { 6081 if (const EnumType *ET = dyn_cast<EnumType>(T)) 6082 return ET->getDecl()->isScoped(); 6083 return false; 6084} 6085 6086static void DiagnoseBadShiftValues(Sema& S, ExprResult &lex, ExprResult &rex, 6087 SourceLocation Loc, unsigned Opc, 6088 QualType LHSTy) { 6089 llvm::APSInt Right; 6090 // Check right/shifter operand 6091 if (rex.get()->isValueDependent() || 6092 !rex.get()->isIntegerConstantExpr(Right, S.Context)) 6093 return; 6094 6095 if (Right.isNegative()) { 6096 S.DiagRuntimeBehavior(Loc, rex.get(), 6097 S.PDiag(diag::warn_shift_negative) 6098 << rex.get()->getSourceRange()); 6099 return; 6100 } 6101 llvm::APInt LeftBits(Right.getBitWidth(), 6102 S.Context.getTypeSize(lex.get()->getType())); 6103 if (Right.uge(LeftBits)) { 6104 S.DiagRuntimeBehavior(Loc, rex.get(), 6105 S.PDiag(diag::warn_shift_gt_typewidth) 6106 << rex.get()->getSourceRange()); 6107 return; 6108 } 6109 if (Opc != BO_Shl) 6110 return; 6111 6112 // When left shifting an ICE which is signed, we can check for overflow which 6113 // according to C++ has undefined behavior ([expr.shift] 5.8/2). Unsigned 6114 // integers have defined behavior modulo one more than the maximum value 6115 // representable in the result type, so never warn for those. 6116 llvm::APSInt Left; 6117 if (lex.get()->isValueDependent() || 6118 !lex.get()->isIntegerConstantExpr(Left, S.Context) || 6119 LHSTy->hasUnsignedIntegerRepresentation()) 6120 return; 6121 llvm::APInt ResultBits = 6122 static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits(); 6123 if (LeftBits.uge(ResultBits)) 6124 return; 6125 llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue()); 6126 Result = Result.shl(Right); 6127 6128 // Print the bit representation of the signed integer as an unsigned 6129 // hexadecimal number. 6130 llvm::SmallString<40> HexResult; 6131 Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true); 6132 6133 // If we are only missing a sign bit, this is less likely to result in actual 6134 // bugs -- if the result is cast back to an unsigned type, it will have the 6135 // expected value. Thus we place this behind a different warning that can be 6136 // turned off separately if needed. 6137 if (LeftBits == ResultBits - 1) { 6138 S.Diag(Loc, diag::warn_shift_result_sets_sign_bit) 6139 << HexResult.str() << LHSTy 6140 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 6141 return; 6142 } 6143 6144 S.Diag(Loc, diag::warn_shift_result_gt_typewidth) 6145 << HexResult.str() << Result.getMinSignedBits() << LHSTy 6146 << Left.getBitWidth() << lex.get()->getSourceRange() 6147 << rex.get()->getSourceRange(); 6148} 6149 6150// C99 6.5.7 6151QualType Sema::CheckShiftOperands(ExprResult &lex, ExprResult &rex, 6152 SourceLocation Loc, unsigned Opc, 6153 bool isCompAssign) { 6154 // C99 6.5.7p2: Each of the operands shall have integer type. 6155 if (!lex.get()->getType()->hasIntegerRepresentation() || 6156 !rex.get()->getType()->hasIntegerRepresentation()) 6157 return InvalidOperands(Loc, lex, rex); 6158 6159 // C++0x: Don't allow scoped enums. FIXME: Use something better than 6160 // hasIntegerRepresentation() above instead of this. 6161 if (isScopedEnumerationType(lex.get()->getType()) || 6162 isScopedEnumerationType(rex.get()->getType())) { 6163 return InvalidOperands(Loc, lex, rex); 6164 } 6165 6166 // Vector shifts promote their scalar inputs to vector type. 6167 if (lex.get()->getType()->isVectorType() || 6168 rex.get()->getType()->isVectorType()) 6169 return CheckVectorOperands(lex, rex, Loc, isCompAssign); 6170 6171 // Shifts don't perform usual arithmetic conversions, they just do integer 6172 // promotions on each operand. C99 6.5.7p3 6173 6174 // For the LHS, do usual unary conversions, but then reset them away 6175 // if this is a compound assignment. 6176 ExprResult old_lex = lex; 6177 lex = UsualUnaryConversions(lex.take()); 6178 if (lex.isInvalid()) 6179 return QualType(); 6180 QualType LHSTy = lex.get()->getType(); 6181 if (isCompAssign) lex = old_lex; 6182 6183 // The RHS is simpler. 6184 rex = UsualUnaryConversions(rex.take()); 6185 if (rex.isInvalid()) 6186 return QualType(); 6187 6188 // Sanity-check shift operands 6189 DiagnoseBadShiftValues(*this, lex, rex, Loc, Opc, LHSTy); 6190 6191 // "The type of the result is that of the promoted left operand." 6192 return LHSTy; 6193} 6194 6195static bool IsWithinTemplateSpecialization(Decl *D) { 6196 if (DeclContext *DC = D->getDeclContext()) { 6197 if (isa<ClassTemplateSpecializationDecl>(DC)) 6198 return true; 6199 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) 6200 return FD->isFunctionTemplateSpecialization(); 6201 } 6202 return false; 6203} 6204 6205/// If two different enums are compared, raise a warning. 6206static void checkEnumComparison(Sema &S, SourceLocation Loc, ExprResult &lex, 6207 ExprResult &rex) { 6208 QualType LHSStrippedType = lex.get()->IgnoreParenImpCasts()->getType(); 6209 QualType RHSStrippedType = rex.get()->IgnoreParenImpCasts()->getType(); 6210 6211 const EnumType *LHSEnumType = LHSStrippedType->getAs<EnumType>(); 6212 if (!LHSEnumType) 6213 return; 6214 const EnumType *RHSEnumType = RHSStrippedType->getAs<EnumType>(); 6215 if (!RHSEnumType) 6216 return; 6217 6218 // Ignore anonymous enums. 6219 if (!LHSEnumType->getDecl()->getIdentifier()) 6220 return; 6221 if (!RHSEnumType->getDecl()->getIdentifier()) 6222 return; 6223 6224 if (S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType)) 6225 return; 6226 6227 S.Diag(Loc, diag::warn_comparison_of_mixed_enum_types) 6228 << LHSStrippedType << RHSStrippedType 6229 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 6230} 6231 6232/// \brief Diagnose bad pointer comparisons. 6233static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, 6234 ExprResult &lex, ExprResult &rex, 6235 bool isError) { 6236 S.Diag(Loc, isError ? diag::err_typecheck_comparison_of_distinct_pointers 6237 : diag::ext_typecheck_comparison_of_distinct_pointers) 6238 << lex.get()->getType() << rex.get()->getType() 6239 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 6240} 6241 6242/// \brief Returns false if the pointers are converted to a composite type, 6243/// true otherwise. 6244static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc, 6245 ExprResult &lex, ExprResult &rex) { 6246 // C++ [expr.rel]p2: 6247 // [...] Pointer conversions (4.10) and qualification 6248 // conversions (4.4) are performed on pointer operands (or on 6249 // a pointer operand and a null pointer constant) to bring 6250 // them to their composite pointer type. [...] 6251 // 6252 // C++ [expr.eq]p1 uses the same notion for (in)equality 6253 // comparisons of pointers. 6254 6255 // C++ [expr.eq]p2: 6256 // In addition, pointers to members can be compared, or a pointer to 6257 // member and a null pointer constant. Pointer to member conversions 6258 // (4.11) and qualification conversions (4.4) are performed to bring 6259 // them to a common type. If one operand is a null pointer constant, 6260 // the common type is the type of the other operand. Otherwise, the 6261 // common type is a pointer to member type similar (4.4) to the type 6262 // of one of the operands, with a cv-qualification signature (4.4) 6263 // that is the union of the cv-qualification signatures of the operand 6264 // types. 6265 6266 QualType lType = lex.get()->getType(); 6267 QualType rType = rex.get()->getType(); 6268 assert((lType->isPointerType() && rType->isPointerType()) || 6269 (lType->isMemberPointerType() && rType->isMemberPointerType())); 6270 6271 bool NonStandardCompositeType = false; 6272 bool *BoolPtr = S.isSFINAEContext() ? 0 : &NonStandardCompositeType; 6273 QualType T = S.FindCompositePointerType(Loc, lex, rex, BoolPtr); 6274 if (T.isNull()) { 6275 diagnoseDistinctPointerComparison(S, Loc, lex, rex, /*isError*/true); 6276 return true; 6277 } 6278 6279 if (NonStandardCompositeType) 6280 S.Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard) 6281 << lType << rType << T << lex.get()->getSourceRange() 6282 << rex.get()->getSourceRange(); 6283 6284 lex = S.ImpCastExprToType(lex.take(), T, CK_BitCast); 6285 rex = S.ImpCastExprToType(rex.take(), T, CK_BitCast); 6286 return false; 6287} 6288 6289static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc, 6290 ExprResult &lex, 6291 ExprResult &rex, 6292 bool isError) { 6293 S.Diag(Loc,isError ? diag::err_typecheck_comparison_of_fptr_to_void 6294 : diag::ext_typecheck_comparison_of_fptr_to_void) 6295 << lex.get()->getType() << rex.get()->getType() 6296 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 6297} 6298 6299// C99 6.5.8, C++ [expr.rel] 6300QualType Sema::CheckCompareOperands(ExprResult &lex, ExprResult &rex, 6301 SourceLocation Loc, unsigned OpaqueOpc, 6302 bool isRelational) { 6303 BinaryOperatorKind Opc = (BinaryOperatorKind) OpaqueOpc; 6304 6305 // Handle vector comparisons separately. 6306 if (lex.get()->getType()->isVectorType() || 6307 rex.get()->getType()->isVectorType()) 6308 return CheckVectorCompareOperands(lex, rex, Loc, isRelational); 6309 6310 QualType lType = lex.get()->getType(); 6311 QualType rType = rex.get()->getType(); 6312 6313 Expr *LHSStripped = lex.get()->IgnoreParenImpCasts(); 6314 Expr *RHSStripped = rex.get()->IgnoreParenImpCasts(); 6315 6316 checkEnumComparison(*this, Loc, lex, rex); 6317 6318 if (!lType->hasFloatingRepresentation() && 6319 !(lType->isBlockPointerType() && isRelational) && 6320 !lex.get()->getLocStart().isMacroID() && 6321 !rex.get()->getLocStart().isMacroID()) { 6322 // For non-floating point types, check for self-comparisons of the form 6323 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 6324 // often indicate logic errors in the program. 6325 // 6326 // NOTE: Don't warn about comparison expressions resulting from macro 6327 // expansion. Also don't warn about comparisons which are only self 6328 // comparisons within a template specialization. The warnings should catch 6329 // obvious cases in the definition of the template anyways. The idea is to 6330 // warn when the typed comparison operator will always evaluate to the same 6331 // result. 6332 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHSStripped)) { 6333 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHSStripped)) { 6334 if (DRL->getDecl() == DRR->getDecl() && 6335 !IsWithinTemplateSpecialization(DRL->getDecl())) { 6336 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always) 6337 << 0 // self- 6338 << (Opc == BO_EQ 6339 || Opc == BO_LE 6340 || Opc == BO_GE)); 6341 } else if (lType->isArrayType() && rType->isArrayType() && 6342 !DRL->getDecl()->getType()->isReferenceType() && 6343 !DRR->getDecl()->getType()->isReferenceType()) { 6344 // what is it always going to eval to? 6345 char always_evals_to; 6346 switch(Opc) { 6347 case BO_EQ: // e.g. array1 == array2 6348 always_evals_to = 0; // false 6349 break; 6350 case BO_NE: // e.g. array1 != array2 6351 always_evals_to = 1; // true 6352 break; 6353 default: 6354 // best we can say is 'a constant' 6355 always_evals_to = 2; // e.g. array1 <= array2 6356 break; 6357 } 6358 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always) 6359 << 1 // array 6360 << always_evals_to); 6361 } 6362 } 6363 } 6364 6365 if (isa<CastExpr>(LHSStripped)) 6366 LHSStripped = LHSStripped->IgnoreParenCasts(); 6367 if (isa<CastExpr>(RHSStripped)) 6368 RHSStripped = RHSStripped->IgnoreParenCasts(); 6369 6370 // Warn about comparisons against a string constant (unless the other 6371 // operand is null), the user probably wants strcmp. 6372 Expr *literalString = 0; 6373 Expr *literalStringStripped = 0; 6374 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) && 6375 !RHSStripped->isNullPointerConstant(Context, 6376 Expr::NPC_ValueDependentIsNull)) { 6377 literalString = lex.get(); 6378 literalStringStripped = LHSStripped; 6379 } else if ((isa<StringLiteral>(RHSStripped) || 6380 isa<ObjCEncodeExpr>(RHSStripped)) && 6381 !LHSStripped->isNullPointerConstant(Context, 6382 Expr::NPC_ValueDependentIsNull)) { 6383 literalString = rex.get(); 6384 literalStringStripped = RHSStripped; 6385 } 6386 6387 if (literalString) { 6388 std::string resultComparison; 6389 switch (Opc) { 6390 case BO_LT: resultComparison = ") < 0"; break; 6391 case BO_GT: resultComparison = ") > 0"; break; 6392 case BO_LE: resultComparison = ") <= 0"; break; 6393 case BO_GE: resultComparison = ") >= 0"; break; 6394 case BO_EQ: resultComparison = ") == 0"; break; 6395 case BO_NE: resultComparison = ") != 0"; break; 6396 default: assert(false && "Invalid comparison operator"); 6397 } 6398 6399 DiagRuntimeBehavior(Loc, 0, 6400 PDiag(diag::warn_stringcompare) 6401 << isa<ObjCEncodeExpr>(literalStringStripped) 6402 << literalString->getSourceRange()); 6403 } 6404 } 6405 6406 // C99 6.5.8p3 / C99 6.5.9p4 6407 if (lex.get()->getType()->isArithmeticType() && 6408 rex.get()->getType()->isArithmeticType()) { 6409 UsualArithmeticConversions(lex, rex); 6410 if (lex.isInvalid() || rex.isInvalid()) 6411 return QualType(); 6412 } 6413 else { 6414 lex = UsualUnaryConversions(lex.take()); 6415 if (lex.isInvalid()) 6416 return QualType(); 6417 6418 rex = UsualUnaryConversions(rex.take()); 6419 if (rex.isInvalid()) 6420 return QualType(); 6421 } 6422 6423 lType = lex.get()->getType(); 6424 rType = rex.get()->getType(); 6425 6426 // The result of comparisons is 'bool' in C++, 'int' in C. 6427 QualType ResultTy = Context.getLogicalOperationType(); 6428 6429 if (isRelational) { 6430 if (lType->isRealType() && rType->isRealType()) 6431 return ResultTy; 6432 } else { 6433 // Check for comparisons of floating point operands using != and ==. 6434 if (lType->hasFloatingRepresentation()) 6435 CheckFloatComparison(Loc, lex.get(), rex.get()); 6436 6437 if (lType->isArithmeticType() && rType->isArithmeticType()) 6438 return ResultTy; 6439 } 6440 6441 bool LHSIsNull = lex.get()->isNullPointerConstant(Context, 6442 Expr::NPC_ValueDependentIsNull); 6443 bool RHSIsNull = rex.get()->isNullPointerConstant(Context, 6444 Expr::NPC_ValueDependentIsNull); 6445 6446 // All of the following pointer-related warnings are GCC extensions, except 6447 // when handling null pointer constants. 6448 if (lType->isPointerType() && rType->isPointerType()) { // C99 6.5.8p2 6449 QualType LCanPointeeTy = 6450 Context.getCanonicalType(lType->getAs<PointerType>()->getPointeeType()); 6451 QualType RCanPointeeTy = 6452 Context.getCanonicalType(rType->getAs<PointerType>()->getPointeeType()); 6453 6454 if (getLangOptions().CPlusPlus) { 6455 if (LCanPointeeTy == RCanPointeeTy) 6456 return ResultTy; 6457 if (!isRelational && 6458 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 6459 // Valid unless comparison between non-null pointer and function pointer 6460 // This is a gcc extension compatibility comparison. 6461 // In a SFINAE context, we treat this as a hard error to maintain 6462 // conformance with the C++ standard. 6463 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 6464 && !LHSIsNull && !RHSIsNull) { 6465 diagnoseFunctionPointerToVoidComparison( 6466 *this, Loc, lex, rex, /*isError*/ isSFINAEContext()); 6467 6468 if (isSFINAEContext()) 6469 return QualType(); 6470 6471 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 6472 return ResultTy; 6473 } 6474 } 6475 6476 if (convertPointersToCompositeType(*this, Loc, lex, rex)) 6477 return QualType(); 6478 else 6479 return ResultTy; 6480 } 6481 // C99 6.5.9p2 and C99 6.5.8p2 6482 if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(), 6483 RCanPointeeTy.getUnqualifiedType())) { 6484 // Valid unless a relational comparison of function pointers 6485 if (isRelational && LCanPointeeTy->isFunctionType()) { 6486 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers) 6487 << lType << rType << lex.get()->getSourceRange() 6488 << rex.get()->getSourceRange(); 6489 } 6490 } else if (!isRelational && 6491 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 6492 // Valid unless comparison between non-null pointer and function pointer 6493 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 6494 && !LHSIsNull && !RHSIsNull) 6495 diagnoseFunctionPointerToVoidComparison(*this, Loc, lex, rex, 6496 /*isError*/false); 6497 } else { 6498 // Invalid 6499 diagnoseDistinctPointerComparison(*this, Loc, lex, rex, /*isError*/false); 6500 } 6501 if (LCanPointeeTy != RCanPointeeTy) { 6502 if (LHSIsNull && !RHSIsNull) 6503 lex = ImpCastExprToType(lex.take(), rType, CK_BitCast); 6504 else 6505 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 6506 } 6507 return ResultTy; 6508 } 6509 6510 if (getLangOptions().CPlusPlus) { 6511 // Comparison of nullptr_t with itself. 6512 if (lType->isNullPtrType() && rType->isNullPtrType()) 6513 return ResultTy; 6514 6515 // Comparison of pointers with null pointer constants and equality 6516 // comparisons of member pointers to null pointer constants. 6517 if (RHSIsNull && 6518 ((lType->isAnyPointerType() || lType->isNullPtrType()) || 6519 (!isRelational && 6520 (lType->isMemberPointerType() || lType->isBlockPointerType())))) { 6521 rex = ImpCastExprToType(rex.take(), lType, 6522 lType->isMemberPointerType() 6523 ? CK_NullToMemberPointer 6524 : CK_NullToPointer); 6525 return ResultTy; 6526 } 6527 if (LHSIsNull && 6528 ((rType->isAnyPointerType() || rType->isNullPtrType()) || 6529 (!isRelational && 6530 (rType->isMemberPointerType() || rType->isBlockPointerType())))) { 6531 lex = ImpCastExprToType(lex.take(), rType, 6532 rType->isMemberPointerType() 6533 ? CK_NullToMemberPointer 6534 : CK_NullToPointer); 6535 return ResultTy; 6536 } 6537 6538 // Comparison of member pointers. 6539 if (!isRelational && 6540 lType->isMemberPointerType() && rType->isMemberPointerType()) { 6541 if (convertPointersToCompositeType(*this, Loc, lex, rex)) 6542 return QualType(); 6543 else 6544 return ResultTy; 6545 } 6546 6547 // Handle scoped enumeration types specifically, since they don't promote 6548 // to integers. 6549 if (lex.get()->getType()->isEnumeralType() && 6550 Context.hasSameUnqualifiedType(lex.get()->getType(), 6551 rex.get()->getType())) 6552 return ResultTy; 6553 } 6554 6555 // Handle block pointer types. 6556 if (!isRelational && lType->isBlockPointerType() && 6557 rType->isBlockPointerType()) { 6558 QualType lpointee = lType->getAs<BlockPointerType>()->getPointeeType(); 6559 QualType rpointee = rType->getAs<BlockPointerType>()->getPointeeType(); 6560 6561 if (!LHSIsNull && !RHSIsNull && 6562 !Context.typesAreCompatible(lpointee, rpointee)) { 6563 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 6564 << lType << rType << lex.get()->getSourceRange() 6565 << rex.get()->getSourceRange(); 6566 } 6567 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 6568 return ResultTy; 6569 } 6570 6571 // Allow block pointers to be compared with null pointer constants. 6572 if (!isRelational 6573 && ((lType->isBlockPointerType() && rType->isPointerType()) 6574 || (lType->isPointerType() && rType->isBlockPointerType()))) { 6575 if (!LHSIsNull && !RHSIsNull) { 6576 if (!((rType->isPointerType() && rType->castAs<PointerType>() 6577 ->getPointeeType()->isVoidType()) 6578 || (lType->isPointerType() && lType->castAs<PointerType>() 6579 ->getPointeeType()->isVoidType()))) 6580 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 6581 << lType << rType << lex.get()->getSourceRange() 6582 << rex.get()->getSourceRange(); 6583 } 6584 if (LHSIsNull && !RHSIsNull) 6585 lex = ImpCastExprToType(lex.take(), rType, CK_BitCast); 6586 else 6587 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 6588 return ResultTy; 6589 } 6590 6591 if (lType->isObjCObjectPointerType() || rType->isObjCObjectPointerType()) { 6592 const PointerType *LPT = lType->getAs<PointerType>(); 6593 const PointerType *RPT = rType->getAs<PointerType>(); 6594 if (LPT || RPT) { 6595 bool LPtrToVoid = LPT ? LPT->getPointeeType()->isVoidType() : false; 6596 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() : false; 6597 6598 if (!LPtrToVoid && !RPtrToVoid && 6599 !Context.typesAreCompatible(lType, rType)) { 6600 diagnoseDistinctPointerComparison(*this, Loc, lex, rex, 6601 /*isError*/false); 6602 } 6603 if (LHSIsNull && !RHSIsNull) 6604 lex = ImpCastExprToType(lex.take(), rType, CK_BitCast); 6605 else 6606 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 6607 return ResultTy; 6608 } 6609 if (lType->isObjCObjectPointerType() && rType->isObjCObjectPointerType()) { 6610 if (!Context.areComparableObjCPointerTypes(lType, rType)) 6611 diagnoseDistinctPointerComparison(*this, Loc, lex, rex, 6612 /*isError*/false); 6613 if (LHSIsNull && !RHSIsNull) 6614 lex = ImpCastExprToType(lex.take(), rType, CK_BitCast); 6615 else 6616 rex = ImpCastExprToType(rex.take(), lType, CK_BitCast); 6617 return ResultTy; 6618 } 6619 } 6620 if ((lType->isAnyPointerType() && rType->isIntegerType()) || 6621 (lType->isIntegerType() && rType->isAnyPointerType())) { 6622 unsigned DiagID = 0; 6623 bool isError = false; 6624 if ((LHSIsNull && lType->isIntegerType()) || 6625 (RHSIsNull && rType->isIntegerType())) { 6626 if (isRelational && !getLangOptions().CPlusPlus) 6627 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero; 6628 } else if (isRelational && !getLangOptions().CPlusPlus) 6629 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer; 6630 else if (getLangOptions().CPlusPlus) { 6631 DiagID = diag::err_typecheck_comparison_of_pointer_integer; 6632 isError = true; 6633 } else 6634 DiagID = diag::ext_typecheck_comparison_of_pointer_integer; 6635 6636 if (DiagID) { 6637 Diag(Loc, DiagID) 6638 << lType << rType << lex.get()->getSourceRange() 6639 << rex.get()->getSourceRange(); 6640 if (isError) 6641 return QualType(); 6642 } 6643 6644 if (lType->isIntegerType()) 6645 lex = ImpCastExprToType(lex.take(), rType, 6646 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 6647 else 6648 rex = ImpCastExprToType(rex.take(), lType, 6649 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 6650 return ResultTy; 6651 } 6652 6653 // Handle block pointers. 6654 if (!isRelational && RHSIsNull 6655 && lType->isBlockPointerType() && rType->isIntegerType()) { 6656 rex = ImpCastExprToType(rex.take(), lType, CK_NullToPointer); 6657 return ResultTy; 6658 } 6659 if (!isRelational && LHSIsNull 6660 && lType->isIntegerType() && rType->isBlockPointerType()) { 6661 lex = ImpCastExprToType(lex.take(), rType, CK_NullToPointer); 6662 return ResultTy; 6663 } 6664 6665 return InvalidOperands(Loc, lex, rex); 6666} 6667 6668/// CheckVectorCompareOperands - vector comparisons are a clang extension that 6669/// operates on extended vector types. Instead of producing an IntTy result, 6670/// like a scalar comparison, a vector comparison produces a vector of integer 6671/// types. 6672QualType Sema::CheckVectorCompareOperands(ExprResult &lex, ExprResult &rex, 6673 SourceLocation Loc, 6674 bool isRelational) { 6675 // Check to make sure we're operating on vectors of the same type and width, 6676 // Allowing one side to be a scalar of element type. 6677 QualType vType = CheckVectorOperands(lex, rex, Loc, /*isCompAssign*/false); 6678 if (vType.isNull()) 6679 return vType; 6680 6681 QualType lType = lex.get()->getType(); 6682 QualType rType = rex.get()->getType(); 6683 6684 // If AltiVec, the comparison results in a numeric type, i.e. 6685 // bool for C++, int for C 6686 if (vType->getAs<VectorType>()->getVectorKind() == VectorType::AltiVecVector) 6687 return Context.getLogicalOperationType(); 6688 6689 // For non-floating point types, check for self-comparisons of the form 6690 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 6691 // often indicate logic errors in the program. 6692 if (!lType->hasFloatingRepresentation()) { 6693 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(lex.get()->IgnoreParens())) 6694 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(rex.get()->IgnoreParens())) 6695 if (DRL->getDecl() == DRR->getDecl()) 6696 DiagRuntimeBehavior(Loc, 0, 6697 PDiag(diag::warn_comparison_always) 6698 << 0 // self- 6699 << 2 // "a constant" 6700 ); 6701 } 6702 6703 // Check for comparisons of floating point operands using != and ==. 6704 if (!isRelational && lType->hasFloatingRepresentation()) { 6705 assert (rType->hasFloatingRepresentation()); 6706 CheckFloatComparison(Loc, lex.get(), rex.get()); 6707 } 6708 6709 // Return the type for the comparison, which is the same as vector type for 6710 // integer vectors, or an integer type of identical size and number of 6711 // elements for floating point vectors. 6712 if (lType->hasIntegerRepresentation()) 6713 return lType; 6714 6715 const VectorType *VTy = lType->getAs<VectorType>(); 6716 unsigned TypeSize = Context.getTypeSize(VTy->getElementType()); 6717 if (TypeSize == Context.getTypeSize(Context.IntTy)) 6718 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements()); 6719 if (TypeSize == Context.getTypeSize(Context.LongTy)) 6720 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements()); 6721 6722 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) && 6723 "Unhandled vector element size in vector compare"); 6724 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements()); 6725} 6726 6727inline QualType Sema::CheckBitwiseOperands( 6728 ExprResult &lex, ExprResult &rex, SourceLocation Loc, bool isCompAssign) { 6729 if (lex.get()->getType()->isVectorType() || 6730 rex.get()->getType()->isVectorType()) { 6731 if (lex.get()->getType()->hasIntegerRepresentation() && 6732 rex.get()->getType()->hasIntegerRepresentation()) 6733 return CheckVectorOperands(lex, rex, Loc, isCompAssign); 6734 6735 return InvalidOperands(Loc, lex, rex); 6736 } 6737 6738 ExprResult lexResult = Owned(lex), rexResult = Owned(rex); 6739 QualType compType = UsualArithmeticConversions(lexResult, rexResult, 6740 isCompAssign); 6741 if (lexResult.isInvalid() || rexResult.isInvalid()) 6742 return QualType(); 6743 lex = lexResult.take(); 6744 rex = rexResult.take(); 6745 6746 if (lex.get()->getType()->isIntegralOrUnscopedEnumerationType() && 6747 rex.get()->getType()->isIntegralOrUnscopedEnumerationType()) 6748 return compType; 6749 return InvalidOperands(Loc, lex, rex); 6750} 6751 6752inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14] 6753 ExprResult &lex, ExprResult &rex, SourceLocation Loc, unsigned Opc) { 6754 6755 // Diagnose cases where the user write a logical and/or but probably meant a 6756 // bitwise one. We do this when the LHS is a non-bool integer and the RHS 6757 // is a constant. 6758 if (lex.get()->getType()->isIntegerType() && 6759 !lex.get()->getType()->isBooleanType() && 6760 rex.get()->getType()->isIntegerType() && !rex.get()->isValueDependent() && 6761 // Don't warn in macros or template instantiations. 6762 !Loc.isMacroID() && ActiveTemplateInstantiations.empty()) { 6763 // If the RHS can be constant folded, and if it constant folds to something 6764 // that isn't 0 or 1 (which indicate a potential logical operation that 6765 // happened to fold to true/false) then warn. 6766 // Parens on the RHS are ignored. 6767 Expr::EvalResult Result; 6768 if (rex.get()->Evaluate(Result, Context) && !Result.HasSideEffects) 6769 if ((getLangOptions().Bool && !rex.get()->getType()->isBooleanType()) || 6770 (Result.Val.getInt() != 0 && Result.Val.getInt() != 1)) { 6771 Diag(Loc, diag::warn_logical_instead_of_bitwise) 6772 << rex.get()->getSourceRange() 6773 << (Opc == BO_LAnd ? "&&" : "||"); 6774 // Suggest replacing the logical operator with the bitwise version 6775 Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator) 6776 << (Opc == BO_LAnd ? "&" : "|") 6777 << FixItHint::CreateReplacement(SourceRange( 6778 Loc, Lexer::getLocForEndOfToken(Loc, 0, getSourceManager(), 6779 getLangOptions())), 6780 Opc == BO_LAnd ? "&" : "|"); 6781 if (Opc == BO_LAnd) 6782 // Suggest replacing "Foo() && kNonZero" with "Foo()" 6783 Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant) 6784 << FixItHint::CreateRemoval( 6785 SourceRange( 6786 Lexer::getLocForEndOfToken(lex.get()->getLocEnd(), 6787 0, getSourceManager(), 6788 getLangOptions()), 6789 rex.get()->getLocEnd())); 6790 } 6791 } 6792 6793 if (!Context.getLangOptions().CPlusPlus) { 6794 lex = UsualUnaryConversions(lex.take()); 6795 if (lex.isInvalid()) 6796 return QualType(); 6797 6798 rex = UsualUnaryConversions(rex.take()); 6799 if (rex.isInvalid()) 6800 return QualType(); 6801 6802 if (!lex.get()->getType()->isScalarType() || 6803 !rex.get()->getType()->isScalarType()) 6804 return InvalidOperands(Loc, lex, rex); 6805 6806 return Context.IntTy; 6807 } 6808 6809 // The following is safe because we only use this method for 6810 // non-overloadable operands. 6811 6812 // C++ [expr.log.and]p1 6813 // C++ [expr.log.or]p1 6814 // The operands are both contextually converted to type bool. 6815 ExprResult lexRes = PerformContextuallyConvertToBool(lex.get()); 6816 if (lexRes.isInvalid()) 6817 return InvalidOperands(Loc, lex, rex); 6818 lex = move(lexRes); 6819 6820 ExprResult rexRes = PerformContextuallyConvertToBool(rex.get()); 6821 if (rexRes.isInvalid()) 6822 return InvalidOperands(Loc, lex, rex); 6823 rex = move(rexRes); 6824 6825 // C++ [expr.log.and]p2 6826 // C++ [expr.log.or]p2 6827 // The result is a bool. 6828 return Context.BoolTy; 6829} 6830 6831/// IsReadonlyProperty - Verify that otherwise a valid l-value expression 6832/// is a read-only property; return true if so. A readonly property expression 6833/// depends on various declarations and thus must be treated specially. 6834/// 6835static bool IsReadonlyProperty(Expr *E, Sema &S) { 6836 if (E->getStmtClass() == Expr::ObjCPropertyRefExprClass) { 6837 const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(E); 6838 if (PropExpr->isImplicitProperty()) return false; 6839 6840 ObjCPropertyDecl *PDecl = PropExpr->getExplicitProperty(); 6841 QualType BaseType = PropExpr->isSuperReceiver() ? 6842 PropExpr->getSuperReceiverType() : 6843 PropExpr->getBase()->getType(); 6844 6845 if (const ObjCObjectPointerType *OPT = 6846 BaseType->getAsObjCInterfacePointerType()) 6847 if (ObjCInterfaceDecl *IFace = OPT->getInterfaceDecl()) 6848 if (S.isPropertyReadonly(PDecl, IFace)) 6849 return true; 6850 } 6851 return false; 6852} 6853 6854static bool IsConstProperty(Expr *E, Sema &S) { 6855 if (E->getStmtClass() == Expr::ObjCPropertyRefExprClass) { 6856 const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(E); 6857 if (PropExpr->isImplicitProperty()) return false; 6858 6859 ObjCPropertyDecl *PDecl = PropExpr->getExplicitProperty(); 6860 QualType T = PDecl->getType(); 6861 if (T->isReferenceType()) 6862 T = T->getAs<ReferenceType>()->getPointeeType(); 6863 CanQualType CT = S.Context.getCanonicalType(T); 6864 return CT.isConstQualified(); 6865 } 6866 return false; 6867} 6868 6869static bool IsReadonlyMessage(Expr *E, Sema &S) { 6870 if (E->getStmtClass() != Expr::MemberExprClass) 6871 return false; 6872 const MemberExpr *ME = cast<MemberExpr>(E); 6873 NamedDecl *Member = ME->getMemberDecl(); 6874 if (isa<FieldDecl>(Member)) { 6875 Expr *Base = ME->getBase()->IgnoreParenImpCasts(); 6876 if (Base->getStmtClass() != Expr::ObjCMessageExprClass) 6877 return false; 6878 return cast<ObjCMessageExpr>(Base)->getMethodDecl() != 0; 6879 } 6880 return false; 6881} 6882 6883/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not, 6884/// emit an error and return true. If so, return false. 6885static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) { 6886 SourceLocation OrigLoc = Loc; 6887 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context, 6888 &Loc); 6889 if (IsLV == Expr::MLV_Valid && IsReadonlyProperty(E, S)) 6890 IsLV = Expr::MLV_ReadonlyProperty; 6891 else if (Expr::MLV_ConstQualified && IsConstProperty(E, S)) 6892 IsLV = Expr::MLV_Valid; 6893 else if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S)) 6894 IsLV = Expr::MLV_InvalidMessageExpression; 6895 if (IsLV == Expr::MLV_Valid) 6896 return false; 6897 6898 unsigned Diag = 0; 6899 bool NeedType = false; 6900 switch (IsLV) { // C99 6.5.16p2 6901 case Expr::MLV_ConstQualified: 6902 Diag = diag::err_typecheck_assign_const; 6903 6904 // In ARC, use some specialized diagnostics for occasions where we 6905 // infer 'const'. These are always pseudo-strong variables. 6906 if (S.getLangOptions().ObjCAutoRefCount) { 6907 DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()); 6908 if (declRef && isa<VarDecl>(declRef->getDecl())) { 6909 VarDecl *var = cast<VarDecl>(declRef->getDecl()); 6910 6911 // Use the normal diagnostic if it's pseudo-__strong but the 6912 // user actually wrote 'const'. 6913 if (var->isARCPseudoStrong() && 6914 (!var->getTypeSourceInfo() || 6915 !var->getTypeSourceInfo()->getType().isConstQualified())) { 6916 // There are two pseudo-strong cases: 6917 // - self 6918 ObjCMethodDecl *method = S.getCurMethodDecl(); 6919 if (method && var == method->getSelfDecl()) 6920 Diag = diag::err_typecheck_arr_assign_self; 6921 6922 // - fast enumeration variables 6923 else 6924 Diag = diag::err_typecheck_arr_assign_enumeration; 6925 6926 SourceRange Assign; 6927 if (Loc != OrigLoc) 6928 Assign = SourceRange(OrigLoc, OrigLoc); 6929 S.Diag(Loc, Diag) << E->getSourceRange() << Assign; 6930 // We need to preserve the AST regardless, so migration tool 6931 // can do its job. 6932 return false; 6933 } 6934 } 6935 } 6936 6937 break; 6938 case Expr::MLV_ArrayType: 6939 Diag = diag::err_typecheck_array_not_modifiable_lvalue; 6940 NeedType = true; 6941 break; 6942 case Expr::MLV_NotObjectType: 6943 Diag = diag::err_typecheck_non_object_not_modifiable_lvalue; 6944 NeedType = true; 6945 break; 6946 case Expr::MLV_LValueCast: 6947 Diag = diag::err_typecheck_lvalue_casts_not_supported; 6948 break; 6949 case Expr::MLV_Valid: 6950 llvm_unreachable("did not take early return for MLV_Valid"); 6951 case Expr::MLV_InvalidExpression: 6952 case Expr::MLV_MemberFunction: 6953 case Expr::MLV_ClassTemporary: 6954 Diag = diag::err_typecheck_expression_not_modifiable_lvalue; 6955 break; 6956 case Expr::MLV_IncompleteType: 6957 case Expr::MLV_IncompleteVoidType: 6958 return S.RequireCompleteType(Loc, E->getType(), 6959 S.PDiag(diag::err_typecheck_incomplete_type_not_modifiable_lvalue) 6960 << E->getSourceRange()); 6961 case Expr::MLV_DuplicateVectorComponents: 6962 Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue; 6963 break; 6964 case Expr::MLV_NotBlockQualified: 6965 Diag = diag::err_block_decl_ref_not_modifiable_lvalue; 6966 break; 6967 case Expr::MLV_ReadonlyProperty: 6968 Diag = diag::error_readonly_property_assignment; 6969 break; 6970 case Expr::MLV_NoSetterProperty: 6971 Diag = diag::error_nosetter_property_assignment; 6972 break; 6973 case Expr::MLV_InvalidMessageExpression: 6974 Diag = diag::error_readonly_message_assignment; 6975 break; 6976 case Expr::MLV_SubObjCPropertySetting: 6977 Diag = diag::error_no_subobject_property_setting; 6978 break; 6979 } 6980 6981 SourceRange Assign; 6982 if (Loc != OrigLoc) 6983 Assign = SourceRange(OrigLoc, OrigLoc); 6984 if (NeedType) 6985 S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign; 6986 else 6987 S.Diag(Loc, Diag) << E->getSourceRange() << Assign; 6988 return true; 6989} 6990 6991 6992 6993// C99 6.5.16.1 6994QualType Sema::CheckAssignmentOperands(Expr *LHS, ExprResult &RHS, 6995 SourceLocation Loc, 6996 QualType CompoundType) { 6997 // Verify that LHS is a modifiable lvalue, and emit error if not. 6998 if (CheckForModifiableLvalue(LHS, Loc, *this)) 6999 return QualType(); 7000 7001 QualType LHSType = LHS->getType(); 7002 QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() : 7003 CompoundType; 7004 AssignConvertType ConvTy; 7005 if (CompoundType.isNull()) { 7006 QualType LHSTy(LHSType); 7007 // Simple assignment "x = y". 7008 if (LHS->getObjectKind() == OK_ObjCProperty) { 7009 ExprResult LHSResult = Owned(LHS); 7010 ConvertPropertyForLValue(LHSResult, RHS, LHSTy); 7011 if (LHSResult.isInvalid()) 7012 return QualType(); 7013 LHS = LHSResult.take(); 7014 } 7015 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS); 7016 if (RHS.isInvalid()) 7017 return QualType(); 7018 // Special case of NSObject attributes on c-style pointer types. 7019 if (ConvTy == IncompatiblePointer && 7020 ((Context.isObjCNSObjectType(LHSType) && 7021 RHSType->isObjCObjectPointerType()) || 7022 (Context.isObjCNSObjectType(RHSType) && 7023 LHSType->isObjCObjectPointerType()))) 7024 ConvTy = Compatible; 7025 7026 if (ConvTy == Compatible && 7027 getLangOptions().ObjCNonFragileABI && 7028 LHSType->isObjCObjectType()) 7029 Diag(Loc, diag::err_assignment_requires_nonfragile_object) 7030 << LHSType; 7031 7032 // If the RHS is a unary plus or minus, check to see if they = and + are 7033 // right next to each other. If so, the user may have typo'd "x =+ 4" 7034 // instead of "x += 4". 7035 Expr *RHSCheck = RHS.get(); 7036 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck)) 7037 RHSCheck = ICE->getSubExpr(); 7038 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) { 7039 if ((UO->getOpcode() == UO_Plus || 7040 UO->getOpcode() == UO_Minus) && 7041 Loc.isFileID() && UO->getOperatorLoc().isFileID() && 7042 // Only if the two operators are exactly adjacent. 7043 Loc.getFileLocWithOffset(1) == UO->getOperatorLoc() && 7044 // And there is a space or other character before the subexpr of the 7045 // unary +/-. We don't want to warn on "x=-1". 7046 Loc.getFileLocWithOffset(2) != UO->getSubExpr()->getLocStart() && 7047 UO->getSubExpr()->getLocStart().isFileID()) { 7048 Diag(Loc, diag::warn_not_compound_assign) 7049 << (UO->getOpcode() == UO_Plus ? "+" : "-") 7050 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc()); 7051 } 7052 } 7053 7054 if (ConvTy == Compatible) { 7055 if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong) 7056 checkRetainCycles(LHS, RHS.get()); 7057 else if (getLangOptions().ObjCAutoRefCount) 7058 checkUnsafeExprAssigns(Loc, LHS, RHS.get()); 7059 } 7060 } else { 7061 // Compound assignment "x += y" 7062 ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType); 7063 } 7064 7065 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType, 7066 RHS.get(), AA_Assigning)) 7067 return QualType(); 7068 7069 CheckForNullPointerDereference(*this, LHS); 7070 7071 // C99 6.5.16p3: The type of an assignment expression is the type of the 7072 // left operand unless the left operand has qualified type, in which case 7073 // it is the unqualified version of the type of the left operand. 7074 // C99 6.5.16.1p2: In simple assignment, the value of the right operand 7075 // is converted to the type of the assignment expression (above). 7076 // C++ 5.17p1: the type of the assignment expression is that of its left 7077 // operand. 7078 return (getLangOptions().CPlusPlus 7079 ? LHSType : LHSType.getUnqualifiedType()); 7080} 7081 7082// C99 6.5.17 7083static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, 7084 SourceLocation Loc) { 7085 S.DiagnoseUnusedExprResult(LHS.get()); 7086 7087 LHS = S.CheckPlaceholderExpr(LHS.take()); 7088 RHS = S.CheckPlaceholderExpr(RHS.take()); 7089 if (LHS.isInvalid() || RHS.isInvalid()) 7090 return QualType(); 7091 7092 // C's comma performs lvalue conversion (C99 6.3.2.1) on both its 7093 // operands, but not unary promotions. 7094 // C++'s comma does not do any conversions at all (C++ [expr.comma]p1). 7095 7096 // So we treat the LHS as a ignored value, and in C++ we allow the 7097 // containing site to determine what should be done with the RHS. 7098 LHS = S.IgnoredValueConversions(LHS.take()); 7099 if (LHS.isInvalid()) 7100 return QualType(); 7101 7102 if (!S.getLangOptions().CPlusPlus) { 7103 RHS = S.DefaultFunctionArrayLvalueConversion(RHS.take()); 7104 if (RHS.isInvalid()) 7105 return QualType(); 7106 if (!RHS.get()->getType()->isVoidType()) 7107 S.RequireCompleteType(Loc, RHS.get()->getType(), 7108 diag::err_incomplete_type); 7109 } 7110 7111 return RHS.get()->getType(); 7112} 7113 7114/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine 7115/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions. 7116static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, 7117 ExprValueKind &VK, 7118 SourceLocation OpLoc, 7119 bool isInc, bool isPrefix) { 7120 if (Op->isTypeDependent()) 7121 return S.Context.DependentTy; 7122 7123 QualType ResType = Op->getType(); 7124 assert(!ResType.isNull() && "no type for increment/decrement expression"); 7125 7126 if (S.getLangOptions().CPlusPlus && ResType->isBooleanType()) { 7127 // Decrement of bool is not allowed. 7128 if (!isInc) { 7129 S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange(); 7130 return QualType(); 7131 } 7132 // Increment of bool sets it to true, but is deprecated. 7133 S.Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange(); 7134 } else if (ResType->isRealType()) { 7135 // OK! 7136 } else if (ResType->isAnyPointerType()) { 7137 // C99 6.5.2.4p2, 6.5.6p2 7138 if (!checkArithmeticOpPointerOperand(S, OpLoc, Op)) 7139 return QualType(); 7140 7141 // Diagnose bad cases where we step over interface counts. 7142 else if (!checkArithmethicPointerOnNonFragileABI(S, OpLoc, Op)) 7143 return QualType(); 7144 } else if (ResType->isAnyComplexType()) { 7145 // C99 does not support ++/-- on complex types, we allow as an extension. 7146 S.Diag(OpLoc, diag::ext_integer_increment_complex) 7147 << ResType << Op->getSourceRange(); 7148 } else if (ResType->isPlaceholderType()) { 7149 ExprResult PR = S.CheckPlaceholderExpr(Op); 7150 if (PR.isInvalid()) return QualType(); 7151 return CheckIncrementDecrementOperand(S, PR.take(), VK, OpLoc, 7152 isInc, isPrefix); 7153 } else if (S.getLangOptions().AltiVec && ResType->isVectorType()) { 7154 // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 ) 7155 } else { 7156 S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement) 7157 << ResType << int(isInc) << Op->getSourceRange(); 7158 return QualType(); 7159 } 7160 // At this point, we know we have a real, complex or pointer type. 7161 // Now make sure the operand is a modifiable lvalue. 7162 if (CheckForModifiableLvalue(Op, OpLoc, S)) 7163 return QualType(); 7164 // In C++, a prefix increment is the same type as the operand. Otherwise 7165 // (in C or with postfix), the increment is the unqualified type of the 7166 // operand. 7167 if (isPrefix && S.getLangOptions().CPlusPlus) { 7168 VK = VK_LValue; 7169 return ResType; 7170 } else { 7171 VK = VK_RValue; 7172 return ResType.getUnqualifiedType(); 7173 } 7174} 7175 7176ExprResult Sema::ConvertPropertyForRValue(Expr *E) { 7177 assert(E->getValueKind() == VK_LValue && 7178 E->getObjectKind() == OK_ObjCProperty); 7179 const ObjCPropertyRefExpr *PRE = E->getObjCProperty(); 7180 7181 QualType T = E->getType(); 7182 QualType ReceiverType; 7183 if (PRE->isObjectReceiver()) 7184 ReceiverType = PRE->getBase()->getType(); 7185 else if (PRE->isSuperReceiver()) 7186 ReceiverType = PRE->getSuperReceiverType(); 7187 else 7188 ReceiverType = Context.getObjCInterfaceType(PRE->getClassReceiver()); 7189 7190 ExprValueKind VK = VK_RValue; 7191 if (PRE->isImplicitProperty()) { 7192 if (ObjCMethodDecl *GetterMethod = 7193 PRE->getImplicitPropertyGetter()) { 7194 T = getMessageSendResultType(ReceiverType, GetterMethod, 7195 PRE->isClassReceiver(), 7196 PRE->isSuperReceiver()); 7197 VK = Expr::getValueKindForType(GetterMethod->getResultType()); 7198 } 7199 else { 7200 Diag(PRE->getLocation(), diag::err_getter_not_found) 7201 << PRE->getBase()->getType(); 7202 } 7203 } 7204 7205 E = ImplicitCastExpr::Create(Context, T, CK_GetObjCProperty, 7206 E, 0, VK); 7207 7208 ExprResult Result = MaybeBindToTemporary(E); 7209 if (!Result.isInvalid()) 7210 E = Result.take(); 7211 7212 return Owned(E); 7213} 7214 7215void Sema::ConvertPropertyForLValue(ExprResult &LHS, ExprResult &RHS, 7216 QualType &LHSTy) { 7217 assert(LHS.get()->getValueKind() == VK_LValue && 7218 LHS.get()->getObjectKind() == OK_ObjCProperty); 7219 const ObjCPropertyRefExpr *PropRef = LHS.get()->getObjCProperty(); 7220 7221 bool Consumed = false; 7222 7223 if (PropRef->isImplicitProperty()) { 7224 // If using property-dot syntax notation for assignment, and there is a 7225 // setter, RHS expression is being passed to the setter argument. So, 7226 // type conversion (and comparison) is RHS to setter's argument type. 7227 if (const ObjCMethodDecl *SetterMD = PropRef->getImplicitPropertySetter()) { 7228 ObjCMethodDecl::param_iterator P = SetterMD->param_begin(); 7229 LHSTy = (*P)->getType(); 7230 Consumed = (getLangOptions().ObjCAutoRefCount && 7231 (*P)->hasAttr<NSConsumedAttr>()); 7232 7233 // Otherwise, if the getter returns an l-value, just call that. 7234 } else { 7235 QualType Result = PropRef->getImplicitPropertyGetter()->getResultType(); 7236 ExprValueKind VK = Expr::getValueKindForType(Result); 7237 if (VK == VK_LValue) { 7238 LHS = ImplicitCastExpr::Create(Context, LHS.get()->getType(), 7239 CK_GetObjCProperty, LHS.take(), 0, VK); 7240 return; 7241 } 7242 } 7243 } else if (getLangOptions().ObjCAutoRefCount) { 7244 const ObjCMethodDecl *setter 7245 = PropRef->getExplicitProperty()->getSetterMethodDecl(); 7246 if (setter) { 7247 ObjCMethodDecl::param_iterator P = setter->param_begin(); 7248 LHSTy = (*P)->getType(); 7249 Consumed = (*P)->hasAttr<NSConsumedAttr>(); 7250 } 7251 } 7252 7253 if ((getLangOptions().CPlusPlus && LHSTy->isRecordType()) || 7254 getLangOptions().ObjCAutoRefCount) { 7255 InitializedEntity Entity = 7256 InitializedEntity::InitializeParameter(Context, LHSTy, Consumed); 7257 ExprResult ArgE = PerformCopyInitialization(Entity, SourceLocation(), RHS); 7258 if (!ArgE.isInvalid()) { 7259 RHS = ArgE; 7260 if (getLangOptions().ObjCAutoRefCount && !PropRef->isSuperReceiver()) 7261 checkRetainCycles(const_cast<Expr*>(PropRef->getBase()), RHS.get()); 7262 } 7263 } 7264} 7265 7266 7267/// getPrimaryDecl - Helper function for CheckAddressOfOperand(). 7268/// This routine allows us to typecheck complex/recursive expressions 7269/// where the declaration is needed for type checking. We only need to 7270/// handle cases when the expression references a function designator 7271/// or is an lvalue. Here are some examples: 7272/// - &(x) => x 7273/// - &*****f => f for f a function designator. 7274/// - &s.xx => s 7275/// - &s.zz[1].yy -> s, if zz is an array 7276/// - *(x + 1) -> x, if x is an array 7277/// - &"123"[2] -> 0 7278/// - & __real__ x -> x 7279static ValueDecl *getPrimaryDecl(Expr *E) { 7280 switch (E->getStmtClass()) { 7281 case Stmt::DeclRefExprClass: 7282 return cast<DeclRefExpr>(E)->getDecl(); 7283 case Stmt::MemberExprClass: 7284 // If this is an arrow operator, the address is an offset from 7285 // the base's value, so the object the base refers to is 7286 // irrelevant. 7287 if (cast<MemberExpr>(E)->isArrow()) 7288 return 0; 7289 // Otherwise, the expression refers to a part of the base 7290 return getPrimaryDecl(cast<MemberExpr>(E)->getBase()); 7291 case Stmt::ArraySubscriptExprClass: { 7292 // FIXME: This code shouldn't be necessary! We should catch the implicit 7293 // promotion of register arrays earlier. 7294 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase(); 7295 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) { 7296 if (ICE->getSubExpr()->getType()->isArrayType()) 7297 return getPrimaryDecl(ICE->getSubExpr()); 7298 } 7299 return 0; 7300 } 7301 case Stmt::UnaryOperatorClass: { 7302 UnaryOperator *UO = cast<UnaryOperator>(E); 7303 7304 switch(UO->getOpcode()) { 7305 case UO_Real: 7306 case UO_Imag: 7307 case UO_Extension: 7308 return getPrimaryDecl(UO->getSubExpr()); 7309 default: 7310 return 0; 7311 } 7312 } 7313 case Stmt::ParenExprClass: 7314 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr()); 7315 case Stmt::ImplicitCastExprClass: 7316 // If the result of an implicit cast is an l-value, we care about 7317 // the sub-expression; otherwise, the result here doesn't matter. 7318 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr()); 7319 default: 7320 return 0; 7321 } 7322} 7323 7324/// \brief Diagnose invalid operand for address of operations. 7325/// 7326/// \param Type The type of operand which cannot have its address taken. 7327/// 0:bit-field 1:vector element 2:property expression 3:register variable 7328static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, 7329 Expr *E, unsigned Type) { 7330 S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange(); 7331} 7332 7333/// CheckAddressOfOperand - The operand of & must be either a function 7334/// designator or an lvalue designating an object. If it is an lvalue, the 7335/// object cannot be declared with storage class register or be a bit field. 7336/// Note: The usual conversions are *not* applied to the operand of the & 7337/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue. 7338/// In C++, the operand might be an overloaded function name, in which case 7339/// we allow the '&' but retain the overloaded-function type. 7340static QualType CheckAddressOfOperand(Sema &S, Expr *OrigOp, 7341 SourceLocation OpLoc) { 7342 if (OrigOp->isTypeDependent()) 7343 return S.Context.DependentTy; 7344 if (OrigOp->getType() == S.Context.OverloadTy) 7345 return S.Context.OverloadTy; 7346 if (OrigOp->getType() == S.Context.UnknownAnyTy) 7347 return S.Context.UnknownAnyTy; 7348 if (OrigOp->getType() == S.Context.BoundMemberTy) { 7349 S.Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 7350 << OrigOp->getSourceRange(); 7351 return QualType(); 7352 } 7353 7354 assert(!OrigOp->getType()->isPlaceholderType()); 7355 7356 // Make sure to ignore parentheses in subsequent checks 7357 Expr *op = OrigOp->IgnoreParens(); 7358 7359 if (S.getLangOptions().C99) { 7360 // Implement C99-only parts of addressof rules. 7361 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) { 7362 if (uOp->getOpcode() == UO_Deref) 7363 // Per C99 6.5.3.2, the address of a deref always returns a valid result 7364 // (assuming the deref expression is valid). 7365 return uOp->getSubExpr()->getType(); 7366 } 7367 // Technically, there should be a check for array subscript 7368 // expressions here, but the result of one is always an lvalue anyway. 7369 } 7370 ValueDecl *dcl = getPrimaryDecl(op); 7371 Expr::LValueClassification lval = op->ClassifyLValue(S.Context); 7372 7373 if (lval == Expr::LV_ClassTemporary) { 7374 bool sfinae = S.isSFINAEContext(); 7375 S.Diag(OpLoc, sfinae ? diag::err_typecheck_addrof_class_temporary 7376 : diag::ext_typecheck_addrof_class_temporary) 7377 << op->getType() << op->getSourceRange(); 7378 if (sfinae) 7379 return QualType(); 7380 } else if (isa<ObjCSelectorExpr>(op)) { 7381 return S.Context.getPointerType(op->getType()); 7382 } else if (lval == Expr::LV_MemberFunction) { 7383 // If it's an instance method, make a member pointer. 7384 // The expression must have exactly the form &A::foo. 7385 7386 // If the underlying expression isn't a decl ref, give up. 7387 if (!isa<DeclRefExpr>(op)) { 7388 S.Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 7389 << OrigOp->getSourceRange(); 7390 return QualType(); 7391 } 7392 DeclRefExpr *DRE = cast<DeclRefExpr>(op); 7393 CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl()); 7394 7395 // The id-expression was parenthesized. 7396 if (OrigOp != DRE) { 7397 S.Diag(OpLoc, diag::err_parens_pointer_member_function) 7398 << OrigOp->getSourceRange(); 7399 7400 // The method was named without a qualifier. 7401 } else if (!DRE->getQualifier()) { 7402 S.Diag(OpLoc, diag::err_unqualified_pointer_member_function) 7403 << op->getSourceRange(); 7404 } 7405 7406 return S.Context.getMemberPointerType(op->getType(), 7407 S.Context.getTypeDeclType(MD->getParent()).getTypePtr()); 7408 } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) { 7409 // C99 6.5.3.2p1 7410 // The operand must be either an l-value or a function designator 7411 if (!op->getType()->isFunctionType()) { 7412 // FIXME: emit more specific diag... 7413 S.Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof) 7414 << op->getSourceRange(); 7415 return QualType(); 7416 } 7417 } else if (op->getObjectKind() == OK_BitField) { // C99 6.5.3.2p1 7418 // The operand cannot be a bit-field 7419 diagnoseAddressOfInvalidType(S, OpLoc, op, /*bit-field*/ 0); 7420 return QualType(); 7421 } else if (op->getObjectKind() == OK_VectorComponent) { 7422 // The operand cannot be an element of a vector 7423 diagnoseAddressOfInvalidType(S, OpLoc, op, /*vector element*/ 1); 7424 return QualType(); 7425 } else if (op->getObjectKind() == OK_ObjCProperty) { 7426 // cannot take address of a property expression. 7427 diagnoseAddressOfInvalidType(S, OpLoc, op, /*property expression*/ 2); 7428 return QualType(); 7429 } else if (dcl) { // C99 6.5.3.2p1 7430 // We have an lvalue with a decl. Make sure the decl is not declared 7431 // with the register storage-class specifier. 7432 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) { 7433 // in C++ it is not error to take address of a register 7434 // variable (c++03 7.1.1P3) 7435 if (vd->getStorageClass() == SC_Register && 7436 !S.getLangOptions().CPlusPlus) { 7437 diagnoseAddressOfInvalidType(S, OpLoc, op, /*register variable*/ 3); 7438 return QualType(); 7439 } 7440 } else if (isa<FunctionTemplateDecl>(dcl)) { 7441 return S.Context.OverloadTy; 7442 } else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) { 7443 // Okay: we can take the address of a field. 7444 // Could be a pointer to member, though, if there is an explicit 7445 // scope qualifier for the class. 7446 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) { 7447 DeclContext *Ctx = dcl->getDeclContext(); 7448 if (Ctx && Ctx->isRecord()) { 7449 if (dcl->getType()->isReferenceType()) { 7450 S.Diag(OpLoc, 7451 diag::err_cannot_form_pointer_to_member_of_reference_type) 7452 << dcl->getDeclName() << dcl->getType(); 7453 return QualType(); 7454 } 7455 7456 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion()) 7457 Ctx = Ctx->getParent(); 7458 return S.Context.getMemberPointerType(op->getType(), 7459 S.Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr()); 7460 } 7461 } 7462 } else if (!isa<FunctionDecl>(dcl) && !isa<NonTypeTemplateParmDecl>(dcl)) 7463 assert(0 && "Unknown/unexpected decl type"); 7464 } 7465 7466 if (lval == Expr::LV_IncompleteVoidType) { 7467 // Taking the address of a void variable is technically illegal, but we 7468 // allow it in cases which are otherwise valid. 7469 // Example: "extern void x; void* y = &x;". 7470 S.Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange(); 7471 } 7472 7473 // If the operand has type "type", the result has type "pointer to type". 7474 if (op->getType()->isObjCObjectType()) 7475 return S.Context.getObjCObjectPointerType(op->getType()); 7476 return S.Context.getPointerType(op->getType()); 7477} 7478 7479/// CheckIndirectionOperand - Type check unary indirection (prefix '*'). 7480static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK, 7481 SourceLocation OpLoc) { 7482 if (Op->isTypeDependent()) 7483 return S.Context.DependentTy; 7484 7485 ExprResult ConvResult = S.UsualUnaryConversions(Op); 7486 if (ConvResult.isInvalid()) 7487 return QualType(); 7488 Op = ConvResult.take(); 7489 QualType OpTy = Op->getType(); 7490 QualType Result; 7491 7492 if (isa<CXXReinterpretCastExpr>(Op)) { 7493 QualType OpOrigType = Op->IgnoreParenCasts()->getType(); 7494 S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true, 7495 Op->getSourceRange()); 7496 } 7497 7498 // Note that per both C89 and C99, indirection is always legal, even if OpTy 7499 // is an incomplete type or void. It would be possible to warn about 7500 // dereferencing a void pointer, but it's completely well-defined, and such a 7501 // warning is unlikely to catch any mistakes. 7502 if (const PointerType *PT = OpTy->getAs<PointerType>()) 7503 Result = PT->getPointeeType(); 7504 else if (const ObjCObjectPointerType *OPT = 7505 OpTy->getAs<ObjCObjectPointerType>()) 7506 Result = OPT->getPointeeType(); 7507 else { 7508 ExprResult PR = S.CheckPlaceholderExpr(Op); 7509 if (PR.isInvalid()) return QualType(); 7510 if (PR.take() != Op) 7511 return CheckIndirectionOperand(S, PR.take(), VK, OpLoc); 7512 } 7513 7514 if (Result.isNull()) { 7515 S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer) 7516 << OpTy << Op->getSourceRange(); 7517 return QualType(); 7518 } 7519 7520 // Dereferences are usually l-values... 7521 VK = VK_LValue; 7522 7523 // ...except that certain expressions are never l-values in C. 7524 if (!S.getLangOptions().CPlusPlus && Result.isCForbiddenLValueType()) 7525 VK = VK_RValue; 7526 7527 return Result; 7528} 7529 7530static inline BinaryOperatorKind ConvertTokenKindToBinaryOpcode( 7531 tok::TokenKind Kind) { 7532 BinaryOperatorKind Opc; 7533 switch (Kind) { 7534 default: assert(0 && "Unknown binop!"); 7535 case tok::periodstar: Opc = BO_PtrMemD; break; 7536 case tok::arrowstar: Opc = BO_PtrMemI; break; 7537 case tok::star: Opc = BO_Mul; break; 7538 case tok::slash: Opc = BO_Div; break; 7539 case tok::percent: Opc = BO_Rem; break; 7540 case tok::plus: Opc = BO_Add; break; 7541 case tok::minus: Opc = BO_Sub; break; 7542 case tok::lessless: Opc = BO_Shl; break; 7543 case tok::greatergreater: Opc = BO_Shr; break; 7544 case tok::lessequal: Opc = BO_LE; break; 7545 case tok::less: Opc = BO_LT; break; 7546 case tok::greaterequal: Opc = BO_GE; break; 7547 case tok::greater: Opc = BO_GT; break; 7548 case tok::exclaimequal: Opc = BO_NE; break; 7549 case tok::equalequal: Opc = BO_EQ; break; 7550 case tok::amp: Opc = BO_And; break; 7551 case tok::caret: Opc = BO_Xor; break; 7552 case tok::pipe: Opc = BO_Or; break; 7553 case tok::ampamp: Opc = BO_LAnd; break; 7554 case tok::pipepipe: Opc = BO_LOr; break; 7555 case tok::equal: Opc = BO_Assign; break; 7556 case tok::starequal: Opc = BO_MulAssign; break; 7557 case tok::slashequal: Opc = BO_DivAssign; break; 7558 case tok::percentequal: Opc = BO_RemAssign; break; 7559 case tok::plusequal: Opc = BO_AddAssign; break; 7560 case tok::minusequal: Opc = BO_SubAssign; break; 7561 case tok::lesslessequal: Opc = BO_ShlAssign; break; 7562 case tok::greatergreaterequal: Opc = BO_ShrAssign; break; 7563 case tok::ampequal: Opc = BO_AndAssign; break; 7564 case tok::caretequal: Opc = BO_XorAssign; break; 7565 case tok::pipeequal: Opc = BO_OrAssign; break; 7566 case tok::comma: Opc = BO_Comma; break; 7567 } 7568 return Opc; 7569} 7570 7571static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode( 7572 tok::TokenKind Kind) { 7573 UnaryOperatorKind Opc; 7574 switch (Kind) { 7575 default: assert(0 && "Unknown unary op!"); 7576 case tok::plusplus: Opc = UO_PreInc; break; 7577 case tok::minusminus: Opc = UO_PreDec; break; 7578 case tok::amp: Opc = UO_AddrOf; break; 7579 case tok::star: Opc = UO_Deref; break; 7580 case tok::plus: Opc = UO_Plus; break; 7581 case tok::minus: Opc = UO_Minus; break; 7582 case tok::tilde: Opc = UO_Not; break; 7583 case tok::exclaim: Opc = UO_LNot; break; 7584 case tok::kw___real: Opc = UO_Real; break; 7585 case tok::kw___imag: Opc = UO_Imag; break; 7586 case tok::kw___extension__: Opc = UO_Extension; break; 7587 } 7588 return Opc; 7589} 7590 7591/// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself. 7592/// This warning is only emitted for builtin assignment operations. It is also 7593/// suppressed in the event of macro expansions. 7594static void DiagnoseSelfAssignment(Sema &S, Expr *lhs, Expr *rhs, 7595 SourceLocation OpLoc) { 7596 if (!S.ActiveTemplateInstantiations.empty()) 7597 return; 7598 if (OpLoc.isInvalid() || OpLoc.isMacroID()) 7599 return; 7600 lhs = lhs->IgnoreParenImpCasts(); 7601 rhs = rhs->IgnoreParenImpCasts(); 7602 const DeclRefExpr *LeftDeclRef = dyn_cast<DeclRefExpr>(lhs); 7603 const DeclRefExpr *RightDeclRef = dyn_cast<DeclRefExpr>(rhs); 7604 if (!LeftDeclRef || !RightDeclRef || 7605 LeftDeclRef->getLocation().isMacroID() || 7606 RightDeclRef->getLocation().isMacroID()) 7607 return; 7608 const ValueDecl *LeftDecl = 7609 cast<ValueDecl>(LeftDeclRef->getDecl()->getCanonicalDecl()); 7610 const ValueDecl *RightDecl = 7611 cast<ValueDecl>(RightDeclRef->getDecl()->getCanonicalDecl()); 7612 if (LeftDecl != RightDecl) 7613 return; 7614 if (LeftDecl->getType().isVolatileQualified()) 7615 return; 7616 if (const ReferenceType *RefTy = LeftDecl->getType()->getAs<ReferenceType>()) 7617 if (RefTy->getPointeeType().isVolatileQualified()) 7618 return; 7619 7620 S.Diag(OpLoc, diag::warn_self_assignment) 7621 << LeftDeclRef->getType() 7622 << lhs->getSourceRange() << rhs->getSourceRange(); 7623} 7624 7625// checkArithmeticNull - Detect when a NULL constant is used improperly in an 7626// expression. These are mainly cases where the null pointer is used as an 7627// integer instead of a pointer. 7628static void checkArithmeticNull(Sema &S, ExprResult &lex, ExprResult &rex, 7629 SourceLocation Loc, bool isCompare) { 7630 // The canonical way to check for a GNU null is with isNullPointerConstant, 7631 // but we use a bit of a hack here for speed; this is a relatively 7632 // hot path, and isNullPointerConstant is slow. 7633 bool LeftNull = isa<GNUNullExpr>(lex.get()->IgnoreParenImpCasts()); 7634 bool RightNull = isa<GNUNullExpr>(rex.get()->IgnoreParenImpCasts()); 7635 7636 // Detect when a NULL constant is used improperly in an expression. These 7637 // are mainly cases where the null pointer is used as an integer instead 7638 // of a pointer. 7639 if (!LeftNull && !RightNull) 7640 return; 7641 7642 QualType LeftType = lex.get()->getType(); 7643 QualType RightType = rex.get()->getType(); 7644 7645 // Avoid analyzing cases where the result will either be invalid (and 7646 // diagnosed as such) or entirely valid and not something to warn about. 7647 if (LeftType->isBlockPointerType() || LeftType->isMemberPointerType() || 7648 LeftType->isFunctionType() || RightType->isBlockPointerType() || 7649 RightType->isMemberPointerType() || RightType->isFunctionType()) 7650 return; 7651 7652 // Comparison operations would not make sense with a null pointer no matter 7653 // what the other expression is. 7654 if (!isCompare) { 7655 S.Diag(Loc, diag::warn_null_in_arithmetic_operation) 7656 << (LeftNull ? lex.get()->getSourceRange() : SourceRange()) 7657 << (RightNull ? rex.get()->getSourceRange() : SourceRange()); 7658 return; 7659 } 7660 7661 // The rest of the operations only make sense with a null pointer 7662 // if the other expression is a pointer. 7663 if (LeftNull == RightNull || LeftType->isAnyPointerType() || 7664 LeftType->canDecayToPointerType() || RightType->isAnyPointerType() || 7665 RightType->canDecayToPointerType()) 7666 return; 7667 7668 S.Diag(Loc, diag::warn_null_in_comparison_operation) 7669 << LeftNull /* LHS is NULL */ 7670 << (LeftNull ? rex.get()->getType() : lex.get()->getType()) 7671 << lex.get()->getSourceRange() << rex.get()->getSourceRange(); 7672} 7673/// CreateBuiltinBinOp - Creates a new built-in binary operation with 7674/// operator @p Opc at location @c TokLoc. This routine only supports 7675/// built-in operations; ActOnBinOp handles overloaded operators. 7676ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc, 7677 BinaryOperatorKind Opc, 7678 Expr *lhsExpr, Expr *rhsExpr) { 7679 ExprResult lhs = Owned(lhsExpr), rhs = Owned(rhsExpr); 7680 QualType ResultTy; // Result type of the binary operator. 7681 // The following two variables are used for compound assignment operators 7682 QualType CompLHSTy; // Type of LHS after promotions for computation 7683 QualType CompResultTy; // Type of computation result 7684 ExprValueKind VK = VK_RValue; 7685 ExprObjectKind OK = OK_Ordinary; 7686 7687 // Check if a 'foo<int>' involved in a binary op, identifies a single 7688 // function unambiguously (i.e. an lvalue ala 13.4) 7689 // But since an assignment can trigger target based overload, exclude it in 7690 // our blind search. i.e: 7691 // template<class T> void f(); template<class T, class U> void f(U); 7692 // f<int> == 0; // resolve f<int> blindly 7693 // void (*p)(int); p = f<int>; // resolve f<int> using target 7694 if (Opc != BO_Assign) { 7695 ExprResult resolvedLHS = CheckPlaceholderExpr(lhs.get()); 7696 if (!resolvedLHS.isUsable()) return ExprError(); 7697 lhs = move(resolvedLHS); 7698 7699 ExprResult resolvedRHS = CheckPlaceholderExpr(rhs.get()); 7700 if (!resolvedRHS.isUsable()) return ExprError(); 7701 rhs = move(resolvedRHS); 7702 } 7703 7704 if (Opc == BO_Mul || Opc == BO_Div || Opc == BO_Rem || Opc == BO_Add || 7705 Opc == BO_Sub || Opc == BO_Shl || Opc == BO_Shr || Opc == BO_And || 7706 Opc == BO_Xor || Opc == BO_Or || Opc == BO_MulAssign || 7707 Opc == BO_DivAssign || Opc == BO_AddAssign || Opc == BO_SubAssign || 7708 Opc == BO_RemAssign || Opc == BO_ShlAssign || Opc == BO_ShrAssign || 7709 Opc == BO_AndAssign || Opc == BO_OrAssign || Opc == BO_XorAssign) 7710 checkArithmeticNull(*this, lhs, rhs, OpLoc, /*isCompare=*/false); 7711 else if (Opc == BO_LE || Opc == BO_LT || Opc == BO_GE || Opc == BO_GT || 7712 Opc == BO_EQ || Opc == BO_NE) 7713 checkArithmeticNull(*this, lhs, rhs, OpLoc, /*isCompare=*/true); 7714 7715 switch (Opc) { 7716 case BO_Assign: 7717 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, QualType()); 7718 if (getLangOptions().CPlusPlus && 7719 lhs.get()->getObjectKind() != OK_ObjCProperty) { 7720 VK = lhs.get()->getValueKind(); 7721 OK = lhs.get()->getObjectKind(); 7722 } 7723 if (!ResultTy.isNull()) 7724 DiagnoseSelfAssignment(*this, lhs.get(), rhs.get(), OpLoc); 7725 break; 7726 case BO_PtrMemD: 7727 case BO_PtrMemI: 7728 ResultTy = CheckPointerToMemberOperands(lhs, rhs, VK, OpLoc, 7729 Opc == BO_PtrMemI); 7730 break; 7731 case BO_Mul: 7732 case BO_Div: 7733 ResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc, false, 7734 Opc == BO_Div); 7735 break; 7736 case BO_Rem: 7737 ResultTy = CheckRemainderOperands(lhs, rhs, OpLoc); 7738 break; 7739 case BO_Add: 7740 ResultTy = CheckAdditionOperands(lhs, rhs, OpLoc); 7741 break; 7742 case BO_Sub: 7743 ResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc); 7744 break; 7745 case BO_Shl: 7746 case BO_Shr: 7747 ResultTy = CheckShiftOperands(lhs, rhs, OpLoc, Opc); 7748 break; 7749 case BO_LE: 7750 case BO_LT: 7751 case BO_GE: 7752 case BO_GT: 7753 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, true); 7754 break; 7755 case BO_EQ: 7756 case BO_NE: 7757 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, false); 7758 break; 7759 case BO_And: 7760 case BO_Xor: 7761 case BO_Or: 7762 ResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc); 7763 break; 7764 case BO_LAnd: 7765 case BO_LOr: 7766 ResultTy = CheckLogicalOperands(lhs, rhs, OpLoc, Opc); 7767 break; 7768 case BO_MulAssign: 7769 case BO_DivAssign: 7770 CompResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc, true, 7771 Opc == BO_DivAssign); 7772 CompLHSTy = CompResultTy; 7773 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 7774 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 7775 break; 7776 case BO_RemAssign: 7777 CompResultTy = CheckRemainderOperands(lhs, rhs, OpLoc, true); 7778 CompLHSTy = CompResultTy; 7779 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 7780 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 7781 break; 7782 case BO_AddAssign: 7783 CompResultTy = CheckAdditionOperands(lhs, rhs, OpLoc, &CompLHSTy); 7784 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 7785 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 7786 break; 7787 case BO_SubAssign: 7788 CompResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc, &CompLHSTy); 7789 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 7790 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 7791 break; 7792 case BO_ShlAssign: 7793 case BO_ShrAssign: 7794 CompResultTy = CheckShiftOperands(lhs, rhs, OpLoc, Opc, true); 7795 CompLHSTy = CompResultTy; 7796 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 7797 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 7798 break; 7799 case BO_AndAssign: 7800 case BO_XorAssign: 7801 case BO_OrAssign: 7802 CompResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc, true); 7803 CompLHSTy = CompResultTy; 7804 if (!CompResultTy.isNull() && !lhs.isInvalid() && !rhs.isInvalid()) 7805 ResultTy = CheckAssignmentOperands(lhs.get(), rhs, OpLoc, CompResultTy); 7806 break; 7807 case BO_Comma: 7808 ResultTy = CheckCommaOperands(*this, lhs, rhs, OpLoc); 7809 if (getLangOptions().CPlusPlus && !rhs.isInvalid()) { 7810 VK = rhs.get()->getValueKind(); 7811 OK = rhs.get()->getObjectKind(); 7812 } 7813 break; 7814 } 7815 if (ResultTy.isNull() || lhs.isInvalid() || rhs.isInvalid()) 7816 return ExprError(); 7817 7818 // Check for array bounds violations for both sides of the BinaryOperator 7819 CheckArrayAccess(lhs.get()); 7820 CheckArrayAccess(rhs.get()); 7821 7822 if (CompResultTy.isNull()) 7823 return Owned(new (Context) BinaryOperator(lhs.take(), rhs.take(), Opc, 7824 ResultTy, VK, OK, OpLoc)); 7825 if (getLangOptions().CPlusPlus && lhs.get()->getObjectKind() != 7826 OK_ObjCProperty) { 7827 VK = VK_LValue; 7828 OK = lhs.get()->getObjectKind(); 7829 } 7830 return Owned(new (Context) CompoundAssignOperator(lhs.take(), rhs.take(), Opc, 7831 ResultTy, VK, OK, CompLHSTy, 7832 CompResultTy, OpLoc)); 7833} 7834 7835/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison 7836/// operators are mixed in a way that suggests that the programmer forgot that 7837/// comparison operators have higher precedence. The most typical example of 7838/// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1". 7839static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, 7840 SourceLocation OpLoc,Expr *lhs,Expr *rhs){ 7841 typedef BinaryOperator BinOp; 7842 BinOp::Opcode lhsopc = static_cast<BinOp::Opcode>(-1), 7843 rhsopc = static_cast<BinOp::Opcode>(-1); 7844 if (BinOp *BO = dyn_cast<BinOp>(lhs)) 7845 lhsopc = BO->getOpcode(); 7846 if (BinOp *BO = dyn_cast<BinOp>(rhs)) 7847 rhsopc = BO->getOpcode(); 7848 7849 // Subs are not binary operators. 7850 if (lhsopc == -1 && rhsopc == -1) 7851 return; 7852 7853 // Bitwise operations are sometimes used as eager logical ops. 7854 // Don't diagnose this. 7855 if ((BinOp::isComparisonOp(lhsopc) || BinOp::isBitwiseOp(lhsopc)) && 7856 (BinOp::isComparisonOp(rhsopc) || BinOp::isBitwiseOp(rhsopc))) 7857 return; 7858 7859 bool isLeftComp = BinOp::isComparisonOp(lhsopc); 7860 bool isRightComp = BinOp::isComparisonOp(rhsopc); 7861 if (!isLeftComp && !isRightComp) return; 7862 7863 SourceRange DiagRange = isLeftComp ? SourceRange(lhs->getLocStart(), OpLoc) 7864 : SourceRange(OpLoc, rhs->getLocEnd()); 7865 std::string OpStr = isLeftComp ? BinOp::getOpcodeStr(lhsopc) 7866 : BinOp::getOpcodeStr(rhsopc); 7867 SourceRange ParensRange = isLeftComp ? 7868 SourceRange(cast<BinOp>(lhs)->getRHS()->getLocStart(), 7869 rhs->getLocEnd()) 7870 : SourceRange(lhs->getLocStart(), 7871 cast<BinOp>(rhs)->getLHS()->getLocStart()); 7872 7873 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel) 7874 << DiagRange << BinOp::getOpcodeStr(Opc) << OpStr; 7875 SuggestParentheses(Self, OpLoc, 7876 Self.PDiag(diag::note_precedence_bitwise_silence) << OpStr, 7877 rhs->getSourceRange()); 7878 SuggestParentheses(Self, OpLoc, 7879 Self.PDiag(diag::note_precedence_bitwise_first) << BinOp::getOpcodeStr(Opc), 7880 ParensRange); 7881} 7882 7883/// \brief It accepts a '&' expr that is inside a '|' one. 7884/// Emit a diagnostic together with a fixit hint that wraps the '&' expression 7885/// in parentheses. 7886static void 7887EmitDiagnosticForBitwiseAndInBitwiseOr(Sema &Self, SourceLocation OpLoc, 7888 BinaryOperator *Bop) { 7889 assert(Bop->getOpcode() == BO_And); 7890 Self.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_and_in_bitwise_or) 7891 << Bop->getSourceRange() << OpLoc; 7892 SuggestParentheses(Self, Bop->getOperatorLoc(), 7893 Self.PDiag(diag::note_bitwise_and_in_bitwise_or_silence), 7894 Bop->getSourceRange()); 7895} 7896 7897/// \brief It accepts a '&&' expr that is inside a '||' one. 7898/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression 7899/// in parentheses. 7900static void 7901EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, 7902 BinaryOperator *Bop) { 7903 assert(Bop->getOpcode() == BO_LAnd); 7904 Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or) 7905 << Bop->getSourceRange() << OpLoc; 7906 SuggestParentheses(Self, Bop->getOperatorLoc(), 7907 Self.PDiag(diag::note_logical_and_in_logical_or_silence), 7908 Bop->getSourceRange()); 7909} 7910 7911/// \brief Returns true if the given expression can be evaluated as a constant 7912/// 'true'. 7913static bool EvaluatesAsTrue(Sema &S, Expr *E) { 7914 bool Res; 7915 return E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res; 7916} 7917 7918/// \brief Returns true if the given expression can be evaluated as a constant 7919/// 'false'. 7920static bool EvaluatesAsFalse(Sema &S, Expr *E) { 7921 bool Res; 7922 return E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res; 7923} 7924 7925/// \brief Look for '&&' in the left hand of a '||' expr. 7926static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, 7927 Expr *OrLHS, Expr *OrRHS) { 7928 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrLHS)) { 7929 if (Bop->getOpcode() == BO_LAnd) { 7930 // If it's "a && b || 0" don't warn since the precedence doesn't matter. 7931 if (EvaluatesAsFalse(S, OrRHS)) 7932 return; 7933 // If it's "1 && a || b" don't warn since the precedence doesn't matter. 7934 if (!EvaluatesAsTrue(S, Bop->getLHS())) 7935 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 7936 } else if (Bop->getOpcode() == BO_LOr) { 7937 if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) { 7938 // If it's "a || b && 1 || c" we didn't warn earlier for 7939 // "a || b && 1", but warn now. 7940 if (RBop->getOpcode() == BO_LAnd && EvaluatesAsTrue(S, RBop->getRHS())) 7941 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop); 7942 } 7943 } 7944 } 7945} 7946 7947/// \brief Look for '&&' in the right hand of a '||' expr. 7948static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, 7949 Expr *OrLHS, Expr *OrRHS) { 7950 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrRHS)) { 7951 if (Bop->getOpcode() == BO_LAnd) { 7952 // If it's "0 || a && b" don't warn since the precedence doesn't matter. 7953 if (EvaluatesAsFalse(S, OrLHS)) 7954 return; 7955 // If it's "a || b && 1" don't warn since the precedence doesn't matter. 7956 if (!EvaluatesAsTrue(S, Bop->getRHS())) 7957 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 7958 } 7959 } 7960} 7961 7962/// \brief Look for '&' in the left or right hand of a '|' expr. 7963static void DiagnoseBitwiseAndInBitwiseOr(Sema &S, SourceLocation OpLoc, 7964 Expr *OrArg) { 7965 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrArg)) { 7966 if (Bop->getOpcode() == BO_And) 7967 return EmitDiagnosticForBitwiseAndInBitwiseOr(S, OpLoc, Bop); 7968 } 7969} 7970 7971/// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky 7972/// precedence. 7973static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc, 7974 SourceLocation OpLoc, Expr *lhs, Expr *rhs){ 7975 // Diagnose "arg1 'bitwise' arg2 'eq' arg3". 7976 if (BinaryOperator::isBitwiseOp(Opc)) 7977 DiagnoseBitwisePrecedence(Self, Opc, OpLoc, lhs, rhs); 7978 7979 // Diagnose "arg1 & arg2 | arg3" 7980 if (Opc == BO_Or && !OpLoc.isMacroID()/* Don't warn in macros. */) { 7981 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, lhs); 7982 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, rhs); 7983 } 7984 7985 // Warn about arg1 || arg2 && arg3, as GCC 4.3+ does. 7986 // We don't warn for 'assert(a || b && "bad")' since this is safe. 7987 if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) { 7988 DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, lhs, rhs); 7989 DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, lhs, rhs); 7990 } 7991} 7992 7993// Binary Operators. 'Tok' is the token for the operator. 7994ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc, 7995 tok::TokenKind Kind, 7996 Expr *lhs, Expr *rhs) { 7997 BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind); 7998 assert((lhs != 0) && "ActOnBinOp(): missing left expression"); 7999 assert((rhs != 0) && "ActOnBinOp(): missing right expression"); 8000 8001 // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0" 8002 DiagnoseBinOpPrecedence(*this, Opc, TokLoc, lhs, rhs); 8003 8004 return BuildBinOp(S, TokLoc, Opc, lhs, rhs); 8005} 8006 8007ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc, 8008 BinaryOperatorKind Opc, 8009 Expr *lhs, Expr *rhs) { 8010 if (getLangOptions().CPlusPlus) { 8011 bool UseBuiltinOperator; 8012 8013 if (lhs->isTypeDependent() || rhs->isTypeDependent()) { 8014 UseBuiltinOperator = false; 8015 } else if (Opc == BO_Assign && lhs->getObjectKind() == OK_ObjCProperty) { 8016 UseBuiltinOperator = true; 8017 } else { 8018 UseBuiltinOperator = !lhs->getType()->isOverloadableType() && 8019 !rhs->getType()->isOverloadableType(); 8020 } 8021 8022 if (!UseBuiltinOperator) { 8023 // Find all of the overloaded operators visible from this 8024 // point. We perform both an operator-name lookup from the local 8025 // scope and an argument-dependent lookup based on the types of 8026 // the arguments. 8027 UnresolvedSet<16> Functions; 8028 OverloadedOperatorKind OverOp 8029 = BinaryOperator::getOverloadedOperator(Opc); 8030 if (S && OverOp != OO_None) 8031 LookupOverloadedOperatorName(OverOp, S, lhs->getType(), rhs->getType(), 8032 Functions); 8033 8034 // Build the (potentially-overloaded, potentially-dependent) 8035 // binary operation. 8036 return CreateOverloadedBinOp(OpLoc, Opc, Functions, lhs, rhs); 8037 } 8038 } 8039 8040 // Build a built-in binary operation. 8041 return CreateBuiltinBinOp(OpLoc, Opc, lhs, rhs); 8042} 8043 8044ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc, 8045 UnaryOperatorKind Opc, 8046 Expr *InputExpr) { 8047 ExprResult Input = Owned(InputExpr); 8048 ExprValueKind VK = VK_RValue; 8049 ExprObjectKind OK = OK_Ordinary; 8050 QualType resultType; 8051 switch (Opc) { 8052 case UO_PreInc: 8053 case UO_PreDec: 8054 case UO_PostInc: 8055 case UO_PostDec: 8056 resultType = CheckIncrementDecrementOperand(*this, Input.get(), VK, OpLoc, 8057 Opc == UO_PreInc || 8058 Opc == UO_PostInc, 8059 Opc == UO_PreInc || 8060 Opc == UO_PreDec); 8061 break; 8062 case UO_AddrOf: 8063 resultType = CheckAddressOfOperand(*this, Input.get(), OpLoc); 8064 break; 8065 case UO_Deref: { 8066 ExprResult resolved = CheckPlaceholderExpr(Input.get()); 8067 if (!resolved.isUsable()) return ExprError(); 8068 Input = move(resolved); 8069 Input = DefaultFunctionArrayLvalueConversion(Input.take()); 8070 resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc); 8071 break; 8072 } 8073 case UO_Plus: 8074 case UO_Minus: 8075 Input = UsualUnaryConversions(Input.take()); 8076 if (Input.isInvalid()) return ExprError(); 8077 resultType = Input.get()->getType(); 8078 if (resultType->isDependentType()) 8079 break; 8080 if (resultType->isArithmeticType() || // C99 6.5.3.3p1 8081 resultType->isVectorType()) 8082 break; 8083 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6-7 8084 resultType->isEnumeralType()) 8085 break; 8086 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6 8087 Opc == UO_Plus && 8088 resultType->isPointerType()) 8089 break; 8090 else if (resultType->isPlaceholderType()) { 8091 Input = CheckPlaceholderExpr(Input.take()); 8092 if (Input.isInvalid()) return ExprError(); 8093 return CreateBuiltinUnaryOp(OpLoc, Opc, Input.take()); 8094 } 8095 8096 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 8097 << resultType << Input.get()->getSourceRange()); 8098 8099 case UO_Not: // bitwise complement 8100 Input = UsualUnaryConversions(Input.take()); 8101 if (Input.isInvalid()) return ExprError(); 8102 resultType = Input.get()->getType(); 8103 if (resultType->isDependentType()) 8104 break; 8105 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension. 8106 if (resultType->isComplexType() || resultType->isComplexIntegerType()) 8107 // C99 does not support '~' for complex conjugation. 8108 Diag(OpLoc, diag::ext_integer_complement_complex) 8109 << resultType << Input.get()->getSourceRange(); 8110 else if (resultType->hasIntegerRepresentation()) 8111 break; 8112 else if (resultType->isPlaceholderType()) { 8113 Input = CheckPlaceholderExpr(Input.take()); 8114 if (Input.isInvalid()) return ExprError(); 8115 return CreateBuiltinUnaryOp(OpLoc, Opc, Input.take()); 8116 } else { 8117 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 8118 << resultType << Input.get()->getSourceRange()); 8119 } 8120 break; 8121 8122 case UO_LNot: // logical negation 8123 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5). 8124 Input = DefaultFunctionArrayLvalueConversion(Input.take()); 8125 if (Input.isInvalid()) return ExprError(); 8126 resultType = Input.get()->getType(); 8127 if (resultType->isDependentType()) 8128 break; 8129 if (resultType->isScalarType()) { 8130 // C99 6.5.3.3p1: ok, fallthrough; 8131 if (Context.getLangOptions().CPlusPlus) { 8132 // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9: 8133 // operand contextually converted to bool. 8134 Input = ImpCastExprToType(Input.take(), Context.BoolTy, 8135 ScalarTypeToBooleanCastKind(resultType)); 8136 } 8137 } else if (resultType->isPlaceholderType()) { 8138 Input = CheckPlaceholderExpr(Input.take()); 8139 if (Input.isInvalid()) return ExprError(); 8140 return CreateBuiltinUnaryOp(OpLoc, Opc, Input.take()); 8141 } else { 8142 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 8143 << resultType << Input.get()->getSourceRange()); 8144 } 8145 8146 // LNot always has type int. C99 6.5.3.3p5. 8147 // In C++, it's bool. C++ 5.3.1p8 8148 resultType = Context.getLogicalOperationType(); 8149 break; 8150 case UO_Real: 8151 case UO_Imag: 8152 resultType = CheckRealImagOperand(*this, Input, OpLoc, Opc == UO_Real); 8153 // _Real and _Imag map ordinary l-values into ordinary l-values. 8154 if (Input.isInvalid()) return ExprError(); 8155 if (Input.get()->getValueKind() != VK_RValue && 8156 Input.get()->getObjectKind() == OK_Ordinary) 8157 VK = Input.get()->getValueKind(); 8158 break; 8159 case UO_Extension: 8160 resultType = Input.get()->getType(); 8161 VK = Input.get()->getValueKind(); 8162 OK = Input.get()->getObjectKind(); 8163 break; 8164 } 8165 if (resultType.isNull() || Input.isInvalid()) 8166 return ExprError(); 8167 8168 // Check for array bounds violations in the operand of the UnaryOperator, 8169 // except for the '*' and '&' operators that have to be handled specially 8170 // by CheckArrayAccess (as there are special cases like &array[arraysize] 8171 // that are explicitly defined as valid by the standard). 8172 if (Opc != UO_AddrOf && Opc != UO_Deref) 8173 CheckArrayAccess(Input.get()); 8174 8175 return Owned(new (Context) UnaryOperator(Input.take(), Opc, resultType, 8176 VK, OK, OpLoc)); 8177} 8178 8179ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc, 8180 UnaryOperatorKind Opc, 8181 Expr *Input) { 8182 if (getLangOptions().CPlusPlus && Input->getType()->isOverloadableType() && 8183 UnaryOperator::getOverloadedOperator(Opc) != OO_None) { 8184 // Find all of the overloaded operators visible from this 8185 // point. We perform both an operator-name lookup from the local 8186 // scope and an argument-dependent lookup based on the types of 8187 // the arguments. 8188 UnresolvedSet<16> Functions; 8189 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc); 8190 if (S && OverOp != OO_None) 8191 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(), 8192 Functions); 8193 8194 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input); 8195 } 8196 8197 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 8198} 8199 8200// Unary Operators. 'Tok' is the token for the operator. 8201ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc, 8202 tok::TokenKind Op, Expr *Input) { 8203 return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input); 8204} 8205 8206/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo". 8207ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, 8208 LabelDecl *TheDecl) { 8209 TheDecl->setUsed(); 8210 // Create the AST node. The address of a label always has type 'void*'. 8211 return Owned(new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl, 8212 Context.getPointerType(Context.VoidTy))); 8213} 8214 8215/// Given the last statement in a statement-expression, check whether 8216/// the result is a producing expression (like a call to an 8217/// ns_returns_retained function) and, if so, rebuild it to hoist the 8218/// release out of the full-expression. Otherwise, return null. 8219/// Cannot fail. 8220static Expr *maybeRebuildARCConsumingStmt(Stmt *s) { 8221 // Should always be wrapped with one of these. 8222 ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(s); 8223 if (!cleanups) return 0; 8224 8225 ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(cleanups->getSubExpr()); 8226 if (!cast || cast->getCastKind() != CK_ObjCConsumeObject) 8227 return 0; 8228 8229 // Splice out the cast. This shouldn't modify any interesting 8230 // features of the statement. 8231 Expr *producer = cast->getSubExpr(); 8232 assert(producer->getType() == cast->getType()); 8233 assert(producer->getValueKind() == cast->getValueKind()); 8234 cleanups->setSubExpr(producer); 8235 return cleanups; 8236} 8237 8238ExprResult 8239Sema::ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, 8240 SourceLocation RPLoc) { // "({..})" 8241 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!"); 8242 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt); 8243 8244 bool isFileScope 8245 = (getCurFunctionOrMethodDecl() == 0) && (getCurBlock() == 0); 8246 if (isFileScope) 8247 return ExprError(Diag(LPLoc, diag::err_stmtexpr_file_scope)); 8248 8249 // FIXME: there are a variety of strange constraints to enforce here, for 8250 // example, it is not possible to goto into a stmt expression apparently. 8251 // More semantic analysis is needed. 8252 8253 // If there are sub stmts in the compound stmt, take the type of the last one 8254 // as the type of the stmtexpr. 8255 QualType Ty = Context.VoidTy; 8256 bool StmtExprMayBindToTemp = false; 8257 if (!Compound->body_empty()) { 8258 Stmt *LastStmt = Compound->body_back(); 8259 LabelStmt *LastLabelStmt = 0; 8260 // If LastStmt is a label, skip down through into the body. 8261 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt)) { 8262 LastLabelStmt = Label; 8263 LastStmt = Label->getSubStmt(); 8264 } 8265 8266 if (Expr *LastE = dyn_cast<Expr>(LastStmt)) { 8267 // Do function/array conversion on the last expression, but not 8268 // lvalue-to-rvalue. However, initialize an unqualified type. 8269 ExprResult LastExpr = DefaultFunctionArrayConversion(LastE); 8270 if (LastExpr.isInvalid()) 8271 return ExprError(); 8272 Ty = LastExpr.get()->getType().getUnqualifiedType(); 8273 8274 if (!Ty->isDependentType() && !LastExpr.get()->isTypeDependent()) { 8275 // In ARC, if the final expression ends in a consume, splice 8276 // the consume out and bind it later. In the alternate case 8277 // (when dealing with a retainable type), the result 8278 // initialization will create a produce. In both cases the 8279 // result will be +1, and we'll need to balance that out with 8280 // a bind. 8281 if (Expr *rebuiltLastStmt 8282 = maybeRebuildARCConsumingStmt(LastExpr.get())) { 8283 LastExpr = rebuiltLastStmt; 8284 } else { 8285 LastExpr = PerformCopyInitialization( 8286 InitializedEntity::InitializeResult(LPLoc, 8287 Ty, 8288 false), 8289 SourceLocation(), 8290 LastExpr); 8291 } 8292 8293 if (LastExpr.isInvalid()) 8294 return ExprError(); 8295 if (LastExpr.get() != 0) { 8296 if (!LastLabelStmt) 8297 Compound->setLastStmt(LastExpr.take()); 8298 else 8299 LastLabelStmt->setSubStmt(LastExpr.take()); 8300 StmtExprMayBindToTemp = true; 8301 } 8302 } 8303 } 8304 } 8305 8306 // FIXME: Check that expression type is complete/non-abstract; statement 8307 // expressions are not lvalues. 8308 Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc); 8309 if (StmtExprMayBindToTemp) 8310 return MaybeBindToTemporary(ResStmtExpr); 8311 return Owned(ResStmtExpr); 8312} 8313 8314ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, 8315 TypeSourceInfo *TInfo, 8316 OffsetOfComponent *CompPtr, 8317 unsigned NumComponents, 8318 SourceLocation RParenLoc) { 8319 QualType ArgTy = TInfo->getType(); 8320 bool Dependent = ArgTy->isDependentType(); 8321 SourceRange TypeRange = TInfo->getTypeLoc().getLocalSourceRange(); 8322 8323 // We must have at least one component that refers to the type, and the first 8324 // one is known to be a field designator. Verify that the ArgTy represents 8325 // a struct/union/class. 8326 if (!Dependent && !ArgTy->isRecordType()) 8327 return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type) 8328 << ArgTy << TypeRange); 8329 8330 // Type must be complete per C99 7.17p3 because a declaring a variable 8331 // with an incomplete type would be ill-formed. 8332 if (!Dependent 8333 && RequireCompleteType(BuiltinLoc, ArgTy, 8334 PDiag(diag::err_offsetof_incomplete_type) 8335 << TypeRange)) 8336 return ExprError(); 8337 8338 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a 8339 // GCC extension, diagnose them. 8340 // FIXME: This diagnostic isn't actually visible because the location is in 8341 // a system header! 8342 if (NumComponents != 1) 8343 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator) 8344 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd); 8345 8346 bool DidWarnAboutNonPOD = false; 8347 QualType CurrentType = ArgTy; 8348 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode; 8349 SmallVector<OffsetOfNode, 4> Comps; 8350 SmallVector<Expr*, 4> Exprs; 8351 for (unsigned i = 0; i != NumComponents; ++i) { 8352 const OffsetOfComponent &OC = CompPtr[i]; 8353 if (OC.isBrackets) { 8354 // Offset of an array sub-field. TODO: Should we allow vector elements? 8355 if (!CurrentType->isDependentType()) { 8356 const ArrayType *AT = Context.getAsArrayType(CurrentType); 8357 if(!AT) 8358 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type) 8359 << CurrentType); 8360 CurrentType = AT->getElementType(); 8361 } else 8362 CurrentType = Context.DependentTy; 8363 8364 // The expression must be an integral expression. 8365 // FIXME: An integral constant expression? 8366 Expr *Idx = static_cast<Expr*>(OC.U.E); 8367 if (!Idx->isTypeDependent() && !Idx->isValueDependent() && 8368 !Idx->getType()->isIntegerType()) 8369 return ExprError(Diag(Idx->getLocStart(), 8370 diag::err_typecheck_subscript_not_integer) 8371 << Idx->getSourceRange()); 8372 8373 // Record this array index. 8374 Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd)); 8375 Exprs.push_back(Idx); 8376 continue; 8377 } 8378 8379 // Offset of a field. 8380 if (CurrentType->isDependentType()) { 8381 // We have the offset of a field, but we can't look into the dependent 8382 // type. Just record the identifier of the field. 8383 Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd)); 8384 CurrentType = Context.DependentTy; 8385 continue; 8386 } 8387 8388 // We need to have a complete type to look into. 8389 if (RequireCompleteType(OC.LocStart, CurrentType, 8390 diag::err_offsetof_incomplete_type)) 8391 return ExprError(); 8392 8393 // Look for the designated field. 8394 const RecordType *RC = CurrentType->getAs<RecordType>(); 8395 if (!RC) 8396 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type) 8397 << CurrentType); 8398 RecordDecl *RD = RC->getDecl(); 8399 8400 // C++ [lib.support.types]p5: 8401 // The macro offsetof accepts a restricted set of type arguments in this 8402 // International Standard. type shall be a POD structure or a POD union 8403 // (clause 9). 8404 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) { 8405 if (!CRD->isPOD() && !DidWarnAboutNonPOD && 8406 DiagRuntimeBehavior(BuiltinLoc, 0, 8407 PDiag(diag::warn_offsetof_non_pod_type) 8408 << SourceRange(CompPtr[0].LocStart, OC.LocEnd) 8409 << CurrentType)) 8410 DidWarnAboutNonPOD = true; 8411 } 8412 8413 // Look for the field. 8414 LookupResult R(*this, OC.U.IdentInfo, OC.LocStart, LookupMemberName); 8415 LookupQualifiedName(R, RD); 8416 FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>(); 8417 IndirectFieldDecl *IndirectMemberDecl = 0; 8418 if (!MemberDecl) { 8419 if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>())) 8420 MemberDecl = IndirectMemberDecl->getAnonField(); 8421 } 8422 8423 if (!MemberDecl) 8424 return ExprError(Diag(BuiltinLoc, diag::err_no_member) 8425 << OC.U.IdentInfo << RD << SourceRange(OC.LocStart, 8426 OC.LocEnd)); 8427 8428 // C99 7.17p3: 8429 // (If the specified member is a bit-field, the behavior is undefined.) 8430 // 8431 // We diagnose this as an error. 8432 if (MemberDecl->getBitWidth()) { 8433 Diag(OC.LocEnd, diag::err_offsetof_bitfield) 8434 << MemberDecl->getDeclName() 8435 << SourceRange(BuiltinLoc, RParenLoc); 8436 Diag(MemberDecl->getLocation(), diag::note_bitfield_decl); 8437 return ExprError(); 8438 } 8439 8440 RecordDecl *Parent = MemberDecl->getParent(); 8441 if (IndirectMemberDecl) 8442 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext()); 8443 8444 // If the member was found in a base class, introduce OffsetOfNodes for 8445 // the base class indirections. 8446 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 8447 /*DetectVirtual=*/false); 8448 if (IsDerivedFrom(CurrentType, Context.getTypeDeclType(Parent), Paths)) { 8449 CXXBasePath &Path = Paths.front(); 8450 for (CXXBasePath::iterator B = Path.begin(), BEnd = Path.end(); 8451 B != BEnd; ++B) 8452 Comps.push_back(OffsetOfNode(B->Base)); 8453 } 8454 8455 if (IndirectMemberDecl) { 8456 for (IndirectFieldDecl::chain_iterator FI = 8457 IndirectMemberDecl->chain_begin(), 8458 FEnd = IndirectMemberDecl->chain_end(); FI != FEnd; FI++) { 8459 assert(isa<FieldDecl>(*FI)); 8460 Comps.push_back(OffsetOfNode(OC.LocStart, 8461 cast<FieldDecl>(*FI), OC.LocEnd)); 8462 } 8463 } else 8464 Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd)); 8465 8466 CurrentType = MemberDecl->getType().getNonReferenceType(); 8467 } 8468 8469 return Owned(OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc, 8470 TInfo, Comps.data(), Comps.size(), 8471 Exprs.data(), Exprs.size(), RParenLoc)); 8472} 8473 8474ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S, 8475 SourceLocation BuiltinLoc, 8476 SourceLocation TypeLoc, 8477 ParsedType argty, 8478 OffsetOfComponent *CompPtr, 8479 unsigned NumComponents, 8480 SourceLocation RPLoc) { 8481 8482 TypeSourceInfo *ArgTInfo; 8483 QualType ArgTy = GetTypeFromParser(argty, &ArgTInfo); 8484 if (ArgTy.isNull()) 8485 return ExprError(); 8486 8487 if (!ArgTInfo) 8488 ArgTInfo = Context.getTrivialTypeSourceInfo(ArgTy, TypeLoc); 8489 8490 return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, CompPtr, NumComponents, 8491 RPLoc); 8492} 8493 8494 8495ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, 8496 Expr *CondExpr, 8497 Expr *LHSExpr, Expr *RHSExpr, 8498 SourceLocation RPLoc) { 8499 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)"); 8500 8501 ExprValueKind VK = VK_RValue; 8502 ExprObjectKind OK = OK_Ordinary; 8503 QualType resType; 8504 bool ValueDependent = false; 8505 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) { 8506 resType = Context.DependentTy; 8507 ValueDependent = true; 8508 } else { 8509 // The conditional expression is required to be a constant expression. 8510 llvm::APSInt condEval(32); 8511 SourceLocation ExpLoc; 8512 if (!CondExpr->isIntegerConstantExpr(condEval, Context, &ExpLoc)) 8513 return ExprError(Diag(ExpLoc, 8514 diag::err_typecheck_choose_expr_requires_constant) 8515 << CondExpr->getSourceRange()); 8516 8517 // If the condition is > zero, then the AST type is the same as the LSHExpr. 8518 Expr *ActiveExpr = condEval.getZExtValue() ? LHSExpr : RHSExpr; 8519 8520 resType = ActiveExpr->getType(); 8521 ValueDependent = ActiveExpr->isValueDependent(); 8522 VK = ActiveExpr->getValueKind(); 8523 OK = ActiveExpr->getObjectKind(); 8524 } 8525 8526 return Owned(new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, 8527 resType, VK, OK, RPLoc, 8528 resType->isDependentType(), 8529 ValueDependent)); 8530} 8531 8532//===----------------------------------------------------------------------===// 8533// Clang Extensions. 8534//===----------------------------------------------------------------------===// 8535 8536/// ActOnBlockStart - This callback is invoked when a block literal is started. 8537void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *BlockScope) { 8538 BlockDecl *Block = BlockDecl::Create(Context, CurContext, CaretLoc); 8539 PushBlockScope(BlockScope, Block); 8540 CurContext->addDecl(Block); 8541 if (BlockScope) 8542 PushDeclContext(BlockScope, Block); 8543 else 8544 CurContext = Block; 8545} 8546 8547void Sema::ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope) { 8548 assert(ParamInfo.getIdentifier()==0 && "block-id should have no identifier!"); 8549 assert(ParamInfo.getContext() == Declarator::BlockLiteralContext); 8550 BlockScopeInfo *CurBlock = getCurBlock(); 8551 8552 TypeSourceInfo *Sig = GetTypeForDeclarator(ParamInfo, CurScope); 8553 QualType T = Sig->getType(); 8554 8555 // GetTypeForDeclarator always produces a function type for a block 8556 // literal signature. Furthermore, it is always a FunctionProtoType 8557 // unless the function was written with a typedef. 8558 assert(T->isFunctionType() && 8559 "GetTypeForDeclarator made a non-function block signature"); 8560 8561 // Look for an explicit signature in that function type. 8562 FunctionProtoTypeLoc ExplicitSignature; 8563 8564 TypeLoc tmp = Sig->getTypeLoc().IgnoreParens(); 8565 if (isa<FunctionProtoTypeLoc>(tmp)) { 8566 ExplicitSignature = cast<FunctionProtoTypeLoc>(tmp); 8567 8568 // Check whether that explicit signature was synthesized by 8569 // GetTypeForDeclarator. If so, don't save that as part of the 8570 // written signature. 8571 if (ExplicitSignature.getLocalRangeBegin() == 8572 ExplicitSignature.getLocalRangeEnd()) { 8573 // This would be much cheaper if we stored TypeLocs instead of 8574 // TypeSourceInfos. 8575 TypeLoc Result = ExplicitSignature.getResultLoc(); 8576 unsigned Size = Result.getFullDataSize(); 8577 Sig = Context.CreateTypeSourceInfo(Result.getType(), Size); 8578 Sig->getTypeLoc().initializeFullCopy(Result, Size); 8579 8580 ExplicitSignature = FunctionProtoTypeLoc(); 8581 } 8582 } 8583 8584 CurBlock->TheDecl->setSignatureAsWritten(Sig); 8585 CurBlock->FunctionType = T; 8586 8587 const FunctionType *Fn = T->getAs<FunctionType>(); 8588 QualType RetTy = Fn->getResultType(); 8589 bool isVariadic = 8590 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic()); 8591 8592 CurBlock->TheDecl->setIsVariadic(isVariadic); 8593 8594 // Don't allow returning a objc interface by value. 8595 if (RetTy->isObjCObjectType()) { 8596 Diag(ParamInfo.getSourceRange().getBegin(), 8597 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy; 8598 return; 8599 } 8600 8601 // Context.DependentTy is used as a placeholder for a missing block 8602 // return type. TODO: what should we do with declarators like: 8603 // ^ * { ... } 8604 // If the answer is "apply template argument deduction".... 8605 if (RetTy != Context.DependentTy) 8606 CurBlock->ReturnType = RetTy; 8607 8608 // Push block parameters from the declarator if we had them. 8609 SmallVector<ParmVarDecl*, 8> Params; 8610 if (ExplicitSignature) { 8611 for (unsigned I = 0, E = ExplicitSignature.getNumArgs(); I != E; ++I) { 8612 ParmVarDecl *Param = ExplicitSignature.getArg(I); 8613 if (Param->getIdentifier() == 0 && 8614 !Param->isImplicit() && 8615 !Param->isInvalidDecl() && 8616 !getLangOptions().CPlusPlus) 8617 Diag(Param->getLocation(), diag::err_parameter_name_omitted); 8618 Params.push_back(Param); 8619 } 8620 8621 // Fake up parameter variables if we have a typedef, like 8622 // ^ fntype { ... } 8623 } else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) { 8624 for (FunctionProtoType::arg_type_iterator 8625 I = Fn->arg_type_begin(), E = Fn->arg_type_end(); I != E; ++I) { 8626 ParmVarDecl *Param = 8627 BuildParmVarDeclForTypedef(CurBlock->TheDecl, 8628 ParamInfo.getSourceRange().getBegin(), 8629 *I); 8630 Params.push_back(Param); 8631 } 8632 } 8633 8634 // Set the parameters on the block decl. 8635 if (!Params.empty()) { 8636 CurBlock->TheDecl->setParams(Params.data(), Params.size()); 8637 CheckParmsForFunctionDef(CurBlock->TheDecl->param_begin(), 8638 CurBlock->TheDecl->param_end(), 8639 /*CheckParameterNames=*/false); 8640 } 8641 8642 // Finally we can process decl attributes. 8643 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo); 8644 8645 if (!isVariadic && CurBlock->TheDecl->getAttr<SentinelAttr>()) { 8646 Diag(ParamInfo.getAttributes()->getLoc(), 8647 diag::warn_attribute_sentinel_not_variadic) << 1; 8648 // FIXME: remove the attribute. 8649 } 8650 8651 // Put the parameter variables in scope. We can bail out immediately 8652 // if we don't have any. 8653 if (Params.empty()) 8654 return; 8655 8656 for (BlockDecl::param_iterator AI = CurBlock->TheDecl->param_begin(), 8657 E = CurBlock->TheDecl->param_end(); AI != E; ++AI) { 8658 (*AI)->setOwningFunction(CurBlock->TheDecl); 8659 8660 // If this has an identifier, add it to the scope stack. 8661 if ((*AI)->getIdentifier()) { 8662 CheckShadow(CurBlock->TheScope, *AI); 8663 8664 PushOnScopeChains(*AI, CurBlock->TheScope); 8665 } 8666 } 8667} 8668 8669/// ActOnBlockError - If there is an error parsing a block, this callback 8670/// is invoked to pop the information about the block from the action impl. 8671void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) { 8672 // Pop off CurBlock, handle nested blocks. 8673 PopDeclContext(); 8674 PopFunctionOrBlockScope(); 8675} 8676 8677/// ActOnBlockStmtExpr - This is called when the body of a block statement 8678/// literal was successfully completed. ^(int x){...} 8679ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, 8680 Stmt *Body, Scope *CurScope) { 8681 // If blocks are disabled, emit an error. 8682 if (!LangOpts.Blocks) 8683 Diag(CaretLoc, diag::err_blocks_disable); 8684 8685 BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back()); 8686 8687 PopDeclContext(); 8688 8689 QualType RetTy = Context.VoidTy; 8690 if (!BSI->ReturnType.isNull()) 8691 RetTy = BSI->ReturnType; 8692 8693 bool NoReturn = BSI->TheDecl->getAttr<NoReturnAttr>(); 8694 QualType BlockTy; 8695 8696 // Set the captured variables on the block. 8697 BSI->TheDecl->setCaptures(Context, BSI->Captures.begin(), BSI->Captures.end(), 8698 BSI->CapturesCXXThis); 8699 8700 // If the user wrote a function type in some form, try to use that. 8701 if (!BSI->FunctionType.isNull()) { 8702 const FunctionType *FTy = BSI->FunctionType->getAs<FunctionType>(); 8703 8704 FunctionType::ExtInfo Ext = FTy->getExtInfo(); 8705 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true); 8706 8707 // Turn protoless block types into nullary block types. 8708 if (isa<FunctionNoProtoType>(FTy)) { 8709 FunctionProtoType::ExtProtoInfo EPI; 8710 EPI.ExtInfo = Ext; 8711 BlockTy = Context.getFunctionType(RetTy, 0, 0, EPI); 8712 8713 // Otherwise, if we don't need to change anything about the function type, 8714 // preserve its sugar structure. 8715 } else if (FTy->getResultType() == RetTy && 8716 (!NoReturn || FTy->getNoReturnAttr())) { 8717 BlockTy = BSI->FunctionType; 8718 8719 // Otherwise, make the minimal modifications to the function type. 8720 } else { 8721 const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy); 8722 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 8723 EPI.TypeQuals = 0; // FIXME: silently? 8724 EPI.ExtInfo = Ext; 8725 BlockTy = Context.getFunctionType(RetTy, 8726 FPT->arg_type_begin(), 8727 FPT->getNumArgs(), 8728 EPI); 8729 } 8730 8731 // If we don't have a function type, just build one from nothing. 8732 } else { 8733 FunctionProtoType::ExtProtoInfo EPI; 8734 EPI.ExtInfo = FunctionType::ExtInfo().withNoReturn(NoReturn); 8735 BlockTy = Context.getFunctionType(RetTy, 0, 0, EPI); 8736 } 8737 8738 DiagnoseUnusedParameters(BSI->TheDecl->param_begin(), 8739 BSI->TheDecl->param_end()); 8740 BlockTy = Context.getBlockPointerType(BlockTy); 8741 8742 // If needed, diagnose invalid gotos and switches in the block. 8743 if (getCurFunction()->NeedsScopeChecking() && 8744 !hasAnyUnrecoverableErrorsInThisFunction()) 8745 DiagnoseInvalidJumps(cast<CompoundStmt>(Body)); 8746 8747 BSI->TheDecl->setBody(cast<CompoundStmt>(Body)); 8748 8749 for (BlockDecl::capture_const_iterator ci = BSI->TheDecl->capture_begin(), 8750 ce = BSI->TheDecl->capture_end(); ci != ce; ++ci) { 8751 const VarDecl *variable = ci->getVariable(); 8752 QualType T = variable->getType(); 8753 QualType::DestructionKind destructKind = T.isDestructedType(); 8754 if (destructKind != QualType::DK_none) 8755 getCurFunction()->setHasBranchProtectedScope(); 8756 } 8757 8758 computeNRVO(Body, getCurBlock()); 8759 8760 BlockExpr *Result = new (Context) BlockExpr(BSI->TheDecl, BlockTy); 8761 const AnalysisBasedWarnings::Policy &WP = AnalysisWarnings.getDefaultPolicy(); 8762 PopFunctionOrBlockScope(&WP, Result->getBlockDecl(), Result); 8763 8764 return Owned(Result); 8765} 8766 8767ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc, 8768 Expr *expr, ParsedType type, 8769 SourceLocation RPLoc) { 8770 TypeSourceInfo *TInfo; 8771 GetTypeFromParser(type, &TInfo); 8772 return BuildVAArgExpr(BuiltinLoc, expr, TInfo, RPLoc); 8773} 8774 8775ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, 8776 Expr *E, TypeSourceInfo *TInfo, 8777 SourceLocation RPLoc) { 8778 Expr *OrigExpr = E; 8779 8780 // Get the va_list type 8781 QualType VaListType = Context.getBuiltinVaListType(); 8782 if (VaListType->isArrayType()) { 8783 // Deal with implicit array decay; for example, on x86-64, 8784 // va_list is an array, but it's supposed to decay to 8785 // a pointer for va_arg. 8786 VaListType = Context.getArrayDecayedType(VaListType); 8787 // Make sure the input expression also decays appropriately. 8788 ExprResult Result = UsualUnaryConversions(E); 8789 if (Result.isInvalid()) 8790 return ExprError(); 8791 E = Result.take(); 8792 } else { 8793 // Otherwise, the va_list argument must be an l-value because 8794 // it is modified by va_arg. 8795 if (!E->isTypeDependent() && 8796 CheckForModifiableLvalue(E, BuiltinLoc, *this)) 8797 return ExprError(); 8798 } 8799 8800 if (!E->isTypeDependent() && 8801 !Context.hasSameType(VaListType, E->getType())) { 8802 return ExprError(Diag(E->getLocStart(), 8803 diag::err_first_argument_to_va_arg_not_of_type_va_list) 8804 << OrigExpr->getType() << E->getSourceRange()); 8805 } 8806 8807 if (!TInfo->getType()->isDependentType()) { 8808 if (RequireCompleteType(TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(), 8809 PDiag(diag::err_second_parameter_to_va_arg_incomplete) 8810 << TInfo->getTypeLoc().getSourceRange())) 8811 return ExprError(); 8812 8813 if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(), 8814 TInfo->getType(), 8815 PDiag(diag::err_second_parameter_to_va_arg_abstract) 8816 << TInfo->getTypeLoc().getSourceRange())) 8817 return ExprError(); 8818 8819 if (!TInfo->getType().isPODType(Context)) { 8820 Diag(TInfo->getTypeLoc().getBeginLoc(), 8821 TInfo->getType()->isObjCLifetimeType() 8822 ? diag::warn_second_parameter_to_va_arg_ownership_qualified 8823 : diag::warn_second_parameter_to_va_arg_not_pod) 8824 << TInfo->getType() 8825 << TInfo->getTypeLoc().getSourceRange(); 8826 } 8827 8828 // Check for va_arg where arguments of the given type will be promoted 8829 // (i.e. this va_arg is guaranteed to have undefined behavior). 8830 QualType PromoteType; 8831 if (TInfo->getType()->isPromotableIntegerType()) { 8832 PromoteType = Context.getPromotedIntegerType(TInfo->getType()); 8833 if (Context.typesAreCompatible(PromoteType, TInfo->getType())) 8834 PromoteType = QualType(); 8835 } 8836 if (TInfo->getType()->isSpecificBuiltinType(BuiltinType::Float)) 8837 PromoteType = Context.DoubleTy; 8838 if (!PromoteType.isNull()) 8839 Diag(TInfo->getTypeLoc().getBeginLoc(), 8840 diag::warn_second_parameter_to_va_arg_never_compatible) 8841 << TInfo->getType() 8842 << PromoteType 8843 << TInfo->getTypeLoc().getSourceRange(); 8844 } 8845 8846 QualType T = TInfo->getType().getNonLValueExprType(Context); 8847 return Owned(new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T)); 8848} 8849 8850ExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) { 8851 // The type of __null will be int or long, depending on the size of 8852 // pointers on the target. 8853 QualType Ty; 8854 unsigned pw = Context.getTargetInfo().getPointerWidth(0); 8855 if (pw == Context.getTargetInfo().getIntWidth()) 8856 Ty = Context.IntTy; 8857 else if (pw == Context.getTargetInfo().getLongWidth()) 8858 Ty = Context.LongTy; 8859 else if (pw == Context.getTargetInfo().getLongLongWidth()) 8860 Ty = Context.LongLongTy; 8861 else { 8862 assert(!"I don't know size of pointer!"); 8863 Ty = Context.IntTy; 8864 } 8865 8866 return Owned(new (Context) GNUNullExpr(Ty, TokenLoc)); 8867} 8868 8869static void MakeObjCStringLiteralFixItHint(Sema& SemaRef, QualType DstType, 8870 Expr *SrcExpr, FixItHint &Hint) { 8871 if (!SemaRef.getLangOptions().ObjC1) 8872 return; 8873 8874 const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>(); 8875 if (!PT) 8876 return; 8877 8878 // Check if the destination is of type 'id'. 8879 if (!PT->isObjCIdType()) { 8880 // Check if the destination is the 'NSString' interface. 8881 const ObjCInterfaceDecl *ID = PT->getInterfaceDecl(); 8882 if (!ID || !ID->getIdentifier()->isStr("NSString")) 8883 return; 8884 } 8885 8886 // Strip off any parens and casts. 8887 StringLiteral *SL = dyn_cast<StringLiteral>(SrcExpr->IgnoreParenCasts()); 8888 if (!SL || !SL->isAscii()) 8889 return; 8890 8891 Hint = FixItHint::CreateInsertion(SL->getLocStart(), "@"); 8892} 8893 8894bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy, 8895 SourceLocation Loc, 8896 QualType DstType, QualType SrcType, 8897 Expr *SrcExpr, AssignmentAction Action, 8898 bool *Complained) { 8899 if (Complained) 8900 *Complained = false; 8901 8902 // Decode the result (notice that AST's are still created for extensions). 8903 bool CheckInferredResultType = false; 8904 bool isInvalid = false; 8905 unsigned DiagKind; 8906 FixItHint Hint; 8907 ConversionFixItGenerator ConvHints; 8908 bool MayHaveConvFixit = false; 8909 8910 switch (ConvTy) { 8911 default: assert(0 && "Unknown conversion type"); 8912 case Compatible: return false; 8913 case PointerToInt: 8914 DiagKind = diag::ext_typecheck_convert_pointer_int; 8915 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 8916 MayHaveConvFixit = true; 8917 break; 8918 case IntToPointer: 8919 DiagKind = diag::ext_typecheck_convert_int_pointer; 8920 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 8921 MayHaveConvFixit = true; 8922 break; 8923 case IncompatiblePointer: 8924 MakeObjCStringLiteralFixItHint(*this, DstType, SrcExpr, Hint); 8925 DiagKind = diag::ext_typecheck_convert_incompatible_pointer; 8926 CheckInferredResultType = DstType->isObjCObjectPointerType() && 8927 SrcType->isObjCObjectPointerType(); 8928 if (Hint.isNull() && !CheckInferredResultType) { 8929 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 8930 } 8931 MayHaveConvFixit = true; 8932 break; 8933 case IncompatiblePointerSign: 8934 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign; 8935 break; 8936 case FunctionVoidPointer: 8937 DiagKind = diag::ext_typecheck_convert_pointer_void_func; 8938 break; 8939 case IncompatiblePointerDiscardsQualifiers: { 8940 // Perform array-to-pointer decay if necessary. 8941 if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType); 8942 8943 Qualifiers lhq = SrcType->getPointeeType().getQualifiers(); 8944 Qualifiers rhq = DstType->getPointeeType().getQualifiers(); 8945 if (lhq.getAddressSpace() != rhq.getAddressSpace()) { 8946 DiagKind = diag::err_typecheck_incompatible_address_space; 8947 break; 8948 8949 8950 } else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) { 8951 DiagKind = diag::err_typecheck_incompatible_ownership; 8952 break; 8953 } 8954 8955 llvm_unreachable("unknown error case for discarding qualifiers!"); 8956 // fallthrough 8957 } 8958 case CompatiblePointerDiscardsQualifiers: 8959 // If the qualifiers lost were because we were applying the 8960 // (deprecated) C++ conversion from a string literal to a char* 8961 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME: 8962 // Ideally, this check would be performed in 8963 // checkPointerTypesForAssignment. However, that would require a 8964 // bit of refactoring (so that the second argument is an 8965 // expression, rather than a type), which should be done as part 8966 // of a larger effort to fix checkPointerTypesForAssignment for 8967 // C++ semantics. 8968 if (getLangOptions().CPlusPlus && 8969 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType)) 8970 return false; 8971 DiagKind = diag::ext_typecheck_convert_discards_qualifiers; 8972 break; 8973 case IncompatibleNestedPointerQualifiers: 8974 DiagKind = diag::ext_nested_pointer_qualifier_mismatch; 8975 break; 8976 case IntToBlockPointer: 8977 DiagKind = diag::err_int_to_block_pointer; 8978 break; 8979 case IncompatibleBlockPointer: 8980 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer; 8981 break; 8982 case IncompatibleObjCQualifiedId: 8983 // FIXME: Diagnose the problem in ObjCQualifiedIdTypesAreCompatible, since 8984 // it can give a more specific diagnostic. 8985 DiagKind = diag::warn_incompatible_qualified_id; 8986 break; 8987 case IncompatibleVectors: 8988 DiagKind = diag::warn_incompatible_vectors; 8989 break; 8990 case IncompatibleObjCWeakRef: 8991 DiagKind = diag::err_arc_weak_unavailable_assign; 8992 break; 8993 case Incompatible: 8994 DiagKind = diag::err_typecheck_convert_incompatible; 8995 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 8996 MayHaveConvFixit = true; 8997 isInvalid = true; 8998 break; 8999 } 9000 9001 QualType FirstType, SecondType; 9002 switch (Action) { 9003 case AA_Assigning: 9004 case AA_Initializing: 9005 // The destination type comes first. 9006 FirstType = DstType; 9007 SecondType = SrcType; 9008 break; 9009 9010 case AA_Returning: 9011 case AA_Passing: 9012 case AA_Converting: 9013 case AA_Sending: 9014 case AA_Casting: 9015 // The source type comes first. 9016 FirstType = SrcType; 9017 SecondType = DstType; 9018 break; 9019 } 9020 9021 PartialDiagnostic FDiag = PDiag(DiagKind); 9022 FDiag << FirstType << SecondType << Action << SrcExpr->getSourceRange(); 9023 9024 // If we can fix the conversion, suggest the FixIts. 9025 assert(ConvHints.isNull() || Hint.isNull()); 9026 if (!ConvHints.isNull()) { 9027 for (llvm::SmallVector<FixItHint, 1>::iterator 9028 HI = ConvHints.Hints.begin(), HE = ConvHints.Hints.end(); 9029 HI != HE; ++HI) 9030 FDiag << *HI; 9031 } else { 9032 FDiag << Hint; 9033 } 9034 if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); } 9035 9036 Diag(Loc, FDiag); 9037 9038 if (CheckInferredResultType) 9039 EmitRelatedResultTypeNote(SrcExpr); 9040 9041 if (Complained) 9042 *Complained = true; 9043 return isInvalid; 9044} 9045 9046bool Sema::VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result){ 9047 llvm::APSInt ICEResult; 9048 if (E->isIntegerConstantExpr(ICEResult, Context)) { 9049 if (Result) 9050 *Result = ICEResult; 9051 return false; 9052 } 9053 9054 Expr::EvalResult EvalResult; 9055 9056 if (!E->Evaluate(EvalResult, Context) || !EvalResult.Val.isInt() || 9057 EvalResult.HasSideEffects) { 9058 Diag(E->getExprLoc(), diag::err_expr_not_ice) << E->getSourceRange(); 9059 9060 if (EvalResult.Diag) { 9061 // We only show the note if it's not the usual "invalid subexpression" 9062 // or if it's actually in a subexpression. 9063 if (EvalResult.Diag != diag::note_invalid_subexpr_in_ice || 9064 E->IgnoreParens() != EvalResult.DiagExpr->IgnoreParens()) 9065 Diag(EvalResult.DiagLoc, EvalResult.Diag); 9066 } 9067 9068 return true; 9069 } 9070 9071 Diag(E->getExprLoc(), diag::ext_expr_not_ice) << 9072 E->getSourceRange(); 9073 9074 if (EvalResult.Diag && 9075 Diags.getDiagnosticLevel(diag::ext_expr_not_ice, EvalResult.DiagLoc) 9076 != Diagnostic::Ignored) 9077 Diag(EvalResult.DiagLoc, EvalResult.Diag); 9078 9079 if (Result) 9080 *Result = EvalResult.Val.getInt(); 9081 return false; 9082} 9083 9084void 9085Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext) { 9086 ExprEvalContexts.push_back( 9087 ExpressionEvaluationContextRecord(NewContext, 9088 ExprTemporaries.size(), 9089 ExprNeedsCleanups)); 9090 ExprNeedsCleanups = false; 9091} 9092 9093void Sema::PopExpressionEvaluationContext() { 9094 // Pop the current expression evaluation context off the stack. 9095 ExpressionEvaluationContextRecord Rec = ExprEvalContexts.back(); 9096 ExprEvalContexts.pop_back(); 9097 9098 if (Rec.Context == PotentiallyPotentiallyEvaluated) { 9099 if (Rec.PotentiallyReferenced) { 9100 // Mark any remaining declarations in the current position of the stack 9101 // as "referenced". If they were not meant to be referenced, semantic 9102 // analysis would have eliminated them (e.g., in ActOnCXXTypeId). 9103 for (PotentiallyReferencedDecls::iterator 9104 I = Rec.PotentiallyReferenced->begin(), 9105 IEnd = Rec.PotentiallyReferenced->end(); 9106 I != IEnd; ++I) 9107 MarkDeclarationReferenced(I->first, I->second); 9108 } 9109 9110 if (Rec.PotentiallyDiagnosed) { 9111 // Emit any pending diagnostics. 9112 for (PotentiallyEmittedDiagnostics::iterator 9113 I = Rec.PotentiallyDiagnosed->begin(), 9114 IEnd = Rec.PotentiallyDiagnosed->end(); 9115 I != IEnd; ++I) 9116 Diag(I->first, I->second); 9117 } 9118 } 9119 9120 // When are coming out of an unevaluated context, clear out any 9121 // temporaries that we may have created as part of the evaluation of 9122 // the expression in that context: they aren't relevant because they 9123 // will never be constructed. 9124 if (Rec.Context == Unevaluated) { 9125 ExprTemporaries.erase(ExprTemporaries.begin() + Rec.NumTemporaries, 9126 ExprTemporaries.end()); 9127 ExprNeedsCleanups = Rec.ParentNeedsCleanups; 9128 9129 // Otherwise, merge the contexts together. 9130 } else { 9131 ExprNeedsCleanups |= Rec.ParentNeedsCleanups; 9132 } 9133 9134 // Destroy the popped expression evaluation record. 9135 Rec.Destroy(); 9136} 9137 9138void Sema::DiscardCleanupsInEvaluationContext() { 9139 ExprTemporaries.erase( 9140 ExprTemporaries.begin() + ExprEvalContexts.back().NumTemporaries, 9141 ExprTemporaries.end()); 9142 ExprNeedsCleanups = false; 9143} 9144 9145/// \brief Note that the given declaration was referenced in the source code. 9146/// 9147/// This routine should be invoke whenever a given declaration is referenced 9148/// in the source code, and where that reference occurred. If this declaration 9149/// reference means that the the declaration is used (C++ [basic.def.odr]p2, 9150/// C99 6.9p3), then the declaration will be marked as used. 9151/// 9152/// \param Loc the location where the declaration was referenced. 9153/// 9154/// \param D the declaration that has been referenced by the source code. 9155void Sema::MarkDeclarationReferenced(SourceLocation Loc, Decl *D) { 9156 assert(D && "No declaration?"); 9157 9158 D->setReferenced(); 9159 9160 if (D->isUsed(false)) 9161 return; 9162 9163 // Mark a parameter or variable declaration "used", regardless of whether 9164 // we're in a template or not. The reason for this is that unevaluated 9165 // expressions (e.g. (void)sizeof()) constitute a use for warning purposes 9166 // (-Wunused-variables and -Wunused-parameters) 9167 if (isa<ParmVarDecl>(D) || 9168 (isa<VarDecl>(D) && D->getDeclContext()->isFunctionOrMethod())) { 9169 D->setUsed(); 9170 return; 9171 } 9172 9173 if (!isa<VarDecl>(D) && !isa<FunctionDecl>(D)) 9174 return; 9175 9176 // Do not mark anything as "used" within a dependent context; wait for 9177 // an instantiation. 9178 if (CurContext->isDependentContext()) 9179 return; 9180 9181 switch (ExprEvalContexts.back().Context) { 9182 case Unevaluated: 9183 // We are in an expression that is not potentially evaluated; do nothing. 9184 return; 9185 9186 case PotentiallyEvaluated: 9187 // We are in a potentially-evaluated expression, so this declaration is 9188 // "used"; handle this below. 9189 break; 9190 9191 case PotentiallyPotentiallyEvaluated: 9192 // We are in an expression that may be potentially evaluated; queue this 9193 // declaration reference until we know whether the expression is 9194 // potentially evaluated. 9195 ExprEvalContexts.back().addReferencedDecl(Loc, D); 9196 return; 9197 9198 case PotentiallyEvaluatedIfUsed: 9199 // Referenced declarations will only be used if the construct in the 9200 // containing expression is used. 9201 return; 9202 } 9203 9204 // Note that this declaration has been used. 9205 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) { 9206 if (Constructor->isDefaulted()) { 9207 if (Constructor->isDefaultConstructor()) { 9208 if (Constructor->isTrivial()) 9209 return; 9210 if (!Constructor->isUsed(false)) 9211 DefineImplicitDefaultConstructor(Loc, Constructor); 9212 } else if (Constructor->isCopyConstructor()) { 9213 if (!Constructor->isUsed(false)) 9214 DefineImplicitCopyConstructor(Loc, Constructor); 9215 } else if (Constructor->isMoveConstructor()) { 9216 if (!Constructor->isUsed(false)) 9217 DefineImplicitMoveConstructor(Loc, Constructor); 9218 } 9219 } 9220 9221 MarkVTableUsed(Loc, Constructor->getParent()); 9222 } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) { 9223 if (Destructor->isDefaulted() && !Destructor->isUsed(false)) 9224 DefineImplicitDestructor(Loc, Destructor); 9225 if (Destructor->isVirtual()) 9226 MarkVTableUsed(Loc, Destructor->getParent()); 9227 } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D)) { 9228 if (MethodDecl->isDefaulted() && MethodDecl->isOverloadedOperator() && 9229 MethodDecl->getOverloadedOperator() == OO_Equal) { 9230 if (!MethodDecl->isUsed(false)) { 9231 if (MethodDecl->isCopyAssignmentOperator()) 9232 DefineImplicitCopyAssignment(Loc, MethodDecl); 9233 else 9234 DefineImplicitMoveAssignment(Loc, MethodDecl); 9235 } 9236 } else if (MethodDecl->isVirtual()) 9237 MarkVTableUsed(Loc, MethodDecl->getParent()); 9238 } 9239 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 9240 // Recursive functions should be marked when used from another function. 9241 if (CurContext == Function) return; 9242 9243 // Implicit instantiation of function templates and member functions of 9244 // class templates. 9245 if (Function->isImplicitlyInstantiable()) { 9246 bool AlreadyInstantiated = false; 9247 if (FunctionTemplateSpecializationInfo *SpecInfo 9248 = Function->getTemplateSpecializationInfo()) { 9249 if (SpecInfo->getPointOfInstantiation().isInvalid()) 9250 SpecInfo->setPointOfInstantiation(Loc); 9251 else if (SpecInfo->getTemplateSpecializationKind() 9252 == TSK_ImplicitInstantiation) 9253 AlreadyInstantiated = true; 9254 } else if (MemberSpecializationInfo *MSInfo 9255 = Function->getMemberSpecializationInfo()) { 9256 if (MSInfo->getPointOfInstantiation().isInvalid()) 9257 MSInfo->setPointOfInstantiation(Loc); 9258 else if (MSInfo->getTemplateSpecializationKind() 9259 == TSK_ImplicitInstantiation) 9260 AlreadyInstantiated = true; 9261 } 9262 9263 if (!AlreadyInstantiated) { 9264 if (isa<CXXRecordDecl>(Function->getDeclContext()) && 9265 cast<CXXRecordDecl>(Function->getDeclContext())->isLocalClass()) 9266 PendingLocalImplicitInstantiations.push_back(std::make_pair(Function, 9267 Loc)); 9268 else 9269 PendingInstantiations.push_back(std::make_pair(Function, Loc)); 9270 } 9271 } else { 9272 // Walk redefinitions, as some of them may be instantiable. 9273 for (FunctionDecl::redecl_iterator i(Function->redecls_begin()), 9274 e(Function->redecls_end()); i != e; ++i) { 9275 if (!i->isUsed(false) && i->isImplicitlyInstantiable()) 9276 MarkDeclarationReferenced(Loc, *i); 9277 } 9278 } 9279 9280 // Keep track of used but undefined functions. 9281 if (!Function->isPure() && !Function->hasBody() && 9282 Function->getLinkage() != ExternalLinkage) { 9283 SourceLocation &old = UndefinedInternals[Function->getCanonicalDecl()]; 9284 if (old.isInvalid()) old = Loc; 9285 } 9286 9287 Function->setUsed(true); 9288 return; 9289 } 9290 9291 if (VarDecl *Var = dyn_cast<VarDecl>(D)) { 9292 // Implicit instantiation of static data members of class templates. 9293 if (Var->isStaticDataMember() && 9294 Var->getInstantiatedFromStaticDataMember()) { 9295 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo(); 9296 assert(MSInfo && "Missing member specialization information?"); 9297 if (MSInfo->getPointOfInstantiation().isInvalid() && 9298 MSInfo->getTemplateSpecializationKind()== TSK_ImplicitInstantiation) { 9299 MSInfo->setPointOfInstantiation(Loc); 9300 // This is a modification of an existing AST node. Notify listeners. 9301 if (ASTMutationListener *L = getASTMutationListener()) 9302 L->StaticDataMemberInstantiated(Var); 9303 PendingInstantiations.push_back(std::make_pair(Var, Loc)); 9304 } 9305 } 9306 9307 // Keep track of used but undefined variables. We make a hole in 9308 // the warning for static const data members with in-line 9309 // initializers. 9310 if (Var->hasDefinition() == VarDecl::DeclarationOnly 9311 && Var->getLinkage() != ExternalLinkage 9312 && !(Var->isStaticDataMember() && Var->hasInit())) { 9313 SourceLocation &old = UndefinedInternals[Var->getCanonicalDecl()]; 9314 if (old.isInvalid()) old = Loc; 9315 } 9316 9317 D->setUsed(true); 9318 return; 9319 } 9320} 9321 9322namespace { 9323 // Mark all of the declarations referenced 9324 // FIXME: Not fully implemented yet! We need to have a better understanding 9325 // of when we're entering 9326 class MarkReferencedDecls : public RecursiveASTVisitor<MarkReferencedDecls> { 9327 Sema &S; 9328 SourceLocation Loc; 9329 9330 public: 9331 typedef RecursiveASTVisitor<MarkReferencedDecls> Inherited; 9332 9333 MarkReferencedDecls(Sema &S, SourceLocation Loc) : S(S), Loc(Loc) { } 9334 9335 bool TraverseTemplateArgument(const TemplateArgument &Arg); 9336 bool TraverseRecordType(RecordType *T); 9337 }; 9338} 9339 9340bool MarkReferencedDecls::TraverseTemplateArgument( 9341 const TemplateArgument &Arg) { 9342 if (Arg.getKind() == TemplateArgument::Declaration) { 9343 S.MarkDeclarationReferenced(Loc, Arg.getAsDecl()); 9344 } 9345 9346 return Inherited::TraverseTemplateArgument(Arg); 9347} 9348 9349bool MarkReferencedDecls::TraverseRecordType(RecordType *T) { 9350 if (ClassTemplateSpecializationDecl *Spec 9351 = dyn_cast<ClassTemplateSpecializationDecl>(T->getDecl())) { 9352 const TemplateArgumentList &Args = Spec->getTemplateArgs(); 9353 return TraverseTemplateArguments(Args.data(), Args.size()); 9354 } 9355 9356 return true; 9357} 9358 9359void Sema::MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T) { 9360 MarkReferencedDecls Marker(*this, Loc); 9361 Marker.TraverseType(Context.getCanonicalType(T)); 9362} 9363 9364namespace { 9365 /// \brief Helper class that marks all of the declarations referenced by 9366 /// potentially-evaluated subexpressions as "referenced". 9367 class EvaluatedExprMarker : public EvaluatedExprVisitor<EvaluatedExprMarker> { 9368 Sema &S; 9369 9370 public: 9371 typedef EvaluatedExprVisitor<EvaluatedExprMarker> Inherited; 9372 9373 explicit EvaluatedExprMarker(Sema &S) : Inherited(S.Context), S(S) { } 9374 9375 void VisitDeclRefExpr(DeclRefExpr *E) { 9376 S.MarkDeclarationReferenced(E->getLocation(), E->getDecl()); 9377 } 9378 9379 void VisitMemberExpr(MemberExpr *E) { 9380 S.MarkDeclarationReferenced(E->getMemberLoc(), E->getMemberDecl()); 9381 Inherited::VisitMemberExpr(E); 9382 } 9383 9384 void VisitCXXNewExpr(CXXNewExpr *E) { 9385 if (E->getConstructor()) 9386 S.MarkDeclarationReferenced(E->getLocStart(), E->getConstructor()); 9387 if (E->getOperatorNew()) 9388 S.MarkDeclarationReferenced(E->getLocStart(), E->getOperatorNew()); 9389 if (E->getOperatorDelete()) 9390 S.MarkDeclarationReferenced(E->getLocStart(), E->getOperatorDelete()); 9391 Inherited::VisitCXXNewExpr(E); 9392 } 9393 9394 void VisitCXXDeleteExpr(CXXDeleteExpr *E) { 9395 if (E->getOperatorDelete()) 9396 S.MarkDeclarationReferenced(E->getLocStart(), E->getOperatorDelete()); 9397 QualType Destroyed = S.Context.getBaseElementType(E->getDestroyedType()); 9398 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) { 9399 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl()); 9400 S.MarkDeclarationReferenced(E->getLocStart(), 9401 S.LookupDestructor(Record)); 9402 } 9403 9404 Inherited::VisitCXXDeleteExpr(E); 9405 } 9406 9407 void VisitCXXConstructExpr(CXXConstructExpr *E) { 9408 S.MarkDeclarationReferenced(E->getLocStart(), E->getConstructor()); 9409 Inherited::VisitCXXConstructExpr(E); 9410 } 9411 9412 void VisitBlockDeclRefExpr(BlockDeclRefExpr *E) { 9413 S.MarkDeclarationReferenced(E->getLocation(), E->getDecl()); 9414 } 9415 9416 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 9417 Visit(E->getExpr()); 9418 } 9419 }; 9420} 9421 9422/// \brief Mark any declarations that appear within this expression or any 9423/// potentially-evaluated subexpressions as "referenced". 9424void Sema::MarkDeclarationsReferencedInExpr(Expr *E) { 9425 EvaluatedExprMarker(*this).Visit(E); 9426} 9427 9428/// \brief Emit a diagnostic that describes an effect on the run-time behavior 9429/// of the program being compiled. 9430/// 9431/// This routine emits the given diagnostic when the code currently being 9432/// type-checked is "potentially evaluated", meaning that there is a 9433/// possibility that the code will actually be executable. Code in sizeof() 9434/// expressions, code used only during overload resolution, etc., are not 9435/// potentially evaluated. This routine will suppress such diagnostics or, 9436/// in the absolutely nutty case of potentially potentially evaluated 9437/// expressions (C++ typeid), queue the diagnostic to potentially emit it 9438/// later. 9439/// 9440/// This routine should be used for all diagnostics that describe the run-time 9441/// behavior of a program, such as passing a non-POD value through an ellipsis. 9442/// Failure to do so will likely result in spurious diagnostics or failures 9443/// during overload resolution or within sizeof/alignof/typeof/typeid. 9444bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *stmt, 9445 const PartialDiagnostic &PD) { 9446 switch (ExprEvalContexts.back().Context) { 9447 case Unevaluated: 9448 // The argument will never be evaluated, so don't complain. 9449 break; 9450 9451 case PotentiallyEvaluated: 9452 case PotentiallyEvaluatedIfUsed: 9453 if (stmt && getCurFunctionOrMethodDecl()) { 9454 FunctionScopes.back()->PossiblyUnreachableDiags. 9455 push_back(sema::PossiblyUnreachableDiag(PD, Loc, stmt)); 9456 } 9457 else 9458 Diag(Loc, PD); 9459 9460 return true; 9461 9462 case PotentiallyPotentiallyEvaluated: 9463 ExprEvalContexts.back().addDiagnostic(Loc, PD); 9464 break; 9465 } 9466 9467 return false; 9468} 9469 9470bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc, 9471 CallExpr *CE, FunctionDecl *FD) { 9472 if (ReturnType->isVoidType() || !ReturnType->isIncompleteType()) 9473 return false; 9474 9475 PartialDiagnostic Note = 9476 FD ? PDiag(diag::note_function_with_incomplete_return_type_declared_here) 9477 << FD->getDeclName() : PDiag(); 9478 SourceLocation NoteLoc = FD ? FD->getLocation() : SourceLocation(); 9479 9480 if (RequireCompleteType(Loc, ReturnType, 9481 FD ? 9482 PDiag(diag::err_call_function_incomplete_return) 9483 << CE->getSourceRange() << FD->getDeclName() : 9484 PDiag(diag::err_call_incomplete_return) 9485 << CE->getSourceRange(), 9486 std::make_pair(NoteLoc, Note))) 9487 return true; 9488 9489 return false; 9490} 9491 9492// Diagnose the s/=/==/ and s/\|=/!=/ typos. Note that adding parentheses 9493// will prevent this condition from triggering, which is what we want. 9494void Sema::DiagnoseAssignmentAsCondition(Expr *E) { 9495 SourceLocation Loc; 9496 9497 unsigned diagnostic = diag::warn_condition_is_assignment; 9498 bool IsOrAssign = false; 9499 9500 if (BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) { 9501 if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign) 9502 return; 9503 9504 IsOrAssign = Op->getOpcode() == BO_OrAssign; 9505 9506 // Greylist some idioms by putting them into a warning subcategory. 9507 if (ObjCMessageExpr *ME 9508 = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) { 9509 Selector Sel = ME->getSelector(); 9510 9511 // self = [<foo> init...] 9512 if (isSelfExpr(Op->getLHS()) && Sel.getNameForSlot(0).startswith("init")) 9513 diagnostic = diag::warn_condition_is_idiomatic_assignment; 9514 9515 // <foo> = [<bar> nextObject] 9516 else if (Sel.isUnarySelector() && Sel.getNameForSlot(0) == "nextObject") 9517 diagnostic = diag::warn_condition_is_idiomatic_assignment; 9518 } 9519 9520 Loc = Op->getOperatorLoc(); 9521 } else if (CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) { 9522 if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual) 9523 return; 9524 9525 IsOrAssign = Op->getOperator() == OO_PipeEqual; 9526 Loc = Op->getOperatorLoc(); 9527 } else { 9528 // Not an assignment. 9529 return; 9530 } 9531 9532 Diag(Loc, diagnostic) << E->getSourceRange(); 9533 9534 SourceLocation Open = E->getSourceRange().getBegin(); 9535 SourceLocation Close = PP.getLocForEndOfToken(E->getSourceRange().getEnd()); 9536 Diag(Loc, diag::note_condition_assign_silence) 9537 << FixItHint::CreateInsertion(Open, "(") 9538 << FixItHint::CreateInsertion(Close, ")"); 9539 9540 if (IsOrAssign) 9541 Diag(Loc, diag::note_condition_or_assign_to_comparison) 9542 << FixItHint::CreateReplacement(Loc, "!="); 9543 else 9544 Diag(Loc, diag::note_condition_assign_to_comparison) 9545 << FixItHint::CreateReplacement(Loc, "=="); 9546} 9547 9548/// \brief Redundant parentheses over an equality comparison can indicate 9549/// that the user intended an assignment used as condition. 9550void Sema::DiagnoseEqualityWithExtraParens(ParenExpr *parenE) { 9551 // Don't warn if the parens came from a macro. 9552 SourceLocation parenLoc = parenE->getLocStart(); 9553 if (parenLoc.isInvalid() || parenLoc.isMacroID()) 9554 return; 9555 // Don't warn for dependent expressions. 9556 if (parenE->isTypeDependent()) 9557 return; 9558 9559 Expr *E = parenE->IgnoreParens(); 9560 9561 if (BinaryOperator *opE = dyn_cast<BinaryOperator>(E)) 9562 if (opE->getOpcode() == BO_EQ && 9563 opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context) 9564 == Expr::MLV_Valid) { 9565 SourceLocation Loc = opE->getOperatorLoc(); 9566 9567 Diag(Loc, diag::warn_equality_with_extra_parens) << E->getSourceRange(); 9568 Diag(Loc, diag::note_equality_comparison_silence) 9569 << FixItHint::CreateRemoval(parenE->getSourceRange().getBegin()) 9570 << FixItHint::CreateRemoval(parenE->getSourceRange().getEnd()); 9571 Diag(Loc, diag::note_equality_comparison_to_assign) 9572 << FixItHint::CreateReplacement(Loc, "="); 9573 } 9574} 9575 9576ExprResult Sema::CheckBooleanCondition(Expr *E, SourceLocation Loc) { 9577 DiagnoseAssignmentAsCondition(E); 9578 if (ParenExpr *parenE = dyn_cast<ParenExpr>(E)) 9579 DiagnoseEqualityWithExtraParens(parenE); 9580 9581 ExprResult result = CheckPlaceholderExpr(E); 9582 if (result.isInvalid()) return ExprError(); 9583 E = result.take(); 9584 9585 if (!E->isTypeDependent()) { 9586 if (getLangOptions().CPlusPlus) 9587 return CheckCXXBooleanCondition(E); // C++ 6.4p4 9588 9589 ExprResult ERes = DefaultFunctionArrayLvalueConversion(E); 9590 if (ERes.isInvalid()) 9591 return ExprError(); 9592 E = ERes.take(); 9593 9594 QualType T = E->getType(); 9595 if (!T->isScalarType()) { // C99 6.8.4.1p1 9596 Diag(Loc, diag::err_typecheck_statement_requires_scalar) 9597 << T << E->getSourceRange(); 9598 return ExprError(); 9599 } 9600 } 9601 9602 return Owned(E); 9603} 9604 9605ExprResult Sema::ActOnBooleanCondition(Scope *S, SourceLocation Loc, 9606 Expr *Sub) { 9607 if (!Sub) 9608 return ExprError(); 9609 9610 return CheckBooleanCondition(Sub, Loc); 9611} 9612 9613namespace { 9614 /// A visitor for rebuilding a call to an __unknown_any expression 9615 /// to have an appropriate type. 9616 struct RebuildUnknownAnyFunction 9617 : StmtVisitor<RebuildUnknownAnyFunction, ExprResult> { 9618 9619 Sema &S; 9620 9621 RebuildUnknownAnyFunction(Sema &S) : S(S) {} 9622 9623 ExprResult VisitStmt(Stmt *S) { 9624 llvm_unreachable("unexpected statement!"); 9625 return ExprError(); 9626 } 9627 9628 ExprResult VisitExpr(Expr *expr) { 9629 S.Diag(expr->getExprLoc(), diag::err_unsupported_unknown_any_call) 9630 << expr->getSourceRange(); 9631 return ExprError(); 9632 } 9633 9634 /// Rebuild an expression which simply semantically wraps another 9635 /// expression which it shares the type and value kind of. 9636 template <class T> ExprResult rebuildSugarExpr(T *expr) { 9637 ExprResult subResult = Visit(expr->getSubExpr()); 9638 if (subResult.isInvalid()) return ExprError(); 9639 9640 Expr *subExpr = subResult.take(); 9641 expr->setSubExpr(subExpr); 9642 expr->setType(subExpr->getType()); 9643 expr->setValueKind(subExpr->getValueKind()); 9644 assert(expr->getObjectKind() == OK_Ordinary); 9645 return expr; 9646 } 9647 9648 ExprResult VisitParenExpr(ParenExpr *paren) { 9649 return rebuildSugarExpr(paren); 9650 } 9651 9652 ExprResult VisitUnaryExtension(UnaryOperator *op) { 9653 return rebuildSugarExpr(op); 9654 } 9655 9656 ExprResult VisitUnaryAddrOf(UnaryOperator *op) { 9657 ExprResult subResult = Visit(op->getSubExpr()); 9658 if (subResult.isInvalid()) return ExprError(); 9659 9660 Expr *subExpr = subResult.take(); 9661 op->setSubExpr(subExpr); 9662 op->setType(S.Context.getPointerType(subExpr->getType())); 9663 assert(op->getValueKind() == VK_RValue); 9664 assert(op->getObjectKind() == OK_Ordinary); 9665 return op; 9666 } 9667 9668 ExprResult resolveDecl(Expr *expr, ValueDecl *decl) { 9669 if (!isa<FunctionDecl>(decl)) return VisitExpr(expr); 9670 9671 expr->setType(decl->getType()); 9672 9673 assert(expr->getValueKind() == VK_RValue); 9674 if (S.getLangOptions().CPlusPlus && 9675 !(isa<CXXMethodDecl>(decl) && 9676 cast<CXXMethodDecl>(decl)->isInstance())) 9677 expr->setValueKind(VK_LValue); 9678 9679 return expr; 9680 } 9681 9682 ExprResult VisitMemberExpr(MemberExpr *mem) { 9683 return resolveDecl(mem, mem->getMemberDecl()); 9684 } 9685 9686 ExprResult VisitDeclRefExpr(DeclRefExpr *ref) { 9687 return resolveDecl(ref, ref->getDecl()); 9688 } 9689 }; 9690} 9691 9692/// Given a function expression of unknown-any type, try to rebuild it 9693/// to have a function type. 9694static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn) { 9695 ExprResult result = RebuildUnknownAnyFunction(S).Visit(fn); 9696 if (result.isInvalid()) return ExprError(); 9697 return S.DefaultFunctionArrayConversion(result.take()); 9698} 9699 9700namespace { 9701 /// A visitor for rebuilding an expression of type __unknown_anytype 9702 /// into one which resolves the type directly on the referring 9703 /// expression. Strict preservation of the original source 9704 /// structure is not a goal. 9705 struct RebuildUnknownAnyExpr 9706 : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> { 9707 9708 Sema &S; 9709 9710 /// The current destination type. 9711 QualType DestType; 9712 9713 RebuildUnknownAnyExpr(Sema &S, QualType castType) 9714 : S(S), DestType(castType) {} 9715 9716 ExprResult VisitStmt(Stmt *S) { 9717 llvm_unreachable("unexpected statement!"); 9718 return ExprError(); 9719 } 9720 9721 ExprResult VisitExpr(Expr *expr) { 9722 S.Diag(expr->getExprLoc(), diag::err_unsupported_unknown_any_expr) 9723 << expr->getSourceRange(); 9724 return ExprError(); 9725 } 9726 9727 ExprResult VisitCallExpr(CallExpr *call); 9728 ExprResult VisitObjCMessageExpr(ObjCMessageExpr *message); 9729 9730 /// Rebuild an expression which simply semantically wraps another 9731 /// expression which it shares the type and value kind of. 9732 template <class T> ExprResult rebuildSugarExpr(T *expr) { 9733 ExprResult subResult = Visit(expr->getSubExpr()); 9734 if (subResult.isInvalid()) return ExprError(); 9735 Expr *subExpr = subResult.take(); 9736 expr->setSubExpr(subExpr); 9737 expr->setType(subExpr->getType()); 9738 expr->setValueKind(subExpr->getValueKind()); 9739 assert(expr->getObjectKind() == OK_Ordinary); 9740 return expr; 9741 } 9742 9743 ExprResult VisitParenExpr(ParenExpr *paren) { 9744 return rebuildSugarExpr(paren); 9745 } 9746 9747 ExprResult VisitUnaryExtension(UnaryOperator *op) { 9748 return rebuildSugarExpr(op); 9749 } 9750 9751 ExprResult VisitUnaryAddrOf(UnaryOperator *op) { 9752 const PointerType *ptr = DestType->getAs<PointerType>(); 9753 if (!ptr) { 9754 S.Diag(op->getOperatorLoc(), diag::err_unknown_any_addrof) 9755 << op->getSourceRange(); 9756 return ExprError(); 9757 } 9758 assert(op->getValueKind() == VK_RValue); 9759 assert(op->getObjectKind() == OK_Ordinary); 9760 op->setType(DestType); 9761 9762 // Build the sub-expression as if it were an object of the pointee type. 9763 DestType = ptr->getPointeeType(); 9764 ExprResult subResult = Visit(op->getSubExpr()); 9765 if (subResult.isInvalid()) return ExprError(); 9766 op->setSubExpr(subResult.take()); 9767 return op; 9768 } 9769 9770 ExprResult VisitImplicitCastExpr(ImplicitCastExpr *ice); 9771 9772 ExprResult resolveDecl(Expr *expr, ValueDecl *decl); 9773 9774 ExprResult VisitMemberExpr(MemberExpr *mem) { 9775 return resolveDecl(mem, mem->getMemberDecl()); 9776 } 9777 9778 ExprResult VisitDeclRefExpr(DeclRefExpr *ref) { 9779 return resolveDecl(ref, ref->getDecl()); 9780 } 9781 }; 9782} 9783 9784/// Rebuilds a call expression which yielded __unknown_anytype. 9785ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *call) { 9786 Expr *callee = call->getCallee(); 9787 9788 enum FnKind { 9789 FK_MemberFunction, 9790 FK_FunctionPointer, 9791 FK_BlockPointer 9792 }; 9793 9794 FnKind kind; 9795 QualType type = callee->getType(); 9796 if (type == S.Context.BoundMemberTy) { 9797 assert(isa<CXXMemberCallExpr>(call) || isa<CXXOperatorCallExpr>(call)); 9798 kind = FK_MemberFunction; 9799 type = Expr::findBoundMemberType(callee); 9800 } else if (const PointerType *ptr = type->getAs<PointerType>()) { 9801 type = ptr->getPointeeType(); 9802 kind = FK_FunctionPointer; 9803 } else { 9804 type = type->castAs<BlockPointerType>()->getPointeeType(); 9805 kind = FK_BlockPointer; 9806 } 9807 const FunctionType *fnType = type->castAs<FunctionType>(); 9808 9809 // Verify that this is a legal result type of a function. 9810 if (DestType->isArrayType() || DestType->isFunctionType()) { 9811 unsigned diagID = diag::err_func_returning_array_function; 9812 if (kind == FK_BlockPointer) 9813 diagID = diag::err_block_returning_array_function; 9814 9815 S.Diag(call->getExprLoc(), diagID) 9816 << DestType->isFunctionType() << DestType; 9817 return ExprError(); 9818 } 9819 9820 // Otherwise, go ahead and set DestType as the call's result. 9821 call->setType(DestType.getNonLValueExprType(S.Context)); 9822 call->setValueKind(Expr::getValueKindForType(DestType)); 9823 assert(call->getObjectKind() == OK_Ordinary); 9824 9825 // Rebuild the function type, replacing the result type with DestType. 9826 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) 9827 DestType = S.Context.getFunctionType(DestType, 9828 proto->arg_type_begin(), 9829 proto->getNumArgs(), 9830 proto->getExtProtoInfo()); 9831 else 9832 DestType = S.Context.getFunctionNoProtoType(DestType, 9833 fnType->getExtInfo()); 9834 9835 // Rebuild the appropriate pointer-to-function type. 9836 switch (kind) { 9837 case FK_MemberFunction: 9838 // Nothing to do. 9839 break; 9840 9841 case FK_FunctionPointer: 9842 DestType = S.Context.getPointerType(DestType); 9843 break; 9844 9845 case FK_BlockPointer: 9846 DestType = S.Context.getBlockPointerType(DestType); 9847 break; 9848 } 9849 9850 // Finally, we can recurse. 9851 ExprResult calleeResult = Visit(callee); 9852 if (!calleeResult.isUsable()) return ExprError(); 9853 call->setCallee(calleeResult.take()); 9854 9855 // Bind a temporary if necessary. 9856 return S.MaybeBindToTemporary(call); 9857} 9858 9859ExprResult RebuildUnknownAnyExpr::VisitObjCMessageExpr(ObjCMessageExpr *msg) { 9860 // Verify that this is a legal result type of a call. 9861 if (DestType->isArrayType() || DestType->isFunctionType()) { 9862 S.Diag(msg->getExprLoc(), diag::err_func_returning_array_function) 9863 << DestType->isFunctionType() << DestType; 9864 return ExprError(); 9865 } 9866 9867 // Rewrite the method result type if available. 9868 if (ObjCMethodDecl *method = msg->getMethodDecl()) { 9869 assert(method->getResultType() == S.Context.UnknownAnyTy); 9870 method->setResultType(DestType); 9871 } 9872 9873 // Change the type of the message. 9874 msg->setType(DestType.getNonReferenceType()); 9875 msg->setValueKind(Expr::getValueKindForType(DestType)); 9876 9877 return S.MaybeBindToTemporary(msg); 9878} 9879 9880ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *ice) { 9881 // The only case we should ever see here is a function-to-pointer decay. 9882 assert(ice->getCastKind() == CK_FunctionToPointerDecay); 9883 assert(ice->getValueKind() == VK_RValue); 9884 assert(ice->getObjectKind() == OK_Ordinary); 9885 9886 ice->setType(DestType); 9887 9888 // Rebuild the sub-expression as the pointee (function) type. 9889 DestType = DestType->castAs<PointerType>()->getPointeeType(); 9890 9891 ExprResult result = Visit(ice->getSubExpr()); 9892 if (!result.isUsable()) return ExprError(); 9893 9894 ice->setSubExpr(result.take()); 9895 return S.Owned(ice); 9896} 9897 9898ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *expr, ValueDecl *decl) { 9899 ExprValueKind valueKind = VK_LValue; 9900 QualType type = DestType; 9901 9902 // We know how to make this work for certain kinds of decls: 9903 9904 // - functions 9905 if (FunctionDecl *fn = dyn_cast<FunctionDecl>(decl)) { 9906 if (const PointerType *ptr = type->getAs<PointerType>()) { 9907 DestType = ptr->getPointeeType(); 9908 ExprResult result = resolveDecl(expr, decl); 9909 if (result.isInvalid()) return ExprError(); 9910 return S.ImpCastExprToType(result.take(), type, 9911 CK_FunctionToPointerDecay, VK_RValue); 9912 } 9913 9914 if (!type->isFunctionType()) { 9915 S.Diag(expr->getExprLoc(), diag::err_unknown_any_function) 9916 << decl << expr->getSourceRange(); 9917 return ExprError(); 9918 } 9919 9920 if (CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(fn)) 9921 if (method->isInstance()) { 9922 valueKind = VK_RValue; 9923 type = S.Context.BoundMemberTy; 9924 } 9925 9926 // Function references aren't l-values in C. 9927 if (!S.getLangOptions().CPlusPlus) 9928 valueKind = VK_RValue; 9929 9930 // - variables 9931 } else if (isa<VarDecl>(decl)) { 9932 if (const ReferenceType *refTy = type->getAs<ReferenceType>()) { 9933 type = refTy->getPointeeType(); 9934 } else if (type->isFunctionType()) { 9935 S.Diag(expr->getExprLoc(), diag::err_unknown_any_var_function_type) 9936 << decl << expr->getSourceRange(); 9937 return ExprError(); 9938 } 9939 9940 // - nothing else 9941 } else { 9942 S.Diag(expr->getExprLoc(), diag::err_unsupported_unknown_any_decl) 9943 << decl << expr->getSourceRange(); 9944 return ExprError(); 9945 } 9946 9947 decl->setType(DestType); 9948 expr->setType(type); 9949 expr->setValueKind(valueKind); 9950 return S.Owned(expr); 9951} 9952 9953/// Check a cast of an unknown-any type. We intentionally only 9954/// trigger this for C-style casts. 9955ExprResult Sema::checkUnknownAnyCast(SourceRange typeRange, QualType castType, 9956 Expr *castExpr, CastKind &castKind, 9957 ExprValueKind &VK, CXXCastPath &path) { 9958 // Rewrite the casted expression from scratch. 9959 ExprResult result = RebuildUnknownAnyExpr(*this, castType).Visit(castExpr); 9960 if (!result.isUsable()) return ExprError(); 9961 9962 castExpr = result.take(); 9963 VK = castExpr->getValueKind(); 9964 castKind = CK_NoOp; 9965 9966 return castExpr; 9967} 9968 9969static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *e) { 9970 Expr *orig = e; 9971 unsigned diagID = diag::err_uncasted_use_of_unknown_any; 9972 while (true) { 9973 e = e->IgnoreParenImpCasts(); 9974 if (CallExpr *call = dyn_cast<CallExpr>(e)) { 9975 e = call->getCallee(); 9976 diagID = diag::err_uncasted_call_of_unknown_any; 9977 } else { 9978 break; 9979 } 9980 } 9981 9982 SourceLocation loc; 9983 NamedDecl *d; 9984 if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e)) { 9985 loc = ref->getLocation(); 9986 d = ref->getDecl(); 9987 } else if (MemberExpr *mem = dyn_cast<MemberExpr>(e)) { 9988 loc = mem->getMemberLoc(); 9989 d = mem->getMemberDecl(); 9990 } else if (ObjCMessageExpr *msg = dyn_cast<ObjCMessageExpr>(e)) { 9991 diagID = diag::err_uncasted_call_of_unknown_any; 9992 loc = msg->getSelectorLoc(); 9993 d = msg->getMethodDecl(); 9994 if (!d) { 9995 S.Diag(loc, diag::err_uncasted_send_to_unknown_any_method) 9996 << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector() 9997 << orig->getSourceRange(); 9998 return ExprError(); 9999 } 10000 } else { 10001 S.Diag(e->getExprLoc(), diag::err_unsupported_unknown_any_expr) 10002 << e->getSourceRange(); 10003 return ExprError(); 10004 } 10005 10006 S.Diag(loc, diagID) << d << orig->getSourceRange(); 10007 10008 // Never recoverable. 10009 return ExprError(); 10010} 10011 10012/// Check for operands with placeholder types and complain if found. 10013/// Returns true if there was an error and no recovery was possible. 10014ExprResult Sema::CheckPlaceholderExpr(Expr *E) { 10015 // Placeholder types are always *exactly* the appropriate builtin type. 10016 QualType type = E->getType(); 10017 10018 // Overloaded expressions. 10019 if (type == Context.OverloadTy) 10020 return ResolveAndFixSingleFunctionTemplateSpecialization(E, false, true, 10021 E->getSourceRange(), 10022 QualType(), 10023 diag::err_ovl_unresolvable); 10024 10025 // Bound member functions. 10026 if (type == Context.BoundMemberTy) { 10027 Diag(E->getLocStart(), diag::err_invalid_use_of_bound_member_func) 10028 << E->getSourceRange(); 10029 return ExprError(); 10030 } 10031 10032 // Expressions of unknown type. 10033 if (type == Context.UnknownAnyTy) 10034 return diagnoseUnknownAnyExpr(*this, E); 10035 10036 assert(!type->isPlaceholderType()); 10037 return Owned(E); 10038} 10039 10040bool Sema::CheckCaseExpression(Expr *expr) { 10041 if (expr->isTypeDependent()) 10042 return true; 10043 if (expr->isValueDependent() || expr->isIntegerConstantExpr(Context)) 10044 return expr->getType()->isIntegralOrEnumerationType(); 10045 return false; 10046} 10047