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/DelayedDiagnostic.h" 16 #include "clang/Sema/Initialization.h" 17 #include "clang/Sema/Lookup.h" 18 #include "clang/Sema/ScopeInfo.h" 19 #include "clang/Sema/AnalysisBasedWarnings.h" 20 #include "clang/AST/ASTContext.h" 21 #include "clang/AST/ASTConsumer.h" 22 #include "clang/AST/ASTMutationListener.h" 23 #include "clang/AST/CXXInheritance.h" 24 #include "clang/AST/DeclObjC.h" 25 #include "clang/AST/DeclTemplate.h" 26 #include "clang/AST/EvaluatedExprVisitor.h" 27 #include "clang/AST/Expr.h" 28 #include "clang/AST/ExprCXX.h" 29 #include "clang/AST/ExprObjC.h" 30 #include "clang/AST/RecursiveASTVisitor.h" 31 #include "clang/AST/TypeLoc.h" 32 #include "clang/Basic/PartialDiagnostic.h" 33 #include "clang/Basic/SourceManager.h" 34 #include "clang/Basic/TargetInfo.h" 35 #include "clang/Lex/LiteralSupport.h" 36 #include "clang/Lex/Preprocessor.h" 37 #include "clang/Sema/DeclSpec.h" 38 #include "clang/Sema/Designator.h" 39 #include "clang/Sema/Scope.h" 40 #include "clang/Sema/ScopeInfo.h" 41 #include "clang/Sema/ParsedTemplate.h" 42 #include "clang/Sema/SemaFixItUtils.h" 43 #include "clang/Sema/Template.h" 44 #include "TreeTransform.h" 45 using namespace clang; 46 using namespace sema; 47 48 /// \brief Determine whether the use of this declaration is valid, without 49 /// emitting diagnostics. 50 bool Sema::CanUseDecl(NamedDecl *D) { 51 // See if this is an auto-typed variable whose initializer we are parsing. 52 if (ParsingInitForAutoVars.count(D)) 53 return false; 54 55 // See if this is a deleted function. 56 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 57 if (FD->isDeleted()) 58 return false; 59 } 60 61 // See if this function is unavailable. 62 if (D->getAvailability() == AR_Unavailable && 63 cast<Decl>(CurContext)->getAvailability() != AR_Unavailable) 64 return false; 65 66 return true; 67 } 68 69 static AvailabilityResult DiagnoseAvailabilityOfDecl(Sema &S, 70 NamedDecl *D, SourceLocation Loc, 71 const ObjCInterfaceDecl *UnknownObjCClass) { 72 // See if this declaration is unavailable or deprecated. 73 std::string Message; 74 AvailabilityResult Result = D->getAvailability(&Message); 75 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) 76 if (Result == AR_Available) { 77 const DeclContext *DC = ECD->getDeclContext(); 78 if (const EnumDecl *TheEnumDecl = dyn_cast<EnumDecl>(DC)) 79 Result = TheEnumDecl->getAvailability(&Message); 80 } 81 82 switch (Result) { 83 case AR_Available: 84 case AR_NotYetIntroduced: 85 break; 86 87 case AR_Deprecated: 88 S.EmitDeprecationWarning(D, Message, Loc, UnknownObjCClass); 89 break; 90 91 case AR_Unavailable: 92 if (S.getCurContextAvailability() != AR_Unavailable) { 93 if (Message.empty()) { 94 if (!UnknownObjCClass) 95 S.Diag(Loc, diag::err_unavailable) << D->getDeclName(); 96 else 97 S.Diag(Loc, diag::warn_unavailable_fwdclass_message) 98 << D->getDeclName(); 99 } 100 else 101 S.Diag(Loc, diag::err_unavailable_message) 102 << D->getDeclName() << Message; 103 S.Diag(D->getLocation(), diag::note_unavailable_here) 104 << isa<FunctionDecl>(D) << false; 105 } 106 break; 107 } 108 return Result; 109 } 110 111 /// \brief Emit a note explaining that this function is deleted or unavailable. 112 void Sema::NoteDeletedFunction(FunctionDecl *Decl) { 113 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Decl); 114 115 if (Method && Method->isDeleted() && !Method->isDeletedAsWritten()) { 116 // If the method was explicitly defaulted, point at that declaration. 117 if (!Method->isImplicit()) 118 Diag(Decl->getLocation(), diag::note_implicitly_deleted); 119 120 // Try to diagnose why this special member function was implicitly 121 // deleted. This might fail, if that reason no longer applies. 122 CXXSpecialMember CSM = getSpecialMember(Method); 123 if (CSM != CXXInvalid) 124 ShouldDeleteSpecialMember(Method, CSM, /*Diagnose=*/true); 125 126 return; 127 } 128 129 Diag(Decl->getLocation(), diag::note_unavailable_here) 130 << 1 << Decl->isDeleted(); 131 } 132 133 /// \brief Determine whether the use of this declaration is valid, and 134 /// emit any corresponding diagnostics. 135 /// 136 /// This routine diagnoses various problems with referencing 137 /// declarations that can occur when using a declaration. For example, 138 /// it might warn if a deprecated or unavailable declaration is being 139 /// used, or produce an error (and return true) if a C++0x deleted 140 /// function is being used. 141 /// 142 /// \returns true if there was an error (this declaration cannot be 143 /// referenced), false otherwise. 144 /// 145 bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, 146 const ObjCInterfaceDecl *UnknownObjCClass) { 147 if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) { 148 // If there were any diagnostics suppressed by template argument deduction, 149 // emit them now. 150 llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >::iterator 151 Pos = SuppressedDiagnostics.find(D->getCanonicalDecl()); 152 if (Pos != SuppressedDiagnostics.end()) { 153 SmallVectorImpl<PartialDiagnosticAt> &Suppressed = Pos->second; 154 for (unsigned I = 0, N = Suppressed.size(); I != N; ++I) 155 Diag(Suppressed[I].first, Suppressed[I].second); 156 157 // Clear out the list of suppressed diagnostics, so that we don't emit 158 // them again for this specialization. However, we don't obsolete this 159 // entry from the table, because we want to avoid ever emitting these 160 // diagnostics again. 161 Suppressed.clear(); 162 } 163 } 164 165 // See if this is an auto-typed variable whose initializer we are parsing. 166 if (ParsingInitForAutoVars.count(D)) { 167 Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer) 168 << D->getDeclName(); 169 return true; 170 } 171 172 // See if this is a deleted function. 173 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 174 if (FD->isDeleted()) { 175 Diag(Loc, diag::err_deleted_function_use); 176 NoteDeletedFunction(FD); 177 return true; 178 } 179 } 180 DiagnoseAvailabilityOfDecl(*this, D, Loc, UnknownObjCClass); 181 182 // Warn if this is used but marked unused. 183 if (D->hasAttr<UnusedAttr>()) 184 Diag(Loc, diag::warn_used_but_marked_unused) << D->getDeclName(); 185 return false; 186 } 187 188 /// \brief Retrieve the message suffix that should be added to a 189 /// diagnostic complaining about the given function being deleted or 190 /// unavailable. 191 std::string Sema::getDeletedOrUnavailableSuffix(const FunctionDecl *FD) { 192 // FIXME: C++0x implicitly-deleted special member functions could be 193 // detected here so that we could improve diagnostics to say, e.g., 194 // "base class 'A' had a deleted copy constructor". 195 if (FD->isDeleted()) 196 return std::string(); 197 198 std::string Message; 199 if (FD->getAvailability(&Message)) 200 return ": " + Message; 201 202 return std::string(); 203 } 204 205 /// DiagnoseSentinelCalls - This routine checks whether a call or 206 /// message-send is to a declaration with the sentinel attribute, and 207 /// if so, it checks that the requirements of the sentinel are 208 /// satisfied. 209 void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, 210 Expr **args, unsigned numArgs) { 211 const SentinelAttr *attr = D->getAttr<SentinelAttr>(); 212 if (!attr) 213 return; 214 215 // The number of formal parameters of the declaration. 216 unsigned numFormalParams; 217 218 // The kind of declaration. This is also an index into a %select in 219 // the diagnostic. 220 enum CalleeType { CT_Function, CT_Method, CT_Block } calleeType; 221 222 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 223 numFormalParams = MD->param_size(); 224 calleeType = CT_Method; 225 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 226 numFormalParams = FD->param_size(); 227 calleeType = CT_Function; 228 } else if (isa<VarDecl>(D)) { 229 QualType type = cast<ValueDecl>(D)->getType(); 230 const FunctionType *fn = 0; 231 if (const PointerType *ptr = type->getAs<PointerType>()) { 232 fn = ptr->getPointeeType()->getAs<FunctionType>(); 233 if (!fn) return; 234 calleeType = CT_Function; 235 } else if (const BlockPointerType *ptr = type->getAs<BlockPointerType>()) { 236 fn = ptr->getPointeeType()->castAs<FunctionType>(); 237 calleeType = CT_Block; 238 } else { 239 return; 240 } 241 242 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fn)) { 243 numFormalParams = proto->getNumArgs(); 244 } else { 245 numFormalParams = 0; 246 } 247 } else { 248 return; 249 } 250 251 // "nullPos" is the number of formal parameters at the end which 252 // effectively count as part of the variadic arguments. This is 253 // useful if you would prefer to not have *any* formal parameters, 254 // but the language forces you to have at least one. 255 unsigned nullPos = attr->getNullPos(); 256 assert((nullPos == 0 || nullPos == 1) && "invalid null position on sentinel"); 257 numFormalParams = (nullPos > numFormalParams ? 0 : numFormalParams - nullPos); 258 259 // The number of arguments which should follow the sentinel. 260 unsigned numArgsAfterSentinel = attr->getSentinel(); 261 262 // If there aren't enough arguments for all the formal parameters, 263 // the sentinel, and the args after the sentinel, complain. 264 if (numArgs < numFormalParams + numArgsAfterSentinel + 1) { 265 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName(); 266 Diag(D->getLocation(), diag::note_sentinel_here) << calleeType; 267 return; 268 } 269 270 // Otherwise, find the sentinel expression. 271 Expr *sentinelExpr = args[numArgs - numArgsAfterSentinel - 1]; 272 if (!sentinelExpr) return; 273 if (sentinelExpr->isValueDependent()) return; 274 if (Context.isSentinelNullExpr(sentinelExpr)) return; 275 276 // Pick a reasonable string to insert. Optimistically use 'nil' or 277 // 'NULL' if those are actually defined in the context. Only use 278 // 'nil' for ObjC methods, where it's much more likely that the 279 // variadic arguments form a list of object pointers. 280 SourceLocation MissingNilLoc 281 = PP.getLocForEndOfToken(sentinelExpr->getLocEnd()); 282 std::string NullValue; 283 if (calleeType == CT_Method && 284 PP.getIdentifierInfo("nil")->hasMacroDefinition()) 285 NullValue = "nil"; 286 else if (PP.getIdentifierInfo("NULL")->hasMacroDefinition()) 287 NullValue = "NULL"; 288 else 289 NullValue = "(void*) 0"; 290 291 if (MissingNilLoc.isInvalid()) 292 Diag(Loc, diag::warn_missing_sentinel) << calleeType; 293 else 294 Diag(MissingNilLoc, diag::warn_missing_sentinel) 295 << calleeType 296 << FixItHint::CreateInsertion(MissingNilLoc, ", " + NullValue); 297 Diag(D->getLocation(), diag::note_sentinel_here) << calleeType; 298 } 299 300 SourceRange Sema::getExprRange(Expr *E) const { 301 return E ? E->getSourceRange() : SourceRange(); 302 } 303 304 //===----------------------------------------------------------------------===// 305 // Standard Promotions and Conversions 306 //===----------------------------------------------------------------------===// 307 308 /// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4). 309 ExprResult Sema::DefaultFunctionArrayConversion(Expr *E) { 310 // Handle any placeholder expressions which made it here. 311 if (E->getType()->isPlaceholderType()) { 312 ExprResult result = CheckPlaceholderExpr(E); 313 if (result.isInvalid()) return ExprError(); 314 E = result.take(); 315 } 316 317 QualType Ty = E->getType(); 318 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type"); 319 320 if (Ty->isFunctionType()) 321 E = ImpCastExprToType(E, Context.getPointerType(Ty), 322 CK_FunctionToPointerDecay).take(); 323 else if (Ty->isArrayType()) { 324 // In C90 mode, arrays only promote to pointers if the array expression is 325 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has 326 // type 'array of type' is converted to an expression that has type 'pointer 327 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression 328 // that has type 'array of type' ...". The relevant change is "an lvalue" 329 // (C90) to "an expression" (C99). 330 // 331 // C++ 4.2p1: 332 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of 333 // T" can be converted to an rvalue of type "pointer to T". 334 // 335 if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue()) 336 E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty), 337 CK_ArrayToPointerDecay).take(); 338 } 339 return Owned(E); 340 } 341 342 static void CheckForNullPointerDereference(Sema &S, Expr *E) { 343 // Check to see if we are dereferencing a null pointer. If so, 344 // and if not volatile-qualified, this is undefined behavior that the 345 // optimizer will delete, so warn about it. People sometimes try to use this 346 // to get a deterministic trap and are surprised by clang's behavior. This 347 // only handles the pattern "*null", which is a very syntactic check. 348 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts())) 349 if (UO->getOpcode() == UO_Deref && 350 UO->getSubExpr()->IgnoreParenCasts()-> 351 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) && 352 !UO->getType().isVolatileQualified()) { 353 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 354 S.PDiag(diag::warn_indirection_through_null) 355 << UO->getSubExpr()->getSourceRange()); 356 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 357 S.PDiag(diag::note_indirection_through_null)); 358 } 359 } 360 361 ExprResult Sema::DefaultLvalueConversion(Expr *E) { 362 // Handle any placeholder expressions which made it here. 363 if (E->getType()->isPlaceholderType()) { 364 ExprResult result = CheckPlaceholderExpr(E); 365 if (result.isInvalid()) return ExprError(); 366 E = result.take(); 367 } 368 369 // C++ [conv.lval]p1: 370 // A glvalue of a non-function, non-array type T can be 371 // converted to a prvalue. 372 if (!E->isGLValue()) return Owned(E); 373 374 QualType T = E->getType(); 375 assert(!T.isNull() && "r-value conversion on typeless expression?"); 376 377 // We don't want to throw lvalue-to-rvalue casts on top of 378 // expressions of certain types in C++. 379 if (getLangOpts().CPlusPlus && 380 (E->getType() == Context.OverloadTy || 381 T->isDependentType() || 382 T->isRecordType())) 383 return Owned(E); 384 385 // The C standard is actually really unclear on this point, and 386 // DR106 tells us what the result should be but not why. It's 387 // generally best to say that void types just doesn't undergo 388 // lvalue-to-rvalue at all. Note that expressions of unqualified 389 // 'void' type are never l-values, but qualified void can be. 390 if (T->isVoidType()) 391 return Owned(E); 392 393 CheckForNullPointerDereference(*this, E); 394 395 // C++ [conv.lval]p1: 396 // [...] If T is a non-class type, the type of the prvalue is the 397 // cv-unqualified version of T. Otherwise, the type of the 398 // rvalue is T. 399 // 400 // C99 6.3.2.1p2: 401 // If the lvalue has qualified type, the value has the unqualified 402 // version of the type of the lvalue; otherwise, the value has the 403 // type of the lvalue. 404 if (T.hasQualifiers()) 405 T = T.getUnqualifiedType(); 406 407 UpdateMarkingForLValueToRValue(E); 408 409 ExprResult Res = Owned(ImplicitCastExpr::Create(Context, T, CK_LValueToRValue, 410 E, 0, VK_RValue)); 411 412 // C11 6.3.2.1p2: 413 // ... if the lvalue has atomic type, the value has the non-atomic version 414 // of the type of the lvalue ... 415 if (const AtomicType *Atomic = T->getAs<AtomicType>()) { 416 T = Atomic->getValueType().getUnqualifiedType(); 417 Res = Owned(ImplicitCastExpr::Create(Context, T, CK_AtomicToNonAtomic, 418 Res.get(), 0, VK_RValue)); 419 } 420 421 return Res; 422 } 423 424 ExprResult Sema::DefaultFunctionArrayLvalueConversion(Expr *E) { 425 ExprResult Res = DefaultFunctionArrayConversion(E); 426 if (Res.isInvalid()) 427 return ExprError(); 428 Res = DefaultLvalueConversion(Res.take()); 429 if (Res.isInvalid()) 430 return ExprError(); 431 return move(Res); 432 } 433 434 435 /// UsualUnaryConversions - Performs various conversions that are common to most 436 /// operators (C99 6.3). The conversions of array and function types are 437 /// sometimes suppressed. For example, the array->pointer conversion doesn't 438 /// apply if the array is an argument to the sizeof or address (&) operators. 439 /// In these instances, this routine should *not* be called. 440 ExprResult Sema::UsualUnaryConversions(Expr *E) { 441 // First, convert to an r-value. 442 ExprResult Res = DefaultFunctionArrayLvalueConversion(E); 443 if (Res.isInvalid()) 444 return Owned(E); 445 E = Res.take(); 446 447 QualType Ty = E->getType(); 448 assert(!Ty.isNull() && "UsualUnaryConversions - missing type"); 449 450 // Half FP is a bit different: it's a storage-only type, meaning that any 451 // "use" of it should be promoted to float. 452 if (Ty->isHalfType()) 453 return ImpCastExprToType(Res.take(), Context.FloatTy, CK_FloatingCast); 454 455 // Try to perform integral promotions if the object has a theoretically 456 // promotable type. 457 if (Ty->isIntegralOrUnscopedEnumerationType()) { 458 // C99 6.3.1.1p2: 459 // 460 // The following may be used in an expression wherever an int or 461 // unsigned int may be used: 462 // - an object or expression with an integer type whose integer 463 // conversion rank is less than or equal to the rank of int 464 // and unsigned int. 465 // - A bit-field of type _Bool, int, signed int, or unsigned int. 466 // 467 // If an int can represent all values of the original type, the 468 // value is converted to an int; otherwise, it is converted to an 469 // unsigned int. These are called the integer promotions. All 470 // other types are unchanged by the integer promotions. 471 472 QualType PTy = Context.isPromotableBitField(E); 473 if (!PTy.isNull()) { 474 E = ImpCastExprToType(E, PTy, CK_IntegralCast).take(); 475 return Owned(E); 476 } 477 if (Ty->isPromotableIntegerType()) { 478 QualType PT = Context.getPromotedIntegerType(Ty); 479 E = ImpCastExprToType(E, PT, CK_IntegralCast).take(); 480 return Owned(E); 481 } 482 } 483 return Owned(E); 484 } 485 486 /// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that 487 /// do not have a prototype. Arguments that have type float are promoted to 488 /// double. All other argument types are converted by UsualUnaryConversions(). 489 ExprResult Sema::DefaultArgumentPromotion(Expr *E) { 490 QualType Ty = E->getType(); 491 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type"); 492 493 ExprResult Res = UsualUnaryConversions(E); 494 if (Res.isInvalid()) 495 return Owned(E); 496 E = Res.take(); 497 498 // If this is a 'float' (CVR qualified or typedef) promote to double. 499 if (Ty->isSpecificBuiltinType(BuiltinType::Float)) 500 E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).take(); 501 502 // C++ performs lvalue-to-rvalue conversion as a default argument 503 // promotion, even on class types, but note: 504 // C++11 [conv.lval]p2: 505 // When an lvalue-to-rvalue conversion occurs in an unevaluated 506 // operand or a subexpression thereof the value contained in the 507 // referenced object is not accessed. Otherwise, if the glvalue 508 // has a class type, the conversion copy-initializes a temporary 509 // of type T from the glvalue and the result of the conversion 510 // is a prvalue for the temporary. 511 // FIXME: add some way to gate this entire thing for correctness in 512 // potentially potentially evaluated contexts. 513 if (getLangOpts().CPlusPlus && E->isGLValue() && 514 ExprEvalContexts.back().Context != Unevaluated) { 515 ExprResult Temp = PerformCopyInitialization( 516 InitializedEntity::InitializeTemporary(E->getType()), 517 E->getExprLoc(), 518 Owned(E)); 519 if (Temp.isInvalid()) 520 return ExprError(); 521 E = Temp.get(); 522 } 523 524 return Owned(E); 525 } 526 527 /// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but 528 /// will warn if the resulting type is not a POD type, and rejects ObjC 529 /// interfaces passed by value. 530 ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, 531 FunctionDecl *FDecl) { 532 if (const BuiltinType *PlaceholderTy = E->getType()->getAsPlaceholderType()) { 533 // Strip the unbridged-cast placeholder expression off, if applicable. 534 if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast && 535 (CT == VariadicMethod || 536 (FDecl && FDecl->hasAttr<CFAuditedTransferAttr>()))) { 537 E = stripARCUnbridgedCast(E); 538 539 // Otherwise, do normal placeholder checking. 540 } else { 541 ExprResult ExprRes = CheckPlaceholderExpr(E); 542 if (ExprRes.isInvalid()) 543 return ExprError(); 544 E = ExprRes.take(); 545 } 546 } 547 548 ExprResult ExprRes = DefaultArgumentPromotion(E); 549 if (ExprRes.isInvalid()) 550 return ExprError(); 551 E = ExprRes.take(); 552 553 // Don't allow one to pass an Objective-C interface to a vararg. 554 if (E->getType()->isObjCObjectType() && 555 DiagRuntimeBehavior(E->getLocStart(), 0, 556 PDiag(diag::err_cannot_pass_objc_interface_to_vararg) 557 << E->getType() << CT)) 558 return ExprError(); 559 560 // Complain about passing non-POD types through varargs. However, don't 561 // perform this check for incomplete types, which we can get here when we're 562 // in an unevaluated context. 563 if (!E->getType()->isIncompleteType() && !E->getType().isPODType(Context)) { 564 // C++0x [expr.call]p7: 565 // Passing a potentially-evaluated argument of class type (Clause 9) 566 // having a non-trivial copy constructor, a non-trivial move constructor, 567 // or a non-trivial destructor, with no corresponding parameter, 568 // is conditionally-supported with implementation-defined semantics. 569 bool TrivialEnough = false; 570 if (getLangOpts().CPlusPlus0x && !E->getType()->isDependentType()) { 571 if (CXXRecordDecl *Record = E->getType()->getAsCXXRecordDecl()) { 572 if (Record->hasTrivialCopyConstructor() && 573 Record->hasTrivialMoveConstructor() && 574 Record->hasTrivialDestructor()) { 575 DiagRuntimeBehavior(E->getLocStart(), 0, 576 PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) 577 << E->getType() << CT); 578 TrivialEnough = true; 579 } 580 } 581 } 582 583 if (!TrivialEnough && 584 getLangOpts().ObjCAutoRefCount && 585 E->getType()->isObjCLifetimeType()) 586 TrivialEnough = true; 587 588 if (TrivialEnough) { 589 // Nothing to diagnose. This is okay. 590 } else if (DiagRuntimeBehavior(E->getLocStart(), 0, 591 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg) 592 << getLangOpts().CPlusPlus0x << E->getType() 593 << CT)) { 594 // Turn this into a trap. 595 CXXScopeSpec SS; 596 SourceLocation TemplateKWLoc; 597 UnqualifiedId Name; 598 Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"), 599 E->getLocStart()); 600 ExprResult TrapFn = ActOnIdExpression(TUScope, SS, TemplateKWLoc, Name, 601 true, false); 602 if (TrapFn.isInvalid()) 603 return ExprError(); 604 605 ExprResult Call = ActOnCallExpr(TUScope, TrapFn.get(), E->getLocStart(), 606 MultiExprArg(), E->getLocEnd()); 607 if (Call.isInvalid()) 608 return ExprError(); 609 610 ExprResult Comma = ActOnBinOp(TUScope, E->getLocStart(), tok::comma, 611 Call.get(), E); 612 if (Comma.isInvalid()) 613 return ExprError(); 614 E = Comma.get(); 615 } 616 } 617 // c++ rules are enforced elsewhere. 618 if (!getLangOpts().CPlusPlus && 619 RequireCompleteType(E->getExprLoc(), E->getType(), 620 diag::err_call_incomplete_argument)) 621 return ExprError(); 622 623 return Owned(E); 624 } 625 626 /// \brief Converts an integer to complex float type. Helper function of 627 /// UsualArithmeticConversions() 628 /// 629 /// \return false if the integer expression is an integer type and is 630 /// successfully converted to the complex type. 631 static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &IntExpr, 632 ExprResult &ComplexExpr, 633 QualType IntTy, 634 QualType ComplexTy, 635 bool SkipCast) { 636 if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true; 637 if (SkipCast) return false; 638 if (IntTy->isIntegerType()) { 639 QualType fpTy = cast<ComplexType>(ComplexTy)->getElementType(); 640 IntExpr = S.ImpCastExprToType(IntExpr.take(), fpTy, CK_IntegralToFloating); 641 IntExpr = S.ImpCastExprToType(IntExpr.take(), ComplexTy, 642 CK_FloatingRealToComplex); 643 } else { 644 assert(IntTy->isComplexIntegerType()); 645 IntExpr = S.ImpCastExprToType(IntExpr.take(), ComplexTy, 646 CK_IntegralComplexToFloatingComplex); 647 } 648 return false; 649 } 650 651 /// \brief Takes two complex float types and converts them to the same type. 652 /// Helper function of UsualArithmeticConversions() 653 static QualType 654 handleComplexFloatToComplexFloatConverstion(Sema &S, ExprResult &LHS, 655 ExprResult &RHS, QualType LHSType, 656 QualType RHSType, 657 bool IsCompAssign) { 658 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 659 660 if (order < 0) { 661 // _Complex float -> _Complex double 662 if (!IsCompAssign) 663 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingComplexCast); 664 return RHSType; 665 } 666 if (order > 0) 667 // _Complex float -> _Complex double 668 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingComplexCast); 669 return LHSType; 670 } 671 672 /// \brief Converts otherExpr to complex float and promotes complexExpr if 673 /// necessary. Helper function of UsualArithmeticConversions() 674 static QualType handleOtherComplexFloatConversion(Sema &S, 675 ExprResult &ComplexExpr, 676 ExprResult &OtherExpr, 677 QualType ComplexTy, 678 QualType OtherTy, 679 bool ConvertComplexExpr, 680 bool ConvertOtherExpr) { 681 int order = S.Context.getFloatingTypeOrder(ComplexTy, OtherTy); 682 683 // If just the complexExpr is complex, the otherExpr needs to be converted, 684 // and the complexExpr might need to be promoted. 685 if (order > 0) { // complexExpr is wider 686 // float -> _Complex double 687 if (ConvertOtherExpr) { 688 QualType fp = cast<ComplexType>(ComplexTy)->getElementType(); 689 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), fp, CK_FloatingCast); 690 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), ComplexTy, 691 CK_FloatingRealToComplex); 692 } 693 return ComplexTy; 694 } 695 696 // otherTy is at least as wide. Find its corresponding complex type. 697 QualType result = (order == 0 ? ComplexTy : 698 S.Context.getComplexType(OtherTy)); 699 700 // double -> _Complex double 701 if (ConvertOtherExpr) 702 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), result, 703 CK_FloatingRealToComplex); 704 705 // _Complex float -> _Complex double 706 if (ConvertComplexExpr && order < 0) 707 ComplexExpr = S.ImpCastExprToType(ComplexExpr.take(), result, 708 CK_FloatingComplexCast); 709 710 return result; 711 } 712 713 /// \brief Handle arithmetic conversion with complex types. Helper function of 714 /// UsualArithmeticConversions() 715 static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS, 716 ExprResult &RHS, QualType LHSType, 717 QualType RHSType, 718 bool IsCompAssign) { 719 // if we have an integer operand, the result is the complex type. 720 if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType, 721 /*skipCast*/false)) 722 return LHSType; 723 if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType, 724 /*skipCast*/IsCompAssign)) 725 return RHSType; 726 727 // This handles complex/complex, complex/float, or float/complex. 728 // When both operands are complex, the shorter operand is converted to the 729 // type of the longer, and that is the type of the result. This corresponds 730 // to what is done when combining two real floating-point operands. 731 // The fun begins when size promotion occur across type domains. 732 // From H&S 6.3.4: When one operand is complex and the other is a real 733 // floating-point type, the less precise type is converted, within it's 734 // real or complex domain, to the precision of the other type. For example, 735 // when combining a "long double" with a "double _Complex", the 736 // "double _Complex" is promoted to "long double _Complex". 737 738 bool LHSComplexFloat = LHSType->isComplexType(); 739 bool RHSComplexFloat = RHSType->isComplexType(); 740 741 // If both are complex, just cast to the more precise type. 742 if (LHSComplexFloat && RHSComplexFloat) 743 return handleComplexFloatToComplexFloatConverstion(S, LHS, RHS, 744 LHSType, RHSType, 745 IsCompAssign); 746 747 // If only one operand is complex, promote it if necessary and convert the 748 // other operand to complex. 749 if (LHSComplexFloat) 750 return handleOtherComplexFloatConversion( 751 S, LHS, RHS, LHSType, RHSType, /*convertComplexExpr*/!IsCompAssign, 752 /*convertOtherExpr*/ true); 753 754 assert(RHSComplexFloat); 755 return handleOtherComplexFloatConversion( 756 S, RHS, LHS, RHSType, LHSType, /*convertComplexExpr*/true, 757 /*convertOtherExpr*/ !IsCompAssign); 758 } 759 760 /// \brief Hande arithmetic conversion from integer to float. Helper function 761 /// of UsualArithmeticConversions() 762 static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, 763 ExprResult &IntExpr, 764 QualType FloatTy, QualType IntTy, 765 bool ConvertFloat, bool ConvertInt) { 766 if (IntTy->isIntegerType()) { 767 if (ConvertInt) 768 // Convert intExpr to the lhs floating point type. 769 IntExpr = S.ImpCastExprToType(IntExpr.take(), FloatTy, 770 CK_IntegralToFloating); 771 return FloatTy; 772 } 773 774 // Convert both sides to the appropriate complex float. 775 assert(IntTy->isComplexIntegerType()); 776 QualType result = S.Context.getComplexType(FloatTy); 777 778 // _Complex int -> _Complex float 779 if (ConvertInt) 780 IntExpr = S.ImpCastExprToType(IntExpr.take(), result, 781 CK_IntegralComplexToFloatingComplex); 782 783 // float -> _Complex float 784 if (ConvertFloat) 785 FloatExpr = S.ImpCastExprToType(FloatExpr.take(), result, 786 CK_FloatingRealToComplex); 787 788 return result; 789 } 790 791 /// \brief Handle arithmethic conversion with floating point types. Helper 792 /// function of UsualArithmeticConversions() 793 static QualType handleFloatConversion(Sema &S, ExprResult &LHS, 794 ExprResult &RHS, QualType LHSType, 795 QualType RHSType, bool IsCompAssign) { 796 bool LHSFloat = LHSType->isRealFloatingType(); 797 bool RHSFloat = RHSType->isRealFloatingType(); 798 799 // If we have two real floating types, convert the smaller operand 800 // to the bigger result. 801 if (LHSFloat && RHSFloat) { 802 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 803 if (order > 0) { 804 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingCast); 805 return LHSType; 806 } 807 808 assert(order < 0 && "illegal float comparison"); 809 if (!IsCompAssign) 810 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingCast); 811 return RHSType; 812 } 813 814 if (LHSFloat) 815 return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType, 816 /*convertFloat=*/!IsCompAssign, 817 /*convertInt=*/ true); 818 assert(RHSFloat); 819 return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType, 820 /*convertInt=*/ true, 821 /*convertFloat=*/!IsCompAssign); 822 } 823 824 /// \brief Handle conversions with GCC complex int extension. Helper function 825 /// of UsualArithmeticConversions() 826 // FIXME: if the operands are (int, _Complex long), we currently 827 // don't promote the complex. Also, signedness? 828 static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS, 829 ExprResult &RHS, QualType LHSType, 830 QualType RHSType, 831 bool IsCompAssign) { 832 const ComplexType *LHSComplexInt = LHSType->getAsComplexIntegerType(); 833 const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType(); 834 835 if (LHSComplexInt && RHSComplexInt) { 836 int order = S.Context.getIntegerTypeOrder(LHSComplexInt->getElementType(), 837 RHSComplexInt->getElementType()); 838 assert(order && "inequal types with equal element ordering"); 839 if (order > 0) { 840 // _Complex int -> _Complex long 841 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralComplexCast); 842 return LHSType; 843 } 844 845 if (!IsCompAssign) 846 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralComplexCast); 847 return RHSType; 848 } 849 850 if (LHSComplexInt) { 851 // int -> _Complex int 852 // FIXME: This needs to take integer ranks into account 853 RHS = S.ImpCastExprToType(RHS.take(), LHSComplexInt->getElementType(), 854 CK_IntegralCast); 855 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralRealToComplex); 856 return LHSType; 857 } 858 859 assert(RHSComplexInt); 860 // int -> _Complex int 861 // FIXME: This needs to take integer ranks into account 862 if (!IsCompAssign) { 863 LHS = S.ImpCastExprToType(LHS.take(), RHSComplexInt->getElementType(), 864 CK_IntegralCast); 865 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralRealToComplex); 866 } 867 return RHSType; 868 } 869 870 /// \brief Handle integer arithmetic conversions. Helper function of 871 /// UsualArithmeticConversions() 872 static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, 873 ExprResult &RHS, QualType LHSType, 874 QualType RHSType, bool IsCompAssign) { 875 // The rules for this case are in C99 6.3.1.8 876 int order = S.Context.getIntegerTypeOrder(LHSType, RHSType); 877 bool LHSSigned = LHSType->hasSignedIntegerRepresentation(); 878 bool RHSSigned = RHSType->hasSignedIntegerRepresentation(); 879 if (LHSSigned == RHSSigned) { 880 // Same signedness; use the higher-ranked type 881 if (order >= 0) { 882 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 883 return LHSType; 884 } else if (!IsCompAssign) 885 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 886 return RHSType; 887 } else if (order != (LHSSigned ? 1 : -1)) { 888 // The unsigned type has greater than or equal rank to the 889 // signed type, so use the unsigned type 890 if (RHSSigned) { 891 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 892 return LHSType; 893 } else if (!IsCompAssign) 894 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 895 return RHSType; 896 } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) { 897 // The two types are different widths; if we are here, that 898 // means the signed type is larger than the unsigned type, so 899 // use the signed type. 900 if (LHSSigned) { 901 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 902 return LHSType; 903 } else if (!IsCompAssign) 904 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 905 return RHSType; 906 } else { 907 // The signed type is higher-ranked than the unsigned type, 908 // but isn't actually any bigger (like unsigned int and long 909 // on most 32-bit systems). Use the unsigned type corresponding 910 // to the signed type. 911 QualType result = 912 S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType); 913 RHS = S.ImpCastExprToType(RHS.take(), result, CK_IntegralCast); 914 if (!IsCompAssign) 915 LHS = S.ImpCastExprToType(LHS.take(), result, CK_IntegralCast); 916 return result; 917 } 918 } 919 920 /// UsualArithmeticConversions - Performs various conversions that are common to 921 /// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this 922 /// routine returns the first non-arithmetic type found. The client is 923 /// responsible for emitting appropriate error diagnostics. 924 /// FIXME: verify the conversion rules for "complex int" are consistent with 925 /// GCC. 926 QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, 927 bool IsCompAssign) { 928 if (!IsCompAssign) { 929 LHS = UsualUnaryConversions(LHS.take()); 930 if (LHS.isInvalid()) 931 return QualType(); 932 } 933 934 RHS = UsualUnaryConversions(RHS.take()); 935 if (RHS.isInvalid()) 936 return QualType(); 937 938 // For conversion purposes, we ignore any qualifiers. 939 // For example, "const float" and "float" are equivalent. 940 QualType LHSType = 941 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType(); 942 QualType RHSType = 943 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType(); 944 945 // If both types are identical, no conversion is needed. 946 if (LHSType == RHSType) 947 return LHSType; 948 949 // If either side is a non-arithmetic type (e.g. a pointer), we are done. 950 // The caller can deal with this (e.g. pointer + int). 951 if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType()) 952 return LHSType; 953 954 // Apply unary and bitfield promotions to the LHS's type. 955 QualType LHSUnpromotedType = LHSType; 956 if (LHSType->isPromotableIntegerType()) 957 LHSType = Context.getPromotedIntegerType(LHSType); 958 QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get()); 959 if (!LHSBitfieldPromoteTy.isNull()) 960 LHSType = LHSBitfieldPromoteTy; 961 if (LHSType != LHSUnpromotedType && !IsCompAssign) 962 LHS = ImpCastExprToType(LHS.take(), LHSType, CK_IntegralCast); 963 964 // If both types are identical, no conversion is needed. 965 if (LHSType == RHSType) 966 return LHSType; 967 968 // At this point, we have two different arithmetic types. 969 970 // Handle complex types first (C99 6.3.1.8p1). 971 if (LHSType->isComplexType() || RHSType->isComplexType()) 972 return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType, 973 IsCompAssign); 974 975 // Now handle "real" floating types (i.e. float, double, long double). 976 if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType()) 977 return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType, 978 IsCompAssign); 979 980 // Handle GCC complex int extension. 981 if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType()) 982 return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType, 983 IsCompAssign); 984 985 // Finally, we have two differing integer types. 986 return handleIntegerConversion(*this, LHS, RHS, LHSType, RHSType, 987 IsCompAssign); 988 } 989 990 //===----------------------------------------------------------------------===// 991 // Semantic Analysis for various Expression Types 992 //===----------------------------------------------------------------------===// 993 994 995 ExprResult 996 Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc, 997 SourceLocation DefaultLoc, 998 SourceLocation RParenLoc, 999 Expr *ControllingExpr, 1000 MultiTypeArg ArgTypes, 1001 MultiExprArg ArgExprs) { 1002 unsigned NumAssocs = ArgTypes.size(); 1003 assert(NumAssocs == ArgExprs.size()); 1004 1005 ParsedType *ParsedTypes = ArgTypes.release(); 1006 Expr **Exprs = ArgExprs.release(); 1007 1008 TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs]; 1009 for (unsigned i = 0; i < NumAssocs; ++i) { 1010 if (ParsedTypes[i]) 1011 (void) GetTypeFromParser(ParsedTypes[i], &Types[i]); 1012 else 1013 Types[i] = 0; 1014 } 1015 1016 ExprResult ER = CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, 1017 ControllingExpr, Types, Exprs, 1018 NumAssocs); 1019 delete [] Types; 1020 return ER; 1021 } 1022 1023 ExprResult 1024 Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc, 1025 SourceLocation DefaultLoc, 1026 SourceLocation RParenLoc, 1027 Expr *ControllingExpr, 1028 TypeSourceInfo **Types, 1029 Expr **Exprs, 1030 unsigned NumAssocs) { 1031 bool TypeErrorFound = false, 1032 IsResultDependent = ControllingExpr->isTypeDependent(), 1033 ContainsUnexpandedParameterPack 1034 = ControllingExpr->containsUnexpandedParameterPack(); 1035 1036 for (unsigned i = 0; i < NumAssocs; ++i) { 1037 if (Exprs[i]->containsUnexpandedParameterPack()) 1038 ContainsUnexpandedParameterPack = true; 1039 1040 if (Types[i]) { 1041 if (Types[i]->getType()->containsUnexpandedParameterPack()) 1042 ContainsUnexpandedParameterPack = true; 1043 1044 if (Types[i]->getType()->isDependentType()) { 1045 IsResultDependent = true; 1046 } else { 1047 // C11 6.5.1.1p2 "The type name in a generic association shall specify a 1048 // complete object type other than a variably modified type." 1049 unsigned D = 0; 1050 if (Types[i]->getType()->isIncompleteType()) 1051 D = diag::err_assoc_type_incomplete; 1052 else if (!Types[i]->getType()->isObjectType()) 1053 D = diag::err_assoc_type_nonobject; 1054 else if (Types[i]->getType()->isVariablyModifiedType()) 1055 D = diag::err_assoc_type_variably_modified; 1056 1057 if (D != 0) { 1058 Diag(Types[i]->getTypeLoc().getBeginLoc(), D) 1059 << Types[i]->getTypeLoc().getSourceRange() 1060 << Types[i]->getType(); 1061 TypeErrorFound = true; 1062 } 1063 1064 // C11 6.5.1.1p2 "No two generic associations in the same generic 1065 // selection shall specify compatible types." 1066 for (unsigned j = i+1; j < NumAssocs; ++j) 1067 if (Types[j] && !Types[j]->getType()->isDependentType() && 1068 Context.typesAreCompatible(Types[i]->getType(), 1069 Types[j]->getType())) { 1070 Diag(Types[j]->getTypeLoc().getBeginLoc(), 1071 diag::err_assoc_compatible_types) 1072 << Types[j]->getTypeLoc().getSourceRange() 1073 << Types[j]->getType() 1074 << Types[i]->getType(); 1075 Diag(Types[i]->getTypeLoc().getBeginLoc(), 1076 diag::note_compat_assoc) 1077 << Types[i]->getTypeLoc().getSourceRange() 1078 << Types[i]->getType(); 1079 TypeErrorFound = true; 1080 } 1081 } 1082 } 1083 } 1084 if (TypeErrorFound) 1085 return ExprError(); 1086 1087 // If we determined that the generic selection is result-dependent, don't 1088 // try to compute the result expression. 1089 if (IsResultDependent) 1090 return Owned(new (Context) GenericSelectionExpr( 1091 Context, KeyLoc, ControllingExpr, 1092 Types, Exprs, NumAssocs, DefaultLoc, 1093 RParenLoc, ContainsUnexpandedParameterPack)); 1094 1095 SmallVector<unsigned, 1> CompatIndices; 1096 unsigned DefaultIndex = -1U; 1097 for (unsigned i = 0; i < NumAssocs; ++i) { 1098 if (!Types[i]) 1099 DefaultIndex = i; 1100 else if (Context.typesAreCompatible(ControllingExpr->getType(), 1101 Types[i]->getType())) 1102 CompatIndices.push_back(i); 1103 } 1104 1105 // C11 6.5.1.1p2 "The controlling expression of a generic selection shall have 1106 // type compatible with at most one of the types named in its generic 1107 // association list." 1108 if (CompatIndices.size() > 1) { 1109 // We strip parens here because the controlling expression is typically 1110 // parenthesized in macro definitions. 1111 ControllingExpr = ControllingExpr->IgnoreParens(); 1112 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_multi_match) 1113 << ControllingExpr->getSourceRange() << ControllingExpr->getType() 1114 << (unsigned) CompatIndices.size(); 1115 for (SmallVector<unsigned, 1>::iterator I = CompatIndices.begin(), 1116 E = CompatIndices.end(); I != E; ++I) { 1117 Diag(Types[*I]->getTypeLoc().getBeginLoc(), 1118 diag::note_compat_assoc) 1119 << Types[*I]->getTypeLoc().getSourceRange() 1120 << Types[*I]->getType(); 1121 } 1122 return ExprError(); 1123 } 1124 1125 // C11 6.5.1.1p2 "If a generic selection has no default generic association, 1126 // its controlling expression shall have type compatible with exactly one of 1127 // the types named in its generic association list." 1128 if (DefaultIndex == -1U && CompatIndices.size() == 0) { 1129 // We strip parens here because the controlling expression is typically 1130 // parenthesized in macro definitions. 1131 ControllingExpr = ControllingExpr->IgnoreParens(); 1132 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_no_match) 1133 << ControllingExpr->getSourceRange() << ControllingExpr->getType(); 1134 return ExprError(); 1135 } 1136 1137 // C11 6.5.1.1p3 "If a generic selection has a generic association with a 1138 // type name that is compatible with the type of the controlling expression, 1139 // then the result expression of the generic selection is the expression 1140 // in that generic association. Otherwise, the result expression of the 1141 // generic selection is the expression in the default generic association." 1142 unsigned ResultIndex = 1143 CompatIndices.size() ? CompatIndices[0] : DefaultIndex; 1144 1145 return Owned(new (Context) GenericSelectionExpr( 1146 Context, KeyLoc, ControllingExpr, 1147 Types, Exprs, NumAssocs, DefaultLoc, 1148 RParenLoc, ContainsUnexpandedParameterPack, 1149 ResultIndex)); 1150 } 1151 1152 /// getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the 1153 /// location of the token and the offset of the ud-suffix within it. 1154 static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc, 1155 unsigned Offset) { 1156 return Lexer::AdvanceToTokenCharacter(TokLoc, Offset, S.getSourceManager(), 1157 S.getLangOpts()); 1158 } 1159 1160 /// BuildCookedLiteralOperatorCall - A user-defined literal was found. Look up 1161 /// the corresponding cooked (non-raw) literal operator, and build a call to it. 1162 static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope, 1163 IdentifierInfo *UDSuffix, 1164 SourceLocation UDSuffixLoc, 1165 ArrayRef<Expr*> Args, 1166 SourceLocation LitEndLoc) { 1167 assert(Args.size() <= 2 && "too many arguments for literal operator"); 1168 1169 QualType ArgTy[2]; 1170 for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) { 1171 ArgTy[ArgIdx] = Args[ArgIdx]->getType(); 1172 if (ArgTy[ArgIdx]->isArrayType()) 1173 ArgTy[ArgIdx] = S.Context.getArrayDecayedType(ArgTy[ArgIdx]); 1174 } 1175 1176 DeclarationName OpName = 1177 S.Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 1178 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 1179 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 1180 1181 LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName); 1182 if (S.LookupLiteralOperator(Scope, R, llvm::makeArrayRef(ArgTy, Args.size()), 1183 /*AllowRawAndTemplate*/false) == Sema::LOLR_Error) 1184 return ExprError(); 1185 1186 return S.BuildLiteralOperatorCall(R, OpNameInfo, Args, LitEndLoc); 1187 } 1188 1189 /// ActOnStringLiteral - The specified tokens were lexed as pasted string 1190 /// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string 1191 /// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from 1192 /// multiple tokens. However, the common case is that StringToks points to one 1193 /// string. 1194 /// 1195 ExprResult 1196 Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks, 1197 Scope *UDLScope) { 1198 assert(NumStringToks && "Must have at least one string!"); 1199 1200 StringLiteralParser Literal(StringToks, NumStringToks, PP); 1201 if (Literal.hadError) 1202 return ExprError(); 1203 1204 SmallVector<SourceLocation, 4> StringTokLocs; 1205 for (unsigned i = 0; i != NumStringToks; ++i) 1206 StringTokLocs.push_back(StringToks[i].getLocation()); 1207 1208 QualType StrTy = Context.CharTy; 1209 if (Literal.isWide()) 1210 StrTy = Context.getWCharType(); 1211 else if (Literal.isUTF16()) 1212 StrTy = Context.Char16Ty; 1213 else if (Literal.isUTF32()) 1214 StrTy = Context.Char32Ty; 1215 else if (Literal.isPascal()) 1216 StrTy = Context.UnsignedCharTy; 1217 1218 StringLiteral::StringKind Kind = StringLiteral::Ascii; 1219 if (Literal.isWide()) 1220 Kind = StringLiteral::Wide; 1221 else if (Literal.isUTF8()) 1222 Kind = StringLiteral::UTF8; 1223 else if (Literal.isUTF16()) 1224 Kind = StringLiteral::UTF16; 1225 else if (Literal.isUTF32()) 1226 Kind = StringLiteral::UTF32; 1227 1228 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1). 1229 if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings) 1230 StrTy.addConst(); 1231 1232 // Get an array type for the string, according to C99 6.4.5. This includes 1233 // the nul terminator character as well as the string length for pascal 1234 // strings. 1235 StrTy = Context.getConstantArrayType(StrTy, 1236 llvm::APInt(32, Literal.GetNumStringChars()+1), 1237 ArrayType::Normal, 0); 1238 1239 // Pass &StringTokLocs[0], StringTokLocs.size() to factory! 1240 StringLiteral *Lit = StringLiteral::Create(Context, Literal.GetString(), 1241 Kind, Literal.Pascal, StrTy, 1242 &StringTokLocs[0], 1243 StringTokLocs.size()); 1244 if (Literal.getUDSuffix().empty()) 1245 return Owned(Lit); 1246 1247 // We're building a user-defined literal. 1248 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 1249 SourceLocation UDSuffixLoc = 1250 getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()], 1251 Literal.getUDSuffixOffset()); 1252 1253 // Make sure we're allowed user-defined literals here. 1254 if (!UDLScope) 1255 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_string_udl)); 1256 1257 // C++11 [lex.ext]p5: The literal L is treated as a call of the form 1258 // operator "" X (str, len) 1259 QualType SizeType = Context.getSizeType(); 1260 llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars()); 1261 IntegerLiteral *LenArg = IntegerLiteral::Create(Context, Len, SizeType, 1262 StringTokLocs[0]); 1263 Expr *Args[] = { Lit, LenArg }; 1264 return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc, 1265 Args, StringTokLocs.back()); 1266 } 1267 1268 ExprResult 1269 Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1270 SourceLocation Loc, 1271 const CXXScopeSpec *SS) { 1272 DeclarationNameInfo NameInfo(D->getDeclName(), Loc); 1273 return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS); 1274 } 1275 1276 /// BuildDeclRefExpr - Build an expression that references a 1277 /// declaration that does not require a closure capture. 1278 ExprResult 1279 Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1280 const DeclarationNameInfo &NameInfo, 1281 const CXXScopeSpec *SS) { 1282 if (getLangOpts().CUDA) 1283 if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext)) 1284 if (const FunctionDecl *Callee = dyn_cast<FunctionDecl>(D)) { 1285 CUDAFunctionTarget CallerTarget = IdentifyCUDATarget(Caller), 1286 CalleeTarget = IdentifyCUDATarget(Callee); 1287 if (CheckCUDATarget(CallerTarget, CalleeTarget)) { 1288 Diag(NameInfo.getLoc(), diag::err_ref_bad_target) 1289 << CalleeTarget << D->getIdentifier() << CallerTarget; 1290 Diag(D->getLocation(), diag::note_previous_decl) 1291 << D->getIdentifier(); 1292 return ExprError(); 1293 } 1294 } 1295 1296 bool refersToEnclosingScope = 1297 (CurContext != D->getDeclContext() && 1298 D->getDeclContext()->isFunctionOrMethod()); 1299 1300 DeclRefExpr *E = DeclRefExpr::Create(Context, 1301 SS ? SS->getWithLocInContext(Context) 1302 : NestedNameSpecifierLoc(), 1303 SourceLocation(), 1304 D, refersToEnclosingScope, 1305 NameInfo, Ty, VK); 1306 1307 MarkDeclRefReferenced(E); 1308 1309 // Just in case we're building an illegal pointer-to-member. 1310 FieldDecl *FD = dyn_cast<FieldDecl>(D); 1311 if (FD && FD->isBitField()) 1312 E->setObjectKind(OK_BitField); 1313 1314 return Owned(E); 1315 } 1316 1317 /// Decomposes the given name into a DeclarationNameInfo, its location, and 1318 /// possibly a list of template arguments. 1319 /// 1320 /// If this produces template arguments, it is permitted to call 1321 /// DecomposeTemplateName. 1322 /// 1323 /// This actually loses a lot of source location information for 1324 /// non-standard name kinds; we should consider preserving that in 1325 /// some way. 1326 void 1327 Sema::DecomposeUnqualifiedId(const UnqualifiedId &Id, 1328 TemplateArgumentListInfo &Buffer, 1329 DeclarationNameInfo &NameInfo, 1330 const TemplateArgumentListInfo *&TemplateArgs) { 1331 if (Id.getKind() == UnqualifiedId::IK_TemplateId) { 1332 Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc); 1333 Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc); 1334 1335 ASTTemplateArgsPtr TemplateArgsPtr(*this, 1336 Id.TemplateId->getTemplateArgs(), 1337 Id.TemplateId->NumArgs); 1338 translateTemplateArguments(TemplateArgsPtr, Buffer); 1339 TemplateArgsPtr.release(); 1340 1341 TemplateName TName = Id.TemplateId->Template.get(); 1342 SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc; 1343 NameInfo = Context.getNameForTemplate(TName, TNameLoc); 1344 TemplateArgs = &Buffer; 1345 } else { 1346 NameInfo = GetNameFromUnqualifiedId(Id); 1347 TemplateArgs = 0; 1348 } 1349 } 1350 1351 /// Diagnose an empty lookup. 1352 /// 1353 /// \return false if new lookup candidates were found 1354 bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, 1355 CorrectionCandidateCallback &CCC, 1356 TemplateArgumentListInfo *ExplicitTemplateArgs, 1357 llvm::ArrayRef<Expr *> Args) { 1358 DeclarationName Name = R.getLookupName(); 1359 1360 unsigned diagnostic = diag::err_undeclared_var_use; 1361 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest; 1362 if (Name.getNameKind() == DeclarationName::CXXOperatorName || 1363 Name.getNameKind() == DeclarationName::CXXLiteralOperatorName || 1364 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 1365 diagnostic = diag::err_undeclared_use; 1366 diagnostic_suggest = diag::err_undeclared_use_suggest; 1367 } 1368 1369 // If the original lookup was an unqualified lookup, fake an 1370 // unqualified lookup. This is useful when (for example) the 1371 // original lookup would not have found something because it was a 1372 // dependent name. 1373 DeclContext *DC = SS.isEmpty() ? CurContext : 0; 1374 while (DC) { 1375 if (isa<CXXRecordDecl>(DC)) { 1376 LookupQualifiedName(R, DC); 1377 1378 if (!R.empty()) { 1379 // Don't give errors about ambiguities in this lookup. 1380 R.suppressDiagnostics(); 1381 1382 // During a default argument instantiation the CurContext points 1383 // to a CXXMethodDecl; but we can't apply a this-> fixit inside a 1384 // function parameter list, hence add an explicit check. 1385 bool isDefaultArgument = !ActiveTemplateInstantiations.empty() && 1386 ActiveTemplateInstantiations.back().Kind == 1387 ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation; 1388 CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext); 1389 bool isInstance = CurMethod && 1390 CurMethod->isInstance() && 1391 DC == CurMethod->getParent() && !isDefaultArgument; 1392 1393 1394 // Give a code modification hint to insert 'this->'. 1395 // TODO: fixit for inserting 'Base<T>::' in the other cases. 1396 // Actually quite difficult! 1397 if (isInstance) { 1398 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>( 1399 CallsUndergoingInstantiation.back()->getCallee()); 1400 CXXMethodDecl *DepMethod = cast_or_null<CXXMethodDecl>( 1401 CurMethod->getInstantiatedFromMemberFunction()); 1402 if (DepMethod) { 1403 if (getLangOpts().MicrosoftMode) 1404 diagnostic = diag::warn_found_via_dependent_bases_lookup; 1405 Diag(R.getNameLoc(), diagnostic) << Name 1406 << FixItHint::CreateInsertion(R.getNameLoc(), "this->"); 1407 QualType DepThisType = DepMethod->getThisType(Context); 1408 CheckCXXThisCapture(R.getNameLoc()); 1409 CXXThisExpr *DepThis = new (Context) CXXThisExpr( 1410 R.getNameLoc(), DepThisType, false); 1411 TemplateArgumentListInfo TList; 1412 if (ULE->hasExplicitTemplateArgs()) 1413 ULE->copyTemplateArgumentsInto(TList); 1414 1415 CXXScopeSpec SS; 1416 SS.Adopt(ULE->getQualifierLoc()); 1417 CXXDependentScopeMemberExpr *DepExpr = 1418 CXXDependentScopeMemberExpr::Create( 1419 Context, DepThis, DepThisType, true, SourceLocation(), 1420 SS.getWithLocInContext(Context), 1421 ULE->getTemplateKeywordLoc(), 0, 1422 R.getLookupNameInfo(), 1423 ULE->hasExplicitTemplateArgs() ? &TList : 0); 1424 CallsUndergoingInstantiation.back()->setCallee(DepExpr); 1425 } else { 1426 // FIXME: we should be able to handle this case too. It is correct 1427 // to add this-> here. This is a workaround for PR7947. 1428 Diag(R.getNameLoc(), diagnostic) << Name; 1429 } 1430 } else { 1431 if (getLangOpts().MicrosoftMode) 1432 diagnostic = diag::warn_found_via_dependent_bases_lookup; 1433 Diag(R.getNameLoc(), diagnostic) << Name; 1434 } 1435 1436 // Do we really want to note all of these? 1437 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) 1438 Diag((*I)->getLocation(), diag::note_dependent_var_use); 1439 1440 // Return true if we are inside a default argument instantiation 1441 // and the found name refers to an instance member function, otherwise 1442 // the function calling DiagnoseEmptyLookup will try to create an 1443 // implicit member call and this is wrong for default argument. 1444 if (isDefaultArgument && ((*R.begin())->isCXXInstanceMember())) { 1445 Diag(R.getNameLoc(), diag::err_member_call_without_object); 1446 return true; 1447 } 1448 1449 // Tell the callee to try to recover. 1450 return false; 1451 } 1452 1453 R.clear(); 1454 } 1455 1456 // In Microsoft mode, if we are performing lookup from within a friend 1457 // function definition declared at class scope then we must set 1458 // DC to the lexical parent to be able to search into the parent 1459 // class. 1460 if (getLangOpts().MicrosoftMode && isa<FunctionDecl>(DC) && 1461 cast<FunctionDecl>(DC)->getFriendObjectKind() && 1462 DC->getLexicalParent()->isRecord()) 1463 DC = DC->getLexicalParent(); 1464 else 1465 DC = DC->getParent(); 1466 } 1467 1468 // We didn't find anything, so try to correct for a typo. 1469 TypoCorrection Corrected; 1470 if (S && (Corrected = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), 1471 S, &SS, CCC))) { 1472 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 1473 std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOpts())); 1474 R.setLookupName(Corrected.getCorrection()); 1475 1476 if (NamedDecl *ND = Corrected.getCorrectionDecl()) { 1477 if (Corrected.isOverloaded()) { 1478 OverloadCandidateSet OCS(R.getNameLoc()); 1479 OverloadCandidateSet::iterator Best; 1480 for (TypoCorrection::decl_iterator CD = Corrected.begin(), 1481 CDEnd = Corrected.end(); 1482 CD != CDEnd; ++CD) { 1483 if (FunctionTemplateDecl *FTD = 1484 dyn_cast<FunctionTemplateDecl>(*CD)) 1485 AddTemplateOverloadCandidate( 1486 FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs, 1487 Args, OCS); 1488 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD)) 1489 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0) 1490 AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), 1491 Args, OCS); 1492 } 1493 switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) { 1494 case OR_Success: 1495 ND = Best->Function; 1496 break; 1497 default: 1498 break; 1499 } 1500 } 1501 R.addDecl(ND); 1502 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) { 1503 if (SS.isEmpty()) 1504 Diag(R.getNameLoc(), diagnostic_suggest) << Name << CorrectedQuotedStr 1505 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr); 1506 else 1507 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1508 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1509 << SS.getRange() 1510 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr); 1511 if (ND) 1512 Diag(ND->getLocation(), diag::note_previous_decl) 1513 << CorrectedQuotedStr; 1514 1515 // Tell the callee to try to recover. 1516 return false; 1517 } 1518 1519 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) { 1520 // FIXME: If we ended up with a typo for a type name or 1521 // Objective-C class name, we're in trouble because the parser 1522 // is in the wrong place to recover. Suggest the typo 1523 // correction, but don't make it a fix-it since we're not going 1524 // to recover well anyway. 1525 if (SS.isEmpty()) 1526 Diag(R.getNameLoc(), diagnostic_suggest) 1527 << Name << CorrectedQuotedStr; 1528 else 1529 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1530 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1531 << SS.getRange(); 1532 1533 // Don't try to recover; it won't work. 1534 return true; 1535 } 1536 } else { 1537 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it 1538 // because we aren't able to recover. 1539 if (SS.isEmpty()) 1540 Diag(R.getNameLoc(), diagnostic_suggest) << Name << CorrectedQuotedStr; 1541 else 1542 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1543 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1544 << SS.getRange(); 1545 return true; 1546 } 1547 } 1548 R.clear(); 1549 1550 // Emit a special diagnostic for failed member lookups. 1551 // FIXME: computing the declaration context might fail here (?) 1552 if (!SS.isEmpty()) { 1553 Diag(R.getNameLoc(), diag::err_no_member) 1554 << Name << computeDeclContext(SS, false) 1555 << SS.getRange(); 1556 return true; 1557 } 1558 1559 // Give up, we can't recover. 1560 Diag(R.getNameLoc(), diagnostic) << Name; 1561 return true; 1562 } 1563 1564 ExprResult Sema::ActOnIdExpression(Scope *S, 1565 CXXScopeSpec &SS, 1566 SourceLocation TemplateKWLoc, 1567 UnqualifiedId &Id, 1568 bool HasTrailingLParen, 1569 bool IsAddressOfOperand, 1570 CorrectionCandidateCallback *CCC) { 1571 assert(!(IsAddressOfOperand && HasTrailingLParen) && 1572 "cannot be direct & operand and have a trailing lparen"); 1573 1574 if (SS.isInvalid()) 1575 return ExprError(); 1576 1577 TemplateArgumentListInfo TemplateArgsBuffer; 1578 1579 // Decompose the UnqualifiedId into the following data. 1580 DeclarationNameInfo NameInfo; 1581 const TemplateArgumentListInfo *TemplateArgs; 1582 DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs); 1583 1584 DeclarationName Name = NameInfo.getName(); 1585 IdentifierInfo *II = Name.getAsIdentifierInfo(); 1586 SourceLocation NameLoc = NameInfo.getLoc(); 1587 1588 // C++ [temp.dep.expr]p3: 1589 // An id-expression is type-dependent if it contains: 1590 // -- an identifier that was declared with a dependent type, 1591 // (note: handled after lookup) 1592 // -- a template-id that is dependent, 1593 // (note: handled in BuildTemplateIdExpr) 1594 // -- a conversion-function-id that specifies a dependent type, 1595 // -- a nested-name-specifier that contains a class-name that 1596 // names a dependent type. 1597 // Determine whether this is a member of an unknown specialization; 1598 // we need to handle these differently. 1599 bool DependentID = false; 1600 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName && 1601 Name.getCXXNameType()->isDependentType()) { 1602 DependentID = true; 1603 } else if (SS.isSet()) { 1604 if (DeclContext *DC = computeDeclContext(SS, false)) { 1605 if (RequireCompleteDeclContext(SS, DC)) 1606 return ExprError(); 1607 } else { 1608 DependentID = true; 1609 } 1610 } 1611 1612 if (DependentID) 1613 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1614 IsAddressOfOperand, TemplateArgs); 1615 1616 // Perform the required lookup. 1617 LookupResult R(*this, NameInfo, 1618 (Id.getKind() == UnqualifiedId::IK_ImplicitSelfParam) 1619 ? LookupObjCImplicitSelfParam : LookupOrdinaryName); 1620 if (TemplateArgs) { 1621 // Lookup the template name again to correctly establish the context in 1622 // which it was found. This is really unfortunate as we already did the 1623 // lookup to determine that it was a template name in the first place. If 1624 // this becomes a performance hit, we can work harder to preserve those 1625 // results until we get here but it's likely not worth it. 1626 bool MemberOfUnknownSpecialization; 1627 LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false, 1628 MemberOfUnknownSpecialization); 1629 1630 if (MemberOfUnknownSpecialization || 1631 (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)) 1632 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1633 IsAddressOfOperand, TemplateArgs); 1634 } else { 1635 bool IvarLookupFollowUp = II && !SS.isSet() && getCurMethodDecl(); 1636 LookupParsedName(R, S, &SS, !IvarLookupFollowUp); 1637 1638 // If the result might be in a dependent base class, this is a dependent 1639 // id-expression. 1640 if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation) 1641 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1642 IsAddressOfOperand, TemplateArgs); 1643 1644 // If this reference is in an Objective-C method, then we need to do 1645 // some special Objective-C lookup, too. 1646 if (IvarLookupFollowUp) { 1647 ExprResult E(LookupInObjCMethod(R, S, II, true)); 1648 if (E.isInvalid()) 1649 return ExprError(); 1650 1651 if (Expr *Ex = E.takeAs<Expr>()) 1652 return Owned(Ex); 1653 } 1654 } 1655 1656 if (R.isAmbiguous()) 1657 return ExprError(); 1658 1659 // Determine whether this name might be a candidate for 1660 // argument-dependent lookup. 1661 bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen); 1662 1663 if (R.empty() && !ADL) { 1664 // Otherwise, this could be an implicitly declared function reference (legal 1665 // in C90, extension in C99, forbidden in C++). 1666 if (HasTrailingLParen && II && !getLangOpts().CPlusPlus) { 1667 NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S); 1668 if (D) R.addDecl(D); 1669 } 1670 1671 // If this name wasn't predeclared and if this is not a function 1672 // call, diagnose the problem. 1673 if (R.empty()) { 1674 1675 // In Microsoft mode, if we are inside a template class member function 1676 // and we can't resolve an identifier then assume the identifier is type 1677 // dependent. The goal is to postpone name lookup to instantiation time 1678 // to be able to search into type dependent base classes. 1679 if (getLangOpts().MicrosoftMode && CurContext->isDependentContext() && 1680 isa<CXXMethodDecl>(CurContext)) 1681 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1682 IsAddressOfOperand, TemplateArgs); 1683 1684 CorrectionCandidateCallback DefaultValidator; 1685 if (DiagnoseEmptyLookup(S, SS, R, CCC ? *CCC : DefaultValidator)) 1686 return ExprError(); 1687 1688 assert(!R.empty() && 1689 "DiagnoseEmptyLookup returned false but added no results"); 1690 1691 // If we found an Objective-C instance variable, let 1692 // LookupInObjCMethod build the appropriate expression to 1693 // reference the ivar. 1694 if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) { 1695 R.clear(); 1696 ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier())); 1697 // In a hopelessly buggy code, Objective-C instance variable 1698 // lookup fails and no expression will be built to reference it. 1699 if (!E.isInvalid() && !E.get()) 1700 return ExprError(); 1701 return move(E); 1702 } 1703 } 1704 } 1705 1706 // This is guaranteed from this point on. 1707 assert(!R.empty() || ADL); 1708 1709 // Check whether this might be a C++ implicit instance member access. 1710 // C++ [class.mfct.non-static]p3: 1711 // When an id-expression that is not part of a class member access 1712 // syntax and not used to form a pointer to member is used in the 1713 // body of a non-static member function of class X, if name lookup 1714 // resolves the name in the id-expression to a non-static non-type 1715 // member of some class C, the id-expression is transformed into a 1716 // class member access expression using (*this) as the 1717 // postfix-expression to the left of the . operator. 1718 // 1719 // But we don't actually need to do this for '&' operands if R 1720 // resolved to a function or overloaded function set, because the 1721 // expression is ill-formed if it actually works out to be a 1722 // non-static member function: 1723 // 1724 // C++ [expr.ref]p4: 1725 // Otherwise, if E1.E2 refers to a non-static member function. . . 1726 // [t]he expression can be used only as the left-hand operand of a 1727 // member function call. 1728 // 1729 // There are other safeguards against such uses, but it's important 1730 // to get this right here so that we don't end up making a 1731 // spuriously dependent expression if we're inside a dependent 1732 // instance method. 1733 if (!R.empty() && (*R.begin())->isCXXClassMember()) { 1734 bool MightBeImplicitMember; 1735 if (!IsAddressOfOperand) 1736 MightBeImplicitMember = true; 1737 else if (!SS.isEmpty()) 1738 MightBeImplicitMember = false; 1739 else if (R.isOverloadedResult()) 1740 MightBeImplicitMember = false; 1741 else if (R.isUnresolvableResult()) 1742 MightBeImplicitMember = true; 1743 else 1744 MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) || 1745 isa<IndirectFieldDecl>(R.getFoundDecl()); 1746 1747 if (MightBeImplicitMember) 1748 return BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, 1749 R, TemplateArgs); 1750 } 1751 1752 if (TemplateArgs || TemplateKWLoc.isValid()) 1753 return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs); 1754 1755 return BuildDeclarationNameExpr(SS, R, ADL); 1756 } 1757 1758 /// BuildQualifiedDeclarationNameExpr - Build a C++ qualified 1759 /// declaration name, generally during template instantiation. 1760 /// There's a large number of things which don't need to be done along 1761 /// this path. 1762 ExprResult 1763 Sema::BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, 1764 const DeclarationNameInfo &NameInfo) { 1765 DeclContext *DC; 1766 if (!(DC = computeDeclContext(SS, false)) || DC->isDependentContext()) 1767 return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(), 1768 NameInfo, /*TemplateArgs=*/0); 1769 1770 if (RequireCompleteDeclContext(SS, DC)) 1771 return ExprError(); 1772 1773 LookupResult R(*this, NameInfo, LookupOrdinaryName); 1774 LookupQualifiedName(R, DC); 1775 1776 if (R.isAmbiguous()) 1777 return ExprError(); 1778 1779 if (R.empty()) { 1780 Diag(NameInfo.getLoc(), diag::err_no_member) 1781 << NameInfo.getName() << DC << SS.getRange(); 1782 return ExprError(); 1783 } 1784 1785 return BuildDeclarationNameExpr(SS, R, /*ADL*/ false); 1786 } 1787 1788 /// LookupInObjCMethod - The parser has read a name in, and Sema has 1789 /// detected that we're currently inside an ObjC method. Perform some 1790 /// additional lookup. 1791 /// 1792 /// Ideally, most of this would be done by lookup, but there's 1793 /// actually quite a lot of extra work involved. 1794 /// 1795 /// Returns a null sentinel to indicate trivial success. 1796 ExprResult 1797 Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S, 1798 IdentifierInfo *II, bool AllowBuiltinCreation) { 1799 SourceLocation Loc = Lookup.getNameLoc(); 1800 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 1801 1802 // There are two cases to handle here. 1) scoped lookup could have failed, 1803 // in which case we should look for an ivar. 2) scoped lookup could have 1804 // found a decl, but that decl is outside the current instance method (i.e. 1805 // a global variable). In these two cases, we do a lookup for an ivar with 1806 // this name, if the lookup sucedes, we replace it our current decl. 1807 1808 // If we're in a class method, we don't normally want to look for 1809 // ivars. But if we don't find anything else, and there's an 1810 // ivar, that's an error. 1811 bool IsClassMethod = CurMethod->isClassMethod(); 1812 1813 bool LookForIvars; 1814 if (Lookup.empty()) 1815 LookForIvars = true; 1816 else if (IsClassMethod) 1817 LookForIvars = false; 1818 else 1819 LookForIvars = (Lookup.isSingleResult() && 1820 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()); 1821 ObjCInterfaceDecl *IFace = 0; 1822 if (LookForIvars) { 1823 IFace = CurMethod->getClassInterface(); 1824 ObjCInterfaceDecl *ClassDeclared; 1825 ObjCIvarDecl *IV = 0; 1826 if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) { 1827 // Diagnose using an ivar in a class method. 1828 if (IsClassMethod) 1829 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 1830 << IV->getDeclName()); 1831 1832 // If we're referencing an invalid decl, just return this as a silent 1833 // error node. The error diagnostic was already emitted on the decl. 1834 if (IV->isInvalidDecl()) 1835 return ExprError(); 1836 1837 // Check if referencing a field with __attribute__((deprecated)). 1838 if (DiagnoseUseOfDecl(IV, Loc)) 1839 return ExprError(); 1840 1841 // Diagnose the use of an ivar outside of the declaring class. 1842 if (IV->getAccessControl() == ObjCIvarDecl::Private && 1843 !declaresSameEntity(ClassDeclared, IFace) && 1844 !getLangOpts().DebuggerSupport) 1845 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName(); 1846 1847 // FIXME: This should use a new expr for a direct reference, don't 1848 // turn this into Self->ivar, just return a BareIVarExpr or something. 1849 IdentifierInfo &II = Context.Idents.get("self"); 1850 UnqualifiedId SelfName; 1851 SelfName.setIdentifier(&II, SourceLocation()); 1852 SelfName.setKind(UnqualifiedId::IK_ImplicitSelfParam); 1853 CXXScopeSpec SelfScopeSpec; 1854 SourceLocation TemplateKWLoc; 1855 ExprResult SelfExpr = ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc, 1856 SelfName, false, false); 1857 if (SelfExpr.isInvalid()) 1858 return ExprError(); 1859 1860 SelfExpr = DefaultLvalueConversion(SelfExpr.take()); 1861 if (SelfExpr.isInvalid()) 1862 return ExprError(); 1863 1864 MarkAnyDeclReferenced(Loc, IV); 1865 return Owned(new (Context) 1866 ObjCIvarRefExpr(IV, IV->getType(), Loc, 1867 SelfExpr.take(), true, true)); 1868 } 1869 } else if (CurMethod->isInstanceMethod()) { 1870 // We should warn if a local variable hides an ivar. 1871 if (ObjCInterfaceDecl *IFace = CurMethod->getClassInterface()) { 1872 ObjCInterfaceDecl *ClassDeclared; 1873 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) { 1874 if (IV->getAccessControl() != ObjCIvarDecl::Private || 1875 declaresSameEntity(IFace, ClassDeclared)) 1876 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName(); 1877 } 1878 } 1879 } else if (Lookup.isSingleResult() && 1880 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()) { 1881 // If accessing a stand-alone ivar in a class method, this is an error. 1882 if (const ObjCIvarDecl *IV = dyn_cast<ObjCIvarDecl>(Lookup.getFoundDecl())) 1883 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 1884 << IV->getDeclName()); 1885 } 1886 1887 if (Lookup.empty() && II && AllowBuiltinCreation) { 1888 // FIXME. Consolidate this with similar code in LookupName. 1889 if (unsigned BuiltinID = II->getBuiltinID()) { 1890 if (!(getLangOpts().CPlusPlus && 1891 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) { 1892 NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID, 1893 S, Lookup.isForRedeclaration(), 1894 Lookup.getNameLoc()); 1895 if (D) Lookup.addDecl(D); 1896 } 1897 } 1898 } 1899 // Sentinel value saying that we didn't do anything special. 1900 return Owned((Expr*) 0); 1901 } 1902 1903 /// \brief Cast a base object to a member's actual type. 1904 /// 1905 /// Logically this happens in three phases: 1906 /// 1907 /// * First we cast from the base type to the naming class. 1908 /// The naming class is the class into which we were looking 1909 /// when we found the member; it's the qualifier type if a 1910 /// qualifier was provided, and otherwise it's the base type. 1911 /// 1912 /// * Next we cast from the naming class to the declaring class. 1913 /// If the member we found was brought into a class's scope by 1914 /// a using declaration, this is that class; otherwise it's 1915 /// the class declaring the member. 1916 /// 1917 /// * Finally we cast from the declaring class to the "true" 1918 /// declaring class of the member. This conversion does not 1919 /// obey access control. 1920 ExprResult 1921 Sema::PerformObjectMemberConversion(Expr *From, 1922 NestedNameSpecifier *Qualifier, 1923 NamedDecl *FoundDecl, 1924 NamedDecl *Member) { 1925 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext()); 1926 if (!RD) 1927 return Owned(From); 1928 1929 QualType DestRecordType; 1930 QualType DestType; 1931 QualType FromRecordType; 1932 QualType FromType = From->getType(); 1933 bool PointerConversions = false; 1934 if (isa<FieldDecl>(Member)) { 1935 DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD)); 1936 1937 if (FromType->getAs<PointerType>()) { 1938 DestType = Context.getPointerType(DestRecordType); 1939 FromRecordType = FromType->getPointeeType(); 1940 PointerConversions = true; 1941 } else { 1942 DestType = DestRecordType; 1943 FromRecordType = FromType; 1944 } 1945 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) { 1946 if (Method->isStatic()) 1947 return Owned(From); 1948 1949 DestType = Method->getThisType(Context); 1950 DestRecordType = DestType->getPointeeType(); 1951 1952 if (FromType->getAs<PointerType>()) { 1953 FromRecordType = FromType->getPointeeType(); 1954 PointerConversions = true; 1955 } else { 1956 FromRecordType = FromType; 1957 DestType = DestRecordType; 1958 } 1959 } else { 1960 // No conversion necessary. 1961 return Owned(From); 1962 } 1963 1964 if (DestType->isDependentType() || FromType->isDependentType()) 1965 return Owned(From); 1966 1967 // If the unqualified types are the same, no conversion is necessary. 1968 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 1969 return Owned(From); 1970 1971 SourceRange FromRange = From->getSourceRange(); 1972 SourceLocation FromLoc = FromRange.getBegin(); 1973 1974 ExprValueKind VK = From->getValueKind(); 1975 1976 // C++ [class.member.lookup]p8: 1977 // [...] Ambiguities can often be resolved by qualifying a name with its 1978 // class name. 1979 // 1980 // If the member was a qualified name and the qualified referred to a 1981 // specific base subobject type, we'll cast to that intermediate type 1982 // first and then to the object in which the member is declared. That allows 1983 // one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as: 1984 // 1985 // class Base { public: int x; }; 1986 // class Derived1 : public Base { }; 1987 // class Derived2 : public Base { }; 1988 // class VeryDerived : public Derived1, public Derived2 { void f(); }; 1989 // 1990 // void VeryDerived::f() { 1991 // x = 17; // error: ambiguous base subobjects 1992 // Derived1::x = 17; // okay, pick the Base subobject of Derived1 1993 // } 1994 if (Qualifier) { 1995 QualType QType = QualType(Qualifier->getAsType(), 0); 1996 assert(!QType.isNull() && "lookup done with dependent qualifier?"); 1997 assert(QType->isRecordType() && "lookup done with non-record type"); 1998 1999 QualType QRecordType = QualType(QType->getAs<RecordType>(), 0); 2000 2001 // In C++98, the qualifier type doesn't actually have to be a base 2002 // type of the object type, in which case we just ignore it. 2003 // Otherwise build the appropriate casts. 2004 if (IsDerivedFrom(FromRecordType, QRecordType)) { 2005 CXXCastPath BasePath; 2006 if (CheckDerivedToBaseConversion(FromRecordType, QRecordType, 2007 FromLoc, FromRange, &BasePath)) 2008 return ExprError(); 2009 2010 if (PointerConversions) 2011 QType = Context.getPointerType(QType); 2012 From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase, 2013 VK, &BasePath).take(); 2014 2015 FromType = QType; 2016 FromRecordType = QRecordType; 2017 2018 // If the qualifier type was the same as the destination type, 2019 // we're done. 2020 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 2021 return Owned(From); 2022 } 2023 } 2024 2025 bool IgnoreAccess = false; 2026 2027 // If we actually found the member through a using declaration, cast 2028 // down to the using declaration's type. 2029 // 2030 // Pointer equality is fine here because only one declaration of a 2031 // class ever has member declarations. 2032 if (FoundDecl->getDeclContext() != Member->getDeclContext()) { 2033 assert(isa<UsingShadowDecl>(FoundDecl)); 2034 QualType URecordType = Context.getTypeDeclType( 2035 cast<CXXRecordDecl>(FoundDecl->getDeclContext())); 2036 2037 // We only need to do this if the naming-class to declaring-class 2038 // conversion is non-trivial. 2039 if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) { 2040 assert(IsDerivedFrom(FromRecordType, URecordType)); 2041 CXXCastPath BasePath; 2042 if (CheckDerivedToBaseConversion(FromRecordType, URecordType, 2043 FromLoc, FromRange, &BasePath)) 2044 return ExprError(); 2045 2046 QualType UType = URecordType; 2047 if (PointerConversions) 2048 UType = Context.getPointerType(UType); 2049 From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase, 2050 VK, &BasePath).take(); 2051 FromType = UType; 2052 FromRecordType = URecordType; 2053 } 2054 2055 // We don't do access control for the conversion from the 2056 // declaring class to the true declaring class. 2057 IgnoreAccess = true; 2058 } 2059 2060 CXXCastPath BasePath; 2061 if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType, 2062 FromLoc, FromRange, &BasePath, 2063 IgnoreAccess)) 2064 return ExprError(); 2065 2066 return ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase, 2067 VK, &BasePath); 2068 } 2069 2070 bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS, 2071 const LookupResult &R, 2072 bool HasTrailingLParen) { 2073 // Only when used directly as the postfix-expression of a call. 2074 if (!HasTrailingLParen) 2075 return false; 2076 2077 // Never if a scope specifier was provided. 2078 if (SS.isSet()) 2079 return false; 2080 2081 // Only in C++ or ObjC++. 2082 if (!getLangOpts().CPlusPlus) 2083 return false; 2084 2085 // Turn off ADL when we find certain kinds of declarations during 2086 // normal lookup: 2087 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { 2088 NamedDecl *D = *I; 2089 2090 // C++0x [basic.lookup.argdep]p3: 2091 // -- a declaration of a class member 2092 // Since using decls preserve this property, we check this on the 2093 // original decl. 2094 if (D->isCXXClassMember()) 2095 return false; 2096 2097 // C++0x [basic.lookup.argdep]p3: 2098 // -- a block-scope function declaration that is not a 2099 // using-declaration 2100 // NOTE: we also trigger this for function templates (in fact, we 2101 // don't check the decl type at all, since all other decl types 2102 // turn off ADL anyway). 2103 if (isa<UsingShadowDecl>(D)) 2104 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 2105 else if (D->getDeclContext()->isFunctionOrMethod()) 2106 return false; 2107 2108 // C++0x [basic.lookup.argdep]p3: 2109 // -- a declaration that is neither a function or a function 2110 // template 2111 // And also for builtin functions. 2112 if (isa<FunctionDecl>(D)) { 2113 FunctionDecl *FDecl = cast<FunctionDecl>(D); 2114 2115 // But also builtin functions. 2116 if (FDecl->getBuiltinID() && FDecl->isImplicit()) 2117 return false; 2118 } else if (!isa<FunctionTemplateDecl>(D)) 2119 return false; 2120 } 2121 2122 return true; 2123 } 2124 2125 2126 /// Diagnoses obvious problems with the use of the given declaration 2127 /// as an expression. This is only actually called for lookups that 2128 /// were not overloaded, and it doesn't promise that the declaration 2129 /// will in fact be used. 2130 static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) { 2131 if (isa<TypedefNameDecl>(D)) { 2132 S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName(); 2133 return true; 2134 } 2135 2136 if (isa<ObjCInterfaceDecl>(D)) { 2137 S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName(); 2138 return true; 2139 } 2140 2141 if (isa<NamespaceDecl>(D)) { 2142 S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName(); 2143 return true; 2144 } 2145 2146 return false; 2147 } 2148 2149 ExprResult 2150 Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2151 LookupResult &R, 2152 bool NeedsADL) { 2153 // If this is a single, fully-resolved result and we don't need ADL, 2154 // just build an ordinary singleton decl ref. 2155 if (!NeedsADL && R.isSingleResult() && !R.getAsSingle<FunctionTemplateDecl>()) 2156 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), 2157 R.getFoundDecl()); 2158 2159 // We only need to check the declaration if there's exactly one 2160 // result, because in the overloaded case the results can only be 2161 // functions and function templates. 2162 if (R.isSingleResult() && 2163 CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl())) 2164 return ExprError(); 2165 2166 // Otherwise, just build an unresolved lookup expression. Suppress 2167 // any lookup-related diagnostics; we'll hash these out later, when 2168 // we've picked a target. 2169 R.suppressDiagnostics(); 2170 2171 UnresolvedLookupExpr *ULE 2172 = UnresolvedLookupExpr::Create(Context, R.getNamingClass(), 2173 SS.getWithLocInContext(Context), 2174 R.getLookupNameInfo(), 2175 NeedsADL, R.isOverloadedResult(), 2176 R.begin(), R.end()); 2177 2178 return Owned(ULE); 2179 } 2180 2181 /// \brief Complete semantic analysis for a reference to the given declaration. 2182 ExprResult 2183 Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2184 const DeclarationNameInfo &NameInfo, 2185 NamedDecl *D) { 2186 assert(D && "Cannot refer to a NULL declaration"); 2187 assert(!isa<FunctionTemplateDecl>(D) && 2188 "Cannot refer unambiguously to a function template"); 2189 2190 SourceLocation Loc = NameInfo.getLoc(); 2191 if (CheckDeclInExpr(*this, Loc, D)) 2192 return ExprError(); 2193 2194 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) { 2195 // Specifically diagnose references to class templates that are missing 2196 // a template argument list. 2197 Diag(Loc, diag::err_template_decl_ref) 2198 << Template << SS.getRange(); 2199 Diag(Template->getLocation(), diag::note_template_decl_here); 2200 return ExprError(); 2201 } 2202 2203 // Make sure that we're referring to a value. 2204 ValueDecl *VD = dyn_cast<ValueDecl>(D); 2205 if (!VD) { 2206 Diag(Loc, diag::err_ref_non_value) 2207 << D << SS.getRange(); 2208 Diag(D->getLocation(), diag::note_declared_at); 2209 return ExprError(); 2210 } 2211 2212 // Check whether this declaration can be used. Note that we suppress 2213 // this check when we're going to perform argument-dependent lookup 2214 // on this function name, because this might not be the function 2215 // that overload resolution actually selects. 2216 if (DiagnoseUseOfDecl(VD, Loc)) 2217 return ExprError(); 2218 2219 // Only create DeclRefExpr's for valid Decl's. 2220 if (VD->isInvalidDecl()) 2221 return ExprError(); 2222 2223 // Handle members of anonymous structs and unions. If we got here, 2224 // and the reference is to a class member indirect field, then this 2225 // must be the subject of a pointer-to-member expression. 2226 if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD)) 2227 if (!indirectField->isCXXClassMember()) 2228 return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(), 2229 indirectField); 2230 2231 { 2232 QualType type = VD->getType(); 2233 ExprValueKind valueKind = VK_RValue; 2234 2235 switch (D->getKind()) { 2236 // Ignore all the non-ValueDecl kinds. 2237 #define ABSTRACT_DECL(kind) 2238 #define VALUE(type, base) 2239 #define DECL(type, base) \ 2240 case Decl::type: 2241 #include "clang/AST/DeclNodes.inc" 2242 llvm_unreachable("invalid value decl kind"); 2243 2244 // These shouldn't make it here. 2245 case Decl::ObjCAtDefsField: 2246 case Decl::ObjCIvar: 2247 llvm_unreachable("forming non-member reference to ivar?"); 2248 2249 // Enum constants are always r-values and never references. 2250 // Unresolved using declarations are dependent. 2251 case Decl::EnumConstant: 2252 case Decl::UnresolvedUsingValue: 2253 valueKind = VK_RValue; 2254 break; 2255 2256 // Fields and indirect fields that got here must be for 2257 // pointer-to-member expressions; we just call them l-values for 2258 // internal consistency, because this subexpression doesn't really 2259 // exist in the high-level semantics. 2260 case Decl::Field: 2261 case Decl::IndirectField: 2262 assert(getLangOpts().CPlusPlus && 2263 "building reference to field in C?"); 2264 2265 // These can't have reference type in well-formed programs, but 2266 // for internal consistency we do this anyway. 2267 type = type.getNonReferenceType(); 2268 valueKind = VK_LValue; 2269 break; 2270 2271 // Non-type template parameters are either l-values or r-values 2272 // depending on the type. 2273 case Decl::NonTypeTemplateParm: { 2274 if (const ReferenceType *reftype = type->getAs<ReferenceType>()) { 2275 type = reftype->getPointeeType(); 2276 valueKind = VK_LValue; // even if the parameter is an r-value reference 2277 break; 2278 } 2279 2280 // For non-references, we need to strip qualifiers just in case 2281 // the template parameter was declared as 'const int' or whatever. 2282 valueKind = VK_RValue; 2283 type = type.getUnqualifiedType(); 2284 break; 2285 } 2286 2287 case Decl::Var: 2288 // In C, "extern void blah;" is valid and is an r-value. 2289 if (!getLangOpts().CPlusPlus && 2290 !type.hasQualifiers() && 2291 type->isVoidType()) { 2292 valueKind = VK_RValue; 2293 break; 2294 } 2295 // fallthrough 2296 2297 case Decl::ImplicitParam: 2298 case Decl::ParmVar: { 2299 // These are always l-values. 2300 valueKind = VK_LValue; 2301 type = type.getNonReferenceType(); 2302 2303 // FIXME: Does the addition of const really only apply in 2304 // potentially-evaluated contexts? Since the variable isn't actually 2305 // captured in an unevaluated context, it seems that the answer is no. 2306 if (ExprEvalContexts.back().Context != Sema::Unevaluated) { 2307 QualType CapturedType = getCapturedDeclRefType(cast<VarDecl>(VD), Loc); 2308 if (!CapturedType.isNull()) 2309 type = CapturedType; 2310 } 2311 2312 break; 2313 } 2314 2315 case Decl::Function: { 2316 const FunctionType *fty = type->castAs<FunctionType>(); 2317 2318 // If we're referring to a function with an __unknown_anytype 2319 // result type, make the entire expression __unknown_anytype. 2320 if (fty->getResultType() == Context.UnknownAnyTy) { 2321 type = Context.UnknownAnyTy; 2322 valueKind = VK_RValue; 2323 break; 2324 } 2325 2326 // Functions are l-values in C++. 2327 if (getLangOpts().CPlusPlus) { 2328 valueKind = VK_LValue; 2329 break; 2330 } 2331 2332 // C99 DR 316 says that, if a function type comes from a 2333 // function definition (without a prototype), that type is only 2334 // used for checking compatibility. Therefore, when referencing 2335 // the function, we pretend that we don't have the full function 2336 // type. 2337 if (!cast<FunctionDecl>(VD)->hasPrototype() && 2338 isa<FunctionProtoType>(fty)) 2339 type = Context.getFunctionNoProtoType(fty->getResultType(), 2340 fty->getExtInfo()); 2341 2342 // Functions are r-values in C. 2343 valueKind = VK_RValue; 2344 break; 2345 } 2346 2347 case Decl::CXXMethod: 2348 // If we're referring to a method with an __unknown_anytype 2349 // result type, make the entire expression __unknown_anytype. 2350 // This should only be possible with a type written directly. 2351 if (const FunctionProtoType *proto 2352 = dyn_cast<FunctionProtoType>(VD->getType())) 2353 if (proto->getResultType() == Context.UnknownAnyTy) { 2354 type = Context.UnknownAnyTy; 2355 valueKind = VK_RValue; 2356 break; 2357 } 2358 2359 // C++ methods are l-values if static, r-values if non-static. 2360 if (cast<CXXMethodDecl>(VD)->isStatic()) { 2361 valueKind = VK_LValue; 2362 break; 2363 } 2364 // fallthrough 2365 2366 case Decl::CXXConversion: 2367 case Decl::CXXDestructor: 2368 case Decl::CXXConstructor: 2369 valueKind = VK_RValue; 2370 break; 2371 } 2372 2373 return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS); 2374 } 2375 } 2376 2377 ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) { 2378 PredefinedExpr::IdentType IT; 2379 2380 switch (Kind) { 2381 default: llvm_unreachable("Unknown simple primary expr!"); 2382 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2] 2383 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break; 2384 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break; 2385 } 2386 2387 // Pre-defined identifiers are of type char[x], where x is the length of the 2388 // string. 2389 2390 Decl *currentDecl = getCurFunctionOrMethodDecl(); 2391 if (!currentDecl && getCurBlock()) 2392 currentDecl = getCurBlock()->TheDecl; 2393 if (!currentDecl) { 2394 Diag(Loc, diag::ext_predef_outside_function); 2395 currentDecl = Context.getTranslationUnitDecl(); 2396 } 2397 2398 QualType ResTy; 2399 if (cast<DeclContext>(currentDecl)->isDependentContext()) { 2400 ResTy = Context.DependentTy; 2401 } else { 2402 unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length(); 2403 2404 llvm::APInt LengthI(32, Length + 1); 2405 ResTy = Context.CharTy.withConst(); 2406 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0); 2407 } 2408 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT)); 2409 } 2410 2411 ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) { 2412 SmallString<16> CharBuffer; 2413 bool Invalid = false; 2414 StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid); 2415 if (Invalid) 2416 return ExprError(); 2417 2418 CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(), 2419 PP, Tok.getKind()); 2420 if (Literal.hadError()) 2421 return ExprError(); 2422 2423 QualType Ty; 2424 if (Literal.isWide()) 2425 Ty = Context.WCharTy; // L'x' -> wchar_t in C and C++. 2426 else if (Literal.isUTF16()) 2427 Ty = Context.Char16Ty; // u'x' -> char16_t in C11 and C++11. 2428 else if (Literal.isUTF32()) 2429 Ty = Context.Char32Ty; // U'x' -> char32_t in C11 and C++11. 2430 else if (!getLangOpts().CPlusPlus || Literal.isMultiChar()) 2431 Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++. 2432 else 2433 Ty = Context.CharTy; // 'x' -> char in C++ 2434 2435 CharacterLiteral::CharacterKind Kind = CharacterLiteral::Ascii; 2436 if (Literal.isWide()) 2437 Kind = CharacterLiteral::Wide; 2438 else if (Literal.isUTF16()) 2439 Kind = CharacterLiteral::UTF16; 2440 else if (Literal.isUTF32()) 2441 Kind = CharacterLiteral::UTF32; 2442 2443 Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty, 2444 Tok.getLocation()); 2445 2446 if (Literal.getUDSuffix().empty()) 2447 return Owned(Lit); 2448 2449 // We're building a user-defined literal. 2450 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 2451 SourceLocation UDSuffixLoc = 2452 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset()); 2453 2454 // Make sure we're allowed user-defined literals here. 2455 if (!UDLScope) 2456 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_character_udl)); 2457 2458 // C++11 [lex.ext]p6: The literal L is treated as a call of the form 2459 // operator "" X (ch) 2460 return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc, 2461 llvm::makeArrayRef(&Lit, 1), 2462 Tok.getLocation()); 2463 } 2464 2465 ExprResult Sema::ActOnIntegerConstant(SourceLocation Loc, uint64_t Val) { 2466 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 2467 return Owned(IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val), 2468 Context.IntTy, Loc)); 2469 } 2470 2471 static Expr *BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal, 2472 QualType Ty, SourceLocation Loc) { 2473 const llvm::fltSemantics &Format = S.Context.getFloatTypeSemantics(Ty); 2474 2475 using llvm::APFloat; 2476 APFloat Val(Format); 2477 2478 APFloat::opStatus result = Literal.GetFloatValue(Val); 2479 2480 // Overflow is always an error, but underflow is only an error if 2481 // we underflowed to zero (APFloat reports denormals as underflow). 2482 if ((result & APFloat::opOverflow) || 2483 ((result & APFloat::opUnderflow) && Val.isZero())) { 2484 unsigned diagnostic; 2485 SmallString<20> buffer; 2486 if (result & APFloat::opOverflow) { 2487 diagnostic = diag::warn_float_overflow; 2488 APFloat::getLargest(Format).toString(buffer); 2489 } else { 2490 diagnostic = diag::warn_float_underflow; 2491 APFloat::getSmallest(Format).toString(buffer); 2492 } 2493 2494 S.Diag(Loc, diagnostic) 2495 << Ty 2496 << StringRef(buffer.data(), buffer.size()); 2497 } 2498 2499 bool isExact = (result == APFloat::opOK); 2500 return FloatingLiteral::Create(S.Context, Val, isExact, Ty, Loc); 2501 } 2502 2503 ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) { 2504 // Fast path for a single digit (which is quite common). A single digit 2505 // cannot have a trigraph, escaped newline, radix prefix, or suffix. 2506 if (Tok.getLength() == 1) { 2507 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok); 2508 return ActOnIntegerConstant(Tok.getLocation(), Val-'0'); 2509 } 2510 2511 SmallString<512> IntegerBuffer; 2512 // Add padding so that NumericLiteralParser can overread by one character. 2513 IntegerBuffer.resize(Tok.getLength()+1); 2514 const char *ThisTokBegin = &IntegerBuffer[0]; 2515 2516 // Get the spelling of the token, which eliminates trigraphs, etc. 2517 bool Invalid = false; 2518 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid); 2519 if (Invalid) 2520 return ExprError(); 2521 2522 NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength, 2523 Tok.getLocation(), PP); 2524 if (Literal.hadError) 2525 return ExprError(); 2526 2527 if (Literal.hasUDSuffix()) { 2528 // We're building a user-defined literal. 2529 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 2530 SourceLocation UDSuffixLoc = 2531 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset()); 2532 2533 // Make sure we're allowed user-defined literals here. 2534 if (!UDLScope) 2535 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_numeric_udl)); 2536 2537 QualType CookedTy; 2538 if (Literal.isFloatingLiteral()) { 2539 // C++11 [lex.ext]p4: If S contains a literal operator with parameter type 2540 // long double, the literal is treated as a call of the form 2541 // operator "" X (f L) 2542 CookedTy = Context.LongDoubleTy; 2543 } else { 2544 // C++11 [lex.ext]p3: If S contains a literal operator with parameter type 2545 // unsigned long long, the literal is treated as a call of the form 2546 // operator "" X (n ULL) 2547 CookedTy = Context.UnsignedLongLongTy; 2548 } 2549 2550 DeclarationName OpName = 2551 Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 2552 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 2553 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 2554 2555 // Perform literal operator lookup to determine if we're building a raw 2556 // literal or a cooked one. 2557 LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName); 2558 switch (LookupLiteralOperator(UDLScope, R, llvm::makeArrayRef(&CookedTy, 1), 2559 /*AllowRawAndTemplate*/true)) { 2560 case LOLR_Error: 2561 return ExprError(); 2562 2563 case LOLR_Cooked: { 2564 Expr *Lit; 2565 if (Literal.isFloatingLiteral()) { 2566 Lit = BuildFloatingLiteral(*this, Literal, CookedTy, Tok.getLocation()); 2567 } else { 2568 llvm::APInt ResultVal(Context.getTargetInfo().getLongLongWidth(), 0); 2569 if (Literal.GetIntegerValue(ResultVal)) 2570 Diag(Tok.getLocation(), diag::warn_integer_too_large); 2571 Lit = IntegerLiteral::Create(Context, ResultVal, CookedTy, 2572 Tok.getLocation()); 2573 } 2574 return BuildLiteralOperatorCall(R, OpNameInfo, 2575 llvm::makeArrayRef(&Lit, 1), 2576 Tok.getLocation()); 2577 } 2578 2579 case LOLR_Raw: { 2580 // C++11 [lit.ext]p3, p4: If S contains a raw literal operator, the 2581 // literal is treated as a call of the form 2582 // operator "" X ("n") 2583 SourceLocation TokLoc = Tok.getLocation(); 2584 unsigned Length = Literal.getUDSuffixOffset(); 2585 QualType StrTy = Context.getConstantArrayType( 2586 Context.CharTy, llvm::APInt(32, Length + 1), 2587 ArrayType::Normal, 0); 2588 Expr *Lit = StringLiteral::Create( 2589 Context, StringRef(ThisTokBegin, Length), StringLiteral::Ascii, 2590 /*Pascal*/false, StrTy, &TokLoc, 1); 2591 return BuildLiteralOperatorCall(R, OpNameInfo, 2592 llvm::makeArrayRef(&Lit, 1), TokLoc); 2593 } 2594 2595 case LOLR_Template: 2596 // C++11 [lit.ext]p3, p4: Otherwise (S contains a literal operator 2597 // template), L is treated as a call fo the form 2598 // operator "" X <'c1', 'c2', ... 'ck'>() 2599 // where n is the source character sequence c1 c2 ... ck. 2600 TemplateArgumentListInfo ExplicitArgs; 2601 unsigned CharBits = Context.getIntWidth(Context.CharTy); 2602 bool CharIsUnsigned = Context.CharTy->isUnsignedIntegerType(); 2603 llvm::APSInt Value(CharBits, CharIsUnsigned); 2604 for (unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) { 2605 Value = ThisTokBegin[I]; 2606 TemplateArgument Arg(Value, Context.CharTy); 2607 TemplateArgumentLocInfo ArgInfo; 2608 ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo)); 2609 } 2610 return BuildLiteralOperatorCall(R, OpNameInfo, ArrayRef<Expr*>(), 2611 Tok.getLocation(), &ExplicitArgs); 2612 } 2613 2614 llvm_unreachable("unexpected literal operator lookup result"); 2615 } 2616 2617 Expr *Res; 2618 2619 if (Literal.isFloatingLiteral()) { 2620 QualType Ty; 2621 if (Literal.isFloat) 2622 Ty = Context.FloatTy; 2623 else if (!Literal.isLong) 2624 Ty = Context.DoubleTy; 2625 else 2626 Ty = Context.LongDoubleTy; 2627 2628 Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation()); 2629 2630 if (Ty == Context.DoubleTy) { 2631 if (getLangOpts().SinglePrecisionConstants) { 2632 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); 2633 } else if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp64) { 2634 Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64); 2635 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); 2636 } 2637 } 2638 } else if (!Literal.isIntegerLiteral()) { 2639 return ExprError(); 2640 } else { 2641 QualType Ty; 2642 2643 // long long is a C99 feature. 2644 if (!getLangOpts().C99 && Literal.isLongLong) 2645 Diag(Tok.getLocation(), 2646 getLangOpts().CPlusPlus0x ? 2647 diag::warn_cxx98_compat_longlong : diag::ext_longlong); 2648 2649 // Get the value in the widest-possible width. 2650 llvm::APInt ResultVal(Context.getTargetInfo().getIntMaxTWidth(), 0); 2651 2652 if (Literal.GetIntegerValue(ResultVal)) { 2653 // If this value didn't fit into uintmax_t, warn and force to ull. 2654 Diag(Tok.getLocation(), diag::warn_integer_too_large); 2655 Ty = Context.UnsignedLongLongTy; 2656 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() && 2657 "long long is not intmax_t?"); 2658 } else { 2659 // If this value fits into a ULL, try to figure out what else it fits into 2660 // according to the rules of C99 6.4.4.1p5. 2661 2662 // Octal, Hexadecimal, and integers with a U suffix are allowed to 2663 // be an unsigned int. 2664 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10; 2665 2666 // Check from smallest to largest, picking the smallest type we can. 2667 unsigned Width = 0; 2668 if (!Literal.isLong && !Literal.isLongLong) { 2669 // Are int/unsigned possibilities? 2670 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 2671 2672 // Does it fit in a unsigned int? 2673 if (ResultVal.isIntN(IntSize)) { 2674 // Does it fit in a signed int? 2675 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0) 2676 Ty = Context.IntTy; 2677 else if (AllowUnsigned) 2678 Ty = Context.UnsignedIntTy; 2679 Width = IntSize; 2680 } 2681 } 2682 2683 // Are long/unsigned long possibilities? 2684 if (Ty.isNull() && !Literal.isLongLong) { 2685 unsigned LongSize = Context.getTargetInfo().getLongWidth(); 2686 2687 // Does it fit in a unsigned long? 2688 if (ResultVal.isIntN(LongSize)) { 2689 // Does it fit in a signed long? 2690 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0) 2691 Ty = Context.LongTy; 2692 else if (AllowUnsigned) 2693 Ty = Context.UnsignedLongTy; 2694 Width = LongSize; 2695 } 2696 } 2697 2698 // Finally, check long long if needed. 2699 if (Ty.isNull()) { 2700 unsigned LongLongSize = Context.getTargetInfo().getLongLongWidth(); 2701 2702 // Does it fit in a unsigned long long? 2703 if (ResultVal.isIntN(LongLongSize)) { 2704 // Does it fit in a signed long long? 2705 // To be compatible with MSVC, hex integer literals ending with the 2706 // LL or i64 suffix are always signed in Microsoft mode. 2707 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 || 2708 (getLangOpts().MicrosoftExt && Literal.isLongLong))) 2709 Ty = Context.LongLongTy; 2710 else if (AllowUnsigned) 2711 Ty = Context.UnsignedLongLongTy; 2712 Width = LongLongSize; 2713 } 2714 } 2715 2716 // If we still couldn't decide a type, we probably have something that 2717 // does not fit in a signed long long, but has no U suffix. 2718 if (Ty.isNull()) { 2719 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed); 2720 Ty = Context.UnsignedLongLongTy; 2721 Width = Context.getTargetInfo().getLongLongWidth(); 2722 } 2723 2724 if (ResultVal.getBitWidth() != Width) 2725 ResultVal = ResultVal.trunc(Width); 2726 } 2727 Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation()); 2728 } 2729 2730 // If this is an imaginary literal, create the ImaginaryLiteral wrapper. 2731 if (Literal.isImaginary) 2732 Res = new (Context) ImaginaryLiteral(Res, 2733 Context.getComplexType(Res->getType())); 2734 2735 return Owned(Res); 2736 } 2737 2738 ExprResult Sema::ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E) { 2739 assert((E != 0) && "ActOnParenExpr() missing expr"); 2740 return Owned(new (Context) ParenExpr(L, R, E)); 2741 } 2742 2743 static bool CheckVecStepTraitOperandType(Sema &S, QualType T, 2744 SourceLocation Loc, 2745 SourceRange ArgRange) { 2746 // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in 2747 // scalar or vector data type argument..." 2748 // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic 2749 // type (C99 6.2.5p18) or void. 2750 if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) { 2751 S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type) 2752 << T << ArgRange; 2753 return true; 2754 } 2755 2756 assert((T->isVoidType() || !T->isIncompleteType()) && 2757 "Scalar types should always be complete"); 2758 return false; 2759 } 2760 2761 static bool CheckExtensionTraitOperandType(Sema &S, QualType T, 2762 SourceLocation Loc, 2763 SourceRange ArgRange, 2764 UnaryExprOrTypeTrait TraitKind) { 2765 // C99 6.5.3.4p1: 2766 if (T->isFunctionType()) { 2767 // alignof(function) is allowed as an extension. 2768 if (TraitKind == UETT_SizeOf) 2769 S.Diag(Loc, diag::ext_sizeof_function_type) << ArgRange; 2770 return false; 2771 } 2772 2773 // Allow sizeof(void)/alignof(void) as an extension. 2774 if (T->isVoidType()) { 2775 S.Diag(Loc, diag::ext_sizeof_void_type) << TraitKind << ArgRange; 2776 return false; 2777 } 2778 2779 return true; 2780 } 2781 2782 static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, 2783 SourceLocation Loc, 2784 SourceRange ArgRange, 2785 UnaryExprOrTypeTrait TraitKind) { 2786 // Reject sizeof(interface) and sizeof(interface<proto>) in 64-bit mode. 2787 if (S.LangOpts.ObjCNonFragileABI && T->isObjCObjectType()) { 2788 S.Diag(Loc, diag::err_sizeof_nonfragile_interface) 2789 << T << (TraitKind == UETT_SizeOf) 2790 << ArgRange; 2791 return true; 2792 } 2793 2794 return false; 2795 } 2796 2797 /// \brief Check the constrains on expression operands to unary type expression 2798 /// and type traits. 2799 /// 2800 /// Completes any types necessary and validates the constraints on the operand 2801 /// expression. The logic mostly mirrors the type-based overload, but may modify 2802 /// the expression as it completes the type for that expression through template 2803 /// instantiation, etc. 2804 bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E, 2805 UnaryExprOrTypeTrait ExprKind) { 2806 QualType ExprTy = E->getType(); 2807 2808 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 2809 // the result is the size of the referenced type." 2810 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the 2811 // result shall be the alignment of the referenced type." 2812 if (const ReferenceType *Ref = ExprTy->getAs<ReferenceType>()) 2813 ExprTy = Ref->getPointeeType(); 2814 2815 if (ExprKind == UETT_VecStep) 2816 return CheckVecStepTraitOperandType(*this, ExprTy, E->getExprLoc(), 2817 E->getSourceRange()); 2818 2819 // Whitelist some types as extensions 2820 if (!CheckExtensionTraitOperandType(*this, ExprTy, E->getExprLoc(), 2821 E->getSourceRange(), ExprKind)) 2822 return false; 2823 2824 if (RequireCompleteExprType(E, 2825 PDiag(diag::err_sizeof_alignof_incomplete_type) 2826 << ExprKind << E->getSourceRange(), 2827 std::make_pair(SourceLocation(), PDiag(0)))) 2828 return true; 2829 2830 // Completeing the expression's type may have changed it. 2831 ExprTy = E->getType(); 2832 if (const ReferenceType *Ref = ExprTy->getAs<ReferenceType>()) 2833 ExprTy = Ref->getPointeeType(); 2834 2835 if (CheckObjCTraitOperandConstraints(*this, ExprTy, E->getExprLoc(), 2836 E->getSourceRange(), ExprKind)) 2837 return true; 2838 2839 if (ExprKind == UETT_SizeOf) { 2840 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E->IgnoreParens())) { 2841 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) { 2842 QualType OType = PVD->getOriginalType(); 2843 QualType Type = PVD->getType(); 2844 if (Type->isPointerType() && OType->isArrayType()) { 2845 Diag(E->getExprLoc(), diag::warn_sizeof_array_param) 2846 << Type << OType; 2847 Diag(PVD->getLocation(), diag::note_declared_at); 2848 } 2849 } 2850 } 2851 } 2852 2853 return false; 2854 } 2855 2856 /// \brief Check the constraints on operands to unary expression and type 2857 /// traits. 2858 /// 2859 /// This will complete any types necessary, and validate the various constraints 2860 /// on those operands. 2861 /// 2862 /// The UsualUnaryConversions() function is *not* called by this routine. 2863 /// C99 6.3.2.1p[2-4] all state: 2864 /// Except when it is the operand of the sizeof operator ... 2865 /// 2866 /// C++ [expr.sizeof]p4 2867 /// The lvalue-to-rvalue, array-to-pointer, and function-to-pointer 2868 /// standard conversions are not applied to the operand of sizeof. 2869 /// 2870 /// This policy is followed for all of the unary trait expressions. 2871 bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType, 2872 SourceLocation OpLoc, 2873 SourceRange ExprRange, 2874 UnaryExprOrTypeTrait ExprKind) { 2875 if (ExprType->isDependentType()) 2876 return false; 2877 2878 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 2879 // the result is the size of the referenced type." 2880 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the 2881 // result shall be the alignment of the referenced type." 2882 if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>()) 2883 ExprType = Ref->getPointeeType(); 2884 2885 if (ExprKind == UETT_VecStep) 2886 return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange); 2887 2888 // Whitelist some types as extensions 2889 if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange, 2890 ExprKind)) 2891 return false; 2892 2893 if (RequireCompleteType(OpLoc, ExprType, 2894 PDiag(diag::err_sizeof_alignof_incomplete_type) 2895 << ExprKind << ExprRange)) 2896 return true; 2897 2898 if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange, 2899 ExprKind)) 2900 return true; 2901 2902 return false; 2903 } 2904 2905 static bool CheckAlignOfExpr(Sema &S, Expr *E) { 2906 E = E->IgnoreParens(); 2907 2908 // alignof decl is always ok. 2909 if (isa<DeclRefExpr>(E)) 2910 return false; 2911 2912 // Cannot know anything else if the expression is dependent. 2913 if (E->isTypeDependent()) 2914 return false; 2915 2916 if (E->getBitField()) { 2917 S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) 2918 << 1 << E->getSourceRange(); 2919 return true; 2920 } 2921 2922 // Alignment of a field access is always okay, so long as it isn't a 2923 // bit-field. 2924 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) 2925 if (isa<FieldDecl>(ME->getMemberDecl())) 2926 return false; 2927 2928 return S.CheckUnaryExprOrTypeTraitOperand(E, UETT_AlignOf); 2929 } 2930 2931 bool Sema::CheckVecStepExpr(Expr *E) { 2932 E = E->IgnoreParens(); 2933 2934 // Cannot know anything else if the expression is dependent. 2935 if (E->isTypeDependent()) 2936 return false; 2937 2938 return CheckUnaryExprOrTypeTraitOperand(E, UETT_VecStep); 2939 } 2940 2941 /// \brief Build a sizeof or alignof expression given a type operand. 2942 ExprResult 2943 Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, 2944 SourceLocation OpLoc, 2945 UnaryExprOrTypeTrait ExprKind, 2946 SourceRange R) { 2947 if (!TInfo) 2948 return ExprError(); 2949 2950 QualType T = TInfo->getType(); 2951 2952 if (!T->isDependentType() && 2953 CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind)) 2954 return ExprError(); 2955 2956 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 2957 return Owned(new (Context) UnaryExprOrTypeTraitExpr(ExprKind, TInfo, 2958 Context.getSizeType(), 2959 OpLoc, R.getEnd())); 2960 } 2961 2962 /// \brief Build a sizeof or alignof expression given an expression 2963 /// operand. 2964 ExprResult 2965 Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc, 2966 UnaryExprOrTypeTrait ExprKind) { 2967 ExprResult PE = CheckPlaceholderExpr(E); 2968 if (PE.isInvalid()) 2969 return ExprError(); 2970 2971 E = PE.get(); 2972 2973 // Verify that the operand is valid. 2974 bool isInvalid = false; 2975 if (E->isTypeDependent()) { 2976 // Delay type-checking for type-dependent expressions. 2977 } else if (ExprKind == UETT_AlignOf) { 2978 isInvalid = CheckAlignOfExpr(*this, E); 2979 } else if (ExprKind == UETT_VecStep) { 2980 isInvalid = CheckVecStepExpr(E); 2981 } else if (E->getBitField()) { // C99 6.5.3.4p1. 2982 Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) << 0; 2983 isInvalid = true; 2984 } else { 2985 isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf); 2986 } 2987 2988 if (isInvalid) 2989 return ExprError(); 2990 2991 if (ExprKind == UETT_SizeOf && E->getType()->isVariableArrayType()) { 2992 PE = TranformToPotentiallyEvaluated(E); 2993 if (PE.isInvalid()) return ExprError(); 2994 E = PE.take(); 2995 } 2996 2997 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 2998 return Owned(new (Context) UnaryExprOrTypeTraitExpr( 2999 ExprKind, E, Context.getSizeType(), OpLoc, 3000 E->getSourceRange().getEnd())); 3001 } 3002 3003 /// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c 3004 /// expr and the same for @c alignof and @c __alignof 3005 /// Note that the ArgRange is invalid if isType is false. 3006 ExprResult 3007 Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, 3008 UnaryExprOrTypeTrait ExprKind, bool IsType, 3009 void *TyOrEx, const SourceRange &ArgRange) { 3010 // If error parsing type, ignore. 3011 if (TyOrEx == 0) return ExprError(); 3012 3013 if (IsType) { 3014 TypeSourceInfo *TInfo; 3015 (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo); 3016 return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange); 3017 } 3018 3019 Expr *ArgEx = (Expr *)TyOrEx; 3020 ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind); 3021 return move(Result); 3022 } 3023 3024 static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, 3025 bool IsReal) { 3026 if (V.get()->isTypeDependent()) 3027 return S.Context.DependentTy; 3028 3029 // _Real and _Imag are only l-values for normal l-values. 3030 if (V.get()->getObjectKind() != OK_Ordinary) { 3031 V = S.DefaultLvalueConversion(V.take()); 3032 if (V.isInvalid()) 3033 return QualType(); 3034 } 3035 3036 // These operators return the element type of a complex type. 3037 if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>()) 3038 return CT->getElementType(); 3039 3040 // Otherwise they pass through real integer and floating point types here. 3041 if (V.get()->getType()->isArithmeticType()) 3042 return V.get()->getType(); 3043 3044 // Test for placeholders. 3045 ExprResult PR = S.CheckPlaceholderExpr(V.get()); 3046 if (PR.isInvalid()) return QualType(); 3047 if (PR.get() != V.get()) { 3048 V = move(PR); 3049 return CheckRealImagOperand(S, V, Loc, IsReal); 3050 } 3051 3052 // Reject anything else. 3053 S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType() 3054 << (IsReal ? "__real" : "__imag"); 3055 return QualType(); 3056 } 3057 3058 3059 3060 ExprResult 3061 Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, 3062 tok::TokenKind Kind, Expr *Input) { 3063 UnaryOperatorKind Opc; 3064 switch (Kind) { 3065 default: llvm_unreachable("Unknown unary op!"); 3066 case tok::plusplus: Opc = UO_PostInc; break; 3067 case tok::minusminus: Opc = UO_PostDec; break; 3068 } 3069 3070 // Since this might is a postfix expression, get rid of ParenListExprs. 3071 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input); 3072 if (Result.isInvalid()) return ExprError(); 3073 Input = Result.take(); 3074 3075 return BuildUnaryOp(S, OpLoc, Opc, Input); 3076 } 3077 3078 ExprResult 3079 Sema::ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, 3080 Expr *Idx, SourceLocation RLoc) { 3081 // Since this might be a postfix expression, get rid of ParenListExprs. 3082 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); 3083 if (Result.isInvalid()) return ExprError(); 3084 Base = Result.take(); 3085 3086 Expr *LHSExp = Base, *RHSExp = Idx; 3087 3088 if (getLangOpts().CPlusPlus && 3089 (LHSExp->isTypeDependent() || RHSExp->isTypeDependent())) { 3090 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 3091 Context.DependentTy, 3092 VK_LValue, OK_Ordinary, 3093 RLoc)); 3094 } 3095 3096 if (getLangOpts().CPlusPlus && 3097 (LHSExp->getType()->isRecordType() || 3098 LHSExp->getType()->isEnumeralType() || 3099 RHSExp->getType()->isRecordType() || 3100 RHSExp->getType()->isEnumeralType()) && 3101 !LHSExp->getType()->isObjCObjectPointerType()) { 3102 return CreateOverloadedArraySubscriptExpr(LLoc, RLoc, Base, Idx); 3103 } 3104 3105 return CreateBuiltinArraySubscriptExpr(Base, LLoc, Idx, RLoc); 3106 } 3107 3108 3109 ExprResult 3110 Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, 3111 Expr *Idx, SourceLocation RLoc) { 3112 Expr *LHSExp = Base; 3113 Expr *RHSExp = Idx; 3114 3115 // Perform default conversions. 3116 if (!LHSExp->getType()->getAs<VectorType>()) { 3117 ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp); 3118 if (Result.isInvalid()) 3119 return ExprError(); 3120 LHSExp = Result.take(); 3121 } 3122 ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp); 3123 if (Result.isInvalid()) 3124 return ExprError(); 3125 RHSExp = Result.take(); 3126 3127 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType(); 3128 ExprValueKind VK = VK_LValue; 3129 ExprObjectKind OK = OK_Ordinary; 3130 3131 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent 3132 // to the expression *((e1)+(e2)). This means the array "Base" may actually be 3133 // in the subscript position. As a result, we need to derive the array base 3134 // and index from the expression types. 3135 Expr *BaseExpr, *IndexExpr; 3136 QualType ResultType; 3137 if (LHSTy->isDependentType() || RHSTy->isDependentType()) { 3138 BaseExpr = LHSExp; 3139 IndexExpr = RHSExp; 3140 ResultType = Context.DependentTy; 3141 } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) { 3142 BaseExpr = LHSExp; 3143 IndexExpr = RHSExp; 3144 ResultType = PTy->getPointeeType(); 3145 } else if (const ObjCObjectPointerType *PTy = 3146 LHSTy->getAs<ObjCObjectPointerType>()) { 3147 BaseExpr = LHSExp; 3148 IndexExpr = RHSExp; 3149 Result = BuildObjCSubscriptExpression(RLoc, BaseExpr, IndexExpr, 0, 0); 3150 if (!Result.isInvalid()) 3151 return Owned(Result.take()); 3152 ResultType = PTy->getPointeeType(); 3153 } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) { 3154 // Handle the uncommon case of "123[Ptr]". 3155 BaseExpr = RHSExp; 3156 IndexExpr = LHSExp; 3157 ResultType = PTy->getPointeeType(); 3158 } else if (const ObjCObjectPointerType *PTy = 3159 RHSTy->getAs<ObjCObjectPointerType>()) { 3160 // Handle the uncommon case of "123[Ptr]". 3161 BaseExpr = RHSExp; 3162 IndexExpr = LHSExp; 3163 ResultType = PTy->getPointeeType(); 3164 } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) { 3165 BaseExpr = LHSExp; // vectors: V[123] 3166 IndexExpr = RHSExp; 3167 VK = LHSExp->getValueKind(); 3168 if (VK != VK_RValue) 3169 OK = OK_VectorComponent; 3170 3171 // FIXME: need to deal with const... 3172 ResultType = VTy->getElementType(); 3173 } else if (LHSTy->isArrayType()) { 3174 // If we see an array that wasn't promoted by 3175 // DefaultFunctionArrayLvalueConversion, it must be an array that 3176 // wasn't promoted because of the C90 rule that doesn't 3177 // allow promoting non-lvalue arrays. Warn, then 3178 // force the promotion here. 3179 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3180 LHSExp->getSourceRange(); 3181 LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy), 3182 CK_ArrayToPointerDecay).take(); 3183 LHSTy = LHSExp->getType(); 3184 3185 BaseExpr = LHSExp; 3186 IndexExpr = RHSExp; 3187 ResultType = LHSTy->getAs<PointerType>()->getPointeeType(); 3188 } else if (RHSTy->isArrayType()) { 3189 // Same as previous, except for 123[f().a] case 3190 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3191 RHSExp->getSourceRange(); 3192 RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy), 3193 CK_ArrayToPointerDecay).take(); 3194 RHSTy = RHSExp->getType(); 3195 3196 BaseExpr = RHSExp; 3197 IndexExpr = LHSExp; 3198 ResultType = RHSTy->getAs<PointerType>()->getPointeeType(); 3199 } else { 3200 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value) 3201 << LHSExp->getSourceRange() << RHSExp->getSourceRange()); 3202 } 3203 // C99 6.5.2.1p1 3204 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent()) 3205 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer) 3206 << IndexExpr->getSourceRange()); 3207 3208 if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) || 3209 IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U)) 3210 && !IndexExpr->isTypeDependent()) 3211 Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange(); 3212 3213 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly, 3214 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object 3215 // type. Note that Functions are not objects, and that (in C99 parlance) 3216 // incomplete types are not object types. 3217 if (ResultType->isFunctionType()) { 3218 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type) 3219 << ResultType << BaseExpr->getSourceRange(); 3220 return ExprError(); 3221 } 3222 3223 if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) { 3224 // GNU extension: subscripting on pointer to void 3225 Diag(LLoc, diag::ext_gnu_subscript_void_type) 3226 << BaseExpr->getSourceRange(); 3227 3228 // C forbids expressions of unqualified void type from being l-values. 3229 // See IsCForbiddenLValueType. 3230 if (!ResultType.hasQualifiers()) VK = VK_RValue; 3231 } else if (!ResultType->isDependentType() && 3232 RequireCompleteType(LLoc, ResultType, 3233 PDiag(diag::err_subscript_incomplete_type) 3234 << BaseExpr->getSourceRange())) 3235 return ExprError(); 3236 3237 // Diagnose bad cases where we step over interface counts. 3238 if (ResultType->isObjCObjectType() && LangOpts.ObjCNonFragileABI) { 3239 Diag(LLoc, diag::err_subscript_nonfragile_interface) 3240 << ResultType << BaseExpr->getSourceRange(); 3241 return ExprError(); 3242 } 3243 3244 assert(VK == VK_RValue || LangOpts.CPlusPlus || 3245 !ResultType.isCForbiddenLValueType()); 3246 3247 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 3248 ResultType, VK, OK, RLoc)); 3249 } 3250 3251 ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc, 3252 FunctionDecl *FD, 3253 ParmVarDecl *Param) { 3254 if (Param->hasUnparsedDefaultArg()) { 3255 Diag(CallLoc, 3256 diag::err_use_of_default_argument_to_function_declared_later) << 3257 FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName(); 3258 Diag(UnparsedDefaultArgLocs[Param], 3259 diag::note_default_argument_declared_here); 3260 return ExprError(); 3261 } 3262 3263 if (Param->hasUninstantiatedDefaultArg()) { 3264 Expr *UninstExpr = Param->getUninstantiatedDefaultArg(); 3265 3266 // Instantiate the expression. 3267 MultiLevelTemplateArgumentList ArgList 3268 = getTemplateInstantiationArgs(FD, 0, /*RelativeToPrimary=*/true); 3269 3270 std::pair<const TemplateArgument *, unsigned> Innermost 3271 = ArgList.getInnermost(); 3272 InstantiatingTemplate Inst(*this, CallLoc, Param, Innermost.first, 3273 Innermost.second); 3274 3275 ExprResult Result; 3276 { 3277 // C++ [dcl.fct.default]p5: 3278 // The names in the [default argument] expression are bound, and 3279 // the semantic constraints are checked, at the point where the 3280 // default argument expression appears. 3281 ContextRAII SavedContext(*this, FD); 3282 LocalInstantiationScope Local(*this); 3283 Result = SubstExpr(UninstExpr, ArgList); 3284 } 3285 if (Result.isInvalid()) 3286 return ExprError(); 3287 3288 // Check the expression as an initializer for the parameter. 3289 InitializedEntity Entity 3290 = InitializedEntity::InitializeParameter(Context, Param); 3291 InitializationKind Kind 3292 = InitializationKind::CreateCopy(Param->getLocation(), 3293 /*FIXME:EqualLoc*/UninstExpr->getLocStart()); 3294 Expr *ResultE = Result.takeAs<Expr>(); 3295 3296 InitializationSequence InitSeq(*this, Entity, Kind, &ResultE, 1); 3297 Result = InitSeq.Perform(*this, Entity, Kind, 3298 MultiExprArg(*this, &ResultE, 1)); 3299 if (Result.isInvalid()) 3300 return ExprError(); 3301 3302 // Build the default argument expression. 3303 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param, 3304 Result.takeAs<Expr>())); 3305 } 3306 3307 // If the default expression creates temporaries, we need to 3308 // push them to the current stack of expression temporaries so they'll 3309 // be properly destroyed. 3310 // FIXME: We should really be rebuilding the default argument with new 3311 // bound temporaries; see the comment in PR5810. 3312 // We don't need to do that with block decls, though, because 3313 // blocks in default argument expression can never capture anything. 3314 if (isa<ExprWithCleanups>(Param->getInit())) { 3315 // Set the "needs cleanups" bit regardless of whether there are 3316 // any explicit objects. 3317 ExprNeedsCleanups = true; 3318 3319 // Append all the objects to the cleanup list. Right now, this 3320 // should always be a no-op, because blocks in default argument 3321 // expressions should never be able to capture anything. 3322 assert(!cast<ExprWithCleanups>(Param->getInit())->getNumObjects() && 3323 "default argument expression has capturing blocks?"); 3324 } 3325 3326 // We already type-checked the argument, so we know it works. 3327 // Just mark all of the declarations in this potentially-evaluated expression 3328 // as being "referenced". 3329 MarkDeclarationsReferencedInExpr(Param->getDefaultArg(), 3330 /*SkipLocalVariables=*/true); 3331 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param)); 3332 } 3333 3334 /// ConvertArgumentsForCall - Converts the arguments specified in 3335 /// Args/NumArgs to the parameter types of the function FDecl with 3336 /// function prototype Proto. Call is the call expression itself, and 3337 /// Fn is the function expression. For a C++ member function, this 3338 /// routine does not attempt to convert the object argument. Returns 3339 /// true if the call is ill-formed. 3340 bool 3341 Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, 3342 FunctionDecl *FDecl, 3343 const FunctionProtoType *Proto, 3344 Expr **Args, unsigned NumArgs, 3345 SourceLocation RParenLoc, 3346 bool IsExecConfig) { 3347 // Bail out early if calling a builtin with custom typechecking. 3348 // We don't need to do this in the 3349 if (FDecl) 3350 if (unsigned ID = FDecl->getBuiltinID()) 3351 if (Context.BuiltinInfo.hasCustomTypechecking(ID)) 3352 return false; 3353 3354 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by 3355 // assignment, to the types of the corresponding parameter, ... 3356 unsigned NumArgsInProto = Proto->getNumArgs(); 3357 bool Invalid = false; 3358 unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumArgsInProto; 3359 unsigned FnKind = Fn->getType()->isBlockPointerType() 3360 ? 1 /* block */ 3361 : (IsExecConfig ? 3 /* kernel function (exec config) */ 3362 : 0 /* function */); 3363 3364 // If too few arguments are available (and we don't have default 3365 // arguments for the remaining parameters), don't make the call. 3366 if (NumArgs < NumArgsInProto) { 3367 if (NumArgs < MinArgs) { 3368 Diag(RParenLoc, MinArgs == NumArgsInProto 3369 ? diag::err_typecheck_call_too_few_args 3370 : diag::err_typecheck_call_too_few_args_at_least) 3371 << FnKind 3372 << MinArgs << NumArgs << Fn->getSourceRange(); 3373 3374 // Emit the location of the prototype. 3375 if (FDecl && !FDecl->getBuiltinID() && !IsExecConfig) 3376 Diag(FDecl->getLocStart(), diag::note_callee_decl) 3377 << FDecl; 3378 3379 return true; 3380 } 3381 Call->setNumArgs(Context, NumArgsInProto); 3382 } 3383 3384 // If too many are passed and not variadic, error on the extras and drop 3385 // them. 3386 if (NumArgs > NumArgsInProto) { 3387 if (!Proto->isVariadic()) { 3388 Diag(Args[NumArgsInProto]->getLocStart(), 3389 MinArgs == NumArgsInProto 3390 ? diag::err_typecheck_call_too_many_args 3391 : diag::err_typecheck_call_too_many_args_at_most) 3392 << FnKind 3393 << NumArgsInProto << NumArgs << Fn->getSourceRange() 3394 << SourceRange(Args[NumArgsInProto]->getLocStart(), 3395 Args[NumArgs-1]->getLocEnd()); 3396 3397 // Emit the location of the prototype. 3398 if (FDecl && !FDecl->getBuiltinID() && !IsExecConfig) 3399 Diag(FDecl->getLocStart(), diag::note_callee_decl) 3400 << FDecl; 3401 3402 // This deletes the extra arguments. 3403 Call->setNumArgs(Context, NumArgsInProto); 3404 return true; 3405 } 3406 } 3407 SmallVector<Expr *, 8> AllArgs; 3408 VariadicCallType CallType = 3409 Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply; 3410 if (Fn->getType()->isBlockPointerType()) 3411 CallType = VariadicBlock; // Block 3412 else if (isa<MemberExpr>(Fn)) 3413 CallType = VariadicMethod; 3414 Invalid = GatherArgumentsForCall(Call->getLocStart(), FDecl, 3415 Proto, 0, Args, NumArgs, AllArgs, CallType); 3416 if (Invalid) 3417 return true; 3418 unsigned TotalNumArgs = AllArgs.size(); 3419 for (unsigned i = 0; i < TotalNumArgs; ++i) 3420 Call->setArg(i, AllArgs[i]); 3421 3422 return false; 3423 } 3424 3425 bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, 3426 FunctionDecl *FDecl, 3427 const FunctionProtoType *Proto, 3428 unsigned FirstProtoArg, 3429 Expr **Args, unsigned NumArgs, 3430 SmallVector<Expr *, 8> &AllArgs, 3431 VariadicCallType CallType, 3432 bool AllowExplicit) { 3433 unsigned NumArgsInProto = Proto->getNumArgs(); 3434 unsigned NumArgsToCheck = NumArgs; 3435 bool Invalid = false; 3436 if (NumArgs != NumArgsInProto) 3437 // Use default arguments for missing arguments 3438 NumArgsToCheck = NumArgsInProto; 3439 unsigned ArgIx = 0; 3440 // Continue to check argument types (even if we have too few/many args). 3441 for (unsigned i = FirstProtoArg; i != NumArgsToCheck; i++) { 3442 QualType ProtoArgType = Proto->getArgType(i); 3443 3444 Expr *Arg; 3445 ParmVarDecl *Param; 3446 if (ArgIx < NumArgs) { 3447 Arg = Args[ArgIx++]; 3448 3449 if (RequireCompleteType(Arg->getLocStart(), 3450 ProtoArgType, 3451 PDiag(diag::err_call_incomplete_argument) 3452 << Arg->getSourceRange())) 3453 return true; 3454 3455 // Pass the argument 3456 Param = 0; 3457 if (FDecl && i < FDecl->getNumParams()) 3458 Param = FDecl->getParamDecl(i); 3459 3460 // Strip the unbridged-cast placeholder expression off, if applicable. 3461 if (Arg->getType() == Context.ARCUnbridgedCastTy && 3462 FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() && 3463 (!Param || !Param->hasAttr<CFConsumedAttr>())) 3464 Arg = stripARCUnbridgedCast(Arg); 3465 3466 InitializedEntity Entity = 3467 Param? InitializedEntity::InitializeParameter(Context, Param) 3468 : InitializedEntity::InitializeParameter(Context, ProtoArgType, 3469 Proto->isArgConsumed(i)); 3470 ExprResult ArgE = PerformCopyInitialization(Entity, 3471 SourceLocation(), 3472 Owned(Arg), 3473 /*TopLevelOfInitList=*/false, 3474 AllowExplicit); 3475 if (ArgE.isInvalid()) 3476 return true; 3477 3478 Arg = ArgE.takeAs<Expr>(); 3479 } else { 3480 Param = FDecl->getParamDecl(i); 3481 3482 ExprResult ArgExpr = 3483 BuildCXXDefaultArgExpr(CallLoc, FDecl, Param); 3484 if (ArgExpr.isInvalid()) 3485 return true; 3486 3487 Arg = ArgExpr.takeAs<Expr>(); 3488 } 3489 3490 // Check for array bounds violations for each argument to the call. This 3491 // check only triggers warnings when the argument isn't a more complex Expr 3492 // with its own checking, such as a BinaryOperator. 3493 CheckArrayAccess(Arg); 3494 3495 // Check for violations of C99 static array rules (C99 6.7.5.3p7). 3496 CheckStaticArrayArgument(CallLoc, Param, Arg); 3497 3498 AllArgs.push_back(Arg); 3499 } 3500 3501 // If this is a variadic call, handle args passed through "...". 3502 if (CallType != VariadicDoesNotApply) { 3503 3504 // Assume that extern "C" functions with variadic arguments that 3505 // return __unknown_anytype aren't *really* variadic. 3506 if (Proto->getResultType() == Context.UnknownAnyTy && 3507 FDecl && FDecl->isExternC()) { 3508 for (unsigned i = ArgIx; i != NumArgs; ++i) { 3509 ExprResult arg; 3510 if (isa<ExplicitCastExpr>(Args[i]->IgnoreParens())) 3511 arg = DefaultFunctionArrayLvalueConversion(Args[i]); 3512 else 3513 arg = DefaultVariadicArgumentPromotion(Args[i], CallType, FDecl); 3514 Invalid |= arg.isInvalid(); 3515 AllArgs.push_back(arg.take()); 3516 } 3517 3518 // Otherwise do argument promotion, (C99 6.5.2.2p7). 3519 } else { 3520 for (unsigned i = ArgIx; i != NumArgs; ++i) { 3521 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], CallType, 3522 FDecl); 3523 Invalid |= Arg.isInvalid(); 3524 AllArgs.push_back(Arg.take()); 3525 } 3526 } 3527 3528 // Check for array bounds violations. 3529 for (unsigned i = ArgIx; i != NumArgs; ++i) 3530 CheckArrayAccess(Args[i]); 3531 } 3532 return Invalid; 3533 } 3534 3535 static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD) { 3536 TypeLoc TL = PVD->getTypeSourceInfo()->getTypeLoc(); 3537 if (ArrayTypeLoc *ATL = dyn_cast<ArrayTypeLoc>(&TL)) 3538 S.Diag(PVD->getLocation(), diag::note_callee_static_array) 3539 << ATL->getLocalSourceRange(); 3540 } 3541 3542 /// CheckStaticArrayArgument - If the given argument corresponds to a static 3543 /// array parameter, check that it is non-null, and that if it is formed by 3544 /// array-to-pointer decay, the underlying array is sufficiently large. 3545 /// 3546 /// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the 3547 /// array type derivation, then for each call to the function, the value of the 3548 /// corresponding actual argument shall provide access to the first element of 3549 /// an array with at least as many elements as specified by the size expression. 3550 void 3551 Sema::CheckStaticArrayArgument(SourceLocation CallLoc, 3552 ParmVarDecl *Param, 3553 const Expr *ArgExpr) { 3554 // Static array parameters are not supported in C++. 3555 if (!Param || getLangOpts().CPlusPlus) 3556 return; 3557 3558 QualType OrigTy = Param->getOriginalType(); 3559 3560 const ArrayType *AT = Context.getAsArrayType(OrigTy); 3561 if (!AT || AT->getSizeModifier() != ArrayType::Static) 3562 return; 3563 3564 if (ArgExpr->isNullPointerConstant(Context, 3565 Expr::NPC_NeverValueDependent)) { 3566 Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange(); 3567 DiagnoseCalleeStaticArrayParam(*this, Param); 3568 return; 3569 } 3570 3571 const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT); 3572 if (!CAT) 3573 return; 3574 3575 const ConstantArrayType *ArgCAT = 3576 Context.getAsConstantArrayType(ArgExpr->IgnoreParenImpCasts()->getType()); 3577 if (!ArgCAT) 3578 return; 3579 3580 if (ArgCAT->getSize().ult(CAT->getSize())) { 3581 Diag(CallLoc, diag::warn_static_array_too_small) 3582 << ArgExpr->getSourceRange() 3583 << (unsigned) ArgCAT->getSize().getZExtValue() 3584 << (unsigned) CAT->getSize().getZExtValue(); 3585 DiagnoseCalleeStaticArrayParam(*this, Param); 3586 } 3587 } 3588 3589 /// Given a function expression of unknown-any type, try to rebuild it 3590 /// to have a function type. 3591 static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn); 3592 3593 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments. 3594 /// This provides the location of the left/right parens and a list of comma 3595 /// locations. 3596 ExprResult 3597 Sema::ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, 3598 MultiExprArg ArgExprs, SourceLocation RParenLoc, 3599 Expr *ExecConfig, bool IsExecConfig) { 3600 unsigned NumArgs = ArgExprs.size(); 3601 3602 // Since this might be a postfix expression, get rid of ParenListExprs. 3603 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn); 3604 if (Result.isInvalid()) return ExprError(); 3605 Fn = Result.take(); 3606 3607 Expr **Args = ArgExprs.release(); 3608 3609 if (getLangOpts().CPlusPlus) { 3610 // If this is a pseudo-destructor expression, build the call immediately. 3611 if (isa<CXXPseudoDestructorExpr>(Fn)) { 3612 if (NumArgs > 0) { 3613 // Pseudo-destructor calls should not have any arguments. 3614 Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args) 3615 << FixItHint::CreateRemoval( 3616 SourceRange(Args[0]->getLocStart(), 3617 Args[NumArgs-1]->getLocEnd())); 3618 } 3619 3620 return Owned(new (Context) CallExpr(Context, Fn, 0, 0, Context.VoidTy, 3621 VK_RValue, RParenLoc)); 3622 } 3623 3624 // Determine whether this is a dependent call inside a C++ template, 3625 // in which case we won't do any semantic analysis now. 3626 // FIXME: Will need to cache the results of name lookup (including ADL) in 3627 // Fn. 3628 bool Dependent = false; 3629 if (Fn->isTypeDependent()) 3630 Dependent = true; 3631 else if (Expr::hasAnyTypeDependentArguments( 3632 llvm::makeArrayRef(Args, NumArgs))) 3633 Dependent = true; 3634 3635 if (Dependent) { 3636 if (ExecConfig) { 3637 return Owned(new (Context) CUDAKernelCallExpr( 3638 Context, Fn, cast<CallExpr>(ExecConfig), Args, NumArgs, 3639 Context.DependentTy, VK_RValue, RParenLoc)); 3640 } else { 3641 return Owned(new (Context) CallExpr(Context, Fn, Args, NumArgs, 3642 Context.DependentTy, VK_RValue, 3643 RParenLoc)); 3644 } 3645 } 3646 3647 // Determine whether this is a call to an object (C++ [over.call.object]). 3648 if (Fn->getType()->isRecordType()) 3649 return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc, Args, NumArgs, 3650 RParenLoc)); 3651 3652 if (Fn->getType() == Context.UnknownAnyTy) { 3653 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 3654 if (result.isInvalid()) return ExprError(); 3655 Fn = result.take(); 3656 } 3657 3658 if (Fn->getType() == Context.BoundMemberTy) { 3659 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs, 3660 RParenLoc); 3661 } 3662 } 3663 3664 // Check for overloaded calls. This can happen even in C due to extensions. 3665 if (Fn->getType() == Context.OverloadTy) { 3666 OverloadExpr::FindResult find = OverloadExpr::find(Fn); 3667 3668 // We aren't supposed to apply this logic for if there's an '&' involved. 3669 if (!find.HasFormOfMemberPointer) { 3670 OverloadExpr *ovl = find.Expression; 3671 if (isa<UnresolvedLookupExpr>(ovl)) { 3672 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(ovl); 3673 return BuildOverloadedCallExpr(S, Fn, ULE, LParenLoc, Args, NumArgs, 3674 RParenLoc, ExecConfig); 3675 } else { 3676 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs, 3677 RParenLoc); 3678 } 3679 } 3680 } 3681 3682 // If we're directly calling a function, get the appropriate declaration. 3683 if (Fn->getType() == Context.UnknownAnyTy) { 3684 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 3685 if (result.isInvalid()) return ExprError(); 3686 Fn = result.take(); 3687 } 3688 3689 Expr *NakedFn = Fn->IgnoreParens(); 3690 3691 NamedDecl *NDecl = 0; 3692 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) 3693 if (UnOp->getOpcode() == UO_AddrOf) 3694 NakedFn = UnOp->getSubExpr()->IgnoreParens(); 3695 3696 if (isa<DeclRefExpr>(NakedFn)) 3697 NDecl = cast<DeclRefExpr>(NakedFn)->getDecl(); 3698 else if (isa<MemberExpr>(NakedFn)) 3699 NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl(); 3700 3701 return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, Args, NumArgs, RParenLoc, 3702 ExecConfig, IsExecConfig); 3703 } 3704 3705 ExprResult 3706 Sema::ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc, 3707 MultiExprArg ExecConfig, SourceLocation GGGLoc) { 3708 FunctionDecl *ConfigDecl = Context.getcudaConfigureCallDecl(); 3709 if (!ConfigDecl) 3710 return ExprError(Diag(LLLLoc, diag::err_undeclared_var_use) 3711 << "cudaConfigureCall"); 3712 QualType ConfigQTy = ConfigDecl->getType(); 3713 3714 DeclRefExpr *ConfigDR = new (Context) DeclRefExpr( 3715 ConfigDecl, false, ConfigQTy, VK_LValue, LLLLoc); 3716 MarkFunctionReferenced(LLLLoc, ConfigDecl); 3717 3718 return ActOnCallExpr(S, ConfigDR, LLLLoc, ExecConfig, GGGLoc, 0, 3719 /*IsExecConfig=*/true); 3720 } 3721 3722 /// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments. 3723 /// 3724 /// __builtin_astype( value, dst type ) 3725 /// 3726 ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, 3727 SourceLocation BuiltinLoc, 3728 SourceLocation RParenLoc) { 3729 ExprValueKind VK = VK_RValue; 3730 ExprObjectKind OK = OK_Ordinary; 3731 QualType DstTy = GetTypeFromParser(ParsedDestTy); 3732 QualType SrcTy = E->getType(); 3733 if (Context.getTypeSize(DstTy) != Context.getTypeSize(SrcTy)) 3734 return ExprError(Diag(BuiltinLoc, 3735 diag::err_invalid_astype_of_different_size) 3736 << DstTy 3737 << SrcTy 3738 << E->getSourceRange()); 3739 return Owned(new (Context) AsTypeExpr(E, DstTy, VK, OK, BuiltinLoc, 3740 RParenLoc)); 3741 } 3742 3743 /// BuildResolvedCallExpr - Build a call to a resolved expression, 3744 /// i.e. an expression not of \p OverloadTy. The expression should 3745 /// unary-convert to an expression of function-pointer or 3746 /// block-pointer type. 3747 /// 3748 /// \param NDecl the declaration being called, if available 3749 ExprResult 3750 Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, 3751 SourceLocation LParenLoc, 3752 Expr **Args, unsigned NumArgs, 3753 SourceLocation RParenLoc, 3754 Expr *Config, bool IsExecConfig) { 3755 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl); 3756 3757 // Promote the function operand. 3758 ExprResult Result = UsualUnaryConversions(Fn); 3759 if (Result.isInvalid()) 3760 return ExprError(); 3761 Fn = Result.take(); 3762 3763 // Make the call expr early, before semantic checks. This guarantees cleanup 3764 // of arguments and function on error. 3765 CallExpr *TheCall; 3766 if (Config) { 3767 TheCall = new (Context) CUDAKernelCallExpr(Context, Fn, 3768 cast<CallExpr>(Config), 3769 Args, NumArgs, 3770 Context.BoolTy, 3771 VK_RValue, 3772 RParenLoc); 3773 } else { 3774 TheCall = new (Context) CallExpr(Context, Fn, 3775 Args, NumArgs, 3776 Context.BoolTy, 3777 VK_RValue, 3778 RParenLoc); 3779 } 3780 3781 unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0); 3782 3783 // Bail out early if calling a builtin with custom typechecking. 3784 if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID)) 3785 return CheckBuiltinFunctionCall(BuiltinID, TheCall); 3786 3787 retry: 3788 const FunctionType *FuncT; 3789 if (const PointerType *PT = Fn->getType()->getAs<PointerType>()) { 3790 // C99 6.5.2.2p1 - "The expression that denotes the called function shall 3791 // have type pointer to function". 3792 FuncT = PT->getPointeeType()->getAs<FunctionType>(); 3793 if (FuncT == 0) 3794 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 3795 << Fn->getType() << Fn->getSourceRange()); 3796 } else if (const BlockPointerType *BPT = 3797 Fn->getType()->getAs<BlockPointerType>()) { 3798 FuncT = BPT->getPointeeType()->castAs<FunctionType>(); 3799 } else { 3800 // Handle calls to expressions of unknown-any type. 3801 if (Fn->getType() == Context.UnknownAnyTy) { 3802 ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn); 3803 if (rewrite.isInvalid()) return ExprError(); 3804 Fn = rewrite.take(); 3805 TheCall->setCallee(Fn); 3806 goto retry; 3807 } 3808 3809 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 3810 << Fn->getType() << Fn->getSourceRange()); 3811 } 3812 3813 if (getLangOpts().CUDA) { 3814 if (Config) { 3815 // CUDA: Kernel calls must be to global functions 3816 if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>()) 3817 return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function) 3818 << FDecl->getName() << Fn->getSourceRange()); 3819 3820 // CUDA: Kernel function must have 'void' return type 3821 if (!FuncT->getResultType()->isVoidType()) 3822 return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return) 3823 << Fn->getType() << Fn->getSourceRange()); 3824 } else { 3825 // CUDA: Calls to global functions must be configured 3826 if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>()) 3827 return ExprError(Diag(LParenLoc, diag::err_global_call_not_config) 3828 << FDecl->getName() << Fn->getSourceRange()); 3829 } 3830 } 3831 3832 // Check for a valid return type 3833 if (CheckCallReturnType(FuncT->getResultType(), 3834 Fn->getLocStart(), TheCall, 3835 FDecl)) 3836 return ExprError(); 3837 3838 // We know the result type of the call, set it. 3839 TheCall->setType(FuncT->getCallResultType(Context)); 3840 TheCall->setValueKind(Expr::getValueKindForType(FuncT->getResultType())); 3841 3842 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) { 3843 if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, NumArgs, 3844 RParenLoc, IsExecConfig)) 3845 return ExprError(); 3846 } else { 3847 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!"); 3848 3849 if (FDecl) { 3850 // Check if we have too few/too many template arguments, based 3851 // on our knowledge of the function definition. 3852 const FunctionDecl *Def = 0; 3853 if (FDecl->hasBody(Def) && NumArgs != Def->param_size()) { 3854 const FunctionProtoType *Proto 3855 = Def->getType()->getAs<FunctionProtoType>(); 3856 if (!Proto || !(Proto->isVariadic() && NumArgs >= Def->param_size())) 3857 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments) 3858 << (NumArgs > Def->param_size()) << FDecl << Fn->getSourceRange(); 3859 } 3860 3861 // If the function we're calling isn't a function prototype, but we have 3862 // a function prototype from a prior declaratiom, use that prototype. 3863 if (!FDecl->hasPrototype()) 3864 Proto = FDecl->getType()->getAs<FunctionProtoType>(); 3865 } 3866 3867 // Promote the arguments (C99 6.5.2.2p6). 3868 for (unsigned i = 0; i != NumArgs; i++) { 3869 Expr *Arg = Args[i]; 3870 3871 if (Proto && i < Proto->getNumArgs()) { 3872 InitializedEntity Entity 3873 = InitializedEntity::InitializeParameter(Context, 3874 Proto->getArgType(i), 3875 Proto->isArgConsumed(i)); 3876 ExprResult ArgE = PerformCopyInitialization(Entity, 3877 SourceLocation(), 3878 Owned(Arg)); 3879 if (ArgE.isInvalid()) 3880 return true; 3881 3882 Arg = ArgE.takeAs<Expr>(); 3883 3884 } else { 3885 ExprResult ArgE = DefaultArgumentPromotion(Arg); 3886 3887 if (ArgE.isInvalid()) 3888 return true; 3889 3890 Arg = ArgE.takeAs<Expr>(); 3891 } 3892 3893 if (RequireCompleteType(Arg->getLocStart(), 3894 Arg->getType(), 3895 PDiag(diag::err_call_incomplete_argument) 3896 << Arg->getSourceRange())) 3897 return ExprError(); 3898 3899 TheCall->setArg(i, Arg); 3900 } 3901 } 3902 3903 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl)) 3904 if (!Method->isStatic()) 3905 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object) 3906 << Fn->getSourceRange()); 3907 3908 // Check for sentinels 3909 if (NDecl) 3910 DiagnoseSentinelCalls(NDecl, LParenLoc, Args, NumArgs); 3911 3912 // Do special checking on direct calls to functions. 3913 if (FDecl) { 3914 if (CheckFunctionCall(FDecl, TheCall)) 3915 return ExprError(); 3916 3917 if (BuiltinID) 3918 return CheckBuiltinFunctionCall(BuiltinID, TheCall); 3919 } else if (NDecl) { 3920 if (CheckBlockCall(NDecl, TheCall)) 3921 return ExprError(); 3922 } 3923 3924 return MaybeBindToTemporary(TheCall); 3925 } 3926 3927 ExprResult 3928 Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, 3929 SourceLocation RParenLoc, Expr *InitExpr) { 3930 assert((Ty != 0) && "ActOnCompoundLiteral(): missing type"); 3931 // FIXME: put back this assert when initializers are worked out. 3932 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression"); 3933 3934 TypeSourceInfo *TInfo; 3935 QualType literalType = GetTypeFromParser(Ty, &TInfo); 3936 if (!TInfo) 3937 TInfo = Context.getTrivialTypeSourceInfo(literalType); 3938 3939 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr); 3940 } 3941 3942 ExprResult 3943 Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, 3944 SourceLocation RParenLoc, Expr *LiteralExpr) { 3945 QualType literalType = TInfo->getType(); 3946 3947 if (literalType->isArrayType()) { 3948 if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType), 3949 PDiag(diag::err_illegal_decl_array_incomplete_type) 3950 << SourceRange(LParenLoc, 3951 LiteralExpr->getSourceRange().getEnd()))) 3952 return ExprError(); 3953 if (literalType->isVariableArrayType()) 3954 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init) 3955 << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())); 3956 } else if (!literalType->isDependentType() && 3957 RequireCompleteType(LParenLoc, literalType, 3958 PDiag(diag::err_typecheck_decl_incomplete_type) 3959 << SourceRange(LParenLoc, 3960 LiteralExpr->getSourceRange().getEnd()))) 3961 return ExprError(); 3962 3963 InitializedEntity Entity 3964 = InitializedEntity::InitializeTemporary(literalType); 3965 InitializationKind Kind 3966 = InitializationKind::CreateCStyleCast(LParenLoc, 3967 SourceRange(LParenLoc, RParenLoc), 3968 /*InitList=*/true); 3969 InitializationSequence InitSeq(*this, Entity, Kind, &LiteralExpr, 1); 3970 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, 3971 MultiExprArg(*this, &LiteralExpr, 1), 3972 &literalType); 3973 if (Result.isInvalid()) 3974 return ExprError(); 3975 LiteralExpr = Result.get(); 3976 3977 bool isFileScope = getCurFunctionOrMethodDecl() == 0; 3978 if (isFileScope) { // 6.5.2.5p3 3979 if (CheckForConstantInitializer(LiteralExpr, literalType)) 3980 return ExprError(); 3981 } 3982 3983 // In C, compound literals are l-values for some reason. 3984 ExprValueKind VK = getLangOpts().CPlusPlus ? VK_RValue : VK_LValue; 3985 3986 return MaybeBindToTemporary( 3987 new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType, 3988 VK, LiteralExpr, isFileScope)); 3989 } 3990 3991 ExprResult 3992 Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, 3993 SourceLocation RBraceLoc) { 3994 unsigned NumInit = InitArgList.size(); 3995 Expr **InitList = InitArgList.release(); 3996 3997 // Immediately handle non-overload placeholders. Overloads can be 3998 // resolved contextually, but everything else here can't. 3999 for (unsigned I = 0; I != NumInit; ++I) { 4000 if (InitList[I]->getType()->isNonOverloadPlaceholderType()) { 4001 ExprResult result = CheckPlaceholderExpr(InitList[I]); 4002 4003 // Ignore failures; dropping the entire initializer list because 4004 // of one failure would be terrible for indexing/etc. 4005 if (result.isInvalid()) continue; 4006 4007 InitList[I] = result.take(); 4008 } 4009 } 4010 4011 // Semantic analysis for initializers is done by ActOnDeclarator() and 4012 // CheckInitializer() - it requires knowledge of the object being intialized. 4013 4014 InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitList, 4015 NumInit, RBraceLoc); 4016 E->setType(Context.VoidTy); // FIXME: just a place holder for now. 4017 return Owned(E); 4018 } 4019 4020 /// Do an explicit extend of the given block pointer if we're in ARC. 4021 static void maybeExtendBlockObject(Sema &S, ExprResult &E) { 4022 assert(E.get()->getType()->isBlockPointerType()); 4023 assert(E.get()->isRValue()); 4024 4025 // Only do this in an r-value context. 4026 if (!S.getLangOpts().ObjCAutoRefCount) return; 4027 4028 E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), 4029 CK_ARCExtendBlockObject, E.get(), 4030 /*base path*/ 0, VK_RValue); 4031 S.ExprNeedsCleanups = true; 4032 } 4033 4034 /// Prepare a conversion of the given expression to an ObjC object 4035 /// pointer type. 4036 CastKind Sema::PrepareCastToObjCObjectPointer(ExprResult &E) { 4037 QualType type = E.get()->getType(); 4038 if (type->isObjCObjectPointerType()) { 4039 return CK_BitCast; 4040 } else if (type->isBlockPointerType()) { 4041 maybeExtendBlockObject(*this, E); 4042 return CK_BlockPointerToObjCPointerCast; 4043 } else { 4044 assert(type->isPointerType()); 4045 return CK_CPointerToObjCPointerCast; 4046 } 4047 } 4048 4049 /// Prepares for a scalar cast, performing all the necessary stages 4050 /// except the final cast and returning the kind required. 4051 CastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) { 4052 // Both Src and Dest are scalar types, i.e. arithmetic or pointer. 4053 // Also, callers should have filtered out the invalid cases with 4054 // pointers. Everything else should be possible. 4055 4056 QualType SrcTy = Src.get()->getType(); 4057 if (const AtomicType *SrcAtomicTy = SrcTy->getAs<AtomicType>()) 4058 SrcTy = SrcAtomicTy->getValueType(); 4059 if (const AtomicType *DestAtomicTy = DestTy->getAs<AtomicType>()) 4060 DestTy = DestAtomicTy->getValueType(); 4061 4062 if (Context.hasSameUnqualifiedType(SrcTy, DestTy)) 4063 return CK_NoOp; 4064 4065 switch (Type::ScalarTypeKind SrcKind = SrcTy->getScalarTypeKind()) { 4066 case Type::STK_MemberPointer: 4067 llvm_unreachable("member pointer type in C"); 4068 4069 case Type::STK_CPointer: 4070 case Type::STK_BlockPointer: 4071 case Type::STK_ObjCObjectPointer: 4072 switch (DestTy->getScalarTypeKind()) { 4073 case Type::STK_CPointer: 4074 return CK_BitCast; 4075 case Type::STK_BlockPointer: 4076 return (SrcKind == Type::STK_BlockPointer 4077 ? CK_BitCast : CK_AnyPointerToBlockPointerCast); 4078 case Type::STK_ObjCObjectPointer: 4079 if (SrcKind == Type::STK_ObjCObjectPointer) 4080 return CK_BitCast; 4081 if (SrcKind == Type::STK_CPointer) 4082 return CK_CPointerToObjCPointerCast; 4083 maybeExtendBlockObject(*this, Src); 4084 return CK_BlockPointerToObjCPointerCast; 4085 case Type::STK_Bool: 4086 return CK_PointerToBoolean; 4087 case Type::STK_Integral: 4088 return CK_PointerToIntegral; 4089 case Type::STK_Floating: 4090 case Type::STK_FloatingComplex: 4091 case Type::STK_IntegralComplex: 4092 case Type::STK_MemberPointer: 4093 llvm_unreachable("illegal cast from pointer"); 4094 } 4095 llvm_unreachable("Should have returned before this"); 4096 4097 case Type::STK_Bool: // casting from bool is like casting from an integer 4098 case Type::STK_Integral: 4099 switch (DestTy->getScalarTypeKind()) { 4100 case Type::STK_CPointer: 4101 case Type::STK_ObjCObjectPointer: 4102 case Type::STK_BlockPointer: 4103 if (Src.get()->isNullPointerConstant(Context, 4104 Expr::NPC_ValueDependentIsNull)) 4105 return CK_NullToPointer; 4106 return CK_IntegralToPointer; 4107 case Type::STK_Bool: 4108 return CK_IntegralToBoolean; 4109 case Type::STK_Integral: 4110 return CK_IntegralCast; 4111 case Type::STK_Floating: 4112 return CK_IntegralToFloating; 4113 case Type::STK_IntegralComplex: 4114 Src = ImpCastExprToType(Src.take(), 4115 DestTy->castAs<ComplexType>()->getElementType(), 4116 CK_IntegralCast); 4117 return CK_IntegralRealToComplex; 4118 case Type::STK_FloatingComplex: 4119 Src = ImpCastExprToType(Src.take(), 4120 DestTy->castAs<ComplexType>()->getElementType(), 4121 CK_IntegralToFloating); 4122 return CK_FloatingRealToComplex; 4123 case Type::STK_MemberPointer: 4124 llvm_unreachable("member pointer type in C"); 4125 } 4126 llvm_unreachable("Should have returned before this"); 4127 4128 case Type::STK_Floating: 4129 switch (DestTy->getScalarTypeKind()) { 4130 case Type::STK_Floating: 4131 return CK_FloatingCast; 4132 case Type::STK_Bool: 4133 return CK_FloatingToBoolean; 4134 case Type::STK_Integral: 4135 return CK_FloatingToIntegral; 4136 case Type::STK_FloatingComplex: 4137 Src = ImpCastExprToType(Src.take(), 4138 DestTy->castAs<ComplexType>()->getElementType(), 4139 CK_FloatingCast); 4140 return CK_FloatingRealToComplex; 4141 case Type::STK_IntegralComplex: 4142 Src = ImpCastExprToType(Src.take(), 4143 DestTy->castAs<ComplexType>()->getElementType(), 4144 CK_FloatingToIntegral); 4145 return CK_IntegralRealToComplex; 4146 case Type::STK_CPointer: 4147 case Type::STK_ObjCObjectPointer: 4148 case Type::STK_BlockPointer: 4149 llvm_unreachable("valid float->pointer cast?"); 4150 case Type::STK_MemberPointer: 4151 llvm_unreachable("member pointer type in C"); 4152 } 4153 llvm_unreachable("Should have returned before this"); 4154 4155 case Type::STK_FloatingComplex: 4156 switch (DestTy->getScalarTypeKind()) { 4157 case Type::STK_FloatingComplex: 4158 return CK_FloatingComplexCast; 4159 case Type::STK_IntegralComplex: 4160 return CK_FloatingComplexToIntegralComplex; 4161 case Type::STK_Floating: { 4162 QualType ET = SrcTy->castAs<ComplexType>()->getElementType(); 4163 if (Context.hasSameType(ET, DestTy)) 4164 return CK_FloatingComplexToReal; 4165 Src = ImpCastExprToType(Src.take(), ET, CK_FloatingComplexToReal); 4166 return CK_FloatingCast; 4167 } 4168 case Type::STK_Bool: 4169 return CK_FloatingComplexToBoolean; 4170 case Type::STK_Integral: 4171 Src = ImpCastExprToType(Src.take(), 4172 SrcTy->castAs<ComplexType>()->getElementType(), 4173 CK_FloatingComplexToReal); 4174 return CK_FloatingToIntegral; 4175 case Type::STK_CPointer: 4176 case Type::STK_ObjCObjectPointer: 4177 case Type::STK_BlockPointer: 4178 llvm_unreachable("valid complex float->pointer cast?"); 4179 case Type::STK_MemberPointer: 4180 llvm_unreachable("member pointer type in C"); 4181 } 4182 llvm_unreachable("Should have returned before this"); 4183 4184 case Type::STK_IntegralComplex: 4185 switch (DestTy->getScalarTypeKind()) { 4186 case Type::STK_FloatingComplex: 4187 return CK_IntegralComplexToFloatingComplex; 4188 case Type::STK_IntegralComplex: 4189 return CK_IntegralComplexCast; 4190 case Type::STK_Integral: { 4191 QualType ET = SrcTy->castAs<ComplexType>()->getElementType(); 4192 if (Context.hasSameType(ET, DestTy)) 4193 return CK_IntegralComplexToReal; 4194 Src = ImpCastExprToType(Src.take(), ET, CK_IntegralComplexToReal); 4195 return CK_IntegralCast; 4196 } 4197 case Type::STK_Bool: 4198 return CK_IntegralComplexToBoolean; 4199 case Type::STK_Floating: 4200 Src = ImpCastExprToType(Src.take(), 4201 SrcTy->castAs<ComplexType>()->getElementType(), 4202 CK_IntegralComplexToReal); 4203 return CK_IntegralToFloating; 4204 case Type::STK_CPointer: 4205 case Type::STK_ObjCObjectPointer: 4206 case Type::STK_BlockPointer: 4207 llvm_unreachable("valid complex int->pointer cast?"); 4208 case Type::STK_MemberPointer: 4209 llvm_unreachable("member pointer type in C"); 4210 } 4211 llvm_unreachable("Should have returned before this"); 4212 } 4213 4214 llvm_unreachable("Unhandled scalar cast"); 4215 } 4216 4217 bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, 4218 CastKind &Kind) { 4219 assert(VectorTy->isVectorType() && "Not a vector type!"); 4220 4221 if (Ty->isVectorType() || Ty->isIntegerType()) { 4222 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty)) 4223 return Diag(R.getBegin(), 4224 Ty->isVectorType() ? 4225 diag::err_invalid_conversion_between_vectors : 4226 diag::err_invalid_conversion_between_vector_and_integer) 4227 << VectorTy << Ty << R; 4228 } else 4229 return Diag(R.getBegin(), 4230 diag::err_invalid_conversion_between_vector_and_scalar) 4231 << VectorTy << Ty << R; 4232 4233 Kind = CK_BitCast; 4234 return false; 4235 } 4236 4237 ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy, 4238 Expr *CastExpr, CastKind &Kind) { 4239 assert(DestTy->isExtVectorType() && "Not an extended vector type!"); 4240 4241 QualType SrcTy = CastExpr->getType(); 4242 4243 // If SrcTy is a VectorType, the total size must match to explicitly cast to 4244 // an ExtVectorType. 4245 // In OpenCL, casts between vectors of different types are not allowed. 4246 // (See OpenCL 6.2). 4247 if (SrcTy->isVectorType()) { 4248 if (Context.getTypeSize(DestTy) != Context.getTypeSize(SrcTy) 4249 || (getLangOpts().OpenCL && 4250 (DestTy.getCanonicalType() != SrcTy.getCanonicalType()))) { 4251 Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors) 4252 << DestTy << SrcTy << R; 4253 return ExprError(); 4254 } 4255 Kind = CK_BitCast; 4256 return Owned(CastExpr); 4257 } 4258 4259 // All non-pointer scalars can be cast to ExtVector type. The appropriate 4260 // conversion will take place first from scalar to elt type, and then 4261 // splat from elt type to vector. 4262 if (SrcTy->isPointerType()) 4263 return Diag(R.getBegin(), 4264 diag::err_invalid_conversion_between_vector_and_scalar) 4265 << DestTy << SrcTy << R; 4266 4267 QualType DestElemTy = DestTy->getAs<ExtVectorType>()->getElementType(); 4268 ExprResult CastExprRes = Owned(CastExpr); 4269 CastKind CK = PrepareScalarCast(CastExprRes, DestElemTy); 4270 if (CastExprRes.isInvalid()) 4271 return ExprError(); 4272 CastExpr = ImpCastExprToType(CastExprRes.take(), DestElemTy, CK).take(); 4273 4274 Kind = CK_VectorSplat; 4275 return Owned(CastExpr); 4276 } 4277 4278 ExprResult 4279 Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, 4280 Declarator &D, ParsedType &Ty, 4281 SourceLocation RParenLoc, Expr *CastExpr) { 4282 assert(!D.isInvalidType() && (CastExpr != 0) && 4283 "ActOnCastExpr(): missing type or expr"); 4284 4285 TypeSourceInfo *castTInfo = GetTypeForDeclaratorCast(D, CastExpr->getType()); 4286 if (D.isInvalidType()) 4287 return ExprError(); 4288 4289 if (getLangOpts().CPlusPlus) { 4290 // Check that there are no default arguments (C++ only). 4291 CheckExtraCXXDefaultArguments(D); 4292 } 4293 4294 checkUnusedDeclAttributes(D); 4295 4296 QualType castType = castTInfo->getType(); 4297 Ty = CreateParsedType(castType, castTInfo); 4298 4299 bool isVectorLiteral = false; 4300 4301 // Check for an altivec or OpenCL literal, 4302 // i.e. all the elements are integer constants. 4303 ParenExpr *PE = dyn_cast<ParenExpr>(CastExpr); 4304 ParenListExpr *PLE = dyn_cast<ParenListExpr>(CastExpr); 4305 if ((getLangOpts().AltiVec || getLangOpts().OpenCL) 4306 && castType->isVectorType() && (PE || PLE)) { 4307 if (PLE && PLE->getNumExprs() == 0) { 4308 Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer); 4309 return ExprError(); 4310 } 4311 if (PE || PLE->getNumExprs() == 1) { 4312 Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0)); 4313 if (!E->getType()->isVectorType()) 4314 isVectorLiteral = true; 4315 } 4316 else 4317 isVectorLiteral = true; 4318 } 4319 4320 // If this is a vector initializer, '(' type ')' '(' init, ..., init ')' 4321 // then handle it as such. 4322 if (isVectorLiteral) 4323 return BuildVectorLiteral(LParenLoc, RParenLoc, CastExpr, castTInfo); 4324 4325 // If the Expr being casted is a ParenListExpr, handle it specially. 4326 // This is not an AltiVec-style cast, so turn the ParenListExpr into a 4327 // sequence of BinOp comma operators. 4328 if (isa<ParenListExpr>(CastExpr)) { 4329 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr); 4330 if (Result.isInvalid()) return ExprError(); 4331 CastExpr = Result.take(); 4332 } 4333 4334 return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, CastExpr); 4335 } 4336 4337 ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc, 4338 SourceLocation RParenLoc, Expr *E, 4339 TypeSourceInfo *TInfo) { 4340 assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) && 4341 "Expected paren or paren list expression"); 4342 4343 Expr **exprs; 4344 unsigned numExprs; 4345 Expr *subExpr; 4346 if (ParenListExpr *PE = dyn_cast<ParenListExpr>(E)) { 4347 exprs = PE->getExprs(); 4348 numExprs = PE->getNumExprs(); 4349 } else { 4350 subExpr = cast<ParenExpr>(E)->getSubExpr(); 4351 exprs = &subExpr; 4352 numExprs = 1; 4353 } 4354 4355 QualType Ty = TInfo->getType(); 4356 assert(Ty->isVectorType() && "Expected vector type"); 4357 4358 SmallVector<Expr *, 8> initExprs; 4359 const VectorType *VTy = Ty->getAs<VectorType>(); 4360 unsigned numElems = Ty->getAs<VectorType>()->getNumElements(); 4361 4362 // '(...)' form of vector initialization in AltiVec: the number of 4363 // initializers must be one or must match the size of the vector. 4364 // If a single value is specified in the initializer then it will be 4365 // replicated to all the components of the vector 4366 if (VTy->getVectorKind() == VectorType::AltiVecVector) { 4367 // The number of initializers must be one or must match the size of the 4368 // vector. If a single value is specified in the initializer then it will 4369 // be replicated to all the components of the vector 4370 if (numExprs == 1) { 4371 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 4372 ExprResult Literal = DefaultLvalueConversion(exprs[0]); 4373 if (Literal.isInvalid()) 4374 return ExprError(); 4375 Literal = ImpCastExprToType(Literal.take(), ElemTy, 4376 PrepareScalarCast(Literal, ElemTy)); 4377 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take()); 4378 } 4379 else if (numExprs < numElems) { 4380 Diag(E->getExprLoc(), 4381 diag::err_incorrect_number_of_vector_initializers); 4382 return ExprError(); 4383 } 4384 else 4385 initExprs.append(exprs, exprs + numExprs); 4386 } 4387 else { 4388 // For OpenCL, when the number of initializers is a single value, 4389 // it will be replicated to all components of the vector. 4390 if (getLangOpts().OpenCL && 4391 VTy->getVectorKind() == VectorType::GenericVector && 4392 numExprs == 1) { 4393 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 4394 ExprResult Literal = DefaultLvalueConversion(exprs[0]); 4395 if (Literal.isInvalid()) 4396 return ExprError(); 4397 Literal = ImpCastExprToType(Literal.take(), ElemTy, 4398 PrepareScalarCast(Literal, ElemTy)); 4399 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take()); 4400 } 4401 4402 initExprs.append(exprs, exprs + numExprs); 4403 } 4404 // FIXME: This means that pretty-printing the final AST will produce curly 4405 // braces instead of the original commas. 4406 InitListExpr *initE = new (Context) InitListExpr(Context, LParenLoc, 4407 &initExprs[0], 4408 initExprs.size(), RParenLoc); 4409 initE->setType(Ty); 4410 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE); 4411 } 4412 4413 /// This is not an AltiVec-style cast or or C++ direct-initialization, so turn 4414 /// the ParenListExpr into a sequence of comma binary operators. 4415 ExprResult 4416 Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *OrigExpr) { 4417 ParenListExpr *E = dyn_cast<ParenListExpr>(OrigExpr); 4418 if (!E) 4419 return Owned(OrigExpr); 4420 4421 ExprResult Result(E->getExpr(0)); 4422 4423 for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i) 4424 Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(), 4425 E->getExpr(i)); 4426 4427 if (Result.isInvalid()) return ExprError(); 4428 4429 return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get()); 4430 } 4431 4432 ExprResult Sema::ActOnParenListExpr(SourceLocation L, 4433 SourceLocation R, 4434 MultiExprArg Val) { 4435 unsigned nexprs = Val.size(); 4436 Expr **exprs = reinterpret_cast<Expr**>(Val.release()); 4437 assert((exprs != 0) && "ActOnParenOrParenListExpr() missing expr list"); 4438 Expr *expr = new (Context) ParenListExpr(Context, L, exprs, nexprs, R); 4439 return Owned(expr); 4440 } 4441 4442 /// \brief Emit a specialized diagnostic when one expression is a null pointer 4443 /// constant and the other is not a pointer. Returns true if a diagnostic is 4444 /// emitted. 4445 bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, 4446 SourceLocation QuestionLoc) { 4447 Expr *NullExpr = LHSExpr; 4448 Expr *NonPointerExpr = RHSExpr; 4449 Expr::NullPointerConstantKind NullKind = 4450 NullExpr->isNullPointerConstant(Context, 4451 Expr::NPC_ValueDependentIsNotNull); 4452 4453 if (NullKind == Expr::NPCK_NotNull) { 4454 NullExpr = RHSExpr; 4455 NonPointerExpr = LHSExpr; 4456 NullKind = 4457 NullExpr->isNullPointerConstant(Context, 4458 Expr::NPC_ValueDependentIsNotNull); 4459 } 4460 4461 if (NullKind == Expr::NPCK_NotNull) 4462 return false; 4463 4464 if (NullKind == Expr::NPCK_ZeroInteger) { 4465 // In this case, check to make sure that we got here from a "NULL" 4466 // string in the source code. 4467 NullExpr = NullExpr->IgnoreParenImpCasts(); 4468 SourceLocation loc = NullExpr->getExprLoc(); 4469 if (!findMacroSpelling(loc, "NULL")) 4470 return false; 4471 } 4472 4473 int DiagType = (NullKind == Expr::NPCK_CXX0X_nullptr); 4474 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null) 4475 << NonPointerExpr->getType() << DiagType 4476 << NonPointerExpr->getSourceRange(); 4477 return true; 4478 } 4479 4480 /// \brief Return false if the condition expression is valid, true otherwise. 4481 static bool checkCondition(Sema &S, Expr *Cond) { 4482 QualType CondTy = Cond->getType(); 4483 4484 // C99 6.5.15p2 4485 if (CondTy->isScalarType()) return false; 4486 4487 // OpenCL: Sec 6.3.i says the condition is allowed to be a vector or scalar. 4488 if (S.getLangOpts().OpenCL && CondTy->isVectorType()) 4489 return false; 4490 4491 // Emit the proper error message. 4492 S.Diag(Cond->getLocStart(), S.getLangOpts().OpenCL ? 4493 diag::err_typecheck_cond_expect_scalar : 4494 diag::err_typecheck_cond_expect_scalar_or_vector) 4495 << CondTy; 4496 return true; 4497 } 4498 4499 /// \brief Return false if the two expressions can be converted to a vector, 4500 /// true otherwise 4501 static bool checkConditionalConvertScalarsToVectors(Sema &S, ExprResult &LHS, 4502 ExprResult &RHS, 4503 QualType CondTy) { 4504 // Both operands should be of scalar type. 4505 if (!LHS.get()->getType()->isScalarType()) { 4506 S.Diag(LHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 4507 << CondTy; 4508 return true; 4509 } 4510 if (!RHS.get()->getType()->isScalarType()) { 4511 S.Diag(RHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 4512 << CondTy; 4513 return true; 4514 } 4515 4516 // Implicity convert these scalars to the type of the condition. 4517 LHS = S.ImpCastExprToType(LHS.take(), CondTy, CK_IntegralCast); 4518 RHS = S.ImpCastExprToType(RHS.take(), CondTy, CK_IntegralCast); 4519 return false; 4520 } 4521 4522 /// \brief Handle when one or both operands are void type. 4523 static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS, 4524 ExprResult &RHS) { 4525 Expr *LHSExpr = LHS.get(); 4526 Expr *RHSExpr = RHS.get(); 4527 4528 if (!LHSExpr->getType()->isVoidType()) 4529 S.Diag(RHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 4530 << RHSExpr->getSourceRange(); 4531 if (!RHSExpr->getType()->isVoidType()) 4532 S.Diag(LHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 4533 << LHSExpr->getSourceRange(); 4534 LHS = S.ImpCastExprToType(LHS.take(), S.Context.VoidTy, CK_ToVoid); 4535 RHS = S.ImpCastExprToType(RHS.take(), S.Context.VoidTy, CK_ToVoid); 4536 return S.Context.VoidTy; 4537 } 4538 4539 /// \brief Return false if the NullExpr can be promoted to PointerTy, 4540 /// true otherwise. 4541 static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, 4542 QualType PointerTy) { 4543 if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) || 4544 !NullExpr.get()->isNullPointerConstant(S.Context, 4545 Expr::NPC_ValueDependentIsNull)) 4546 return true; 4547 4548 NullExpr = S.ImpCastExprToType(NullExpr.take(), PointerTy, CK_NullToPointer); 4549 return false; 4550 } 4551 4552 /// \brief Checks compatibility between two pointers and return the resulting 4553 /// type. 4554 static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, 4555 ExprResult &RHS, 4556 SourceLocation Loc) { 4557 QualType LHSTy = LHS.get()->getType(); 4558 QualType RHSTy = RHS.get()->getType(); 4559 4560 if (S.Context.hasSameType(LHSTy, RHSTy)) { 4561 // Two identical pointers types are always compatible. 4562 return LHSTy; 4563 } 4564 4565 QualType lhptee, rhptee; 4566 4567 // Get the pointee types. 4568 if (const BlockPointerType *LHSBTy = LHSTy->getAs<BlockPointerType>()) { 4569 lhptee = LHSBTy->getPointeeType(); 4570 rhptee = RHSTy->castAs<BlockPointerType>()->getPointeeType(); 4571 } else { 4572 lhptee = LHSTy->castAs<PointerType>()->getPointeeType(); 4573 rhptee = RHSTy->castAs<PointerType>()->getPointeeType(); 4574 } 4575 4576 // C99 6.5.15p6: If both operands are pointers to compatible types or to 4577 // differently qualified versions of compatible types, the result type is 4578 // a pointer to an appropriately qualified version of the composite 4579 // type. 4580 4581 // Only CVR-qualifiers exist in the standard, and the differently-qualified 4582 // clause doesn't make sense for our extensions. E.g. address space 2 should 4583 // be incompatible with address space 3: they may live on different devices or 4584 // anything. 4585 Qualifiers lhQual = lhptee.getQualifiers(); 4586 Qualifiers rhQual = rhptee.getQualifiers(); 4587 4588 unsigned MergedCVRQual = lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers(); 4589 lhQual.removeCVRQualifiers(); 4590 rhQual.removeCVRQualifiers(); 4591 4592 lhptee = S.Context.getQualifiedType(lhptee.getUnqualifiedType(), lhQual); 4593 rhptee = S.Context.getQualifiedType(rhptee.getUnqualifiedType(), rhQual); 4594 4595 QualType CompositeTy = S.Context.mergeTypes(lhptee, rhptee); 4596 4597 if (CompositeTy.isNull()) { 4598 S.Diag(Loc, diag::warn_typecheck_cond_incompatible_pointers) 4599 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4600 << RHS.get()->getSourceRange(); 4601 // In this situation, we assume void* type. No especially good 4602 // reason, but this is what gcc does, and we do have to pick 4603 // to get a consistent AST. 4604 QualType incompatTy = S.Context.getPointerType(S.Context.VoidTy); 4605 LHS = S.ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); 4606 RHS = S.ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); 4607 return incompatTy; 4608 } 4609 4610 // The pointer types are compatible. 4611 QualType ResultTy = CompositeTy.withCVRQualifiers(MergedCVRQual); 4612 ResultTy = S.Context.getPointerType(ResultTy); 4613 4614 LHS = S.ImpCastExprToType(LHS.take(), ResultTy, CK_BitCast); 4615 RHS = S.ImpCastExprToType(RHS.take(), ResultTy, CK_BitCast); 4616 return ResultTy; 4617 } 4618 4619 /// \brief Return the resulting type when the operands are both block pointers. 4620 static QualType checkConditionalBlockPointerCompatibility(Sema &S, 4621 ExprResult &LHS, 4622 ExprResult &RHS, 4623 SourceLocation Loc) { 4624 QualType LHSTy = LHS.get()->getType(); 4625 QualType RHSTy = RHS.get()->getType(); 4626 4627 if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) { 4628 if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) { 4629 QualType destType = S.Context.getPointerType(S.Context.VoidTy); 4630 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast); 4631 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast); 4632 return destType; 4633 } 4634 S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 4635 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4636 << RHS.get()->getSourceRange(); 4637 return QualType(); 4638 } 4639 4640 // We have 2 block pointer types. 4641 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 4642 } 4643 4644 /// \brief Return the resulting type when the operands are both pointers. 4645 static QualType 4646 checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, 4647 ExprResult &RHS, 4648 SourceLocation Loc) { 4649 // get the pointer types 4650 QualType LHSTy = LHS.get()->getType(); 4651 QualType RHSTy = RHS.get()->getType(); 4652 4653 // get the "pointed to" types 4654 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 4655 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 4656 4657 // ignore qualifiers on void (C99 6.5.15p3, clause 6) 4658 if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) { 4659 // Figure out necessary qualifiers (C99 6.5.15p6) 4660 QualType destPointee 4661 = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 4662 QualType destType = S.Context.getPointerType(destPointee); 4663 // Add qualifiers if necessary. 4664 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_NoOp); 4665 // Promote to void*. 4666 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast); 4667 return destType; 4668 } 4669 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) { 4670 QualType destPointee 4671 = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 4672 QualType destType = S.Context.getPointerType(destPointee); 4673 // Add qualifiers if necessary. 4674 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_NoOp); 4675 // Promote to void*. 4676 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast); 4677 return destType; 4678 } 4679 4680 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 4681 } 4682 4683 /// \brief Return false if the first expression is not an integer and the second 4684 /// expression is not a pointer, true otherwise. 4685 static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, 4686 Expr* PointerExpr, SourceLocation Loc, 4687 bool IsIntFirstExpr) { 4688 if (!PointerExpr->getType()->isPointerType() || 4689 !Int.get()->getType()->isIntegerType()) 4690 return false; 4691 4692 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr; 4693 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get(); 4694 4695 S.Diag(Loc, diag::warn_typecheck_cond_pointer_integer_mismatch) 4696 << Expr1->getType() << Expr2->getType() 4697 << Expr1->getSourceRange() << Expr2->getSourceRange(); 4698 Int = S.ImpCastExprToType(Int.take(), PointerExpr->getType(), 4699 CK_IntegralToPointer); 4700 return true; 4701 } 4702 4703 /// Note that LHS is not null here, even if this is the gnu "x ?: y" extension. 4704 /// In that case, LHS = cond. 4705 /// C99 6.5.15 4706 QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, 4707 ExprResult &RHS, ExprValueKind &VK, 4708 ExprObjectKind &OK, 4709 SourceLocation QuestionLoc) { 4710 4711 ExprResult LHSResult = CheckPlaceholderExpr(LHS.get()); 4712 if (!LHSResult.isUsable()) return QualType(); 4713 LHS = move(LHSResult); 4714 4715 ExprResult RHSResult = CheckPlaceholderExpr(RHS.get()); 4716 if (!RHSResult.isUsable()) return QualType(); 4717 RHS = move(RHSResult); 4718 4719 // C++ is sufficiently different to merit its own checker. 4720 if (getLangOpts().CPlusPlus) 4721 return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc); 4722 4723 VK = VK_RValue; 4724 OK = OK_Ordinary; 4725 4726 Cond = UsualUnaryConversions(Cond.take()); 4727 if (Cond.isInvalid()) 4728 return QualType(); 4729 LHS = UsualUnaryConversions(LHS.take()); 4730 if (LHS.isInvalid()) 4731 return QualType(); 4732 RHS = UsualUnaryConversions(RHS.take()); 4733 if (RHS.isInvalid()) 4734 return QualType(); 4735 4736 QualType CondTy = Cond.get()->getType(); 4737 QualType LHSTy = LHS.get()->getType(); 4738 QualType RHSTy = RHS.get()->getType(); 4739 4740 // first, check the condition. 4741 if (checkCondition(*this, Cond.get())) 4742 return QualType(); 4743 4744 // Now check the two expressions. 4745 if (LHSTy->isVectorType() || RHSTy->isVectorType()) 4746 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false); 4747 4748 // OpenCL: If the condition is a vector, and both operands are scalar, 4749 // attempt to implicity convert them to the vector type to act like the 4750 // built in select. 4751 if (getLangOpts().OpenCL && CondTy->isVectorType()) 4752 if (checkConditionalConvertScalarsToVectors(*this, LHS, RHS, CondTy)) 4753 return QualType(); 4754 4755 // If both operands have arithmetic type, do the usual arithmetic conversions 4756 // to find a common type: C99 6.5.15p3,5. 4757 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) { 4758 UsualArithmeticConversions(LHS, RHS); 4759 if (LHS.isInvalid() || RHS.isInvalid()) 4760 return QualType(); 4761 return LHS.get()->getType(); 4762 } 4763 4764 // If both operands are the same structure or union type, the result is that 4765 // type. 4766 if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3 4767 if (const RecordType *RHSRT = RHSTy->getAs<RecordType>()) 4768 if (LHSRT->getDecl() == RHSRT->getDecl()) 4769 // "If both the operands have structure or union type, the result has 4770 // that type." This implies that CV qualifiers are dropped. 4771 return LHSTy.getUnqualifiedType(); 4772 // FIXME: Type of conditional expression must be complete in C mode. 4773 } 4774 4775 // C99 6.5.15p5: "If both operands have void type, the result has void type." 4776 // The following || allows only one side to be void (a GCC-ism). 4777 if (LHSTy->isVoidType() || RHSTy->isVoidType()) { 4778 return checkConditionalVoidType(*this, LHS, RHS); 4779 } 4780 4781 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has 4782 // the type of the other operand." 4783 if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy; 4784 if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy; 4785 4786 // All objective-c pointer type analysis is done here. 4787 QualType compositeType = FindCompositeObjCPointerType(LHS, RHS, 4788 QuestionLoc); 4789 if (LHS.isInvalid() || RHS.isInvalid()) 4790 return QualType(); 4791 if (!compositeType.isNull()) 4792 return compositeType; 4793 4794 4795 // Handle block pointer types. 4796 if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) 4797 return checkConditionalBlockPointerCompatibility(*this, LHS, RHS, 4798 QuestionLoc); 4799 4800 // Check constraints for C object pointers types (C99 6.5.15p3,6). 4801 if (LHSTy->isPointerType() && RHSTy->isPointerType()) 4802 return checkConditionalObjectPointersCompatibility(*this, LHS, RHS, 4803 QuestionLoc); 4804 4805 // GCC compatibility: soften pointer/integer mismatch. Note that 4806 // null pointers have been filtered out by this point. 4807 if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc, 4808 /*isIntFirstExpr=*/true)) 4809 return RHSTy; 4810 if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc, 4811 /*isIntFirstExpr=*/false)) 4812 return LHSTy; 4813 4814 // Emit a better diagnostic if one of the expressions is a null pointer 4815 // constant and the other is not a pointer type. In this case, the user most 4816 // likely forgot to take the address of the other expression. 4817 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc)) 4818 return QualType(); 4819 4820 // Otherwise, the operands are not compatible. 4821 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 4822 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4823 << RHS.get()->getSourceRange(); 4824 return QualType(); 4825 } 4826 4827 /// FindCompositeObjCPointerType - Helper method to find composite type of 4828 /// two objective-c pointer types of the two input expressions. 4829 QualType Sema::FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, 4830 SourceLocation QuestionLoc) { 4831 QualType LHSTy = LHS.get()->getType(); 4832 QualType RHSTy = RHS.get()->getType(); 4833 4834 // Handle things like Class and struct objc_class*. Here we case the result 4835 // to the pseudo-builtin, because that will be implicitly cast back to the 4836 // redefinition type if an attempt is made to access its fields. 4837 if (LHSTy->isObjCClassType() && 4838 (Context.hasSameType(RHSTy, Context.getObjCClassRedefinitionType()))) { 4839 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_CPointerToObjCPointerCast); 4840 return LHSTy; 4841 } 4842 if (RHSTy->isObjCClassType() && 4843 (Context.hasSameType(LHSTy, Context.getObjCClassRedefinitionType()))) { 4844 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_CPointerToObjCPointerCast); 4845 return RHSTy; 4846 } 4847 // And the same for struct objc_object* / id 4848 if (LHSTy->isObjCIdType() && 4849 (Context.hasSameType(RHSTy, Context.getObjCIdRedefinitionType()))) { 4850 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_CPointerToObjCPointerCast); 4851 return LHSTy; 4852 } 4853 if (RHSTy->isObjCIdType() && 4854 (Context.hasSameType(LHSTy, Context.getObjCIdRedefinitionType()))) { 4855 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_CPointerToObjCPointerCast); 4856 return RHSTy; 4857 } 4858 // And the same for struct objc_selector* / SEL 4859 if (Context.isObjCSelType(LHSTy) && 4860 (Context.hasSameType(RHSTy, Context.getObjCSelRedefinitionType()))) { 4861 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 4862 return LHSTy; 4863 } 4864 if (Context.isObjCSelType(RHSTy) && 4865 (Context.hasSameType(LHSTy, Context.getObjCSelRedefinitionType()))) { 4866 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_BitCast); 4867 return RHSTy; 4868 } 4869 // Check constraints for Objective-C object pointers types. 4870 if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) { 4871 4872 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) { 4873 // Two identical object pointer types are always compatible. 4874 return LHSTy; 4875 } 4876 const ObjCObjectPointerType *LHSOPT = LHSTy->castAs<ObjCObjectPointerType>(); 4877 const ObjCObjectPointerType *RHSOPT = RHSTy->castAs<ObjCObjectPointerType>(); 4878 QualType compositeType = LHSTy; 4879 4880 // If both operands are interfaces and either operand can be 4881 // assigned to the other, use that type as the composite 4882 // type. This allows 4883 // xxx ? (A*) a : (B*) b 4884 // where B is a subclass of A. 4885 // 4886 // Additionally, as for assignment, if either type is 'id' 4887 // allow silent coercion. Finally, if the types are 4888 // incompatible then make sure to use 'id' as the composite 4889 // type so the result is acceptable for sending messages to. 4890 4891 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'. 4892 // It could return the composite type. 4893 if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) { 4894 compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy; 4895 } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) { 4896 compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy; 4897 } else if ((LHSTy->isObjCQualifiedIdType() || 4898 RHSTy->isObjCQualifiedIdType()) && 4899 Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) { 4900 // Need to handle "id<xx>" explicitly. 4901 // GCC allows qualified id and any Objective-C type to devolve to 4902 // id. Currently localizing to here until clear this should be 4903 // part of ObjCQualifiedIdTypesAreCompatible. 4904 compositeType = Context.getObjCIdType(); 4905 } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) { 4906 compositeType = Context.getObjCIdType(); 4907 } else if (!(compositeType = 4908 Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull()) 4909 ; 4910 else { 4911 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands) 4912 << LHSTy << RHSTy 4913 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 4914 QualType incompatTy = Context.getObjCIdType(); 4915 LHS = ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); 4916 RHS = ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); 4917 return incompatTy; 4918 } 4919 // The object pointer types are compatible. 4920 LHS = ImpCastExprToType(LHS.take(), compositeType, CK_BitCast); 4921 RHS = ImpCastExprToType(RHS.take(), compositeType, CK_BitCast); 4922 return compositeType; 4923 } 4924 // Check Objective-C object pointer types and 'void *' 4925 if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) { 4926 if (getLangOpts().ObjCAutoRefCount) { 4927 // ARC forbids the implicit conversion of object pointers to 'void *', 4928 // so these types are not compatible. 4929 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy 4930 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 4931 LHS = RHS = true; 4932 return QualType(); 4933 } 4934 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 4935 QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 4936 QualType destPointee 4937 = Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 4938 QualType destType = Context.getPointerType(destPointee); 4939 // Add qualifiers if necessary. 4940 LHS = ImpCastExprToType(LHS.take(), destType, CK_NoOp); 4941 // Promote to void*. 4942 RHS = ImpCastExprToType(RHS.take(), destType, CK_BitCast); 4943 return destType; 4944 } 4945 if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) { 4946 if (getLangOpts().ObjCAutoRefCount) { 4947 // ARC forbids the implicit conversion of object pointers to 'void *', 4948 // so these types are not compatible. 4949 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy 4950 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 4951 LHS = RHS = true; 4952 return QualType(); 4953 } 4954 QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 4955 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 4956 QualType destPointee 4957 = Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 4958 QualType destType = Context.getPointerType(destPointee); 4959 // Add qualifiers if necessary. 4960 RHS = ImpCastExprToType(RHS.take(), destType, CK_NoOp); 4961 // Promote to void*. 4962 LHS = ImpCastExprToType(LHS.take(), destType, CK_BitCast); 4963 return destType; 4964 } 4965 return QualType(); 4966 } 4967 4968 /// SuggestParentheses - Emit a note with a fixit hint that wraps 4969 /// ParenRange in parentheses. 4970 static void SuggestParentheses(Sema &Self, SourceLocation Loc, 4971 const PartialDiagnostic &Note, 4972 SourceRange ParenRange) { 4973 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(ParenRange.getEnd()); 4974 if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() && 4975 EndLoc.isValid()) { 4976 Self.Diag(Loc, Note) 4977 << FixItHint::CreateInsertion(ParenRange.getBegin(), "(") 4978 << FixItHint::CreateInsertion(EndLoc, ")"); 4979 } else { 4980 // We can't display the parentheses, so just show the bare note. 4981 Self.Diag(Loc, Note) << ParenRange; 4982 } 4983 } 4984 4985 static bool IsArithmeticOp(BinaryOperatorKind Opc) { 4986 return Opc >= BO_Mul && Opc <= BO_Shr; 4987 } 4988 4989 /// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary 4990 /// expression, either using a built-in or overloaded operator, 4991 /// and sets *OpCode to the opcode and *RHSExprs to the right-hand side 4992 /// expression. 4993 static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode, 4994 Expr **RHSExprs) { 4995 // Don't strip parenthesis: we should not warn if E is in parenthesis. 4996 E = E->IgnoreImpCasts(); 4997 E = E->IgnoreConversionOperator(); 4998 E = E->IgnoreImpCasts(); 4999 5000 // Built-in binary operator. 5001 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) { 5002 if (IsArithmeticOp(OP->getOpcode())) { 5003 *Opcode = OP->getOpcode(); 5004 *RHSExprs = OP->getRHS(); 5005 return true; 5006 } 5007 } 5008 5009 // Overloaded operator. 5010 if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(E)) { 5011 if (Call->getNumArgs() != 2) 5012 return false; 5013 5014 // Make sure this is really a binary operator that is safe to pass into 5015 // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op. 5016 OverloadedOperatorKind OO = Call->getOperator(); 5017 if (OO < OO_Plus || OO > OO_Arrow) 5018 return false; 5019 5020 BinaryOperatorKind OpKind = BinaryOperator::getOverloadedOpcode(OO); 5021 if (IsArithmeticOp(OpKind)) { 5022 *Opcode = OpKind; 5023 *RHSExprs = Call->getArg(1); 5024 return true; 5025 } 5026 } 5027 5028 return false; 5029 } 5030 5031 static bool IsLogicOp(BinaryOperatorKind Opc) { 5032 return (Opc >= BO_LT && Opc <= BO_NE) || (Opc >= BO_LAnd && Opc <= BO_LOr); 5033 } 5034 5035 /// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type 5036 /// or is a logical expression such as (x==y) which has int type, but is 5037 /// commonly interpreted as boolean. 5038 static bool ExprLooksBoolean(Expr *E) { 5039 E = E->IgnoreParenImpCasts(); 5040 5041 if (E->getType()->isBooleanType()) 5042 return true; 5043 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) 5044 return IsLogicOp(OP->getOpcode()); 5045 if (UnaryOperator *OP = dyn_cast<UnaryOperator>(E)) 5046 return OP->getOpcode() == UO_LNot; 5047 5048 return false; 5049 } 5050 5051 /// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator 5052 /// and binary operator are mixed in a way that suggests the programmer assumed 5053 /// the conditional operator has higher precedence, for example: 5054 /// "int x = a + someBinaryCondition ? 1 : 2". 5055 static void DiagnoseConditionalPrecedence(Sema &Self, 5056 SourceLocation OpLoc, 5057 Expr *Condition, 5058 Expr *LHSExpr, 5059 Expr *RHSExpr) { 5060 BinaryOperatorKind CondOpcode; 5061 Expr *CondRHS; 5062 5063 if (!IsArithmeticBinaryExpr(Condition, &CondOpcode, &CondRHS)) 5064 return; 5065 if (!ExprLooksBoolean(CondRHS)) 5066 return; 5067 5068 // The condition is an arithmetic binary expression, with a right- 5069 // hand side that looks boolean, so warn. 5070 5071 Self.Diag(OpLoc, diag::warn_precedence_conditional) 5072 << Condition->getSourceRange() 5073 << BinaryOperator::getOpcodeStr(CondOpcode); 5074 5075 SuggestParentheses(Self, OpLoc, 5076 Self.PDiag(diag::note_precedence_conditional_silence) 5077 << BinaryOperator::getOpcodeStr(CondOpcode), 5078 SourceRange(Condition->getLocStart(), Condition->getLocEnd())); 5079 5080 SuggestParentheses(Self, OpLoc, 5081 Self.PDiag(diag::note_precedence_conditional_first), 5082 SourceRange(CondRHS->getLocStart(), RHSExpr->getLocEnd())); 5083 } 5084 5085 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null 5086 /// in the case of a the GNU conditional expr extension. 5087 ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc, 5088 SourceLocation ColonLoc, 5089 Expr *CondExpr, Expr *LHSExpr, 5090 Expr *RHSExpr) { 5091 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS 5092 // was the condition. 5093 OpaqueValueExpr *opaqueValue = 0; 5094 Expr *commonExpr = 0; 5095 if (LHSExpr == 0) { 5096 commonExpr = CondExpr; 5097 5098 // We usually want to apply unary conversions *before* saving, except 5099 // in the special case of a C++ l-value conditional. 5100 if (!(getLangOpts().CPlusPlus 5101 && !commonExpr->isTypeDependent() 5102 && commonExpr->getValueKind() == RHSExpr->getValueKind() 5103 && commonExpr->isGLValue() 5104 && commonExpr->isOrdinaryOrBitFieldObject() 5105 && RHSExpr->isOrdinaryOrBitFieldObject() 5106 && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) { 5107 ExprResult commonRes = UsualUnaryConversions(commonExpr); 5108 if (commonRes.isInvalid()) 5109 return ExprError(); 5110 commonExpr = commonRes.take(); 5111 } 5112 5113 opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(), 5114 commonExpr->getType(), 5115 commonExpr->getValueKind(), 5116 commonExpr->getObjectKind(), 5117 commonExpr); 5118 LHSExpr = CondExpr = opaqueValue; 5119 } 5120 5121 ExprValueKind VK = VK_RValue; 5122 ExprObjectKind OK = OK_Ordinary; 5123 ExprResult Cond = Owned(CondExpr), LHS = Owned(LHSExpr), RHS = Owned(RHSExpr); 5124 QualType result = CheckConditionalOperands(Cond, LHS, RHS, 5125 VK, OK, QuestionLoc); 5126 if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() || 5127 RHS.isInvalid()) 5128 return ExprError(); 5129 5130 DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(), 5131 RHS.get()); 5132 5133 if (!commonExpr) 5134 return Owned(new (Context) ConditionalOperator(Cond.take(), QuestionLoc, 5135 LHS.take(), ColonLoc, 5136 RHS.take(), result, VK, OK)); 5137 5138 return Owned(new (Context) 5139 BinaryConditionalOperator(commonExpr, opaqueValue, Cond.take(), LHS.take(), 5140 RHS.take(), QuestionLoc, ColonLoc, result, VK, 5141 OK)); 5142 } 5143 5144 // checkPointerTypesForAssignment - This is a very tricky routine (despite 5145 // being closely modeled after the C99 spec:-). The odd characteristic of this 5146 // routine is it effectively iqnores the qualifiers on the top level pointee. 5147 // This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3]. 5148 // FIXME: add a couple examples in this comment. 5149 static Sema::AssignConvertType 5150 checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) { 5151 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 5152 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 5153 5154 // get the "pointed to" type (ignoring qualifiers at the top level) 5155 const Type *lhptee, *rhptee; 5156 Qualifiers lhq, rhq; 5157 llvm::tie(lhptee, lhq) = cast<PointerType>(LHSType)->getPointeeType().split(); 5158 llvm::tie(rhptee, rhq) = cast<PointerType>(RHSType)->getPointeeType().split(); 5159 5160 Sema::AssignConvertType ConvTy = Sema::Compatible; 5161 5162 // C99 6.5.16.1p1: This following citation is common to constraints 5163 // 3 & 4 (below). ...and the type *pointed to* by the left has all the 5164 // qualifiers of the type *pointed to* by the right; 5165 Qualifiers lq; 5166 5167 // As a special case, 'non-__weak A *' -> 'non-__weak const *' is okay. 5168 if (lhq.getObjCLifetime() != rhq.getObjCLifetime() && 5169 lhq.compatiblyIncludesObjCLifetime(rhq)) { 5170 // Ignore lifetime for further calculation. 5171 lhq.removeObjCLifetime(); 5172 rhq.removeObjCLifetime(); 5173 } 5174 5175 if (!lhq.compatiblyIncludes(rhq)) { 5176 // Treat address-space mismatches as fatal. TODO: address subspaces 5177 if (lhq.getAddressSpace() != rhq.getAddressSpace()) 5178 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 5179 5180 // It's okay to add or remove GC or lifetime qualifiers when converting to 5181 // and from void*. 5182 else if (lhq.withoutObjCGCAttr().withoutObjCLifetime() 5183 .compatiblyIncludes( 5184 rhq.withoutObjCGCAttr().withoutObjCLifetime()) 5185 && (lhptee->isVoidType() || rhptee->isVoidType())) 5186 ; // keep old 5187 5188 // Treat lifetime mismatches as fatal. 5189 else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) 5190 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 5191 5192 // For GCC compatibility, other qualifier mismatches are treated 5193 // as still compatible in C. 5194 else ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 5195 } 5196 5197 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or 5198 // incomplete type and the other is a pointer to a qualified or unqualified 5199 // version of void... 5200 if (lhptee->isVoidType()) { 5201 if (rhptee->isIncompleteOrObjectType()) 5202 return ConvTy; 5203 5204 // As an extension, we allow cast to/from void* to function pointer. 5205 assert(rhptee->isFunctionType()); 5206 return Sema::FunctionVoidPointer; 5207 } 5208 5209 if (rhptee->isVoidType()) { 5210 if (lhptee->isIncompleteOrObjectType()) 5211 return ConvTy; 5212 5213 // As an extension, we allow cast to/from void* to function pointer. 5214 assert(lhptee->isFunctionType()); 5215 return Sema::FunctionVoidPointer; 5216 } 5217 5218 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or 5219 // unqualified versions of compatible types, ... 5220 QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0); 5221 if (!S.Context.typesAreCompatible(ltrans, rtrans)) { 5222 // Check if the pointee types are compatible ignoring the sign. 5223 // We explicitly check for char so that we catch "char" vs 5224 // "unsigned char" on systems where "char" is unsigned. 5225 if (lhptee->isCharType()) 5226 ltrans = S.Context.UnsignedCharTy; 5227 else if (lhptee->hasSignedIntegerRepresentation()) 5228 ltrans = S.Context.getCorrespondingUnsignedType(ltrans); 5229 5230 if (rhptee->isCharType()) 5231 rtrans = S.Context.UnsignedCharTy; 5232 else if (rhptee->hasSignedIntegerRepresentation()) 5233 rtrans = S.Context.getCorrespondingUnsignedType(rtrans); 5234 5235 if (ltrans == rtrans) { 5236 // Types are compatible ignoring the sign. Qualifier incompatibility 5237 // takes priority over sign incompatibility because the sign 5238 // warning can be disabled. 5239 if (ConvTy != Sema::Compatible) 5240 return ConvTy; 5241 5242 return Sema::IncompatiblePointerSign; 5243 } 5244 5245 // If we are a multi-level pointer, it's possible that our issue is simply 5246 // one of qualification - e.g. char ** -> const char ** is not allowed. If 5247 // the eventual target type is the same and the pointers have the same 5248 // level of indirection, this must be the issue. 5249 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) { 5250 do { 5251 lhptee = cast<PointerType>(lhptee)->getPointeeType().getTypePtr(); 5252 rhptee = cast<PointerType>(rhptee)->getPointeeType().getTypePtr(); 5253 } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)); 5254 5255 if (lhptee == rhptee) 5256 return Sema::IncompatibleNestedPointerQualifiers; 5257 } 5258 5259 // General pointer incompatibility takes priority over qualifiers. 5260 return Sema::IncompatiblePointer; 5261 } 5262 if (!S.getLangOpts().CPlusPlus && 5263 S.IsNoReturnConversion(ltrans, rtrans, ltrans)) 5264 return Sema::IncompatiblePointer; 5265 return ConvTy; 5266 } 5267 5268 /// checkBlockPointerTypesForAssignment - This routine determines whether two 5269 /// block pointer types are compatible or whether a block and normal pointer 5270 /// are compatible. It is more restrict than comparing two function pointer 5271 // types. 5272 static Sema::AssignConvertType 5273 checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType, 5274 QualType RHSType) { 5275 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 5276 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 5277 5278 QualType lhptee, rhptee; 5279 5280 // get the "pointed to" type (ignoring qualifiers at the top level) 5281 lhptee = cast<BlockPointerType>(LHSType)->getPointeeType(); 5282 rhptee = cast<BlockPointerType>(RHSType)->getPointeeType(); 5283 5284 // In C++, the types have to match exactly. 5285 if (S.getLangOpts().CPlusPlus) 5286 return Sema::IncompatibleBlockPointer; 5287 5288 Sema::AssignConvertType ConvTy = Sema::Compatible; 5289 5290 // For blocks we enforce that qualifiers are identical. 5291 if (lhptee.getLocalQualifiers() != rhptee.getLocalQualifiers()) 5292 ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 5293 5294 if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType)) 5295 return Sema::IncompatibleBlockPointer; 5296 5297 return ConvTy; 5298 } 5299 5300 /// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types 5301 /// for assignment compatibility. 5302 static Sema::AssignConvertType 5303 checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType, 5304 QualType RHSType) { 5305 assert(LHSType.isCanonical() && "LHS was not canonicalized!"); 5306 assert(RHSType.isCanonical() && "RHS was not canonicalized!"); 5307 5308 if (LHSType->isObjCBuiltinType()) { 5309 // Class is not compatible with ObjC object pointers. 5310 if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() && 5311 !RHSType->isObjCQualifiedClassType()) 5312 return Sema::IncompatiblePointer; 5313 return Sema::Compatible; 5314 } 5315 if (RHSType->isObjCBuiltinType()) { 5316 if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() && 5317 !LHSType->isObjCQualifiedClassType()) 5318 return Sema::IncompatiblePointer; 5319 return Sema::Compatible; 5320 } 5321 QualType lhptee = LHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 5322 QualType rhptee = RHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 5323 5324 if (!lhptee.isAtLeastAsQualifiedAs(rhptee) && 5325 // make an exception for id<P> 5326 !LHSType->isObjCQualifiedIdType()) 5327 return Sema::CompatiblePointerDiscardsQualifiers; 5328 5329 if (S.Context.typesAreCompatible(LHSType, RHSType)) 5330 return Sema::Compatible; 5331 if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType()) 5332 return Sema::IncompatibleObjCQualifiedId; 5333 return Sema::IncompatiblePointer; 5334 } 5335 5336 Sema::AssignConvertType 5337 Sema::CheckAssignmentConstraints(SourceLocation Loc, 5338 QualType LHSType, QualType RHSType) { 5339 // Fake up an opaque expression. We don't actually care about what 5340 // cast operations are required, so if CheckAssignmentConstraints 5341 // adds casts to this they'll be wasted, but fortunately that doesn't 5342 // usually happen on valid code. 5343 OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue); 5344 ExprResult RHSPtr = &RHSExpr; 5345 CastKind K = CK_Invalid; 5346 5347 return CheckAssignmentConstraints(LHSType, RHSPtr, K); 5348 } 5349 5350 /// CheckAssignmentConstraints (C99 6.5.16) - This routine currently 5351 /// has code to accommodate several GCC extensions when type checking 5352 /// pointers. Here are some objectionable examples that GCC considers warnings: 5353 /// 5354 /// int a, *pint; 5355 /// short *pshort; 5356 /// struct foo *pfoo; 5357 /// 5358 /// pint = pshort; // warning: assignment from incompatible pointer type 5359 /// a = pint; // warning: assignment makes integer from pointer without a cast 5360 /// pint = a; // warning: assignment makes pointer from integer without a cast 5361 /// pint = pfoo; // warning: assignment from incompatible pointer type 5362 /// 5363 /// As a result, the code for dealing with pointers is more complex than the 5364 /// C99 spec dictates. 5365 /// 5366 /// Sets 'Kind' for any result kind except Incompatible. 5367 Sema::AssignConvertType 5368 Sema::CheckAssignmentConstraints(QualType LHSType, ExprResult &RHS, 5369 CastKind &Kind) { 5370 QualType RHSType = RHS.get()->getType(); 5371 QualType OrigLHSType = LHSType; 5372 5373 // Get canonical types. We're not formatting these types, just comparing 5374 // them. 5375 LHSType = Context.getCanonicalType(LHSType).getUnqualifiedType(); 5376 RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType(); 5377 5378 5379 // Common case: no conversion required. 5380 if (LHSType == RHSType) { 5381 Kind = CK_NoOp; 5382 return Compatible; 5383 } 5384 5385 if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) { 5386 if (AtomicTy->getValueType() == RHSType) { 5387 Kind = CK_NonAtomicToAtomic; 5388 return Compatible; 5389 } 5390 } 5391 5392 if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(RHSType)) { 5393 if (AtomicTy->getValueType() == LHSType) { 5394 Kind = CK_AtomicToNonAtomic; 5395 return Compatible; 5396 } 5397 } 5398 5399 5400 // If the left-hand side is a reference type, then we are in a 5401 // (rare!) case where we've allowed the use of references in C, 5402 // e.g., as a parameter type in a built-in function. In this case, 5403 // just make sure that the type referenced is compatible with the 5404 // right-hand side type. The caller is responsible for adjusting 5405 // LHSType so that the resulting expression does not have reference 5406 // type. 5407 if (const ReferenceType *LHSTypeRef = LHSType->getAs<ReferenceType>()) { 5408 if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) { 5409 Kind = CK_LValueBitCast; 5410 return Compatible; 5411 } 5412 return Incompatible; 5413 } 5414 5415 // Allow scalar to ExtVector assignments, and assignments of an ExtVector type 5416 // to the same ExtVector type. 5417 if (LHSType->isExtVectorType()) { 5418 if (RHSType->isExtVectorType()) 5419 return Incompatible; 5420 if (RHSType->isArithmeticType()) { 5421 // CK_VectorSplat does T -> vector T, so first cast to the 5422 // element type. 5423 QualType elType = cast<ExtVectorType>(LHSType)->getElementType(); 5424 if (elType != RHSType) { 5425 Kind = PrepareScalarCast(RHS, elType); 5426 RHS = ImpCastExprToType(RHS.take(), elType, Kind); 5427 } 5428 Kind = CK_VectorSplat; 5429 return Compatible; 5430 } 5431 } 5432 5433 // Conversions to or from vector type. 5434 if (LHSType->isVectorType() || RHSType->isVectorType()) { 5435 if (LHSType->isVectorType() && RHSType->isVectorType()) { 5436 // Allow assignments of an AltiVec vector type to an equivalent GCC 5437 // vector type and vice versa 5438 if (Context.areCompatibleVectorTypes(LHSType, RHSType)) { 5439 Kind = CK_BitCast; 5440 return Compatible; 5441 } 5442 5443 // If we are allowing lax vector conversions, and LHS and RHS are both 5444 // vectors, the total size only needs to be the same. This is a bitcast; 5445 // no bits are changed but the result type is different. 5446 if (getLangOpts().LaxVectorConversions && 5447 (Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType))) { 5448 Kind = CK_BitCast; 5449 return IncompatibleVectors; 5450 } 5451 } 5452 return Incompatible; 5453 } 5454 5455 // Arithmetic conversions. 5456 if (LHSType->isArithmeticType() && RHSType->isArithmeticType() && 5457 !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) { 5458 Kind = PrepareScalarCast(RHS, LHSType); 5459 return Compatible; 5460 } 5461 5462 // Conversions to normal pointers. 5463 if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) { 5464 // U* -> T* 5465 if (isa<PointerType>(RHSType)) { 5466 Kind = CK_BitCast; 5467 return checkPointerTypesForAssignment(*this, LHSType, RHSType); 5468 } 5469 5470 // int -> T* 5471 if (RHSType->isIntegerType()) { 5472 Kind = CK_IntegralToPointer; // FIXME: null? 5473 return IntToPointer; 5474 } 5475 5476 // C pointers are not compatible with ObjC object pointers, 5477 // with two exceptions: 5478 if (isa<ObjCObjectPointerType>(RHSType)) { 5479 // - conversions to void* 5480 if (LHSPointer->getPointeeType()->isVoidType()) { 5481 Kind = CK_BitCast; 5482 return Compatible; 5483 } 5484 5485 // - conversions from 'Class' to the redefinition type 5486 if (RHSType->isObjCClassType() && 5487 Context.hasSameType(LHSType, 5488 Context.getObjCClassRedefinitionType())) { 5489 Kind = CK_BitCast; 5490 return Compatible; 5491 } 5492 5493 Kind = CK_BitCast; 5494 return IncompatiblePointer; 5495 } 5496 5497 // U^ -> void* 5498 if (RHSType->getAs<BlockPointerType>()) { 5499 if (LHSPointer->getPointeeType()->isVoidType()) { 5500 Kind = CK_BitCast; 5501 return Compatible; 5502 } 5503 } 5504 5505 return Incompatible; 5506 } 5507 5508 // Conversions to block pointers. 5509 if (isa<BlockPointerType>(LHSType)) { 5510 // U^ -> T^ 5511 if (RHSType->isBlockPointerType()) { 5512 Kind = CK_BitCast; 5513 return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType); 5514 } 5515 5516 // int or null -> T^ 5517 if (RHSType->isIntegerType()) { 5518 Kind = CK_IntegralToPointer; // FIXME: null 5519 return IntToBlockPointer; 5520 } 5521 5522 // id -> T^ 5523 if (getLangOpts().ObjC1 && RHSType->isObjCIdType()) { 5524 Kind = CK_AnyPointerToBlockPointerCast; 5525 return Compatible; 5526 } 5527 5528 // void* -> T^ 5529 if (const PointerType *RHSPT = RHSType->getAs<PointerType>()) 5530 if (RHSPT->getPointeeType()->isVoidType()) { 5531 Kind = CK_AnyPointerToBlockPointerCast; 5532 return Compatible; 5533 } 5534 5535 return Incompatible; 5536 } 5537 5538 // Conversions to Objective-C pointers. 5539 if (isa<ObjCObjectPointerType>(LHSType)) { 5540 // A* -> B* 5541 if (RHSType->isObjCObjectPointerType()) { 5542 Kind = CK_BitCast; 5543 Sema::AssignConvertType result = 5544 checkObjCPointerTypesForAssignment(*this, LHSType, RHSType); 5545 if (getLangOpts().ObjCAutoRefCount && 5546 result == Compatible && 5547 !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType)) 5548 result = IncompatibleObjCWeakRef; 5549 return result; 5550 } 5551 5552 // int or null -> A* 5553 if (RHSType->isIntegerType()) { 5554 Kind = CK_IntegralToPointer; // FIXME: null 5555 return IntToPointer; 5556 } 5557 5558 // In general, C pointers are not compatible with ObjC object pointers, 5559 // with two exceptions: 5560 if (isa<PointerType>(RHSType)) { 5561 Kind = CK_CPointerToObjCPointerCast; 5562 5563 // - conversions from 'void*' 5564 if (RHSType->isVoidPointerType()) { 5565 return Compatible; 5566 } 5567 5568 // - conversions to 'Class' from its redefinition type 5569 if (LHSType->isObjCClassType() && 5570 Context.hasSameType(RHSType, 5571 Context.getObjCClassRedefinitionType())) { 5572 return Compatible; 5573 } 5574 5575 return IncompatiblePointer; 5576 } 5577 5578 // T^ -> A* 5579 if (RHSType->isBlockPointerType()) { 5580 maybeExtendBlockObject(*this, RHS); 5581 Kind = CK_BlockPointerToObjCPointerCast; 5582 return Compatible; 5583 } 5584 5585 return Incompatible; 5586 } 5587 5588 // Conversions from pointers that are not covered by the above. 5589 if (isa<PointerType>(RHSType)) { 5590 // T* -> _Bool 5591 if (LHSType == Context.BoolTy) { 5592 Kind = CK_PointerToBoolean; 5593 return Compatible; 5594 } 5595 5596 // T* -> int 5597 if (LHSType->isIntegerType()) { 5598 Kind = CK_PointerToIntegral; 5599 return PointerToInt; 5600 } 5601 5602 return Incompatible; 5603 } 5604 5605 // Conversions from Objective-C pointers that are not covered by the above. 5606 if (isa<ObjCObjectPointerType>(RHSType)) { 5607 // T* -> _Bool 5608 if (LHSType == Context.BoolTy) { 5609 Kind = CK_PointerToBoolean; 5610 return Compatible; 5611 } 5612 5613 // T* -> int 5614 if (LHSType->isIntegerType()) { 5615 Kind = CK_PointerToIntegral; 5616 return PointerToInt; 5617 } 5618 5619 return Incompatible; 5620 } 5621 5622 // struct A -> struct B 5623 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) { 5624 if (Context.typesAreCompatible(LHSType, RHSType)) { 5625 Kind = CK_NoOp; 5626 return Compatible; 5627 } 5628 } 5629 5630 return Incompatible; 5631 } 5632 5633 /// \brief Constructs a transparent union from an expression that is 5634 /// used to initialize the transparent union. 5635 static void ConstructTransparentUnion(Sema &S, ASTContext &C, 5636 ExprResult &EResult, QualType UnionType, 5637 FieldDecl *Field) { 5638 // Build an initializer list that designates the appropriate member 5639 // of the transparent union. 5640 Expr *E = EResult.take(); 5641 InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(), 5642 &E, 1, 5643 SourceLocation()); 5644 Initializer->setType(UnionType); 5645 Initializer->setInitializedFieldInUnion(Field); 5646 5647 // Build a compound literal constructing a value of the transparent 5648 // union type from this initializer list. 5649 TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType); 5650 EResult = S.Owned( 5651 new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType, 5652 VK_RValue, Initializer, false)); 5653 } 5654 5655 Sema::AssignConvertType 5656 Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, 5657 ExprResult &RHS) { 5658 QualType RHSType = RHS.get()->getType(); 5659 5660 // If the ArgType is a Union type, we want to handle a potential 5661 // transparent_union GCC extension. 5662 const RecordType *UT = ArgType->getAsUnionType(); 5663 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>()) 5664 return Incompatible; 5665 5666 // The field to initialize within the transparent union. 5667 RecordDecl *UD = UT->getDecl(); 5668 FieldDecl *InitField = 0; 5669 // It's compatible if the expression matches any of the fields. 5670 for (RecordDecl::field_iterator it = UD->field_begin(), 5671 itend = UD->field_end(); 5672 it != itend; ++it) { 5673 if (it->getType()->isPointerType()) { 5674 // If the transparent union contains a pointer type, we allow: 5675 // 1) void pointer 5676 // 2) null pointer constant 5677 if (RHSType->isPointerType()) 5678 if (RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) { 5679 RHS = ImpCastExprToType(RHS.take(), it->getType(), CK_BitCast); 5680 InitField = *it; 5681 break; 5682 } 5683 5684 if (RHS.get()->isNullPointerConstant(Context, 5685 Expr::NPC_ValueDependentIsNull)) { 5686 RHS = ImpCastExprToType(RHS.take(), it->getType(), 5687 CK_NullToPointer); 5688 InitField = *it; 5689 break; 5690 } 5691 } 5692 5693 CastKind Kind = CK_Invalid; 5694 if (CheckAssignmentConstraints(it->getType(), RHS, Kind) 5695 == Compatible) { 5696 RHS = ImpCastExprToType(RHS.take(), it->getType(), Kind); 5697 InitField = *it; 5698 break; 5699 } 5700 } 5701 5702 if (!InitField) 5703 return Incompatible; 5704 5705 ConstructTransparentUnion(*this, Context, RHS, ArgType, InitField); 5706 return Compatible; 5707 } 5708 5709 Sema::AssignConvertType 5710 Sema::CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, 5711 bool Diagnose) { 5712 if (getLangOpts().CPlusPlus) { 5713 if (!LHSType->isRecordType() && !LHSType->isAtomicType()) { 5714 // C++ 5.17p3: If the left operand is not of class type, the 5715 // expression is implicitly converted (C++ 4) to the 5716 // cv-unqualified type of the left operand. 5717 ExprResult Res; 5718 if (Diagnose) { 5719 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 5720 AA_Assigning); 5721 } else { 5722 ImplicitConversionSequence ICS = 5723 TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 5724 /*SuppressUserConversions=*/false, 5725 /*AllowExplicit=*/false, 5726 /*InOverloadResolution=*/false, 5727 /*CStyle=*/false, 5728 /*AllowObjCWritebackConversion=*/false); 5729 if (ICS.isFailure()) 5730 return Incompatible; 5731 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 5732 ICS, AA_Assigning); 5733 } 5734 if (Res.isInvalid()) 5735 return Incompatible; 5736 Sema::AssignConvertType result = Compatible; 5737 if (getLangOpts().ObjCAutoRefCount && 5738 !CheckObjCARCUnavailableWeakConversion(LHSType, 5739 RHS.get()->getType())) 5740 result = IncompatibleObjCWeakRef; 5741 RHS = move(Res); 5742 return result; 5743 } 5744 5745 // FIXME: Currently, we fall through and treat C++ classes like C 5746 // structures. 5747 // FIXME: We also fall through for atomics; not sure what should 5748 // happen there, though. 5749 } 5750 5751 // C99 6.5.16.1p1: the left operand is a pointer and the right is 5752 // a null pointer constant. 5753 if ((LHSType->isPointerType() || 5754 LHSType->isObjCObjectPointerType() || 5755 LHSType->isBlockPointerType()) 5756 && RHS.get()->isNullPointerConstant(Context, 5757 Expr::NPC_ValueDependentIsNull)) { 5758 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_NullToPointer); 5759 return Compatible; 5760 } 5761 5762 // This check seems unnatural, however it is necessary to ensure the proper 5763 // conversion of functions/arrays. If the conversion were done for all 5764 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary 5765 // expressions that suppress this implicit conversion (&, sizeof). 5766 // 5767 // Suppress this for references: C++ 8.5.3p5. 5768 if (!LHSType->isReferenceType()) { 5769 RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); 5770 if (RHS.isInvalid()) 5771 return Incompatible; 5772 } 5773 5774 CastKind Kind = CK_Invalid; 5775 Sema::AssignConvertType result = 5776 CheckAssignmentConstraints(LHSType, RHS, Kind); 5777 5778 // C99 6.5.16.1p2: The value of the right operand is converted to the 5779 // type of the assignment expression. 5780 // CheckAssignmentConstraints allows the left-hand side to be a reference, 5781 // so that we can use references in built-in functions even in C. 5782 // The getNonReferenceType() call makes sure that the resulting expression 5783 // does not have reference type. 5784 if (result != Incompatible && RHS.get()->getType() != LHSType) 5785 RHS = ImpCastExprToType(RHS.take(), 5786 LHSType.getNonLValueExprType(Context), Kind); 5787 return result; 5788 } 5789 5790 QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &LHS, 5791 ExprResult &RHS) { 5792 Diag(Loc, diag::err_typecheck_invalid_operands) 5793 << LHS.get()->getType() << RHS.get()->getType() 5794 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5795 return QualType(); 5796 } 5797 5798 QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, 5799 SourceLocation Loc, bool IsCompAssign) { 5800 if (!IsCompAssign) { 5801 LHS = DefaultFunctionArrayLvalueConversion(LHS.take()); 5802 if (LHS.isInvalid()) 5803 return QualType(); 5804 } 5805 RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); 5806 if (RHS.isInvalid()) 5807 return QualType(); 5808 5809 // For conversion purposes, we ignore any qualifiers. 5810 // For example, "const float" and "float" are equivalent. 5811 QualType LHSType = 5812 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType(); 5813 QualType RHSType = 5814 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType(); 5815 5816 // If the vector types are identical, return. 5817 if (LHSType == RHSType) 5818 return LHSType; 5819 5820 // Handle the case of equivalent AltiVec and GCC vector types 5821 if (LHSType->isVectorType() && RHSType->isVectorType() && 5822 Context.areCompatibleVectorTypes(LHSType, RHSType)) { 5823 if (LHSType->isExtVectorType()) { 5824 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 5825 return LHSType; 5826 } 5827 5828 if (!IsCompAssign) 5829 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); 5830 return RHSType; 5831 } 5832 5833 if (getLangOpts().LaxVectorConversions && 5834 Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType)) { 5835 // If we are allowing lax vector conversions, and LHS and RHS are both 5836 // vectors, the total size only needs to be the same. This is a 5837 // bitcast; no bits are changed but the result type is different. 5838 // FIXME: Should we really be allowing this? 5839 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 5840 return LHSType; 5841 } 5842 5843 // Canonicalize the ExtVector to the LHS, remember if we swapped so we can 5844 // swap back (so that we don't reverse the inputs to a subtract, for instance. 5845 bool swapped = false; 5846 if (RHSType->isExtVectorType() && !IsCompAssign) { 5847 swapped = true; 5848 std::swap(RHS, LHS); 5849 std::swap(RHSType, LHSType); 5850 } 5851 5852 // Handle the case of an ext vector and scalar. 5853 if (const ExtVectorType *LV = LHSType->getAs<ExtVectorType>()) { 5854 QualType EltTy = LV->getElementType(); 5855 if (EltTy->isIntegralType(Context) && RHSType->isIntegralType(Context)) { 5856 int order = Context.getIntegerTypeOrder(EltTy, RHSType); 5857 if (order > 0) 5858 RHS = ImpCastExprToType(RHS.take(), EltTy, CK_IntegralCast); 5859 if (order >= 0) { 5860 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_VectorSplat); 5861 if (swapped) std::swap(RHS, LHS); 5862 return LHSType; 5863 } 5864 } 5865 if (EltTy->isRealFloatingType() && RHSType->isScalarType() && 5866 RHSType->isRealFloatingType()) { 5867 int order = Context.getFloatingTypeOrder(EltTy, RHSType); 5868 if (order > 0) 5869 RHS = ImpCastExprToType(RHS.take(), EltTy, CK_FloatingCast); 5870 if (order >= 0) { 5871 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_VectorSplat); 5872 if (swapped) std::swap(RHS, LHS); 5873 return LHSType; 5874 } 5875 } 5876 } 5877 5878 // Vectors of different size or scalar and non-ext-vector are errors. 5879 if (swapped) std::swap(RHS, LHS); 5880 Diag(Loc, diag::err_typecheck_vector_not_convertable) 5881 << LHS.get()->getType() << RHS.get()->getType() 5882 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5883 return QualType(); 5884 } 5885 5886 // checkArithmeticNull - Detect when a NULL constant is used improperly in an 5887 // expression. These are mainly cases where the null pointer is used as an 5888 // integer instead of a pointer. 5889 static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, 5890 SourceLocation Loc, bool IsCompare) { 5891 // The canonical way to check for a GNU null is with isNullPointerConstant, 5892 // but we use a bit of a hack here for speed; this is a relatively 5893 // hot path, and isNullPointerConstant is slow. 5894 bool LHSNull = isa<GNUNullExpr>(LHS.get()->IgnoreParenImpCasts()); 5895 bool RHSNull = isa<GNUNullExpr>(RHS.get()->IgnoreParenImpCasts()); 5896 5897 QualType NonNullType = LHSNull ? RHS.get()->getType() : LHS.get()->getType(); 5898 5899 // Avoid analyzing cases where the result will either be invalid (and 5900 // diagnosed as such) or entirely valid and not something to warn about. 5901 if ((!LHSNull && !RHSNull) || NonNullType->isBlockPointerType() || 5902 NonNullType->isMemberPointerType() || NonNullType->isFunctionType()) 5903 return; 5904 5905 // Comparison operations would not make sense with a null pointer no matter 5906 // what the other expression is. 5907 if (!IsCompare) { 5908 S.Diag(Loc, diag::warn_null_in_arithmetic_operation) 5909 << (LHSNull ? LHS.get()->getSourceRange() : SourceRange()) 5910 << (RHSNull ? RHS.get()->getSourceRange() : SourceRange()); 5911 return; 5912 } 5913 5914 // The rest of the operations only make sense with a null pointer 5915 // if the other expression is a pointer. 5916 if (LHSNull == RHSNull || NonNullType->isAnyPointerType() || 5917 NonNullType->canDecayToPointerType()) 5918 return; 5919 5920 S.Diag(Loc, diag::warn_null_in_comparison_operation) 5921 << LHSNull /* LHS is NULL */ << NonNullType 5922 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5923 } 5924 5925 QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS, 5926 SourceLocation Loc, 5927 bool IsCompAssign, bool IsDiv) { 5928 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 5929 5930 if (LHS.get()->getType()->isVectorType() || 5931 RHS.get()->getType()->isVectorType()) 5932 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 5933 5934 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign); 5935 if (LHS.isInvalid() || RHS.isInvalid()) 5936 return QualType(); 5937 5938 5939 if (!LHS.get()->getType()->isArithmeticType() || 5940 !RHS.get()->getType()->isArithmeticType()) { 5941 if (IsCompAssign && 5942 LHS.get()->getType()->isAtomicType() && 5943 RHS.get()->getType()->isArithmeticType()) 5944 return compType; 5945 return InvalidOperands(Loc, LHS, RHS); 5946 } 5947 5948 // Check for division by zero. 5949 if (IsDiv && 5950 RHS.get()->isNullPointerConstant(Context, 5951 Expr::NPC_ValueDependentIsNotNull)) 5952 DiagRuntimeBehavior(Loc, RHS.get(), PDiag(diag::warn_division_by_zero) 5953 << RHS.get()->getSourceRange()); 5954 5955 return compType; 5956 } 5957 5958 QualType Sema::CheckRemainderOperands( 5959 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { 5960 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 5961 5962 if (LHS.get()->getType()->isVectorType() || 5963 RHS.get()->getType()->isVectorType()) { 5964 if (LHS.get()->getType()->hasIntegerRepresentation() && 5965 RHS.get()->getType()->hasIntegerRepresentation()) 5966 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 5967 return InvalidOperands(Loc, LHS, RHS); 5968 } 5969 5970 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign); 5971 if (LHS.isInvalid() || RHS.isInvalid()) 5972 return QualType(); 5973 5974 if (!LHS.get()->getType()->isIntegerType() || 5975 !RHS.get()->getType()->isIntegerType()) 5976 return InvalidOperands(Loc, LHS, RHS); 5977 5978 // Check for remainder by zero. 5979 if (RHS.get()->isNullPointerConstant(Context, 5980 Expr::NPC_ValueDependentIsNotNull)) 5981 DiagRuntimeBehavior(Loc, RHS.get(), PDiag(diag::warn_remainder_by_zero) 5982 << RHS.get()->getSourceRange()); 5983 5984 return compType; 5985 } 5986 5987 /// \brief Diagnose invalid arithmetic on two void pointers. 5988 static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, 5989 Expr *LHSExpr, Expr *RHSExpr) { 5990 S.Diag(Loc, S.getLangOpts().CPlusPlus 5991 ? diag::err_typecheck_pointer_arith_void_type 5992 : diag::ext_gnu_void_ptr) 5993 << 1 /* two pointers */ << LHSExpr->getSourceRange() 5994 << RHSExpr->getSourceRange(); 5995 } 5996 5997 /// \brief Diagnose invalid arithmetic on a void pointer. 5998 static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, 5999 Expr *Pointer) { 6000 S.Diag(Loc, S.getLangOpts().CPlusPlus 6001 ? diag::err_typecheck_pointer_arith_void_type 6002 : diag::ext_gnu_void_ptr) 6003 << 0 /* one pointer */ << Pointer->getSourceRange(); 6004 } 6005 6006 /// \brief Diagnose invalid arithmetic on two function pointers. 6007 static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, 6008 Expr *LHS, Expr *RHS) { 6009 assert(LHS->getType()->isAnyPointerType()); 6010 assert(RHS->getType()->isAnyPointerType()); 6011 S.Diag(Loc, S.getLangOpts().CPlusPlus 6012 ? diag::err_typecheck_pointer_arith_function_type 6013 : diag::ext_gnu_ptr_func_arith) 6014 << 1 /* two pointers */ << LHS->getType()->getPointeeType() 6015 // We only show the second type if it differs from the first. 6016 << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(), 6017 RHS->getType()) 6018 << RHS->getType()->getPointeeType() 6019 << LHS->getSourceRange() << RHS->getSourceRange(); 6020 } 6021 6022 /// \brief Diagnose invalid arithmetic on a function pointer. 6023 static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, 6024 Expr *Pointer) { 6025 assert(Pointer->getType()->isAnyPointerType()); 6026 S.Diag(Loc, S.getLangOpts().CPlusPlus 6027 ? diag::err_typecheck_pointer_arith_function_type 6028 : diag::ext_gnu_ptr_func_arith) 6029 << 0 /* one pointer */ << Pointer->getType()->getPointeeType() 6030 << 0 /* one pointer, so only one type */ 6031 << Pointer->getSourceRange(); 6032 } 6033 6034 /// \brief Emit error if Operand is incomplete pointer type 6035 /// 6036 /// \returns True if pointer has incomplete type 6037 static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, 6038 Expr *Operand) { 6039 if ((Operand->getType()->isPointerType() && 6040 !Operand->getType()->isDependentType()) || 6041 Operand->getType()->isObjCObjectPointerType()) { 6042 QualType PointeeTy = Operand->getType()->getPointeeType(); 6043 if (S.RequireCompleteType( 6044 Loc, PointeeTy, 6045 S.PDiag(diag::err_typecheck_arithmetic_incomplete_type) 6046 << PointeeTy << Operand->getSourceRange())) 6047 return true; 6048 } 6049 return false; 6050 } 6051 6052 /// \brief Check the validity of an arithmetic pointer operand. 6053 /// 6054 /// If the operand has pointer type, this code will check for pointer types 6055 /// which are invalid in arithmetic operations. These will be diagnosed 6056 /// appropriately, including whether or not the use is supported as an 6057 /// extension. 6058 /// 6059 /// \returns True when the operand is valid to use (even if as an extension). 6060 static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc, 6061 Expr *Operand) { 6062 if (!Operand->getType()->isAnyPointerType()) return true; 6063 6064 QualType PointeeTy = Operand->getType()->getPointeeType(); 6065 if (PointeeTy->isVoidType()) { 6066 diagnoseArithmeticOnVoidPointer(S, Loc, Operand); 6067 return !S.getLangOpts().CPlusPlus; 6068 } 6069 if (PointeeTy->isFunctionType()) { 6070 diagnoseArithmeticOnFunctionPointer(S, Loc, Operand); 6071 return !S.getLangOpts().CPlusPlus; 6072 } 6073 6074 if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false; 6075 6076 return true; 6077 } 6078 6079 /// \brief Check the validity of a binary arithmetic operation w.r.t. pointer 6080 /// operands. 6081 /// 6082 /// This routine will diagnose any invalid arithmetic on pointer operands much 6083 /// like \see checkArithmeticOpPointerOperand. However, it has special logic 6084 /// for emitting a single diagnostic even for operations where both LHS and RHS 6085 /// are (potentially problematic) pointers. 6086 /// 6087 /// \returns True when the operand is valid to use (even if as an extension). 6088 static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc, 6089 Expr *LHSExpr, Expr *RHSExpr) { 6090 bool isLHSPointer = LHSExpr->getType()->isAnyPointerType(); 6091 bool isRHSPointer = RHSExpr->getType()->isAnyPointerType(); 6092 if (!isLHSPointer && !isRHSPointer) return true; 6093 6094 QualType LHSPointeeTy, RHSPointeeTy; 6095 if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType(); 6096 if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType(); 6097 6098 // Check for arithmetic on pointers to incomplete types. 6099 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType(); 6100 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType(); 6101 if (isLHSVoidPtr || isRHSVoidPtr) { 6102 if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr); 6103 else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr); 6104 else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr); 6105 6106 return !S.getLangOpts().CPlusPlus; 6107 } 6108 6109 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType(); 6110 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType(); 6111 if (isLHSFuncPtr || isRHSFuncPtr) { 6112 if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr); 6113 else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, 6114 RHSExpr); 6115 else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr); 6116 6117 return !S.getLangOpts().CPlusPlus; 6118 } 6119 6120 if (checkArithmeticIncompletePointerType(S, Loc, LHSExpr)) return false; 6121 if (checkArithmeticIncompletePointerType(S, Loc, RHSExpr)) return false; 6122 6123 return true; 6124 } 6125 6126 /// \brief Check bad cases where we step over interface counts. 6127 static bool checkArithmethicPointerOnNonFragileABI(Sema &S, 6128 SourceLocation OpLoc, 6129 Expr *Op) { 6130 assert(Op->getType()->isAnyPointerType()); 6131 QualType PointeeTy = Op->getType()->getPointeeType(); 6132 if (!PointeeTy->isObjCObjectType() || !S.LangOpts.ObjCNonFragileABI) 6133 return true; 6134 6135 S.Diag(OpLoc, diag::err_arithmetic_nonfragile_interface) 6136 << PointeeTy << Op->getSourceRange(); 6137 return false; 6138 } 6139 6140 /// diagnoseStringPlusInt - Emit a warning when adding an integer to a string 6141 /// literal. 6142 static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc, 6143 Expr *LHSExpr, Expr *RHSExpr) { 6144 StringLiteral* StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts()); 6145 Expr* IndexExpr = RHSExpr; 6146 if (!StrExpr) { 6147 StrExpr = dyn_cast<StringLiteral>(RHSExpr->IgnoreImpCasts()); 6148 IndexExpr = LHSExpr; 6149 } 6150 6151 bool IsStringPlusInt = StrExpr && 6152 IndexExpr->getType()->isIntegralOrUnscopedEnumerationType(); 6153 if (!IsStringPlusInt) 6154 return; 6155 6156 llvm::APSInt index; 6157 if (IndexExpr->EvaluateAsInt(index, Self.getASTContext())) { 6158 unsigned StrLenWithNull = StrExpr->getLength() + 1; 6159 if (index.isNonNegative() && 6160 index <= llvm::APSInt(llvm::APInt(index.getBitWidth(), StrLenWithNull), 6161 index.isUnsigned())) 6162 return; 6163 } 6164 6165 SourceRange DiagRange(LHSExpr->getLocStart(), RHSExpr->getLocEnd()); 6166 Self.Diag(OpLoc, diag::warn_string_plus_int) 6167 << DiagRange << IndexExpr->IgnoreImpCasts()->getType(); 6168 6169 // Only print a fixit for "str" + int, not for int + "str". 6170 if (IndexExpr == RHSExpr) { 6171 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(RHSExpr->getLocEnd()); 6172 Self.Diag(OpLoc, diag::note_string_plus_int_silence) 6173 << FixItHint::CreateInsertion(LHSExpr->getLocStart(), "&") 6174 << FixItHint::CreateReplacement(SourceRange(OpLoc), "[") 6175 << FixItHint::CreateInsertion(EndLoc, "]"); 6176 } else 6177 Self.Diag(OpLoc, diag::note_string_plus_int_silence); 6178 } 6179 6180 /// \brief Emit error when two pointers are incompatible. 6181 static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, 6182 Expr *LHSExpr, Expr *RHSExpr) { 6183 assert(LHSExpr->getType()->isAnyPointerType()); 6184 assert(RHSExpr->getType()->isAnyPointerType()); 6185 S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible) 6186 << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange() 6187 << RHSExpr->getSourceRange(); 6188 } 6189 6190 QualType Sema::CheckAdditionOperands( // C99 6.5.6 6191 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc, 6192 QualType* CompLHSTy) { 6193 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 6194 6195 if (LHS.get()->getType()->isVectorType() || 6196 RHS.get()->getType()->isVectorType()) { 6197 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy); 6198 if (CompLHSTy) *CompLHSTy = compType; 6199 return compType; 6200 } 6201 6202 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy); 6203 if (LHS.isInvalid() || RHS.isInvalid()) 6204 return QualType(); 6205 6206 // Diagnose "string literal" '+' int. 6207 if (Opc == BO_Add) 6208 diagnoseStringPlusInt(*this, Loc, LHS.get(), RHS.get()); 6209 6210 // handle the common case first (both operands are arithmetic). 6211 if (LHS.get()->getType()->isArithmeticType() && 6212 RHS.get()->getType()->isArithmeticType()) { 6213 if (CompLHSTy) *CompLHSTy = compType; 6214 return compType; 6215 } 6216 6217 if (LHS.get()->getType()->isAtomicType() && 6218 RHS.get()->getType()->isArithmeticType()) { 6219 *CompLHSTy = LHS.get()->getType(); 6220 return compType; 6221 } 6222 6223 // Put any potential pointer into PExp 6224 Expr* PExp = LHS.get(), *IExp = RHS.get(); 6225 if (IExp->getType()->isAnyPointerType()) 6226 std::swap(PExp, IExp); 6227 6228 if (!PExp->getType()->isAnyPointerType()) 6229 return InvalidOperands(Loc, LHS, RHS); 6230 6231 if (!IExp->getType()->isIntegerType()) 6232 return InvalidOperands(Loc, LHS, RHS); 6233 6234 if (!checkArithmeticOpPointerOperand(*this, Loc, PExp)) 6235 return QualType(); 6236 6237 // Diagnose bad cases where we step over interface counts. 6238 if (!checkArithmethicPointerOnNonFragileABI(*this, Loc, PExp)) 6239 return QualType(); 6240 6241 // Check array bounds for pointer arithemtic 6242 CheckArrayAccess(PExp, IExp); 6243 6244 if (CompLHSTy) { 6245 QualType LHSTy = Context.isPromotableBitField(LHS.get()); 6246 if (LHSTy.isNull()) { 6247 LHSTy = LHS.get()->getType(); 6248 if (LHSTy->isPromotableIntegerType()) 6249 LHSTy = Context.getPromotedIntegerType(LHSTy); 6250 } 6251 *CompLHSTy = LHSTy; 6252 } 6253 6254 return PExp->getType(); 6255 } 6256 6257 // C99 6.5.6 6258 QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS, 6259 SourceLocation Loc, 6260 QualType* CompLHSTy) { 6261 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 6262 6263 if (LHS.get()->getType()->isVectorType() || 6264 RHS.get()->getType()->isVectorType()) { 6265 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy); 6266 if (CompLHSTy) *CompLHSTy = compType; 6267 return compType; 6268 } 6269 6270 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy); 6271 if (LHS.isInvalid() || RHS.isInvalid()) 6272 return QualType(); 6273 6274 // Enforce type constraints: C99 6.5.6p3. 6275 6276 // Handle the common case first (both operands are arithmetic). 6277 if (LHS.get()->getType()->isArithmeticType() && 6278 RHS.get()->getType()->isArithmeticType()) { 6279 if (CompLHSTy) *CompLHSTy = compType; 6280 return compType; 6281 } 6282 6283 if (LHS.get()->getType()->isAtomicType() && 6284 RHS.get()->getType()->isArithmeticType()) { 6285 *CompLHSTy = LHS.get()->getType(); 6286 return compType; 6287 } 6288 6289 // Either ptr - int or ptr - ptr. 6290 if (LHS.get()->getType()->isAnyPointerType()) { 6291 QualType lpointee = LHS.get()->getType()->getPointeeType(); 6292 6293 // Diagnose bad cases where we step over interface counts. 6294 if (!checkArithmethicPointerOnNonFragileABI(*this, Loc, LHS.get())) 6295 return QualType(); 6296 6297 // The result type of a pointer-int computation is the pointer type. 6298 if (RHS.get()->getType()->isIntegerType()) { 6299 if (!checkArithmeticOpPointerOperand(*this, Loc, LHS.get())) 6300 return QualType(); 6301 6302 // Check array bounds for pointer arithemtic 6303 CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/0, 6304 /*AllowOnePastEnd*/true, /*IndexNegated*/true); 6305 6306 if (CompLHSTy) *CompLHSTy = LHS.get()->getType(); 6307 return LHS.get()->getType(); 6308 } 6309 6310 // Handle pointer-pointer subtractions. 6311 if (const PointerType *RHSPTy 6312 = RHS.get()->getType()->getAs<PointerType>()) { 6313 QualType rpointee = RHSPTy->getPointeeType(); 6314 6315 if (getLangOpts().CPlusPlus) { 6316 // Pointee types must be the same: C++ [expr.add] 6317 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) { 6318 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get()); 6319 } 6320 } else { 6321 // Pointee types must be compatible C99 6.5.6p3 6322 if (!Context.typesAreCompatible( 6323 Context.getCanonicalType(lpointee).getUnqualifiedType(), 6324 Context.getCanonicalType(rpointee).getUnqualifiedType())) { 6325 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get()); 6326 return QualType(); 6327 } 6328 } 6329 6330 if (!checkArithmeticBinOpPointerOperands(*this, Loc, 6331 LHS.get(), RHS.get())) 6332 return QualType(); 6333 6334 if (CompLHSTy) *CompLHSTy = LHS.get()->getType(); 6335 return Context.getPointerDiffType(); 6336 } 6337 } 6338 6339 return InvalidOperands(Loc, LHS, RHS); 6340 } 6341 6342 static bool isScopedEnumerationType(QualType T) { 6343 if (const EnumType *ET = dyn_cast<EnumType>(T)) 6344 return ET->getDecl()->isScoped(); 6345 return false; 6346 } 6347 6348 static void DiagnoseBadShiftValues(Sema& S, ExprResult &LHS, ExprResult &RHS, 6349 SourceLocation Loc, unsigned Opc, 6350 QualType LHSType) { 6351 llvm::APSInt Right; 6352 // Check right/shifter operand 6353 if (RHS.get()->isValueDependent() || 6354 !RHS.get()->isIntegerConstantExpr(Right, S.Context)) 6355 return; 6356 6357 if (Right.isNegative()) { 6358 S.DiagRuntimeBehavior(Loc, RHS.get(), 6359 S.PDiag(diag::warn_shift_negative) 6360 << RHS.get()->getSourceRange()); 6361 return; 6362 } 6363 llvm::APInt LeftBits(Right.getBitWidth(), 6364 S.Context.getTypeSize(LHS.get()->getType())); 6365 if (Right.uge(LeftBits)) { 6366 S.DiagRuntimeBehavior(Loc, RHS.get(), 6367 S.PDiag(diag::warn_shift_gt_typewidth) 6368 << RHS.get()->getSourceRange()); 6369 return; 6370 } 6371 if (Opc != BO_Shl) 6372 return; 6373 6374 // When left shifting an ICE which is signed, we can check for overflow which 6375 // according to C++ has undefined behavior ([expr.shift] 5.8/2). Unsigned 6376 // integers have defined behavior modulo one more than the maximum value 6377 // representable in the result type, so never warn for those. 6378 llvm::APSInt Left; 6379 if (LHS.get()->isValueDependent() || 6380 !LHS.get()->isIntegerConstantExpr(Left, S.Context) || 6381 LHSType->hasUnsignedIntegerRepresentation()) 6382 return; 6383 llvm::APInt ResultBits = 6384 static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits(); 6385 if (LeftBits.uge(ResultBits)) 6386 return; 6387 llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue()); 6388 Result = Result.shl(Right); 6389 6390 // Print the bit representation of the signed integer as an unsigned 6391 // hexadecimal number. 6392 SmallString<40> HexResult; 6393 Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true); 6394 6395 // If we are only missing a sign bit, this is less likely to result in actual 6396 // bugs -- if the result is cast back to an unsigned type, it will have the 6397 // expected value. Thus we place this behind a different warning that can be 6398 // turned off separately if needed. 6399 if (LeftBits == ResultBits - 1) { 6400 S.Diag(Loc, diag::warn_shift_result_sets_sign_bit) 6401 << HexResult.str() << LHSType 6402 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6403 return; 6404 } 6405 6406 S.Diag(Loc, diag::warn_shift_result_gt_typewidth) 6407 << HexResult.str() << Result.getMinSignedBits() << LHSType 6408 << Left.getBitWidth() << LHS.get()->getSourceRange() 6409 << RHS.get()->getSourceRange(); 6410 } 6411 6412 // C99 6.5.7 6413 QualType Sema::CheckShiftOperands(ExprResult &LHS, ExprResult &RHS, 6414 SourceLocation Loc, unsigned Opc, 6415 bool IsCompAssign) { 6416 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 6417 6418 // C99 6.5.7p2: Each of the operands shall have integer type. 6419 if (!LHS.get()->getType()->hasIntegerRepresentation() || 6420 !RHS.get()->getType()->hasIntegerRepresentation()) 6421 return InvalidOperands(Loc, LHS, RHS); 6422 6423 // C++0x: Don't allow scoped enums. FIXME: Use something better than 6424 // hasIntegerRepresentation() above instead of this. 6425 if (isScopedEnumerationType(LHS.get()->getType()) || 6426 isScopedEnumerationType(RHS.get()->getType())) { 6427 return InvalidOperands(Loc, LHS, RHS); 6428 } 6429 6430 // Vector shifts promote their scalar inputs to vector type. 6431 if (LHS.get()->getType()->isVectorType() || 6432 RHS.get()->getType()->isVectorType()) 6433 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 6434 6435 // Shifts don't perform usual arithmetic conversions, they just do integer 6436 // promotions on each operand. C99 6.5.7p3 6437 6438 // For the LHS, do usual unary conversions, but then reset them away 6439 // if this is a compound assignment. 6440 ExprResult OldLHS = LHS; 6441 LHS = UsualUnaryConversions(LHS.take()); 6442 if (LHS.isInvalid()) 6443 return QualType(); 6444 QualType LHSType = LHS.get()->getType(); 6445 if (IsCompAssign) LHS = OldLHS; 6446 6447 // The RHS is simpler. 6448 RHS = UsualUnaryConversions(RHS.take()); 6449 if (RHS.isInvalid()) 6450 return QualType(); 6451 6452 // Sanity-check shift operands 6453 DiagnoseBadShiftValues(*this, LHS, RHS, Loc, Opc, LHSType); 6454 6455 // "The type of the result is that of the promoted left operand." 6456 return LHSType; 6457 } 6458 6459 static bool IsWithinTemplateSpecialization(Decl *D) { 6460 if (DeclContext *DC = D->getDeclContext()) { 6461 if (isa<ClassTemplateSpecializationDecl>(DC)) 6462 return true; 6463 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) 6464 return FD->isFunctionTemplateSpecialization(); 6465 } 6466 return false; 6467 } 6468 6469 /// If two different enums are compared, raise a warning. 6470 static void checkEnumComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, 6471 ExprResult &RHS) { 6472 QualType LHSStrippedType = LHS.get()->IgnoreParenImpCasts()->getType(); 6473 QualType RHSStrippedType = RHS.get()->IgnoreParenImpCasts()->getType(); 6474 6475 const EnumType *LHSEnumType = LHSStrippedType->getAs<EnumType>(); 6476 if (!LHSEnumType) 6477 return; 6478 const EnumType *RHSEnumType = RHSStrippedType->getAs<EnumType>(); 6479 if (!RHSEnumType) 6480 return; 6481 6482 // Ignore anonymous enums. 6483 if (!LHSEnumType->getDecl()->getIdentifier()) 6484 return; 6485 if (!RHSEnumType->getDecl()->getIdentifier()) 6486 return; 6487 6488 if (S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType)) 6489 return; 6490 6491 S.Diag(Loc, diag::warn_comparison_of_mixed_enum_types) 6492 << LHSStrippedType << RHSStrippedType 6493 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6494 } 6495 6496 /// \brief Diagnose bad pointer comparisons. 6497 static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, 6498 ExprResult &LHS, ExprResult &RHS, 6499 bool IsError) { 6500 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers 6501 : diag::ext_typecheck_comparison_of_distinct_pointers) 6502 << LHS.get()->getType() << RHS.get()->getType() 6503 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6504 } 6505 6506 /// \brief Returns false if the pointers are converted to a composite type, 6507 /// true otherwise. 6508 static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc, 6509 ExprResult &LHS, ExprResult &RHS) { 6510 // C++ [expr.rel]p2: 6511 // [...] Pointer conversions (4.10) and qualification 6512 // conversions (4.4) are performed on pointer operands (or on 6513 // a pointer operand and a null pointer constant) to bring 6514 // them to their composite pointer type. [...] 6515 // 6516 // C++ [expr.eq]p1 uses the same notion for (in)equality 6517 // comparisons of pointers. 6518 6519 // C++ [expr.eq]p2: 6520 // In addition, pointers to members can be compared, or a pointer to 6521 // member and a null pointer constant. Pointer to member conversions 6522 // (4.11) and qualification conversions (4.4) are performed to bring 6523 // them to a common type. If one operand is a null pointer constant, 6524 // the common type is the type of the other operand. Otherwise, the 6525 // common type is a pointer to member type similar (4.4) to the type 6526 // of one of the operands, with a cv-qualification signature (4.4) 6527 // that is the union of the cv-qualification signatures of the operand 6528 // types. 6529 6530 QualType LHSType = LHS.get()->getType(); 6531 QualType RHSType = RHS.get()->getType(); 6532 assert((LHSType->isPointerType() && RHSType->isPointerType()) || 6533 (LHSType->isMemberPointerType() && RHSType->isMemberPointerType())); 6534 6535 bool NonStandardCompositeType = false; 6536 bool *BoolPtr = S.isSFINAEContext() ? 0 : &NonStandardCompositeType; 6537 QualType T = S.FindCompositePointerType(Loc, LHS, RHS, BoolPtr); 6538 if (T.isNull()) { 6539 diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true); 6540 return true; 6541 } 6542 6543 if (NonStandardCompositeType) 6544 S.Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard) 6545 << LHSType << RHSType << T << LHS.get()->getSourceRange() 6546 << RHS.get()->getSourceRange(); 6547 6548 LHS = S.ImpCastExprToType(LHS.take(), T, CK_BitCast); 6549 RHS = S.ImpCastExprToType(RHS.take(), T, CK_BitCast); 6550 return false; 6551 } 6552 6553 static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc, 6554 ExprResult &LHS, 6555 ExprResult &RHS, 6556 bool IsError) { 6557 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void 6558 : diag::ext_typecheck_comparison_of_fptr_to_void) 6559 << LHS.get()->getType() << RHS.get()->getType() 6560 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6561 } 6562 6563 // C99 6.5.8, C++ [expr.rel] 6564 QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS, 6565 SourceLocation Loc, unsigned OpaqueOpc, 6566 bool IsRelational) { 6567 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/true); 6568 6569 BinaryOperatorKind Opc = (BinaryOperatorKind) OpaqueOpc; 6570 6571 // Handle vector comparisons separately. 6572 if (LHS.get()->getType()->isVectorType() || 6573 RHS.get()->getType()->isVectorType()) 6574 return CheckVectorCompareOperands(LHS, RHS, Loc, IsRelational); 6575 6576 QualType LHSType = LHS.get()->getType(); 6577 QualType RHSType = RHS.get()->getType(); 6578 6579 Expr *LHSStripped = LHS.get()->IgnoreParenImpCasts(); 6580 Expr *RHSStripped = RHS.get()->IgnoreParenImpCasts(); 6581 6582 checkEnumComparison(*this, Loc, LHS, RHS); 6583 6584 if (!LHSType->hasFloatingRepresentation() && 6585 !(LHSType->isBlockPointerType() && IsRelational) && 6586 !LHS.get()->getLocStart().isMacroID() && 6587 !RHS.get()->getLocStart().isMacroID()) { 6588 // For non-floating point types, check for self-comparisons of the form 6589 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 6590 // often indicate logic errors in the program. 6591 // 6592 // NOTE: Don't warn about comparison expressions resulting from macro 6593 // expansion. Also don't warn about comparisons which are only self 6594 // comparisons within a template specialization. The warnings should catch 6595 // obvious cases in the definition of the template anyways. The idea is to 6596 // warn when the typed comparison operator will always evaluate to the same 6597 // result. 6598 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHSStripped)) { 6599 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHSStripped)) { 6600 if (DRL->getDecl() == DRR->getDecl() && 6601 !IsWithinTemplateSpecialization(DRL->getDecl())) { 6602 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always) 6603 << 0 // self- 6604 << (Opc == BO_EQ 6605 || Opc == BO_LE 6606 || Opc == BO_GE)); 6607 } else if (LHSType->isArrayType() && RHSType->isArrayType() && 6608 !DRL->getDecl()->getType()->isReferenceType() && 6609 !DRR->getDecl()->getType()->isReferenceType()) { 6610 // what is it always going to eval to? 6611 char always_evals_to; 6612 switch(Opc) { 6613 case BO_EQ: // e.g. array1 == array2 6614 always_evals_to = 0; // false 6615 break; 6616 case BO_NE: // e.g. array1 != array2 6617 always_evals_to = 1; // true 6618 break; 6619 default: 6620 // best we can say is 'a constant' 6621 always_evals_to = 2; // e.g. array1 <= array2 6622 break; 6623 } 6624 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always) 6625 << 1 // array 6626 << always_evals_to); 6627 } 6628 } 6629 } 6630 6631 if (isa<CastExpr>(LHSStripped)) 6632 LHSStripped = LHSStripped->IgnoreParenCasts(); 6633 if (isa<CastExpr>(RHSStripped)) 6634 RHSStripped = RHSStripped->IgnoreParenCasts(); 6635 6636 // Warn about comparisons against a string constant (unless the other 6637 // operand is null), the user probably wants strcmp. 6638 Expr *literalString = 0; 6639 Expr *literalStringStripped = 0; 6640 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) && 6641 !RHSStripped->isNullPointerConstant(Context, 6642 Expr::NPC_ValueDependentIsNull)) { 6643 literalString = LHS.get(); 6644 literalStringStripped = LHSStripped; 6645 } else if ((isa<StringLiteral>(RHSStripped) || 6646 isa<ObjCEncodeExpr>(RHSStripped)) && 6647 !LHSStripped->isNullPointerConstant(Context, 6648 Expr::NPC_ValueDependentIsNull)) { 6649 literalString = RHS.get(); 6650 literalStringStripped = RHSStripped; 6651 } 6652 6653 if (literalString) { 6654 std::string resultComparison; 6655 switch (Opc) { 6656 case BO_LT: resultComparison = ") < 0"; break; 6657 case BO_GT: resultComparison = ") > 0"; break; 6658 case BO_LE: resultComparison = ") <= 0"; break; 6659 case BO_GE: resultComparison = ") >= 0"; break; 6660 case BO_EQ: resultComparison = ") == 0"; break; 6661 case BO_NE: resultComparison = ") != 0"; break; 6662 default: llvm_unreachable("Invalid comparison operator"); 6663 } 6664 6665 DiagRuntimeBehavior(Loc, 0, 6666 PDiag(diag::warn_stringcompare) 6667 << isa<ObjCEncodeExpr>(literalStringStripped) 6668 << literalString->getSourceRange()); 6669 } 6670 } 6671 6672 // C99 6.5.8p3 / C99 6.5.9p4 6673 if (LHS.get()->getType()->isArithmeticType() && 6674 RHS.get()->getType()->isArithmeticType()) { 6675 UsualArithmeticConversions(LHS, RHS); 6676 if (LHS.isInvalid() || RHS.isInvalid()) 6677 return QualType(); 6678 } 6679 else { 6680 LHS = UsualUnaryConversions(LHS.take()); 6681 if (LHS.isInvalid()) 6682 return QualType(); 6683 6684 RHS = UsualUnaryConversions(RHS.take()); 6685 if (RHS.isInvalid()) 6686 return QualType(); 6687 } 6688 6689 LHSType = LHS.get()->getType(); 6690 RHSType = RHS.get()->getType(); 6691 6692 // The result of comparisons is 'bool' in C++, 'int' in C. 6693 QualType ResultTy = Context.getLogicalOperationType(); 6694 6695 if (IsRelational) { 6696 if (LHSType->isRealType() && RHSType->isRealType()) 6697 return ResultTy; 6698 } else { 6699 // Check for comparisons of floating point operands using != and ==. 6700 if (LHSType->hasFloatingRepresentation()) 6701 CheckFloatComparison(Loc, LHS.get(), RHS.get()); 6702 6703 if (LHSType->isArithmeticType() && RHSType->isArithmeticType()) 6704 return ResultTy; 6705 } 6706 6707 bool LHSIsNull = LHS.get()->isNullPointerConstant(Context, 6708 Expr::NPC_ValueDependentIsNull); 6709 bool RHSIsNull = RHS.get()->isNullPointerConstant(Context, 6710 Expr::NPC_ValueDependentIsNull); 6711 6712 // All of the following pointer-related warnings are GCC extensions, except 6713 // when handling null pointer constants. 6714 if (LHSType->isPointerType() && RHSType->isPointerType()) { // C99 6.5.8p2 6715 QualType LCanPointeeTy = 6716 LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType(); 6717 QualType RCanPointeeTy = 6718 RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType(); 6719 6720 if (getLangOpts().CPlusPlus) { 6721 if (LCanPointeeTy == RCanPointeeTy) 6722 return ResultTy; 6723 if (!IsRelational && 6724 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 6725 // Valid unless comparison between non-null pointer and function pointer 6726 // This is a gcc extension compatibility comparison. 6727 // In a SFINAE context, we treat this as a hard error to maintain 6728 // conformance with the C++ standard. 6729 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 6730 && !LHSIsNull && !RHSIsNull) { 6731 diagnoseFunctionPointerToVoidComparison( 6732 *this, Loc, LHS, RHS, /*isError*/ isSFINAEContext()); 6733 6734 if (isSFINAEContext()) 6735 return QualType(); 6736 6737 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 6738 return ResultTy; 6739 } 6740 } 6741 6742 if (convertPointersToCompositeType(*this, Loc, LHS, RHS)) 6743 return QualType(); 6744 else 6745 return ResultTy; 6746 } 6747 // C99 6.5.9p2 and C99 6.5.8p2 6748 if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(), 6749 RCanPointeeTy.getUnqualifiedType())) { 6750 // Valid unless a relational comparison of function pointers 6751 if (IsRelational && LCanPointeeTy->isFunctionType()) { 6752 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers) 6753 << LHSType << RHSType << LHS.get()->getSourceRange() 6754 << RHS.get()->getSourceRange(); 6755 } 6756 } else if (!IsRelational && 6757 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 6758 // Valid unless comparison between non-null pointer and function pointer 6759 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 6760 && !LHSIsNull && !RHSIsNull) 6761 diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS, 6762 /*isError*/false); 6763 } else { 6764 // Invalid 6765 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false); 6766 } 6767 if (LCanPointeeTy != RCanPointeeTy) { 6768 if (LHSIsNull && !RHSIsNull) 6769 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); 6770 else 6771 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 6772 } 6773 return ResultTy; 6774 } 6775 6776 if (getLangOpts().CPlusPlus) { 6777 // Comparison of nullptr_t with itself. 6778 if (LHSType->isNullPtrType() && RHSType->isNullPtrType()) 6779 return ResultTy; 6780 6781 // Comparison of pointers with null pointer constants and equality 6782 // comparisons of member pointers to null pointer constants. 6783 if (RHSIsNull && 6784 ((LHSType->isAnyPointerType() || LHSType->isNullPtrType()) || 6785 (!IsRelational && 6786 (LHSType->isMemberPointerType() || LHSType->isBlockPointerType())))) { 6787 RHS = ImpCastExprToType(RHS.take(), LHSType, 6788 LHSType->isMemberPointerType() 6789 ? CK_NullToMemberPointer 6790 : CK_NullToPointer); 6791 return ResultTy; 6792 } 6793 if (LHSIsNull && 6794 ((RHSType->isAnyPointerType() || RHSType->isNullPtrType()) || 6795 (!IsRelational && 6796 (RHSType->isMemberPointerType() || RHSType->isBlockPointerType())))) { 6797 LHS = ImpCastExprToType(LHS.take(), RHSType, 6798 RHSType->isMemberPointerType() 6799 ? CK_NullToMemberPointer 6800 : CK_NullToPointer); 6801 return ResultTy; 6802 } 6803 6804 // Comparison of member pointers. 6805 if (!IsRelational && 6806 LHSType->isMemberPointerType() && RHSType->isMemberPointerType()) { 6807 if (convertPointersToCompositeType(*this, Loc, LHS, RHS)) 6808 return QualType(); 6809 else 6810 return ResultTy; 6811 } 6812 6813 // Handle scoped enumeration types specifically, since they don't promote 6814 // to integers. 6815 if (LHS.get()->getType()->isEnumeralType() && 6816 Context.hasSameUnqualifiedType(LHS.get()->getType(), 6817 RHS.get()->getType())) 6818 return ResultTy; 6819 } 6820 6821 // Handle block pointer types. 6822 if (!IsRelational && LHSType->isBlockPointerType() && 6823 RHSType->isBlockPointerType()) { 6824 QualType lpointee = LHSType->castAs<BlockPointerType>()->getPointeeType(); 6825 QualType rpointee = RHSType->castAs<BlockPointerType>()->getPointeeType(); 6826 6827 if (!LHSIsNull && !RHSIsNull && 6828 !Context.typesAreCompatible(lpointee, rpointee)) { 6829 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 6830 << LHSType << RHSType << LHS.get()->getSourceRange() 6831 << RHS.get()->getSourceRange(); 6832 } 6833 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 6834 return ResultTy; 6835 } 6836 6837 // Allow block pointers to be compared with null pointer constants. 6838 if (!IsRelational 6839 && ((LHSType->isBlockPointerType() && RHSType->isPointerType()) 6840 || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) { 6841 if (!LHSIsNull && !RHSIsNull) { 6842 if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>() 6843 ->getPointeeType()->isVoidType()) 6844 || (LHSType->isPointerType() && LHSType->castAs<PointerType>() 6845 ->getPointeeType()->isVoidType()))) 6846 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 6847 << LHSType << RHSType << LHS.get()->getSourceRange() 6848 << RHS.get()->getSourceRange(); 6849 } 6850 if (LHSIsNull && !RHSIsNull) 6851 LHS = ImpCastExprToType(LHS.take(), RHSType, 6852 RHSType->isPointerType() ? CK_BitCast 6853 : CK_AnyPointerToBlockPointerCast); 6854 else 6855 RHS = ImpCastExprToType(RHS.take(), LHSType, 6856 LHSType->isPointerType() ? CK_BitCast 6857 : CK_AnyPointerToBlockPointerCast); 6858 return ResultTy; 6859 } 6860 6861 if (LHSType->isObjCObjectPointerType() || 6862 RHSType->isObjCObjectPointerType()) { 6863 const PointerType *LPT = LHSType->getAs<PointerType>(); 6864 const PointerType *RPT = RHSType->getAs<PointerType>(); 6865 if (LPT || RPT) { 6866 bool LPtrToVoid = LPT ? LPT->getPointeeType()->isVoidType() : false; 6867 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() : false; 6868 6869 if (!LPtrToVoid && !RPtrToVoid && 6870 !Context.typesAreCompatible(LHSType, RHSType)) { 6871 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, 6872 /*isError*/false); 6873 } 6874 if (LHSIsNull && !RHSIsNull) 6875 LHS = ImpCastExprToType(LHS.take(), RHSType, 6876 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast); 6877 else 6878 RHS = ImpCastExprToType(RHS.take(), LHSType, 6879 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast); 6880 return ResultTy; 6881 } 6882 if (LHSType->isObjCObjectPointerType() && 6883 RHSType->isObjCObjectPointerType()) { 6884 if (!Context.areComparableObjCPointerTypes(LHSType, RHSType)) 6885 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, 6886 /*isError*/false); 6887 if (LHSIsNull && !RHSIsNull) 6888 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); 6889 else 6890 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 6891 return ResultTy; 6892 } 6893 } 6894 if ((LHSType->isAnyPointerType() && RHSType->isIntegerType()) || 6895 (LHSType->isIntegerType() && RHSType->isAnyPointerType())) { 6896 unsigned DiagID = 0; 6897 bool isError = false; 6898 if ((LHSIsNull && LHSType->isIntegerType()) || 6899 (RHSIsNull && RHSType->isIntegerType())) { 6900 if (IsRelational && !getLangOpts().CPlusPlus) 6901 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero; 6902 } else if (IsRelational && !getLangOpts().CPlusPlus) 6903 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer; 6904 else if (getLangOpts().CPlusPlus) { 6905 DiagID = diag::err_typecheck_comparison_of_pointer_integer; 6906 isError = true; 6907 } else 6908 DiagID = diag::ext_typecheck_comparison_of_pointer_integer; 6909 6910 if (DiagID) { 6911 Diag(Loc, DiagID) 6912 << LHSType << RHSType << LHS.get()->getSourceRange() 6913 << RHS.get()->getSourceRange(); 6914 if (isError) 6915 return QualType(); 6916 } 6917 6918 if (LHSType->isIntegerType()) 6919 LHS = ImpCastExprToType(LHS.take(), RHSType, 6920 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 6921 else 6922 RHS = ImpCastExprToType(RHS.take(), LHSType, 6923 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 6924 return ResultTy; 6925 } 6926 6927 // Handle block pointers. 6928 if (!IsRelational && RHSIsNull 6929 && LHSType->isBlockPointerType() && RHSType->isIntegerType()) { 6930 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_NullToPointer); 6931 return ResultTy; 6932 } 6933 if (!IsRelational && LHSIsNull 6934 && LHSType->isIntegerType() && RHSType->isBlockPointerType()) { 6935 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_NullToPointer); 6936 return ResultTy; 6937 } 6938 6939 return InvalidOperands(Loc, LHS, RHS); 6940 } 6941 6942 6943 // Return a signed type that is of identical size and number of elements. 6944 // For floating point vectors, return an integer type of identical size 6945 // and number of elements. 6946 QualType Sema::GetSignedVectorType(QualType V) { 6947 const VectorType *VTy = V->getAs<VectorType>(); 6948 unsigned TypeSize = Context.getTypeSize(VTy->getElementType()); 6949 if (TypeSize == Context.getTypeSize(Context.CharTy)) 6950 return Context.getExtVectorType(Context.CharTy, VTy->getNumElements()); 6951 else if (TypeSize == Context.getTypeSize(Context.ShortTy)) 6952 return Context.getExtVectorType(Context.ShortTy, VTy->getNumElements()); 6953 else if (TypeSize == Context.getTypeSize(Context.IntTy)) 6954 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements()); 6955 else if (TypeSize == Context.getTypeSize(Context.LongTy)) 6956 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements()); 6957 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) && 6958 "Unhandled vector element size in vector compare"); 6959 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements()); 6960 } 6961 6962 /// CheckVectorCompareOperands - vector comparisons are a clang extension that 6963 /// operates on extended vector types. Instead of producing an IntTy result, 6964 /// like a scalar comparison, a vector comparison produces a vector of integer 6965 /// types. 6966 QualType Sema::CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, 6967 SourceLocation Loc, 6968 bool IsRelational) { 6969 // Check to make sure we're operating on vectors of the same type and width, 6970 // Allowing one side to be a scalar of element type. 6971 QualType vType = CheckVectorOperands(LHS, RHS, Loc, /*isCompAssign*/false); 6972 if (vType.isNull()) 6973 return vType; 6974 6975 QualType LHSType = LHS.get()->getType(); 6976 6977 // If AltiVec, the comparison results in a numeric type, i.e. 6978 // bool for C++, int for C 6979 if (vType->getAs<VectorType>()->getVectorKind() == VectorType::AltiVecVector) 6980 return Context.getLogicalOperationType(); 6981 6982 // For non-floating point types, check for self-comparisons of the form 6983 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 6984 // often indicate logic errors in the program. 6985 if (!LHSType->hasFloatingRepresentation()) { 6986 if (DeclRefExpr* DRL 6987 = dyn_cast<DeclRefExpr>(LHS.get()->IgnoreParenImpCasts())) 6988 if (DeclRefExpr* DRR 6989 = dyn_cast<DeclRefExpr>(RHS.get()->IgnoreParenImpCasts())) 6990 if (DRL->getDecl() == DRR->getDecl()) 6991 DiagRuntimeBehavior(Loc, 0, 6992 PDiag(diag::warn_comparison_always) 6993 << 0 // self- 6994 << 2 // "a constant" 6995 ); 6996 } 6997 6998 // Check for comparisons of floating point operands using != and ==. 6999 if (!IsRelational && LHSType->hasFloatingRepresentation()) { 7000 assert (RHS.get()->getType()->hasFloatingRepresentation()); 7001 CheckFloatComparison(Loc, LHS.get(), RHS.get()); 7002 } 7003 7004 // Return a signed type for the vector. 7005 return GetSignedVectorType(LHSType); 7006 } 7007 7008 QualType Sema::CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, 7009 SourceLocation Loc) { 7010 // Ensure that either both operands are of the same vector type, or 7011 // one operand is of a vector type and the other is of its element type. 7012 QualType vType = CheckVectorOperands(LHS, RHS, Loc, false); 7013 if (vType.isNull() || vType->isFloatingType()) 7014 return InvalidOperands(Loc, LHS, RHS); 7015 7016 return GetSignedVectorType(LHS.get()->getType()); 7017 } 7018 7019 inline QualType Sema::CheckBitwiseOperands( 7020 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { 7021 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7022 7023 if (LHS.get()->getType()->isVectorType() || 7024 RHS.get()->getType()->isVectorType()) { 7025 if (LHS.get()->getType()->hasIntegerRepresentation() && 7026 RHS.get()->getType()->hasIntegerRepresentation()) 7027 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 7028 7029 return InvalidOperands(Loc, LHS, RHS); 7030 } 7031 7032 ExprResult LHSResult = Owned(LHS), RHSResult = Owned(RHS); 7033 QualType compType = UsualArithmeticConversions(LHSResult, RHSResult, 7034 IsCompAssign); 7035 if (LHSResult.isInvalid() || RHSResult.isInvalid()) 7036 return QualType(); 7037 LHS = LHSResult.take(); 7038 RHS = RHSResult.take(); 7039 7040 if (LHS.get()->getType()->isIntegralOrUnscopedEnumerationType() && 7041 RHS.get()->getType()->isIntegralOrUnscopedEnumerationType()) 7042 return compType; 7043 return InvalidOperands(Loc, LHS, RHS); 7044 } 7045 7046 inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14] 7047 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc) { 7048 7049 // Check vector operands differently. 7050 if (LHS.get()->getType()->isVectorType() || RHS.get()->getType()->isVectorType()) 7051 return CheckVectorLogicalOperands(LHS, RHS, Loc); 7052 7053 // Diagnose cases where the user write a logical and/or but probably meant a 7054 // bitwise one. We do this when the LHS is a non-bool integer and the RHS 7055 // is a constant. 7056 if (LHS.get()->getType()->isIntegerType() && 7057 !LHS.get()->getType()->isBooleanType() && 7058 RHS.get()->getType()->isIntegerType() && !RHS.get()->isValueDependent() && 7059 // Don't warn in macros or template instantiations. 7060 !Loc.isMacroID() && ActiveTemplateInstantiations.empty()) { 7061 // If the RHS can be constant folded, and if it constant folds to something 7062 // that isn't 0 or 1 (which indicate a potential logical operation that 7063 // happened to fold to true/false) then warn. 7064 // Parens on the RHS are ignored. 7065 llvm::APSInt Result; 7066 if (RHS.get()->EvaluateAsInt(Result, Context)) 7067 if ((getLangOpts().Bool && !RHS.get()->getType()->isBooleanType()) || 7068 (Result != 0 && Result != 1)) { 7069 Diag(Loc, diag::warn_logical_instead_of_bitwise) 7070 << RHS.get()->getSourceRange() 7071 << (Opc == BO_LAnd ? "&&" : "||"); 7072 // Suggest replacing the logical operator with the bitwise version 7073 Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator) 7074 << (Opc == BO_LAnd ? "&" : "|") 7075 << FixItHint::CreateReplacement(SourceRange( 7076 Loc, Lexer::getLocForEndOfToken(Loc, 0, getSourceManager(), 7077 getLangOpts())), 7078 Opc == BO_LAnd ? "&" : "|"); 7079 if (Opc == BO_LAnd) 7080 // Suggest replacing "Foo() && kNonZero" with "Foo()" 7081 Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant) 7082 << FixItHint::CreateRemoval( 7083 SourceRange( 7084 Lexer::getLocForEndOfToken(LHS.get()->getLocEnd(), 7085 0, getSourceManager(), 7086 getLangOpts()), 7087 RHS.get()->getLocEnd())); 7088 } 7089 } 7090 7091 if (!Context.getLangOpts().CPlusPlus) { 7092 LHS = UsualUnaryConversions(LHS.take()); 7093 if (LHS.isInvalid()) 7094 return QualType(); 7095 7096 RHS = UsualUnaryConversions(RHS.take()); 7097 if (RHS.isInvalid()) 7098 return QualType(); 7099 7100 if (!LHS.get()->getType()->isScalarType() || 7101 !RHS.get()->getType()->isScalarType()) 7102 return InvalidOperands(Loc, LHS, RHS); 7103 7104 return Context.IntTy; 7105 } 7106 7107 // The following is safe because we only use this method for 7108 // non-overloadable operands. 7109 7110 // C++ [expr.log.and]p1 7111 // C++ [expr.log.or]p1 7112 // The operands are both contextually converted to type bool. 7113 ExprResult LHSRes = PerformContextuallyConvertToBool(LHS.get()); 7114 if (LHSRes.isInvalid()) 7115 return InvalidOperands(Loc, LHS, RHS); 7116 LHS = move(LHSRes); 7117 7118 ExprResult RHSRes = PerformContextuallyConvertToBool(RHS.get()); 7119 if (RHSRes.isInvalid()) 7120 return InvalidOperands(Loc, LHS, RHS); 7121 RHS = move(RHSRes); 7122 7123 // C++ [expr.log.and]p2 7124 // C++ [expr.log.or]p2 7125 // The result is a bool. 7126 return Context.BoolTy; 7127 } 7128 7129 /// IsReadonlyProperty - Verify that otherwise a valid l-value expression 7130 /// is a read-only property; return true if so. A readonly property expression 7131 /// depends on various declarations and thus must be treated specially. 7132 /// 7133 static bool IsReadonlyProperty(Expr *E, Sema &S) { 7134 const ObjCPropertyRefExpr *PropExpr = dyn_cast<ObjCPropertyRefExpr>(E); 7135 if (!PropExpr) return false; 7136 if (PropExpr->isImplicitProperty()) return false; 7137 7138 ObjCPropertyDecl *PDecl = PropExpr->getExplicitProperty(); 7139 QualType BaseType = PropExpr->isSuperReceiver() ? 7140 PropExpr->getSuperReceiverType() : 7141 PropExpr->getBase()->getType(); 7142 7143 if (const ObjCObjectPointerType *OPT = 7144 BaseType->getAsObjCInterfacePointerType()) 7145 if (ObjCInterfaceDecl *IFace = OPT->getInterfaceDecl()) 7146 if (S.isPropertyReadonly(PDecl, IFace)) 7147 return true; 7148 return false; 7149 } 7150 7151 static bool IsReadonlyMessage(Expr *E, Sema &S) { 7152 const MemberExpr *ME = dyn_cast<MemberExpr>(E); 7153 if (!ME) return false; 7154 if (!isa<FieldDecl>(ME->getMemberDecl())) return false; 7155 ObjCMessageExpr *Base = 7156 dyn_cast<ObjCMessageExpr>(ME->getBase()->IgnoreParenImpCasts()); 7157 if (!Base) return false; 7158 return Base->getMethodDecl() != 0; 7159 } 7160 7161 /// Is the given expression (which must be 'const') a reference to a 7162 /// variable which was originally non-const, but which has become 7163 /// 'const' due to being captured within a block? 7164 enum NonConstCaptureKind { NCCK_None, NCCK_Block, NCCK_Lambda }; 7165 static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) { 7166 assert(E->isLValue() && E->getType().isConstQualified()); 7167 E = E->IgnoreParens(); 7168 7169 // Must be a reference to a declaration from an enclosing scope. 7170 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 7171 if (!DRE) return NCCK_None; 7172 if (!DRE->refersToEnclosingLocal()) return NCCK_None; 7173 7174 // The declaration must be a variable which is not declared 'const'. 7175 VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl()); 7176 if (!var) return NCCK_None; 7177 if (var->getType().isConstQualified()) return NCCK_None; 7178 assert(var->hasLocalStorage() && "capture added 'const' to non-local?"); 7179 7180 // Decide whether the first capture was for a block or a lambda. 7181 DeclContext *DC = S.CurContext; 7182 while (DC->getParent() != var->getDeclContext()) 7183 DC = DC->getParent(); 7184 return (isa<BlockDecl>(DC) ? NCCK_Block : NCCK_Lambda); 7185 } 7186 7187 /// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not, 7188 /// emit an error and return true. If so, return false. 7189 static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) { 7190 assert(!E->hasPlaceholderType(BuiltinType::PseudoObject)); 7191 SourceLocation OrigLoc = Loc; 7192 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context, 7193 &Loc); 7194 if (IsLV == Expr::MLV_Valid && IsReadonlyProperty(E, S)) 7195 IsLV = Expr::MLV_ReadonlyProperty; 7196 else if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S)) 7197 IsLV = Expr::MLV_InvalidMessageExpression; 7198 if (IsLV == Expr::MLV_Valid) 7199 return false; 7200 7201 unsigned Diag = 0; 7202 bool NeedType = false; 7203 switch (IsLV) { // C99 6.5.16p2 7204 case Expr::MLV_ConstQualified: 7205 Diag = diag::err_typecheck_assign_const; 7206 7207 // Use a specialized diagnostic when we're assigning to an object 7208 // from an enclosing function or block. 7209 if (NonConstCaptureKind NCCK = isReferenceToNonConstCapture(S, E)) { 7210 if (NCCK == NCCK_Block) 7211 Diag = diag::err_block_decl_ref_not_modifiable_lvalue; 7212 else 7213 Diag = diag::err_lambda_decl_ref_not_modifiable_lvalue; 7214 break; 7215 } 7216 7217 // In ARC, use some specialized diagnostics for occasions where we 7218 // infer 'const'. These are always pseudo-strong variables. 7219 if (S.getLangOpts().ObjCAutoRefCount) { 7220 DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()); 7221 if (declRef && isa<VarDecl>(declRef->getDecl())) { 7222 VarDecl *var = cast<VarDecl>(declRef->getDecl()); 7223 7224 // Use the normal diagnostic if it's pseudo-__strong but the 7225 // user actually wrote 'const'. 7226 if (var->isARCPseudoStrong() && 7227 (!var->getTypeSourceInfo() || 7228 !var->getTypeSourceInfo()->getType().isConstQualified())) { 7229 // There are two pseudo-strong cases: 7230 // - self 7231 ObjCMethodDecl *method = S.getCurMethodDecl(); 7232 if (method && var == method->getSelfDecl()) 7233 Diag = method->isClassMethod() 7234 ? diag::err_typecheck_arc_assign_self_class_method 7235 : diag::err_typecheck_arc_assign_self; 7236 7237 // - fast enumeration variables 7238 else 7239 Diag = diag::err_typecheck_arr_assign_enumeration; 7240 7241 SourceRange Assign; 7242 if (Loc != OrigLoc) 7243 Assign = SourceRange(OrigLoc, OrigLoc); 7244 S.Diag(Loc, Diag) << E->getSourceRange() << Assign; 7245 // We need to preserve the AST regardless, so migration tool 7246 // can do its job. 7247 return false; 7248 } 7249 } 7250 } 7251 7252 break; 7253 case Expr::MLV_ArrayType: 7254 Diag = diag::err_typecheck_array_not_modifiable_lvalue; 7255 NeedType = true; 7256 break; 7257 case Expr::MLV_NotObjectType: 7258 Diag = diag::err_typecheck_non_object_not_modifiable_lvalue; 7259 NeedType = true; 7260 break; 7261 case Expr::MLV_LValueCast: 7262 Diag = diag::err_typecheck_lvalue_casts_not_supported; 7263 break; 7264 case Expr::MLV_Valid: 7265 llvm_unreachable("did not take early return for MLV_Valid"); 7266 case Expr::MLV_InvalidExpression: 7267 case Expr::MLV_MemberFunction: 7268 case Expr::MLV_ClassTemporary: 7269 Diag = diag::err_typecheck_expression_not_modifiable_lvalue; 7270 break; 7271 case Expr::MLV_IncompleteType: 7272 case Expr::MLV_IncompleteVoidType: 7273 return S.RequireCompleteType(Loc, E->getType(), 7274 S.PDiag(diag::err_typecheck_incomplete_type_not_modifiable_lvalue) 7275 << E->getSourceRange()); 7276 case Expr::MLV_DuplicateVectorComponents: 7277 Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue; 7278 break; 7279 case Expr::MLV_ReadonlyProperty: 7280 case Expr::MLV_NoSetterProperty: 7281 llvm_unreachable("readonly properties should be processed differently"); 7282 case Expr::MLV_InvalidMessageExpression: 7283 Diag = diag::error_readonly_message_assignment; 7284 break; 7285 case Expr::MLV_SubObjCPropertySetting: 7286 Diag = diag::error_no_subobject_property_setting; 7287 break; 7288 } 7289 7290 SourceRange Assign; 7291 if (Loc != OrigLoc) 7292 Assign = SourceRange(OrigLoc, OrigLoc); 7293 if (NeedType) 7294 S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign; 7295 else 7296 S.Diag(Loc, Diag) << E->getSourceRange() << Assign; 7297 return true; 7298 } 7299 7300 7301 7302 // C99 6.5.16.1 7303 QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, 7304 SourceLocation Loc, 7305 QualType CompoundType) { 7306 assert(!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject)); 7307 7308 // Verify that LHS is a modifiable lvalue, and emit error if not. 7309 if (CheckForModifiableLvalue(LHSExpr, Loc, *this)) 7310 return QualType(); 7311 7312 QualType LHSType = LHSExpr->getType(); 7313 QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() : 7314 CompoundType; 7315 AssignConvertType ConvTy; 7316 if (CompoundType.isNull()) { 7317 QualType LHSTy(LHSType); 7318 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS); 7319 if (RHS.isInvalid()) 7320 return QualType(); 7321 // Special case of NSObject attributes on c-style pointer types. 7322 if (ConvTy == IncompatiblePointer && 7323 ((Context.isObjCNSObjectType(LHSType) && 7324 RHSType->isObjCObjectPointerType()) || 7325 (Context.isObjCNSObjectType(RHSType) && 7326 LHSType->isObjCObjectPointerType()))) 7327 ConvTy = Compatible; 7328 7329 if (ConvTy == Compatible && 7330 LHSType->isObjCObjectType()) 7331 Diag(Loc, diag::err_objc_object_assignment) 7332 << LHSType; 7333 7334 // If the RHS is a unary plus or minus, check to see if they = and + are 7335 // right next to each other. If so, the user may have typo'd "x =+ 4" 7336 // instead of "x += 4". 7337 Expr *RHSCheck = RHS.get(); 7338 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck)) 7339 RHSCheck = ICE->getSubExpr(); 7340 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) { 7341 if ((UO->getOpcode() == UO_Plus || 7342 UO->getOpcode() == UO_Minus) && 7343 Loc.isFileID() && UO->getOperatorLoc().isFileID() && 7344 // Only if the two operators are exactly adjacent. 7345 Loc.getLocWithOffset(1) == UO->getOperatorLoc() && 7346 // And there is a space or other character before the subexpr of the 7347 // unary +/-. We don't want to warn on "x=-1". 7348 Loc.getLocWithOffset(2) != UO->getSubExpr()->getLocStart() && 7349 UO->getSubExpr()->getLocStart().isFileID()) { 7350 Diag(Loc, diag::warn_not_compound_assign) 7351 << (UO->getOpcode() == UO_Plus ? "+" : "-") 7352 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc()); 7353 } 7354 } 7355 7356 if (ConvTy == Compatible) { 7357 if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong) 7358 checkRetainCycles(LHSExpr, RHS.get()); 7359 else if (getLangOpts().ObjCAutoRefCount) 7360 checkUnsafeExprAssigns(Loc, LHSExpr, RHS.get()); 7361 } 7362 } else { 7363 // Compound assignment "x += y" 7364 ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType); 7365 } 7366 7367 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType, 7368 RHS.get(), AA_Assigning)) 7369 return QualType(); 7370 7371 CheckForNullPointerDereference(*this, LHSExpr); 7372 7373 // C99 6.5.16p3: The type of an assignment expression is the type of the 7374 // left operand unless the left operand has qualified type, in which case 7375 // it is the unqualified version of the type of the left operand. 7376 // C99 6.5.16.1p2: In simple assignment, the value of the right operand 7377 // is converted to the type of the assignment expression (above). 7378 // C++ 5.17p1: the type of the assignment expression is that of its left 7379 // operand. 7380 return (getLangOpts().CPlusPlus 7381 ? LHSType : LHSType.getUnqualifiedType()); 7382 } 7383 7384 // C99 6.5.17 7385 static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, 7386 SourceLocation Loc) { 7387 S.DiagnoseUnusedExprResult(LHS.get()); 7388 7389 LHS = S.CheckPlaceholderExpr(LHS.take()); 7390 RHS = S.CheckPlaceholderExpr(RHS.take()); 7391 if (LHS.isInvalid() || RHS.isInvalid()) 7392 return QualType(); 7393 7394 // C's comma performs lvalue conversion (C99 6.3.2.1) on both its 7395 // operands, but not unary promotions. 7396 // C++'s comma does not do any conversions at all (C++ [expr.comma]p1). 7397 7398 // So we treat the LHS as a ignored value, and in C++ we allow the 7399 // containing site to determine what should be done with the RHS. 7400 LHS = S.IgnoredValueConversions(LHS.take()); 7401 if (LHS.isInvalid()) 7402 return QualType(); 7403 7404 if (!S.getLangOpts().CPlusPlus) { 7405 RHS = S.DefaultFunctionArrayLvalueConversion(RHS.take()); 7406 if (RHS.isInvalid()) 7407 return QualType(); 7408 if (!RHS.get()->getType()->isVoidType()) 7409 S.RequireCompleteType(Loc, RHS.get()->getType(), 7410 diag::err_incomplete_type); 7411 } 7412 7413 return RHS.get()->getType(); 7414 } 7415 7416 /// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine 7417 /// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions. 7418 static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, 7419 ExprValueKind &VK, 7420 SourceLocation OpLoc, 7421 bool IsInc, bool IsPrefix) { 7422 if (Op->isTypeDependent()) 7423 return S.Context.DependentTy; 7424 7425 QualType ResType = Op->getType(); 7426 // Atomic types can be used for increment / decrement where the non-atomic 7427 // versions can, so ignore the _Atomic() specifier for the purpose of 7428 // checking. 7429 if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>()) 7430 ResType = ResAtomicType->getValueType(); 7431 7432 assert(!ResType.isNull() && "no type for increment/decrement expression"); 7433 7434 if (S.getLangOpts().CPlusPlus && ResType->isBooleanType()) { 7435 // Decrement of bool is not allowed. 7436 if (!IsInc) { 7437 S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange(); 7438 return QualType(); 7439 } 7440 // Increment of bool sets it to true, but is deprecated. 7441 S.Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange(); 7442 } else if (ResType->isRealType()) { 7443 // OK! 7444 } else if (ResType->isAnyPointerType()) { 7445 // C99 6.5.2.4p2, 6.5.6p2 7446 if (!checkArithmeticOpPointerOperand(S, OpLoc, Op)) 7447 return QualType(); 7448 7449 // Diagnose bad cases where we step over interface counts. 7450 else if (!checkArithmethicPointerOnNonFragileABI(S, OpLoc, Op)) 7451 return QualType(); 7452 } else if (ResType->isAnyComplexType()) { 7453 // C99 does not support ++/-- on complex types, we allow as an extension. 7454 S.Diag(OpLoc, diag::ext_integer_increment_complex) 7455 << ResType << Op->getSourceRange(); 7456 } else if (ResType->isPlaceholderType()) { 7457 ExprResult PR = S.CheckPlaceholderExpr(Op); 7458 if (PR.isInvalid()) return QualType(); 7459 return CheckIncrementDecrementOperand(S, PR.take(), VK, OpLoc, 7460 IsInc, IsPrefix); 7461 } else if (S.getLangOpts().AltiVec && ResType->isVectorType()) { 7462 // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 ) 7463 } else { 7464 S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement) 7465 << ResType << int(IsInc) << Op->getSourceRange(); 7466 return QualType(); 7467 } 7468 // At this point, we know we have a real, complex or pointer type. 7469 // Now make sure the operand is a modifiable lvalue. 7470 if (CheckForModifiableLvalue(Op, OpLoc, S)) 7471 return QualType(); 7472 // In C++, a prefix increment is the same type as the operand. Otherwise 7473 // (in C or with postfix), the increment is the unqualified type of the 7474 // operand. 7475 if (IsPrefix && S.getLangOpts().CPlusPlus) { 7476 VK = VK_LValue; 7477 return ResType; 7478 } else { 7479 VK = VK_RValue; 7480 return ResType.getUnqualifiedType(); 7481 } 7482 } 7483 7484 7485 /// getPrimaryDecl - Helper function for CheckAddressOfOperand(). 7486 /// This routine allows us to typecheck complex/recursive expressions 7487 /// where the declaration is needed for type checking. We only need to 7488 /// handle cases when the expression references a function designator 7489 /// or is an lvalue. Here are some examples: 7490 /// - &(x) => x 7491 /// - &*****f => f for f a function designator. 7492 /// - &s.xx => s 7493 /// - &s.zz[1].yy -> s, if zz is an array 7494 /// - *(x + 1) -> x, if x is an array 7495 /// - &"123"[2] -> 0 7496 /// - & __real__ x -> x 7497 static ValueDecl *getPrimaryDecl(Expr *E) { 7498 switch (E->getStmtClass()) { 7499 case Stmt::DeclRefExprClass: 7500 return cast<DeclRefExpr>(E)->getDecl(); 7501 case Stmt::MemberExprClass: 7502 // If this is an arrow operator, the address is an offset from 7503 // the base's value, so the object the base refers to is 7504 // irrelevant. 7505 if (cast<MemberExpr>(E)->isArrow()) 7506 return 0; 7507 // Otherwise, the expression refers to a part of the base 7508 return getPrimaryDecl(cast<MemberExpr>(E)->getBase()); 7509 case Stmt::ArraySubscriptExprClass: { 7510 // FIXME: This code shouldn't be necessary! We should catch the implicit 7511 // promotion of register arrays earlier. 7512 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase(); 7513 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) { 7514 if (ICE->getSubExpr()->getType()->isArrayType()) 7515 return getPrimaryDecl(ICE->getSubExpr()); 7516 } 7517 return 0; 7518 } 7519 case Stmt::UnaryOperatorClass: { 7520 UnaryOperator *UO = cast<UnaryOperator>(E); 7521 7522 switch(UO->getOpcode()) { 7523 case UO_Real: 7524 case UO_Imag: 7525 case UO_Extension: 7526 return getPrimaryDecl(UO->getSubExpr()); 7527 default: 7528 return 0; 7529 } 7530 } 7531 case Stmt::ParenExprClass: 7532 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr()); 7533 case Stmt::ImplicitCastExprClass: 7534 // If the result of an implicit cast is an l-value, we care about 7535 // the sub-expression; otherwise, the result here doesn't matter. 7536 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr()); 7537 default: 7538 return 0; 7539 } 7540 } 7541 7542 namespace { 7543 enum { 7544 AO_Bit_Field = 0, 7545 AO_Vector_Element = 1, 7546 AO_Property_Expansion = 2, 7547 AO_Register_Variable = 3, 7548 AO_No_Error = 4 7549 }; 7550 } 7551 /// \brief Diagnose invalid operand for address of operations. 7552 /// 7553 /// \param Type The type of operand which cannot have its address taken. 7554 static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, 7555 Expr *E, unsigned Type) { 7556 S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange(); 7557 } 7558 7559 /// CheckAddressOfOperand - The operand of & must be either a function 7560 /// designator or an lvalue designating an object. If it is an lvalue, the 7561 /// object cannot be declared with storage class register or be a bit field. 7562 /// Note: The usual conversions are *not* applied to the operand of the & 7563 /// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue. 7564 /// In C++, the operand might be an overloaded function name, in which case 7565 /// we allow the '&' but retain the overloaded-function type. 7566 static QualType CheckAddressOfOperand(Sema &S, ExprResult &OrigOp, 7567 SourceLocation OpLoc) { 7568 if (const BuiltinType *PTy = OrigOp.get()->getType()->getAsPlaceholderType()){ 7569 if (PTy->getKind() == BuiltinType::Overload) { 7570 if (!isa<OverloadExpr>(OrigOp.get()->IgnoreParens())) { 7571 S.Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof) 7572 << OrigOp.get()->getSourceRange(); 7573 return QualType(); 7574 } 7575 7576 return S.Context.OverloadTy; 7577 } 7578 7579 if (PTy->getKind() == BuiltinType::UnknownAny) 7580 return S.Context.UnknownAnyTy; 7581 7582 if (PTy->getKind() == BuiltinType::BoundMember) { 7583 S.Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 7584 << OrigOp.get()->getSourceRange(); 7585 return QualType(); 7586 } 7587 7588 OrigOp = S.CheckPlaceholderExpr(OrigOp.take()); 7589 if (OrigOp.isInvalid()) return QualType(); 7590 } 7591 7592 if (OrigOp.get()->isTypeDependent()) 7593 return S.Context.DependentTy; 7594 7595 assert(!OrigOp.get()->getType()->isPlaceholderType()); 7596 7597 // Make sure to ignore parentheses in subsequent checks 7598 Expr *op = OrigOp.get()->IgnoreParens(); 7599 7600 if (S.getLangOpts().C99) { 7601 // Implement C99-only parts of addressof rules. 7602 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) { 7603 if (uOp->getOpcode() == UO_Deref) 7604 // Per C99 6.5.3.2, the address of a deref always returns a valid result 7605 // (assuming the deref expression is valid). 7606 return uOp->getSubExpr()->getType(); 7607 } 7608 // Technically, there should be a check for array subscript 7609 // expressions here, but the result of one is always an lvalue anyway. 7610 } 7611 ValueDecl *dcl = getPrimaryDecl(op); 7612 Expr::LValueClassification lval = op->ClassifyLValue(S.Context); 7613 unsigned AddressOfError = AO_No_Error; 7614 7615 if (lval == Expr::LV_ClassTemporary) { 7616 bool sfinae = S.isSFINAEContext(); 7617 S.Diag(OpLoc, sfinae ? diag::err_typecheck_addrof_class_temporary 7618 : diag::ext_typecheck_addrof_class_temporary) 7619 << op->getType() << op->getSourceRange(); 7620 if (sfinae) 7621 return QualType(); 7622 } else if (isa<ObjCSelectorExpr>(op)) { 7623 return S.Context.getPointerType(op->getType()); 7624 } else if (lval == Expr::LV_MemberFunction) { 7625 // If it's an instance method, make a member pointer. 7626 // The expression must have exactly the form &A::foo. 7627 7628 // If the underlying expression isn't a decl ref, give up. 7629 if (!isa<DeclRefExpr>(op)) { 7630 S.Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 7631 << OrigOp.get()->getSourceRange(); 7632 return QualType(); 7633 } 7634 DeclRefExpr *DRE = cast<DeclRefExpr>(op); 7635 CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl()); 7636 7637 // The id-expression was parenthesized. 7638 if (OrigOp.get() != DRE) { 7639 S.Diag(OpLoc, diag::err_parens_pointer_member_function) 7640 << OrigOp.get()->getSourceRange(); 7641 7642 // The method was named without a qualifier. 7643 } else if (!DRE->getQualifier()) { 7644 S.Diag(OpLoc, diag::err_unqualified_pointer_member_function) 7645 << op->getSourceRange(); 7646 } 7647 7648 return S.Context.getMemberPointerType(op->getType(), 7649 S.Context.getTypeDeclType(MD->getParent()).getTypePtr()); 7650 } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) { 7651 // C99 6.5.3.2p1 7652 // The operand must be either an l-value or a function designator 7653 if (!op->getType()->isFunctionType()) { 7654 // Use a special diagnostic for loads from property references. 7655 if (isa<PseudoObjectExpr>(op)) { 7656 AddressOfError = AO_Property_Expansion; 7657 } else { 7658 // FIXME: emit more specific diag... 7659 S.Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof) 7660 << op->getSourceRange(); 7661 return QualType(); 7662 } 7663 } 7664 } else if (op->getObjectKind() == OK_BitField) { // C99 6.5.3.2p1 7665 // The operand cannot be a bit-field 7666 AddressOfError = AO_Bit_Field; 7667 } else if (op->getObjectKind() == OK_VectorComponent) { 7668 // The operand cannot be an element of a vector 7669 AddressOfError = AO_Vector_Element; 7670 } else if (dcl) { // C99 6.5.3.2p1 7671 // We have an lvalue with a decl. Make sure the decl is not declared 7672 // with the register storage-class specifier. 7673 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) { 7674 // in C++ it is not error to take address of a register 7675 // variable (c++03 7.1.1P3) 7676 if (vd->getStorageClass() == SC_Register && 7677 !S.getLangOpts().CPlusPlus) { 7678 AddressOfError = AO_Register_Variable; 7679 } 7680 } else if (isa<FunctionTemplateDecl>(dcl)) { 7681 return S.Context.OverloadTy; 7682 } else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) { 7683 // Okay: we can take the address of a field. 7684 // Could be a pointer to member, though, if there is an explicit 7685 // scope qualifier for the class. 7686 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) { 7687 DeclContext *Ctx = dcl->getDeclContext(); 7688 if (Ctx && Ctx->isRecord()) { 7689 if (dcl->getType()->isReferenceType()) { 7690 S.Diag(OpLoc, 7691 diag::err_cannot_form_pointer_to_member_of_reference_type) 7692 << dcl->getDeclName() << dcl->getType(); 7693 return QualType(); 7694 } 7695 7696 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion()) 7697 Ctx = Ctx->getParent(); 7698 return S.Context.getMemberPointerType(op->getType(), 7699 S.Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr()); 7700 } 7701 } 7702 } else if (!isa<FunctionDecl>(dcl) && !isa<NonTypeTemplateParmDecl>(dcl)) 7703 llvm_unreachable("Unknown/unexpected decl type"); 7704 } 7705 7706 if (AddressOfError != AO_No_Error) { 7707 diagnoseAddressOfInvalidType(S, OpLoc, op, AddressOfError); 7708 return QualType(); 7709 } 7710 7711 if (lval == Expr::LV_IncompleteVoidType) { 7712 // Taking the address of a void variable is technically illegal, but we 7713 // allow it in cases which are otherwise valid. 7714 // Example: "extern void x; void* y = &x;". 7715 S.Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange(); 7716 } 7717 7718 // If the operand has type "type", the result has type "pointer to type". 7719 if (op->getType()->isObjCObjectType()) 7720 return S.Context.getObjCObjectPointerType(op->getType()); 7721 return S.Context.getPointerType(op->getType()); 7722 } 7723 7724 /// CheckIndirectionOperand - Type check unary indirection (prefix '*'). 7725 static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK, 7726 SourceLocation OpLoc) { 7727 if (Op->isTypeDependent()) 7728 return S.Context.DependentTy; 7729 7730 ExprResult ConvResult = S.UsualUnaryConversions(Op); 7731 if (ConvResult.isInvalid()) 7732 return QualType(); 7733 Op = ConvResult.take(); 7734 QualType OpTy = Op->getType(); 7735 QualType Result; 7736 7737 if (isa<CXXReinterpretCastExpr>(Op)) { 7738 QualType OpOrigType = Op->IgnoreParenCasts()->getType(); 7739 S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true, 7740 Op->getSourceRange()); 7741 } 7742 7743 // Note that per both C89 and C99, indirection is always legal, even if OpTy 7744 // is an incomplete type or void. It would be possible to warn about 7745 // dereferencing a void pointer, but it's completely well-defined, and such a 7746 // warning is unlikely to catch any mistakes. 7747 if (const PointerType *PT = OpTy->getAs<PointerType>()) 7748 Result = PT->getPointeeType(); 7749 else if (const ObjCObjectPointerType *OPT = 7750 OpTy->getAs<ObjCObjectPointerType>()) 7751 Result = OPT->getPointeeType(); 7752 else { 7753 ExprResult PR = S.CheckPlaceholderExpr(Op); 7754 if (PR.isInvalid()) return QualType(); 7755 if (PR.take() != Op) 7756 return CheckIndirectionOperand(S, PR.take(), VK, OpLoc); 7757 } 7758 7759 if (Result.isNull()) { 7760 S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer) 7761 << OpTy << Op->getSourceRange(); 7762 return QualType(); 7763 } 7764 7765 // Dereferences are usually l-values... 7766 VK = VK_LValue; 7767 7768 // ...except that certain expressions are never l-values in C. 7769 if (!S.getLangOpts().CPlusPlus && Result.isCForbiddenLValueType()) 7770 VK = VK_RValue; 7771 7772 return Result; 7773 } 7774 7775 static inline BinaryOperatorKind ConvertTokenKindToBinaryOpcode( 7776 tok::TokenKind Kind) { 7777 BinaryOperatorKind Opc; 7778 switch (Kind) { 7779 default: llvm_unreachable("Unknown binop!"); 7780 case tok::periodstar: Opc = BO_PtrMemD; break; 7781 case tok::arrowstar: Opc = BO_PtrMemI; break; 7782 case tok::star: Opc = BO_Mul; break; 7783 case tok::slash: Opc = BO_Div; break; 7784 case tok::percent: Opc = BO_Rem; break; 7785 case tok::plus: Opc = BO_Add; break; 7786 case tok::minus: Opc = BO_Sub; break; 7787 case tok::lessless: Opc = BO_Shl; break; 7788 case tok::greatergreater: Opc = BO_Shr; break; 7789 case tok::lessequal: Opc = BO_LE; break; 7790 case tok::less: Opc = BO_LT; break; 7791 case tok::greaterequal: Opc = BO_GE; break; 7792 case tok::greater: Opc = BO_GT; break; 7793 case tok::exclaimequal: Opc = BO_NE; break; 7794 case tok::equalequal: Opc = BO_EQ; break; 7795 case tok::amp: Opc = BO_And; break; 7796 case tok::caret: Opc = BO_Xor; break; 7797 case tok::pipe: Opc = BO_Or; break; 7798 case tok::ampamp: Opc = BO_LAnd; break; 7799 case tok::pipepipe: Opc = BO_LOr; break; 7800 case tok::equal: Opc = BO_Assign; break; 7801 case tok::starequal: Opc = BO_MulAssign; break; 7802 case tok::slashequal: Opc = BO_DivAssign; break; 7803 case tok::percentequal: Opc = BO_RemAssign; break; 7804 case tok::plusequal: Opc = BO_AddAssign; break; 7805 case tok::minusequal: Opc = BO_SubAssign; break; 7806 case tok::lesslessequal: Opc = BO_ShlAssign; break; 7807 case tok::greatergreaterequal: Opc = BO_ShrAssign; break; 7808 case tok::ampequal: Opc = BO_AndAssign; break; 7809 case tok::caretequal: Opc = BO_XorAssign; break; 7810 case tok::pipeequal: Opc = BO_OrAssign; break; 7811 case tok::comma: Opc = BO_Comma; break; 7812 } 7813 return Opc; 7814 } 7815 7816 static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode( 7817 tok::TokenKind Kind) { 7818 UnaryOperatorKind Opc; 7819 switch (Kind) { 7820 default: llvm_unreachable("Unknown unary op!"); 7821 case tok::plusplus: Opc = UO_PreInc; break; 7822 case tok::minusminus: Opc = UO_PreDec; break; 7823 case tok::amp: Opc = UO_AddrOf; break; 7824 case tok::star: Opc = UO_Deref; break; 7825 case tok::plus: Opc = UO_Plus; break; 7826 case tok::minus: Opc = UO_Minus; break; 7827 case tok::tilde: Opc = UO_Not; break; 7828 case tok::exclaim: Opc = UO_LNot; break; 7829 case tok::kw___real: Opc = UO_Real; break; 7830 case tok::kw___imag: Opc = UO_Imag; break; 7831 case tok::kw___extension__: Opc = UO_Extension; break; 7832 } 7833 return Opc; 7834 } 7835 7836 /// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself. 7837 /// This warning is only emitted for builtin assignment operations. It is also 7838 /// suppressed in the event of macro expansions. 7839 static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr, 7840 SourceLocation OpLoc) { 7841 if (!S.ActiveTemplateInstantiations.empty()) 7842 return; 7843 if (OpLoc.isInvalid() || OpLoc.isMacroID()) 7844 return; 7845 LHSExpr = LHSExpr->IgnoreParenImpCasts(); 7846 RHSExpr = RHSExpr->IgnoreParenImpCasts(); 7847 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr); 7848 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr); 7849 if (!LHSDeclRef || !RHSDeclRef || 7850 LHSDeclRef->getLocation().isMacroID() || 7851 RHSDeclRef->getLocation().isMacroID()) 7852 return; 7853 const ValueDecl *LHSDecl = 7854 cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl()); 7855 const ValueDecl *RHSDecl = 7856 cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl()); 7857 if (LHSDecl != RHSDecl) 7858 return; 7859 if (LHSDecl->getType().isVolatileQualified()) 7860 return; 7861 if (const ReferenceType *RefTy = LHSDecl->getType()->getAs<ReferenceType>()) 7862 if (RefTy->getPointeeType().isVolatileQualified()) 7863 return; 7864 7865 S.Diag(OpLoc, diag::warn_self_assignment) 7866 << LHSDeclRef->getType() 7867 << LHSExpr->getSourceRange() << RHSExpr->getSourceRange(); 7868 } 7869 7870 /// CreateBuiltinBinOp - Creates a new built-in binary operation with 7871 /// operator @p Opc at location @c TokLoc. This routine only supports 7872 /// built-in operations; ActOnBinOp handles overloaded operators. 7873 ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc, 7874 BinaryOperatorKind Opc, 7875 Expr *LHSExpr, Expr *RHSExpr) { 7876 if (getLangOpts().CPlusPlus0x && isa<InitListExpr>(RHSExpr)) { 7877 // The syntax only allows initializer lists on the RHS of assignment, 7878 // so we don't need to worry about accepting invalid code for 7879 // non-assignment operators. 7880 // C++11 5.17p9: 7881 // The meaning of x = {v} [...] is that of x = T(v) [...]. The meaning 7882 // of x = {} is x = T(). 7883 InitializationKind Kind = 7884 InitializationKind::CreateDirectList(RHSExpr->getLocStart()); 7885 InitializedEntity Entity = 7886 InitializedEntity::InitializeTemporary(LHSExpr->getType()); 7887 InitializationSequence InitSeq(*this, Entity, Kind, &RHSExpr, 1); 7888 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, 7889 MultiExprArg(&RHSExpr, 1)); 7890 if (Init.isInvalid()) 7891 return Init; 7892 RHSExpr = Init.take(); 7893 } 7894 7895 ExprResult LHS = Owned(LHSExpr), RHS = Owned(RHSExpr); 7896 QualType ResultTy; // Result type of the binary operator. 7897 // The following two variables are used for compound assignment operators 7898 QualType CompLHSTy; // Type of LHS after promotions for computation 7899 QualType CompResultTy; // Type of computation result 7900 ExprValueKind VK = VK_RValue; 7901 ExprObjectKind OK = OK_Ordinary; 7902 7903 switch (Opc) { 7904 case BO_Assign: 7905 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, QualType()); 7906 if (getLangOpts().CPlusPlus && 7907 LHS.get()->getObjectKind() != OK_ObjCProperty) { 7908 VK = LHS.get()->getValueKind(); 7909 OK = LHS.get()->getObjectKind(); 7910 } 7911 if (!ResultTy.isNull()) 7912 DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc); 7913 break; 7914 case BO_PtrMemD: 7915 case BO_PtrMemI: 7916 ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc, 7917 Opc == BO_PtrMemI); 7918 break; 7919 case BO_Mul: 7920 case BO_Div: 7921 ResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, false, 7922 Opc == BO_Div); 7923 break; 7924 case BO_Rem: 7925 ResultTy = CheckRemainderOperands(LHS, RHS, OpLoc); 7926 break; 7927 case BO_Add: 7928 ResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc); 7929 break; 7930 case BO_Sub: 7931 ResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc); 7932 break; 7933 case BO_Shl: 7934 case BO_Shr: 7935 ResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc); 7936 break; 7937 case BO_LE: 7938 case BO_LT: 7939 case BO_GE: 7940 case BO_GT: 7941 ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, true); 7942 break; 7943 case BO_EQ: 7944 case BO_NE: 7945 ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, false); 7946 break; 7947 case BO_And: 7948 case BO_Xor: 7949 case BO_Or: 7950 ResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc); 7951 break; 7952 case BO_LAnd: 7953 case BO_LOr: 7954 ResultTy = CheckLogicalOperands(LHS, RHS, OpLoc, Opc); 7955 break; 7956 case BO_MulAssign: 7957 case BO_DivAssign: 7958 CompResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, true, 7959 Opc == BO_DivAssign); 7960 CompLHSTy = CompResultTy; 7961 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 7962 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 7963 break; 7964 case BO_RemAssign: 7965 CompResultTy = CheckRemainderOperands(LHS, RHS, OpLoc, true); 7966 CompLHSTy = CompResultTy; 7967 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 7968 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 7969 break; 7970 case BO_AddAssign: 7971 CompResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc, &CompLHSTy); 7972 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 7973 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 7974 break; 7975 case BO_SubAssign: 7976 CompResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc, &CompLHSTy); 7977 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 7978 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 7979 break; 7980 case BO_ShlAssign: 7981 case BO_ShrAssign: 7982 CompResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc, true); 7983 CompLHSTy = CompResultTy; 7984 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 7985 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 7986 break; 7987 case BO_AndAssign: 7988 case BO_XorAssign: 7989 case BO_OrAssign: 7990 CompResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, true); 7991 CompLHSTy = CompResultTy; 7992 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 7993 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 7994 break; 7995 case BO_Comma: 7996 ResultTy = CheckCommaOperands(*this, LHS, RHS, OpLoc); 7997 if (getLangOpts().CPlusPlus && !RHS.isInvalid()) { 7998 VK = RHS.get()->getValueKind(); 7999 OK = RHS.get()->getObjectKind(); 8000 } 8001 break; 8002 } 8003 if (ResultTy.isNull() || LHS.isInvalid() || RHS.isInvalid()) 8004 return ExprError(); 8005 8006 // Check for array bounds violations for both sides of the BinaryOperator 8007 CheckArrayAccess(LHS.get()); 8008 CheckArrayAccess(RHS.get()); 8009 8010 if (CompResultTy.isNull()) 8011 return Owned(new (Context) BinaryOperator(LHS.take(), RHS.take(), Opc, 8012 ResultTy, VK, OK, OpLoc)); 8013 if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() != 8014 OK_ObjCProperty) { 8015 VK = VK_LValue; 8016 OK = LHS.get()->getObjectKind(); 8017 } 8018 return Owned(new (Context) CompoundAssignOperator(LHS.take(), RHS.take(), Opc, 8019 ResultTy, VK, OK, CompLHSTy, 8020 CompResultTy, OpLoc)); 8021 } 8022 8023 /// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison 8024 /// operators are mixed in a way that suggests that the programmer forgot that 8025 /// comparison operators have higher precedence. The most typical example of 8026 /// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1". 8027 static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, 8028 SourceLocation OpLoc, Expr *LHSExpr, 8029 Expr *RHSExpr) { 8030 typedef BinaryOperator BinOp; 8031 BinOp::Opcode LHSopc = static_cast<BinOp::Opcode>(-1), 8032 RHSopc = static_cast<BinOp::Opcode>(-1); 8033 if (BinOp *BO = dyn_cast<BinOp>(LHSExpr)) 8034 LHSopc = BO->getOpcode(); 8035 if (BinOp *BO = dyn_cast<BinOp>(RHSExpr)) 8036 RHSopc = BO->getOpcode(); 8037 8038 // Subs are not binary operators. 8039 if (LHSopc == -1 && RHSopc == -1) 8040 return; 8041 8042 // Bitwise operations are sometimes used as eager logical ops. 8043 // Don't diagnose this. 8044 if ((BinOp::isComparisonOp(LHSopc) || BinOp::isBitwiseOp(LHSopc)) && 8045 (BinOp::isComparisonOp(RHSopc) || BinOp::isBitwiseOp(RHSopc))) 8046 return; 8047 8048 bool isLeftComp = BinOp::isComparisonOp(LHSopc); 8049 bool isRightComp = BinOp::isComparisonOp(RHSopc); 8050 if (!isLeftComp && !isRightComp) return; 8051 8052 SourceRange DiagRange = isLeftComp ? SourceRange(LHSExpr->getLocStart(), 8053 OpLoc) 8054 : SourceRange(OpLoc, RHSExpr->getLocEnd()); 8055 std::string OpStr = isLeftComp ? BinOp::getOpcodeStr(LHSopc) 8056 : BinOp::getOpcodeStr(RHSopc); 8057 SourceRange ParensRange = isLeftComp ? 8058 SourceRange(cast<BinOp>(LHSExpr)->getRHS()->getLocStart(), 8059 RHSExpr->getLocEnd()) 8060 : SourceRange(LHSExpr->getLocStart(), 8061 cast<BinOp>(RHSExpr)->getLHS()->getLocStart()); 8062 8063 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel) 8064 << DiagRange << BinOp::getOpcodeStr(Opc) << OpStr; 8065 SuggestParentheses(Self, OpLoc, 8066 Self.PDiag(diag::note_precedence_bitwise_silence) << OpStr, 8067 RHSExpr->getSourceRange()); 8068 SuggestParentheses(Self, OpLoc, 8069 Self.PDiag(diag::note_precedence_bitwise_first) << BinOp::getOpcodeStr(Opc), 8070 ParensRange); 8071 } 8072 8073 /// \brief It accepts a '&' expr that is inside a '|' one. 8074 /// Emit a diagnostic together with a fixit hint that wraps the '&' expression 8075 /// in parentheses. 8076 static void 8077 EmitDiagnosticForBitwiseAndInBitwiseOr(Sema &Self, SourceLocation OpLoc, 8078 BinaryOperator *Bop) { 8079 assert(Bop->getOpcode() == BO_And); 8080 Self.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_and_in_bitwise_or) 8081 << Bop->getSourceRange() << OpLoc; 8082 SuggestParentheses(Self, Bop->getOperatorLoc(), 8083 Self.PDiag(diag::note_bitwise_and_in_bitwise_or_silence), 8084 Bop->getSourceRange()); 8085 } 8086 8087 /// \brief It accepts a '&&' expr that is inside a '||' one. 8088 /// Emit a diagnostic together with a fixit hint that wraps the '&&' expression 8089 /// in parentheses. 8090 static void 8091 EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, 8092 BinaryOperator *Bop) { 8093 assert(Bop->getOpcode() == BO_LAnd); 8094 Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or) 8095 << Bop->getSourceRange() << OpLoc; 8096 SuggestParentheses(Self, Bop->getOperatorLoc(), 8097 Self.PDiag(diag::note_logical_and_in_logical_or_silence), 8098 Bop->getSourceRange()); 8099 } 8100 8101 /// \brief Returns true if the given expression can be evaluated as a constant 8102 /// 'true'. 8103 static bool EvaluatesAsTrue(Sema &S, Expr *E) { 8104 bool Res; 8105 return E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res; 8106 } 8107 8108 /// \brief Returns true if the given expression can be evaluated as a constant 8109 /// 'false'. 8110 static bool EvaluatesAsFalse(Sema &S, Expr *E) { 8111 bool Res; 8112 return E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res; 8113 } 8114 8115 /// \brief Look for '&&' in the left hand of a '||' expr. 8116 static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, 8117 Expr *LHSExpr, Expr *RHSExpr) { 8118 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(LHSExpr)) { 8119 if (Bop->getOpcode() == BO_LAnd) { 8120 // If it's "a && b || 0" don't warn since the precedence doesn't matter. 8121 if (EvaluatesAsFalse(S, RHSExpr)) 8122 return; 8123 // If it's "1 && a || b" don't warn since the precedence doesn't matter. 8124 if (!EvaluatesAsTrue(S, Bop->getLHS())) 8125 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 8126 } else if (Bop->getOpcode() == BO_LOr) { 8127 if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) { 8128 // If it's "a || b && 1 || c" we didn't warn earlier for 8129 // "a || b && 1", but warn now. 8130 if (RBop->getOpcode() == BO_LAnd && EvaluatesAsTrue(S, RBop->getRHS())) 8131 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop); 8132 } 8133 } 8134 } 8135 } 8136 8137 /// \brief Look for '&&' in the right hand of a '||' expr. 8138 static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, 8139 Expr *LHSExpr, Expr *RHSExpr) { 8140 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(RHSExpr)) { 8141 if (Bop->getOpcode() == BO_LAnd) { 8142 // If it's "0 || a && b" don't warn since the precedence doesn't matter. 8143 if (EvaluatesAsFalse(S, LHSExpr)) 8144 return; 8145 // If it's "a || b && 1" don't warn since the precedence doesn't matter. 8146 if (!EvaluatesAsTrue(S, Bop->getRHS())) 8147 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 8148 } 8149 } 8150 } 8151 8152 /// \brief Look for '&' in the left or right hand of a '|' expr. 8153 static void DiagnoseBitwiseAndInBitwiseOr(Sema &S, SourceLocation OpLoc, 8154 Expr *OrArg) { 8155 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrArg)) { 8156 if (Bop->getOpcode() == BO_And) 8157 return EmitDiagnosticForBitwiseAndInBitwiseOr(S, OpLoc, Bop); 8158 } 8159 } 8160 8161 /// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky 8162 /// precedence. 8163 static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc, 8164 SourceLocation OpLoc, Expr *LHSExpr, 8165 Expr *RHSExpr){ 8166 // Diagnose "arg1 'bitwise' arg2 'eq' arg3". 8167 if (BinaryOperator::isBitwiseOp(Opc)) 8168 DiagnoseBitwisePrecedence(Self, Opc, OpLoc, LHSExpr, RHSExpr); 8169 8170 // Diagnose "arg1 & arg2 | arg3" 8171 if (Opc == BO_Or && !OpLoc.isMacroID()/* Don't warn in macros. */) { 8172 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, LHSExpr); 8173 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, RHSExpr); 8174 } 8175 8176 // Warn about arg1 || arg2 && arg3, as GCC 4.3+ does. 8177 // We don't warn for 'assert(a || b && "bad")' since this is safe. 8178 if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) { 8179 DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, LHSExpr, RHSExpr); 8180 DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, LHSExpr, RHSExpr); 8181 } 8182 } 8183 8184 // Binary Operators. 'Tok' is the token for the operator. 8185 ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc, 8186 tok::TokenKind Kind, 8187 Expr *LHSExpr, Expr *RHSExpr) { 8188 BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind); 8189 assert((LHSExpr != 0) && "ActOnBinOp(): missing left expression"); 8190 assert((RHSExpr != 0) && "ActOnBinOp(): missing right expression"); 8191 8192 // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0" 8193 DiagnoseBinOpPrecedence(*this, Opc, TokLoc, LHSExpr, RHSExpr); 8194 8195 return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr); 8196 } 8197 8198 /// Build an overloaded binary operator expression in the given scope. 8199 static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc, 8200 BinaryOperatorKind Opc, 8201 Expr *LHS, Expr *RHS) { 8202 // Find all of the overloaded operators visible from this 8203 // point. We perform both an operator-name lookup from the local 8204 // scope and an argument-dependent lookup based on the types of 8205 // the arguments. 8206 UnresolvedSet<16> Functions; 8207 OverloadedOperatorKind OverOp 8208 = BinaryOperator::getOverloadedOperator(Opc); 8209 if (Sc && OverOp != OO_None) 8210 S.LookupOverloadedOperatorName(OverOp, Sc, LHS->getType(), 8211 RHS->getType(), Functions); 8212 8213 // Build the (potentially-overloaded, potentially-dependent) 8214 // binary operation. 8215 return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS); 8216 } 8217 8218 ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc, 8219 BinaryOperatorKind Opc, 8220 Expr *LHSExpr, Expr *RHSExpr) { 8221 // We want to end up calling one of checkPseudoObjectAssignment 8222 // (if the LHS is a pseudo-object), BuildOverloadedBinOp (if 8223 // both expressions are overloadable or either is type-dependent), 8224 // or CreateBuiltinBinOp (in any other case). We also want to get 8225 // any placeholder types out of the way. 8226 8227 // Handle pseudo-objects in the LHS. 8228 if (const BuiltinType *pty = LHSExpr->getType()->getAsPlaceholderType()) { 8229 // Assignments with a pseudo-object l-value need special analysis. 8230 if (pty->getKind() == BuiltinType::PseudoObject && 8231 BinaryOperator::isAssignmentOp(Opc)) 8232 return checkPseudoObjectAssignment(S, OpLoc, Opc, LHSExpr, RHSExpr); 8233 8234 // Don't resolve overloads if the other type is overloadable. 8235 if (pty->getKind() == BuiltinType::Overload) { 8236 // We can't actually test that if we still have a placeholder, 8237 // though. Fortunately, none of the exceptions we see in that 8238 // code below are valid when the LHS is an overload set. Note 8239 // that an overload set can be dependently-typed, but it never 8240 // instantiates to having an overloadable type. 8241 ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr); 8242 if (resolvedRHS.isInvalid()) return ExprError(); 8243 RHSExpr = resolvedRHS.take(); 8244 8245 if (RHSExpr->isTypeDependent() || 8246 RHSExpr->getType()->isOverloadableType()) 8247 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8248 } 8249 8250 ExprResult LHS = CheckPlaceholderExpr(LHSExpr); 8251 if (LHS.isInvalid()) return ExprError(); 8252 LHSExpr = LHS.take(); 8253 } 8254 8255 // Handle pseudo-objects in the RHS. 8256 if (const BuiltinType *pty = RHSExpr->getType()->getAsPlaceholderType()) { 8257 // An overload in the RHS can potentially be resolved by the type 8258 // being assigned to. 8259 if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) { 8260 if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent()) 8261 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8262 8263 if (LHSExpr->getType()->isOverloadableType()) 8264 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8265 8266 return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr); 8267 } 8268 8269 // Don't resolve overloads if the other type is overloadable. 8270 if (pty->getKind() == BuiltinType::Overload && 8271 LHSExpr->getType()->isOverloadableType()) 8272 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8273 8274 ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr); 8275 if (!resolvedRHS.isUsable()) return ExprError(); 8276 RHSExpr = resolvedRHS.take(); 8277 } 8278 8279 if (getLangOpts().CPlusPlus) { 8280 // If either expression is type-dependent, always build an 8281 // overloaded op. 8282 if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent()) 8283 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8284 8285 // Otherwise, build an overloaded op if either expression has an 8286 // overloadable type. 8287 if (LHSExpr->getType()->isOverloadableType() || 8288 RHSExpr->getType()->isOverloadableType()) 8289 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8290 } 8291 8292 // Build a built-in binary operation. 8293 return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr); 8294 } 8295 8296 ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc, 8297 UnaryOperatorKind Opc, 8298 Expr *InputExpr) { 8299 ExprResult Input = Owned(InputExpr); 8300 ExprValueKind VK = VK_RValue; 8301 ExprObjectKind OK = OK_Ordinary; 8302 QualType resultType; 8303 switch (Opc) { 8304 case UO_PreInc: 8305 case UO_PreDec: 8306 case UO_PostInc: 8307 case UO_PostDec: 8308 resultType = CheckIncrementDecrementOperand(*this, Input.get(), VK, OpLoc, 8309 Opc == UO_PreInc || 8310 Opc == UO_PostInc, 8311 Opc == UO_PreInc || 8312 Opc == UO_PreDec); 8313 break; 8314 case UO_AddrOf: 8315 resultType = CheckAddressOfOperand(*this, Input, OpLoc); 8316 break; 8317 case UO_Deref: { 8318 Input = DefaultFunctionArrayLvalueConversion(Input.take()); 8319 resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc); 8320 break; 8321 } 8322 case UO_Plus: 8323 case UO_Minus: 8324 Input = UsualUnaryConversions(Input.take()); 8325 if (Input.isInvalid()) return ExprError(); 8326 resultType = Input.get()->getType(); 8327 if (resultType->isDependentType()) 8328 break; 8329 if (resultType->isArithmeticType() || // C99 6.5.3.3p1 8330 resultType->isVectorType()) 8331 break; 8332 else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6-7 8333 resultType->isEnumeralType()) 8334 break; 8335 else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6 8336 Opc == UO_Plus && 8337 resultType->isPointerType()) 8338 break; 8339 8340 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 8341 << resultType << Input.get()->getSourceRange()); 8342 8343 case UO_Not: // bitwise complement 8344 Input = UsualUnaryConversions(Input.take()); 8345 if (Input.isInvalid()) return ExprError(); 8346 resultType = Input.get()->getType(); 8347 if (resultType->isDependentType()) 8348 break; 8349 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension. 8350 if (resultType->isComplexType() || resultType->isComplexIntegerType()) 8351 // C99 does not support '~' for complex conjugation. 8352 Diag(OpLoc, diag::ext_integer_complement_complex) 8353 << resultType << Input.get()->getSourceRange(); 8354 else if (resultType->hasIntegerRepresentation()) 8355 break; 8356 else { 8357 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 8358 << resultType << Input.get()->getSourceRange()); 8359 } 8360 break; 8361 8362 case UO_LNot: // logical negation 8363 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5). 8364 Input = DefaultFunctionArrayLvalueConversion(Input.take()); 8365 if (Input.isInvalid()) return ExprError(); 8366 resultType = Input.get()->getType(); 8367 8368 // Though we still have to promote half FP to float... 8369 if (resultType->isHalfType()) { 8370 Input = ImpCastExprToType(Input.take(), Context.FloatTy, CK_FloatingCast).take(); 8371 resultType = Context.FloatTy; 8372 } 8373 8374 if (resultType->isDependentType()) 8375 break; 8376 if (resultType->isScalarType()) { 8377 // C99 6.5.3.3p1: ok, fallthrough; 8378 if (Context.getLangOpts().CPlusPlus) { 8379 // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9: 8380 // operand contextually converted to bool. 8381 Input = ImpCastExprToType(Input.take(), Context.BoolTy, 8382 ScalarTypeToBooleanCastKind(resultType)); 8383 } 8384 } else if (resultType->isExtVectorType()) { 8385 // Vector logical not returns the signed variant of the operand type. 8386 resultType = GetSignedVectorType(resultType); 8387 break; 8388 } else { 8389 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 8390 << resultType << Input.get()->getSourceRange()); 8391 } 8392 8393 // LNot always has type int. C99 6.5.3.3p5. 8394 // In C++, it's bool. C++ 5.3.1p8 8395 resultType = Context.getLogicalOperationType(); 8396 break; 8397 case UO_Real: 8398 case UO_Imag: 8399 resultType = CheckRealImagOperand(*this, Input, OpLoc, Opc == UO_Real); 8400 // _Real maps ordinary l-values into ordinary l-values. _Imag maps ordinary 8401 // complex l-values to ordinary l-values and all other values to r-values. 8402 if (Input.isInvalid()) return ExprError(); 8403 if (Opc == UO_Real || Input.get()->getType()->isAnyComplexType()) { 8404 if (Input.get()->getValueKind() != VK_RValue && 8405 Input.get()->getObjectKind() == OK_Ordinary) 8406 VK = Input.get()->getValueKind(); 8407 } else if (!getLangOpts().CPlusPlus) { 8408 // In C, a volatile scalar is read by __imag. In C++, it is not. 8409 Input = DefaultLvalueConversion(Input.take()); 8410 } 8411 break; 8412 case UO_Extension: 8413 resultType = Input.get()->getType(); 8414 VK = Input.get()->getValueKind(); 8415 OK = Input.get()->getObjectKind(); 8416 break; 8417 } 8418 if (resultType.isNull() || Input.isInvalid()) 8419 return ExprError(); 8420 8421 // Check for array bounds violations in the operand of the UnaryOperator, 8422 // except for the '*' and '&' operators that have to be handled specially 8423 // by CheckArrayAccess (as there are special cases like &array[arraysize] 8424 // that are explicitly defined as valid by the standard). 8425 if (Opc != UO_AddrOf && Opc != UO_Deref) 8426 CheckArrayAccess(Input.get()); 8427 8428 return Owned(new (Context) UnaryOperator(Input.take(), Opc, resultType, 8429 VK, OK, OpLoc)); 8430 } 8431 8432 /// \brief Determine whether the given expression is a qualified member 8433 /// access expression, of a form that could be turned into a pointer to member 8434 /// with the address-of operator. 8435 static bool isQualifiedMemberAccess(Expr *E) { 8436 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 8437 if (!DRE->getQualifier()) 8438 return false; 8439 8440 ValueDecl *VD = DRE->getDecl(); 8441 if (!VD->isCXXClassMember()) 8442 return false; 8443 8444 if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD)) 8445 return true; 8446 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(VD)) 8447 return Method->isInstance(); 8448 8449 return false; 8450 } 8451 8452 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) { 8453 if (!ULE->getQualifier()) 8454 return false; 8455 8456 for (UnresolvedLookupExpr::decls_iterator D = ULE->decls_begin(), 8457 DEnd = ULE->decls_end(); 8458 D != DEnd; ++D) { 8459 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(*D)) { 8460 if (Method->isInstance()) 8461 return true; 8462 } else { 8463 // Overload set does not contain methods. 8464 break; 8465 } 8466 } 8467 8468 return false; 8469 } 8470 8471 return false; 8472 } 8473 8474 ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc, 8475 UnaryOperatorKind Opc, Expr *Input) { 8476 // First things first: handle placeholders so that the 8477 // overloaded-operator check considers the right type. 8478 if (const BuiltinType *pty = Input->getType()->getAsPlaceholderType()) { 8479 // Increment and decrement of pseudo-object references. 8480 if (pty->getKind() == BuiltinType::PseudoObject && 8481 UnaryOperator::isIncrementDecrementOp(Opc)) 8482 return checkPseudoObjectIncDec(S, OpLoc, Opc, Input); 8483 8484 // extension is always a builtin operator. 8485 if (Opc == UO_Extension) 8486 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 8487 8488 // & gets special logic for several kinds of placeholder. 8489 // The builtin code knows what to do. 8490 if (Opc == UO_AddrOf && 8491 (pty->getKind() == BuiltinType::Overload || 8492 pty->getKind() == BuiltinType::UnknownAny || 8493 pty->getKind() == BuiltinType::BoundMember)) 8494 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 8495 8496 // Anything else needs to be handled now. 8497 ExprResult Result = CheckPlaceholderExpr(Input); 8498 if (Result.isInvalid()) return ExprError(); 8499 Input = Result.take(); 8500 } 8501 8502 if (getLangOpts().CPlusPlus && Input->getType()->isOverloadableType() && 8503 UnaryOperator::getOverloadedOperator(Opc) != OO_None && 8504 !(Opc == UO_AddrOf && isQualifiedMemberAccess(Input))) { 8505 // Find all of the overloaded operators visible from this 8506 // point. We perform both an operator-name lookup from the local 8507 // scope and an argument-dependent lookup based on the types of 8508 // the arguments. 8509 UnresolvedSet<16> Functions; 8510 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc); 8511 if (S && OverOp != OO_None) 8512 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(), 8513 Functions); 8514 8515 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input); 8516 } 8517 8518 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 8519 } 8520 8521 // Unary Operators. 'Tok' is the token for the operator. 8522 ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc, 8523 tok::TokenKind Op, Expr *Input) { 8524 return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input); 8525 } 8526 8527 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo". 8528 ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, 8529 LabelDecl *TheDecl) { 8530 TheDecl->setUsed(); 8531 // Create the AST node. The address of a label always has type 'void*'. 8532 return Owned(new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl, 8533 Context.getPointerType(Context.VoidTy))); 8534 } 8535 8536 /// Given the last statement in a statement-expression, check whether 8537 /// the result is a producing expression (like a call to an 8538 /// ns_returns_retained function) and, if so, rebuild it to hoist the 8539 /// release out of the full-expression. Otherwise, return null. 8540 /// Cannot fail. 8541 static Expr *maybeRebuildARCConsumingStmt(Stmt *Statement) { 8542 // Should always be wrapped with one of these. 8543 ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(Statement); 8544 if (!cleanups) return 0; 8545 8546 ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(cleanups->getSubExpr()); 8547 if (!cast || cast->getCastKind() != CK_ARCConsumeObject) 8548 return 0; 8549 8550 // Splice out the cast. This shouldn't modify any interesting 8551 // features of the statement. 8552 Expr *producer = cast->getSubExpr(); 8553 assert(producer->getType() == cast->getType()); 8554 assert(producer->getValueKind() == cast->getValueKind()); 8555 cleanups->setSubExpr(producer); 8556 return cleanups; 8557 } 8558 8559 void Sema::ActOnStartStmtExpr() { 8560 PushExpressionEvaluationContext(ExprEvalContexts.back().Context); 8561 } 8562 8563 void Sema::ActOnStmtExprError() { 8564 // Note that function is also called by TreeTransform when leaving a 8565 // StmtExpr scope without rebuilding anything. 8566 8567 DiscardCleanupsInEvaluationContext(); 8568 PopExpressionEvaluationContext(); 8569 } 8570 8571 ExprResult 8572 Sema::ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, 8573 SourceLocation RPLoc) { // "({..})" 8574 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!"); 8575 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt); 8576 8577 if (hasAnyUnrecoverableErrorsInThisFunction()) 8578 DiscardCleanupsInEvaluationContext(); 8579 assert(!ExprNeedsCleanups && "cleanups within StmtExpr not correctly bound!"); 8580 PopExpressionEvaluationContext(); 8581 8582 bool isFileScope 8583 = (getCurFunctionOrMethodDecl() == 0) && (getCurBlock() == 0); 8584 if (isFileScope) 8585 return ExprError(Diag(LPLoc, diag::err_stmtexpr_file_scope)); 8586 8587 // FIXME: there are a variety of strange constraints to enforce here, for 8588 // example, it is not possible to goto into a stmt expression apparently. 8589 // More semantic analysis is needed. 8590 8591 // If there are sub stmts in the compound stmt, take the type of the last one 8592 // as the type of the stmtexpr. 8593 QualType Ty = Context.VoidTy; 8594 bool StmtExprMayBindToTemp = false; 8595 if (!Compound->body_empty()) { 8596 Stmt *LastStmt = Compound->body_back(); 8597 LabelStmt *LastLabelStmt = 0; 8598 // If LastStmt is a label, skip down through into the body. 8599 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt)) { 8600 LastLabelStmt = Label; 8601 LastStmt = Label->getSubStmt(); 8602 } 8603 8604 if (Expr *LastE = dyn_cast<Expr>(LastStmt)) { 8605 // Do function/array conversion on the last expression, but not 8606 // lvalue-to-rvalue. However, initialize an unqualified type. 8607 ExprResult LastExpr = DefaultFunctionArrayConversion(LastE); 8608 if (LastExpr.isInvalid()) 8609 return ExprError(); 8610 Ty = LastExpr.get()->getType().getUnqualifiedType(); 8611 8612 if (!Ty->isDependentType() && !LastExpr.get()->isTypeDependent()) { 8613 // In ARC, if the final expression ends in a consume, splice 8614 // the consume out and bind it later. In the alternate case 8615 // (when dealing with a retainable type), the result 8616 // initialization will create a produce. In both cases the 8617 // result will be +1, and we'll need to balance that out with 8618 // a bind. 8619 if (Expr *rebuiltLastStmt 8620 = maybeRebuildARCConsumingStmt(LastExpr.get())) { 8621 LastExpr = rebuiltLastStmt; 8622 } else { 8623 LastExpr = PerformCopyInitialization( 8624 InitializedEntity::InitializeResult(LPLoc, 8625 Ty, 8626 false), 8627 SourceLocation(), 8628 LastExpr); 8629 } 8630 8631 if (LastExpr.isInvalid()) 8632 return ExprError(); 8633 if (LastExpr.get() != 0) { 8634 if (!LastLabelStmt) 8635 Compound->setLastStmt(LastExpr.take()); 8636 else 8637 LastLabelStmt->setSubStmt(LastExpr.take()); 8638 StmtExprMayBindToTemp = true; 8639 } 8640 } 8641 } 8642 } 8643 8644 // FIXME: Check that expression type is complete/non-abstract; statement 8645 // expressions are not lvalues. 8646 Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc); 8647 if (StmtExprMayBindToTemp) 8648 return MaybeBindToTemporary(ResStmtExpr); 8649 return Owned(ResStmtExpr); 8650 } 8651 8652 ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, 8653 TypeSourceInfo *TInfo, 8654 OffsetOfComponent *CompPtr, 8655 unsigned NumComponents, 8656 SourceLocation RParenLoc) { 8657 QualType ArgTy = TInfo->getType(); 8658 bool Dependent = ArgTy->isDependentType(); 8659 SourceRange TypeRange = TInfo->getTypeLoc().getLocalSourceRange(); 8660 8661 // We must have at least one component that refers to the type, and the first 8662 // one is known to be a field designator. Verify that the ArgTy represents 8663 // a struct/union/class. 8664 if (!Dependent && !ArgTy->isRecordType()) 8665 return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type) 8666 << ArgTy << TypeRange); 8667 8668 // Type must be complete per C99 7.17p3 because a declaring a variable 8669 // with an incomplete type would be ill-formed. 8670 if (!Dependent 8671 && RequireCompleteType(BuiltinLoc, ArgTy, 8672 PDiag(diag::err_offsetof_incomplete_type) 8673 << TypeRange)) 8674 return ExprError(); 8675 8676 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a 8677 // GCC extension, diagnose them. 8678 // FIXME: This diagnostic isn't actually visible because the location is in 8679 // a system header! 8680 if (NumComponents != 1) 8681 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator) 8682 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd); 8683 8684 bool DidWarnAboutNonPOD = false; 8685 QualType CurrentType = ArgTy; 8686 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode; 8687 SmallVector<OffsetOfNode, 4> Comps; 8688 SmallVector<Expr*, 4> Exprs; 8689 for (unsigned i = 0; i != NumComponents; ++i) { 8690 const OffsetOfComponent &OC = CompPtr[i]; 8691 if (OC.isBrackets) { 8692 // Offset of an array sub-field. TODO: Should we allow vector elements? 8693 if (!CurrentType->isDependentType()) { 8694 const ArrayType *AT = Context.getAsArrayType(CurrentType); 8695 if(!AT) 8696 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type) 8697 << CurrentType); 8698 CurrentType = AT->getElementType(); 8699 } else 8700 CurrentType = Context.DependentTy; 8701 8702 ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr*>(OC.U.E)); 8703 if (IdxRval.isInvalid()) 8704 return ExprError(); 8705 Expr *Idx = IdxRval.take(); 8706 8707 // The expression must be an integral expression. 8708 // FIXME: An integral constant expression? 8709 if (!Idx->isTypeDependent() && !Idx->isValueDependent() && 8710 !Idx->getType()->isIntegerType()) 8711 return ExprError(Diag(Idx->getLocStart(), 8712 diag::err_typecheck_subscript_not_integer) 8713 << Idx->getSourceRange()); 8714 8715 // Record this array index. 8716 Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd)); 8717 Exprs.push_back(Idx); 8718 continue; 8719 } 8720 8721 // Offset of a field. 8722 if (CurrentType->isDependentType()) { 8723 // We have the offset of a field, but we can't look into the dependent 8724 // type. Just record the identifier of the field. 8725 Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd)); 8726 CurrentType = Context.DependentTy; 8727 continue; 8728 } 8729 8730 // We need to have a complete type to look into. 8731 if (RequireCompleteType(OC.LocStart, CurrentType, 8732 diag::err_offsetof_incomplete_type)) 8733 return ExprError(); 8734 8735 // Look for the designated field. 8736 const RecordType *RC = CurrentType->getAs<RecordType>(); 8737 if (!RC) 8738 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type) 8739 << CurrentType); 8740 RecordDecl *RD = RC->getDecl(); 8741 8742 // C++ [lib.support.types]p5: 8743 // The macro offsetof accepts a restricted set of type arguments in this 8744 // International Standard. type shall be a POD structure or a POD union 8745 // (clause 9). 8746 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) { 8747 if (!CRD->isPOD() && !DidWarnAboutNonPOD && 8748 DiagRuntimeBehavior(BuiltinLoc, 0, 8749 PDiag(diag::warn_offsetof_non_pod_type) 8750 << SourceRange(CompPtr[0].LocStart, OC.LocEnd) 8751 << CurrentType)) 8752 DidWarnAboutNonPOD = true; 8753 } 8754 8755 // Look for the field. 8756 LookupResult R(*this, OC.U.IdentInfo, OC.LocStart, LookupMemberName); 8757 LookupQualifiedName(R, RD); 8758 FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>(); 8759 IndirectFieldDecl *IndirectMemberDecl = 0; 8760 if (!MemberDecl) { 8761 if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>())) 8762 MemberDecl = IndirectMemberDecl->getAnonField(); 8763 } 8764 8765 if (!MemberDecl) 8766 return ExprError(Diag(BuiltinLoc, diag::err_no_member) 8767 << OC.U.IdentInfo << RD << SourceRange(OC.LocStart, 8768 OC.LocEnd)); 8769 8770 // C99 7.17p3: 8771 // (If the specified member is a bit-field, the behavior is undefined.) 8772 // 8773 // We diagnose this as an error. 8774 if (MemberDecl->isBitField()) { 8775 Diag(OC.LocEnd, diag::err_offsetof_bitfield) 8776 << MemberDecl->getDeclName() 8777 << SourceRange(BuiltinLoc, RParenLoc); 8778 Diag(MemberDecl->getLocation(), diag::note_bitfield_decl); 8779 return ExprError(); 8780 } 8781 8782 RecordDecl *Parent = MemberDecl->getParent(); 8783 if (IndirectMemberDecl) 8784 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext()); 8785 8786 // If the member was found in a base class, introduce OffsetOfNodes for 8787 // the base class indirections. 8788 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 8789 /*DetectVirtual=*/false); 8790 if (IsDerivedFrom(CurrentType, Context.getTypeDeclType(Parent), Paths)) { 8791 CXXBasePath &Path = Paths.front(); 8792 for (CXXBasePath::iterator B = Path.begin(), BEnd = Path.end(); 8793 B != BEnd; ++B) 8794 Comps.push_back(OffsetOfNode(B->Base)); 8795 } 8796 8797 if (IndirectMemberDecl) { 8798 for (IndirectFieldDecl::chain_iterator FI = 8799 IndirectMemberDecl->chain_begin(), 8800 FEnd = IndirectMemberDecl->chain_end(); FI != FEnd; FI++) { 8801 assert(isa<FieldDecl>(*FI)); 8802 Comps.push_back(OffsetOfNode(OC.LocStart, 8803 cast<FieldDecl>(*FI), OC.LocEnd)); 8804 } 8805 } else 8806 Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd)); 8807 8808 CurrentType = MemberDecl->getType().getNonReferenceType(); 8809 } 8810 8811 return Owned(OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc, 8812 TInfo, Comps.data(), Comps.size(), 8813 Exprs.data(), Exprs.size(), RParenLoc)); 8814 } 8815 8816 ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S, 8817 SourceLocation BuiltinLoc, 8818 SourceLocation TypeLoc, 8819 ParsedType ParsedArgTy, 8820 OffsetOfComponent *CompPtr, 8821 unsigned NumComponents, 8822 SourceLocation RParenLoc) { 8823 8824 TypeSourceInfo *ArgTInfo; 8825 QualType ArgTy = GetTypeFromParser(ParsedArgTy, &ArgTInfo); 8826 if (ArgTy.isNull()) 8827 return ExprError(); 8828 8829 if (!ArgTInfo) 8830 ArgTInfo = Context.getTrivialTypeSourceInfo(ArgTy, TypeLoc); 8831 8832 return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, CompPtr, NumComponents, 8833 RParenLoc); 8834 } 8835 8836 8837 ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, 8838 Expr *CondExpr, 8839 Expr *LHSExpr, Expr *RHSExpr, 8840 SourceLocation RPLoc) { 8841 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)"); 8842 8843 ExprValueKind VK = VK_RValue; 8844 ExprObjectKind OK = OK_Ordinary; 8845 QualType resType; 8846 bool ValueDependent = false; 8847 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) { 8848 resType = Context.DependentTy; 8849 ValueDependent = true; 8850 } else { 8851 // The conditional expression is required to be a constant expression. 8852 llvm::APSInt condEval(32); 8853 ExprResult CondICE = VerifyIntegerConstantExpression(CondExpr, &condEval, 8854 PDiag(diag::err_typecheck_choose_expr_requires_constant), false); 8855 if (CondICE.isInvalid()) 8856 return ExprError(); 8857 CondExpr = CondICE.take(); 8858 8859 // If the condition is > zero, then the AST type is the same as the LSHExpr. 8860 Expr *ActiveExpr = condEval.getZExtValue() ? LHSExpr : RHSExpr; 8861 8862 resType = ActiveExpr->getType(); 8863 ValueDependent = ActiveExpr->isValueDependent(); 8864 VK = ActiveExpr->getValueKind(); 8865 OK = ActiveExpr->getObjectKind(); 8866 } 8867 8868 return Owned(new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, 8869 resType, VK, OK, RPLoc, 8870 resType->isDependentType(), 8871 ValueDependent)); 8872 } 8873 8874 //===----------------------------------------------------------------------===// 8875 // Clang Extensions. 8876 //===----------------------------------------------------------------------===// 8877 8878 /// ActOnBlockStart - This callback is invoked when a block literal is started. 8879 void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope) { 8880 BlockDecl *Block = BlockDecl::Create(Context, CurContext, CaretLoc); 8881 PushBlockScope(CurScope, Block); 8882 CurContext->addDecl(Block); 8883 if (CurScope) 8884 PushDeclContext(CurScope, Block); 8885 else 8886 CurContext = Block; 8887 8888 getCurBlock()->HasImplicitReturnType = true; 8889 8890 // Enter a new evaluation context to insulate the block from any 8891 // cleanups from the enclosing full-expression. 8892 PushExpressionEvaluationContext(PotentiallyEvaluated); 8893 } 8894 8895 void Sema::ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope) { 8896 assert(ParamInfo.getIdentifier()==0 && "block-id should have no identifier!"); 8897 assert(ParamInfo.getContext() == Declarator::BlockLiteralContext); 8898 BlockScopeInfo *CurBlock = getCurBlock(); 8899 8900 TypeSourceInfo *Sig = GetTypeForDeclarator(ParamInfo, CurScope); 8901 QualType T = Sig->getType(); 8902 8903 // GetTypeForDeclarator always produces a function type for a block 8904 // literal signature. Furthermore, it is always a FunctionProtoType 8905 // unless the function was written with a typedef. 8906 assert(T->isFunctionType() && 8907 "GetTypeForDeclarator made a non-function block signature"); 8908 8909 // Look for an explicit signature in that function type. 8910 FunctionProtoTypeLoc ExplicitSignature; 8911 8912 TypeLoc tmp = Sig->getTypeLoc().IgnoreParens(); 8913 if (isa<FunctionProtoTypeLoc>(tmp)) { 8914 ExplicitSignature = cast<FunctionProtoTypeLoc>(tmp); 8915 8916 // Check whether that explicit signature was synthesized by 8917 // GetTypeForDeclarator. If so, don't save that as part of the 8918 // written signature. 8919 if (ExplicitSignature.getLocalRangeBegin() == 8920 ExplicitSignature.getLocalRangeEnd()) { 8921 // This would be much cheaper if we stored TypeLocs instead of 8922 // TypeSourceInfos. 8923 TypeLoc Result = ExplicitSignature.getResultLoc(); 8924 unsigned Size = Result.getFullDataSize(); 8925 Sig = Context.CreateTypeSourceInfo(Result.getType(), Size); 8926 Sig->getTypeLoc().initializeFullCopy(Result, Size); 8927 8928 ExplicitSignature = FunctionProtoTypeLoc(); 8929 } 8930 } 8931 8932 CurBlock->TheDecl->setSignatureAsWritten(Sig); 8933 CurBlock->FunctionType = T; 8934 8935 const FunctionType *Fn = T->getAs<FunctionType>(); 8936 QualType RetTy = Fn->getResultType(); 8937 bool isVariadic = 8938 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic()); 8939 8940 CurBlock->TheDecl->setIsVariadic(isVariadic); 8941 8942 // Don't allow returning a objc interface by value. 8943 if (RetTy->isObjCObjectType()) { 8944 Diag(ParamInfo.getLocStart(), 8945 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy; 8946 return; 8947 } 8948 8949 // Context.DependentTy is used as a placeholder for a missing block 8950 // return type. TODO: what should we do with declarators like: 8951 // ^ * { ... } 8952 // If the answer is "apply template argument deduction".... 8953 if (RetTy != Context.DependentTy) { 8954 CurBlock->ReturnType = RetTy; 8955 CurBlock->TheDecl->setBlockMissingReturnType(false); 8956 CurBlock->HasImplicitReturnType = false; 8957 } 8958 8959 // Push block parameters from the declarator if we had them. 8960 SmallVector<ParmVarDecl*, 8> Params; 8961 if (ExplicitSignature) { 8962 for (unsigned I = 0, E = ExplicitSignature.getNumArgs(); I != E; ++I) { 8963 ParmVarDecl *Param = ExplicitSignature.getArg(I); 8964 if (Param->getIdentifier() == 0 && 8965 !Param->isImplicit() && 8966 !Param->isInvalidDecl() && 8967 !getLangOpts().CPlusPlus) 8968 Diag(Param->getLocation(), diag::err_parameter_name_omitted); 8969 Params.push_back(Param); 8970 } 8971 8972 // Fake up parameter variables if we have a typedef, like 8973 // ^ fntype { ... } 8974 } else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) { 8975 for (FunctionProtoType::arg_type_iterator 8976 I = Fn->arg_type_begin(), E = Fn->arg_type_end(); I != E; ++I) { 8977 ParmVarDecl *Param = 8978 BuildParmVarDeclForTypedef(CurBlock->TheDecl, 8979 ParamInfo.getLocStart(), 8980 *I); 8981 Params.push_back(Param); 8982 } 8983 } 8984 8985 // Set the parameters on the block decl. 8986 if (!Params.empty()) { 8987 CurBlock->TheDecl->setParams(Params); 8988 CheckParmsForFunctionDef(CurBlock->TheDecl->param_begin(), 8989 CurBlock->TheDecl->param_end(), 8990 /*CheckParameterNames=*/false); 8991 } 8992 8993 // Finally we can process decl attributes. 8994 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo); 8995 8996 // Put the parameter variables in scope. We can bail out immediately 8997 // if we don't have any. 8998 if (Params.empty()) 8999 return; 9000 9001 for (BlockDecl::param_iterator AI = CurBlock->TheDecl->param_begin(), 9002 E = CurBlock->TheDecl->param_end(); AI != E; ++AI) { 9003 (*AI)->setOwningFunction(CurBlock->TheDecl); 9004 9005 // If this has an identifier, add it to the scope stack. 9006 if ((*AI)->getIdentifier()) { 9007 CheckShadow(CurBlock->TheScope, *AI); 9008 9009 PushOnScopeChains(*AI, CurBlock->TheScope); 9010 } 9011 } 9012 } 9013 9014 /// ActOnBlockError - If there is an error parsing a block, this callback 9015 /// is invoked to pop the information about the block from the action impl. 9016 void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) { 9017 // Leave the expression-evaluation context. 9018 DiscardCleanupsInEvaluationContext(); 9019 PopExpressionEvaluationContext(); 9020 9021 // Pop off CurBlock, handle nested blocks. 9022 PopDeclContext(); 9023 PopFunctionScopeInfo(); 9024 } 9025 9026 /// ActOnBlockStmtExpr - This is called when the body of a block statement 9027 /// literal was successfully completed. ^(int x){...} 9028 ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, 9029 Stmt *Body, Scope *CurScope) { 9030 // If blocks are disabled, emit an error. 9031 if (!LangOpts.Blocks) 9032 Diag(CaretLoc, diag::err_blocks_disable); 9033 9034 // Leave the expression-evaluation context. 9035 if (hasAnyUnrecoverableErrorsInThisFunction()) 9036 DiscardCleanupsInEvaluationContext(); 9037 assert(!ExprNeedsCleanups && "cleanups within block not correctly bound!"); 9038 PopExpressionEvaluationContext(); 9039 9040 BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back()); 9041 9042 PopDeclContext(); 9043 9044 QualType RetTy = Context.VoidTy; 9045 if (!BSI->ReturnType.isNull()) 9046 RetTy = BSI->ReturnType; 9047 9048 bool NoReturn = BSI->TheDecl->getAttr<NoReturnAttr>(); 9049 QualType BlockTy; 9050 9051 // Set the captured variables on the block. 9052 // FIXME: Share capture structure between BlockDecl and CapturingScopeInfo! 9053 SmallVector<BlockDecl::Capture, 4> Captures; 9054 for (unsigned i = 0, e = BSI->Captures.size(); i != e; i++) { 9055 CapturingScopeInfo::Capture &Cap = BSI->Captures[i]; 9056 if (Cap.isThisCapture()) 9057 continue; 9058 BlockDecl::Capture NewCap(Cap.getVariable(), Cap.isBlockCapture(), 9059 Cap.isNested(), Cap.getCopyExpr()); 9060 Captures.push_back(NewCap); 9061 } 9062 BSI->TheDecl->setCaptures(Context, Captures.begin(), Captures.end(), 9063 BSI->CXXThisCaptureIndex != 0); 9064 9065 // If the user wrote a function type in some form, try to use that. 9066 if (!BSI->FunctionType.isNull()) { 9067 const FunctionType *FTy = BSI->FunctionType->getAs<FunctionType>(); 9068 9069 FunctionType::ExtInfo Ext = FTy->getExtInfo(); 9070 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true); 9071 9072 // Turn protoless block types into nullary block types. 9073 if (isa<FunctionNoProtoType>(FTy)) { 9074 FunctionProtoType::ExtProtoInfo EPI; 9075 EPI.ExtInfo = Ext; 9076 BlockTy = Context.getFunctionType(RetTy, 0, 0, EPI); 9077 9078 // Otherwise, if we don't need to change anything about the function type, 9079 // preserve its sugar structure. 9080 } else if (FTy->getResultType() == RetTy && 9081 (!NoReturn || FTy->getNoReturnAttr())) { 9082 BlockTy = BSI->FunctionType; 9083 9084 // Otherwise, make the minimal modifications to the function type. 9085 } else { 9086 const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy); 9087 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 9088 EPI.TypeQuals = 0; // FIXME: silently? 9089 EPI.ExtInfo = Ext; 9090 BlockTy = Context.getFunctionType(RetTy, 9091 FPT->arg_type_begin(), 9092 FPT->getNumArgs(), 9093 EPI); 9094 } 9095 9096 // If we don't have a function type, just build one from nothing. 9097 } else { 9098 FunctionProtoType::ExtProtoInfo EPI; 9099 EPI.ExtInfo = FunctionType::ExtInfo().withNoReturn(NoReturn); 9100 BlockTy = Context.getFunctionType(RetTy, 0, 0, EPI); 9101 } 9102 9103 DiagnoseUnusedParameters(BSI->TheDecl->param_begin(), 9104 BSI->TheDecl->param_end()); 9105 BlockTy = Context.getBlockPointerType(BlockTy); 9106 9107 // If needed, diagnose invalid gotos and switches in the block. 9108 if (getCurFunction()->NeedsScopeChecking() && 9109 !hasAnyUnrecoverableErrorsInThisFunction()) 9110 DiagnoseInvalidJumps(cast<CompoundStmt>(Body)); 9111 9112 BSI->TheDecl->setBody(cast<CompoundStmt>(Body)); 9113 9114 computeNRVO(Body, getCurBlock()); 9115 9116 BlockExpr *Result = new (Context) BlockExpr(BSI->TheDecl, BlockTy); 9117 const AnalysisBasedWarnings::Policy &WP = AnalysisWarnings.getDefaultPolicy(); 9118 PopFunctionScopeInfo(&WP, Result->getBlockDecl(), Result); 9119 9120 // If the block isn't obviously global, i.e. it captures anything at 9121 // all, then we need to do a few things in the surrounding context: 9122 if (Result->getBlockDecl()->hasCaptures()) { 9123 // First, this expression has a new cleanup object. 9124 ExprCleanupObjects.push_back(Result->getBlockDecl()); 9125 ExprNeedsCleanups = true; 9126 9127 // It also gets a branch-protected scope if any of the captured 9128 // variables needs destruction. 9129 for (BlockDecl::capture_const_iterator 9130 ci = Result->getBlockDecl()->capture_begin(), 9131 ce = Result->getBlockDecl()->capture_end(); ci != ce; ++ci) { 9132 const VarDecl *var = ci->getVariable(); 9133 if (var->getType().isDestructedType() != QualType::DK_none) { 9134 getCurFunction()->setHasBranchProtectedScope(); 9135 break; 9136 } 9137 } 9138 } 9139 9140 return Owned(Result); 9141 } 9142 9143 ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc, 9144 Expr *E, ParsedType Ty, 9145 SourceLocation RPLoc) { 9146 TypeSourceInfo *TInfo; 9147 GetTypeFromParser(Ty, &TInfo); 9148 return BuildVAArgExpr(BuiltinLoc, E, TInfo, RPLoc); 9149 } 9150 9151 ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, 9152 Expr *E, TypeSourceInfo *TInfo, 9153 SourceLocation RPLoc) { 9154 Expr *OrigExpr = E; 9155 9156 // Get the va_list type 9157 QualType VaListType = Context.getBuiltinVaListType(); 9158 if (VaListType->isArrayType()) { 9159 // Deal with implicit array decay; for example, on x86-64, 9160 // va_list is an array, but it's supposed to decay to 9161 // a pointer for va_arg. 9162 VaListType = Context.getArrayDecayedType(VaListType); 9163 // Make sure the input expression also decays appropriately. 9164 ExprResult Result = UsualUnaryConversions(E); 9165 if (Result.isInvalid()) 9166 return ExprError(); 9167 E = Result.take(); 9168 } else { 9169 // Otherwise, the va_list argument must be an l-value because 9170 // it is modified by va_arg. 9171 if (!E->isTypeDependent() && 9172 CheckForModifiableLvalue(E, BuiltinLoc, *this)) 9173 return ExprError(); 9174 } 9175 9176 if (!E->isTypeDependent() && 9177 !Context.hasSameType(VaListType, E->getType())) { 9178 return ExprError(Diag(E->getLocStart(), 9179 diag::err_first_argument_to_va_arg_not_of_type_va_list) 9180 << OrigExpr->getType() << E->getSourceRange()); 9181 } 9182 9183 if (!TInfo->getType()->isDependentType()) { 9184 if (RequireCompleteType(TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(), 9185 PDiag(diag::err_second_parameter_to_va_arg_incomplete) 9186 << TInfo->getTypeLoc().getSourceRange())) 9187 return ExprError(); 9188 9189 if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(), 9190 TInfo->getType(), 9191 PDiag(diag::err_second_parameter_to_va_arg_abstract) 9192 << TInfo->getTypeLoc().getSourceRange())) 9193 return ExprError(); 9194 9195 if (!TInfo->getType().isPODType(Context)) { 9196 Diag(TInfo->getTypeLoc().getBeginLoc(), 9197 TInfo->getType()->isObjCLifetimeType() 9198 ? diag::warn_second_parameter_to_va_arg_ownership_qualified 9199 : diag::warn_second_parameter_to_va_arg_not_pod) 9200 << TInfo->getType() 9201 << TInfo->getTypeLoc().getSourceRange(); 9202 } 9203 9204 // Check for va_arg where arguments of the given type will be promoted 9205 // (i.e. this va_arg is guaranteed to have undefined behavior). 9206 QualType PromoteType; 9207 if (TInfo->getType()->isPromotableIntegerType()) { 9208 PromoteType = Context.getPromotedIntegerType(TInfo->getType()); 9209 if (Context.typesAreCompatible(PromoteType, TInfo->getType())) 9210 PromoteType = QualType(); 9211 } 9212 if (TInfo->getType()->isSpecificBuiltinType(BuiltinType::Float)) 9213 PromoteType = Context.DoubleTy; 9214 if (!PromoteType.isNull()) 9215 Diag(TInfo->getTypeLoc().getBeginLoc(), 9216 diag::warn_second_parameter_to_va_arg_never_compatible) 9217 << TInfo->getType() 9218 << PromoteType 9219 << TInfo->getTypeLoc().getSourceRange(); 9220 } 9221 9222 QualType T = TInfo->getType().getNonLValueExprType(Context); 9223 return Owned(new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T)); 9224 } 9225 9226 ExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) { 9227 // The type of __null will be int or long, depending on the size of 9228 // pointers on the target. 9229 QualType Ty; 9230 unsigned pw = Context.getTargetInfo().getPointerWidth(0); 9231 if (pw == Context.getTargetInfo().getIntWidth()) 9232 Ty = Context.IntTy; 9233 else if (pw == Context.getTargetInfo().getLongWidth()) 9234 Ty = Context.LongTy; 9235 else if (pw == Context.getTargetInfo().getLongLongWidth()) 9236 Ty = Context.LongLongTy; 9237 else { 9238 llvm_unreachable("I don't know size of pointer!"); 9239 } 9240 9241 return Owned(new (Context) GNUNullExpr(Ty, TokenLoc)); 9242 } 9243 9244 static void MakeObjCStringLiteralFixItHint(Sema& SemaRef, QualType DstType, 9245 Expr *SrcExpr, FixItHint &Hint) { 9246 if (!SemaRef.getLangOpts().ObjC1) 9247 return; 9248 9249 const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>(); 9250 if (!PT) 9251 return; 9252 9253 // Check if the destination is of type 'id'. 9254 if (!PT->isObjCIdType()) { 9255 // Check if the destination is the 'NSString' interface. 9256 const ObjCInterfaceDecl *ID = PT->getInterfaceDecl(); 9257 if (!ID || !ID->getIdentifier()->isStr("NSString")) 9258 return; 9259 } 9260 9261 // Ignore any parens, implicit casts (should only be 9262 // array-to-pointer decays), and not-so-opaque values. The last is 9263 // important for making this trigger for property assignments. 9264 SrcExpr = SrcExpr->IgnoreParenImpCasts(); 9265 if (OpaqueValueExpr *OV = dyn_cast<OpaqueValueExpr>(SrcExpr)) 9266 if (OV->getSourceExpr()) 9267 SrcExpr = OV->getSourceExpr()->IgnoreParenImpCasts(); 9268 9269 StringLiteral *SL = dyn_cast<StringLiteral>(SrcExpr); 9270 if (!SL || !SL->isAscii()) 9271 return; 9272 9273 Hint = FixItHint::CreateInsertion(SL->getLocStart(), "@"); 9274 } 9275 9276 bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy, 9277 SourceLocation Loc, 9278 QualType DstType, QualType SrcType, 9279 Expr *SrcExpr, AssignmentAction Action, 9280 bool *Complained) { 9281 if (Complained) 9282 *Complained = false; 9283 9284 // Decode the result (notice that AST's are still created for extensions). 9285 bool CheckInferredResultType = false; 9286 bool isInvalid = false; 9287 unsigned DiagKind = 0; 9288 FixItHint Hint; 9289 ConversionFixItGenerator ConvHints; 9290 bool MayHaveConvFixit = false; 9291 bool MayHaveFunctionDiff = false; 9292 9293 switch (ConvTy) { 9294 case Compatible: return false; 9295 case PointerToInt: 9296 DiagKind = diag::ext_typecheck_convert_pointer_int; 9297 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 9298 MayHaveConvFixit = true; 9299 break; 9300 case IntToPointer: 9301 DiagKind = diag::ext_typecheck_convert_int_pointer; 9302 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 9303 MayHaveConvFixit = true; 9304 break; 9305 case IncompatiblePointer: 9306 MakeObjCStringLiteralFixItHint(*this, DstType, SrcExpr, Hint); 9307 DiagKind = diag::ext_typecheck_convert_incompatible_pointer; 9308 CheckInferredResultType = DstType->isObjCObjectPointerType() && 9309 SrcType->isObjCObjectPointerType(); 9310 if (Hint.isNull() && !CheckInferredResultType) { 9311 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 9312 } 9313 MayHaveConvFixit = true; 9314 break; 9315 case IncompatiblePointerSign: 9316 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign; 9317 break; 9318 case FunctionVoidPointer: 9319 DiagKind = diag::ext_typecheck_convert_pointer_void_func; 9320 break; 9321 case IncompatiblePointerDiscardsQualifiers: { 9322 // Perform array-to-pointer decay if necessary. 9323 if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType); 9324 9325 Qualifiers lhq = SrcType->getPointeeType().getQualifiers(); 9326 Qualifiers rhq = DstType->getPointeeType().getQualifiers(); 9327 if (lhq.getAddressSpace() != rhq.getAddressSpace()) { 9328 DiagKind = diag::err_typecheck_incompatible_address_space; 9329 break; 9330 9331 9332 } else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) { 9333 DiagKind = diag::err_typecheck_incompatible_ownership; 9334 break; 9335 } 9336 9337 llvm_unreachable("unknown error case for discarding qualifiers!"); 9338 // fallthrough 9339 } 9340 case CompatiblePointerDiscardsQualifiers: 9341 // If the qualifiers lost were because we were applying the 9342 // (deprecated) C++ conversion from a string literal to a char* 9343 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME: 9344 // Ideally, this check would be performed in 9345 // checkPointerTypesForAssignment. However, that would require a 9346 // bit of refactoring (so that the second argument is an 9347 // expression, rather than a type), which should be done as part 9348 // of a larger effort to fix checkPointerTypesForAssignment for 9349 // C++ semantics. 9350 if (getLangOpts().CPlusPlus && 9351 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType)) 9352 return false; 9353 DiagKind = diag::ext_typecheck_convert_discards_qualifiers; 9354 break; 9355 case IncompatibleNestedPointerQualifiers: 9356 DiagKind = diag::ext_nested_pointer_qualifier_mismatch; 9357 break; 9358 case IntToBlockPointer: 9359 DiagKind = diag::err_int_to_block_pointer; 9360 break; 9361 case IncompatibleBlockPointer: 9362 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer; 9363 break; 9364 case IncompatibleObjCQualifiedId: 9365 // FIXME: Diagnose the problem in ObjCQualifiedIdTypesAreCompatible, since 9366 // it can give a more specific diagnostic. 9367 DiagKind = diag::warn_incompatible_qualified_id; 9368 break; 9369 case IncompatibleVectors: 9370 DiagKind = diag::warn_incompatible_vectors; 9371 break; 9372 case IncompatibleObjCWeakRef: 9373 DiagKind = diag::err_arc_weak_unavailable_assign; 9374 break; 9375 case Incompatible: 9376 DiagKind = diag::err_typecheck_convert_incompatible; 9377 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 9378 MayHaveConvFixit = true; 9379 isInvalid = true; 9380 MayHaveFunctionDiff = true; 9381 break; 9382 } 9383 9384 QualType FirstType, SecondType; 9385 switch (Action) { 9386 case AA_Assigning: 9387 case AA_Initializing: 9388 // The destination type comes first. 9389 FirstType = DstType; 9390 SecondType = SrcType; 9391 break; 9392 9393 case AA_Returning: 9394 case AA_Passing: 9395 case AA_Converting: 9396 case AA_Sending: 9397 case AA_Casting: 9398 // The source type comes first. 9399 FirstType = SrcType; 9400 SecondType = DstType; 9401 break; 9402 } 9403 9404 PartialDiagnostic FDiag = PDiag(DiagKind); 9405 FDiag << FirstType << SecondType << Action << SrcExpr->getSourceRange(); 9406 9407 // If we can fix the conversion, suggest the FixIts. 9408 assert(ConvHints.isNull() || Hint.isNull()); 9409 if (!ConvHints.isNull()) { 9410 for (std::vector<FixItHint>::iterator HI = ConvHints.Hints.begin(), 9411 HE = ConvHints.Hints.end(); HI != HE; ++HI) 9412 FDiag << *HI; 9413 } else { 9414 FDiag << Hint; 9415 } 9416 if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); } 9417 9418 if (MayHaveFunctionDiff) 9419 HandleFunctionTypeMismatch(FDiag, SecondType, FirstType); 9420 9421 Diag(Loc, FDiag); 9422 9423 if (SecondType == Context.OverloadTy) 9424 NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression, 9425 FirstType); 9426 9427 if (CheckInferredResultType) 9428 EmitRelatedResultTypeNote(SrcExpr); 9429 9430 if (Complained) 9431 *Complained = true; 9432 return isInvalid; 9433 } 9434 9435 ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, 9436 llvm::APSInt *Result) { 9437 return VerifyIntegerConstantExpression(E, Result, 9438 PDiag(diag::err_expr_not_ice) << LangOpts.CPlusPlus); 9439 } 9440 9441 ExprResult 9442 Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, 9443 const PartialDiagnostic &NotIceDiag, 9444 bool AllowFold, 9445 const PartialDiagnostic &FoldDiag) { 9446 SourceLocation DiagLoc = E->getLocStart(); 9447 9448 if (getLangOpts().CPlusPlus0x) { 9449 // C++11 [expr.const]p5: 9450 // If an expression of literal class type is used in a context where an 9451 // integral constant expression is required, then that class type shall 9452 // have a single non-explicit conversion function to an integral or 9453 // unscoped enumeration type 9454 ExprResult Converted; 9455 if (NotIceDiag.getDiagID()) { 9456 Converted = ConvertToIntegralOrEnumerationType( 9457 DiagLoc, E, 9458 PDiag(diag::err_ice_not_integral), 9459 PDiag(diag::err_ice_incomplete_type), 9460 PDiag(diag::err_ice_explicit_conversion), 9461 PDiag(diag::note_ice_conversion_here), 9462 PDiag(diag::err_ice_ambiguous_conversion), 9463 PDiag(diag::note_ice_conversion_here), 9464 PDiag(0), 9465 /*AllowScopedEnumerations*/ false); 9466 } else { 9467 // The caller wants to silently enquire whether this is an ICE. Don't 9468 // produce any diagnostics if it isn't. 9469 Converted = ConvertToIntegralOrEnumerationType( 9470 DiagLoc, E, PDiag(), PDiag(), PDiag(), PDiag(), 9471 PDiag(), PDiag(), PDiag(), false); 9472 } 9473 if (Converted.isInvalid()) 9474 return Converted; 9475 E = Converted.take(); 9476 if (!E->getType()->isIntegralOrUnscopedEnumerationType()) 9477 return ExprError(); 9478 } else if (!E->getType()->isIntegralOrUnscopedEnumerationType()) { 9479 // An ICE must be of integral or unscoped enumeration type. 9480 if (NotIceDiag.getDiagID()) 9481 Diag(DiagLoc, NotIceDiag) << E->getSourceRange(); 9482 return ExprError(); 9483 } 9484 9485 // Circumvent ICE checking in C++11 to avoid evaluating the expression twice 9486 // in the non-ICE case. 9487 if (!getLangOpts().CPlusPlus0x && E->isIntegerConstantExpr(Context)) { 9488 if (Result) 9489 *Result = E->EvaluateKnownConstInt(Context); 9490 return Owned(E); 9491 } 9492 9493 Expr::EvalResult EvalResult; 9494 llvm::SmallVector<PartialDiagnosticAt, 8> Notes; 9495 EvalResult.Diag = &Notes; 9496 9497 // Try to evaluate the expression, and produce diagnostics explaining why it's 9498 // not a constant expression as a side-effect. 9499 bool Folded = E->EvaluateAsRValue(EvalResult, Context) && 9500 EvalResult.Val.isInt() && !EvalResult.HasSideEffects; 9501 9502 // In C++11, we can rely on diagnostics being produced for any expression 9503 // which is not a constant expression. If no diagnostics were produced, then 9504 // this is a constant expression. 9505 if (Folded && getLangOpts().CPlusPlus0x && Notes.empty()) { 9506 if (Result) 9507 *Result = EvalResult.Val.getInt(); 9508 return Owned(E); 9509 } 9510 9511 // If our only note is the usual "invalid subexpression" note, just point 9512 // the caret at its location rather than producing an essentially 9513 // redundant note. 9514 if (Notes.size() == 1 && Notes[0].second.getDiagID() == 9515 diag::note_invalid_subexpr_in_const_expr) { 9516 DiagLoc = Notes[0].first; 9517 Notes.clear(); 9518 } 9519 9520 if (!Folded || !AllowFold) { 9521 if (NotIceDiag.getDiagID()) { 9522 Diag(DiagLoc, NotIceDiag) << E->getSourceRange(); 9523 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 9524 Diag(Notes[I].first, Notes[I].second); 9525 } 9526 9527 return ExprError(); 9528 } 9529 9530 if (FoldDiag.getDiagID()) 9531 Diag(DiagLoc, FoldDiag) << E->getSourceRange(); 9532 else 9533 Diag(DiagLoc, diag::ext_expr_not_ice) 9534 << E->getSourceRange() << LangOpts.CPlusPlus; 9535 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 9536 Diag(Notes[I].first, Notes[I].second); 9537 9538 if (Result) 9539 *Result = EvalResult.Val.getInt(); 9540 return Owned(E); 9541 } 9542 9543 namespace { 9544 // Handle the case where we conclude a expression which we speculatively 9545 // considered to be unevaluated is actually evaluated. 9546 class TransformToPE : public TreeTransform<TransformToPE> { 9547 typedef TreeTransform<TransformToPE> BaseTransform; 9548 9549 public: 9550 TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) { } 9551 9552 // Make sure we redo semantic analysis 9553 bool AlwaysRebuild() { return true; } 9554 9555 // Make sure we handle LabelStmts correctly. 9556 // FIXME: This does the right thing, but maybe we need a more general 9557 // fix to TreeTransform? 9558 StmtResult TransformLabelStmt(LabelStmt *S) { 9559 S->getDecl()->setStmt(0); 9560 return BaseTransform::TransformLabelStmt(S); 9561 } 9562 9563 // We need to special-case DeclRefExprs referring to FieldDecls which 9564 // are not part of a member pointer formation; normal TreeTransforming 9565 // doesn't catch this case because of the way we represent them in the AST. 9566 // FIXME: This is a bit ugly; is it really the best way to handle this 9567 // case? 9568 // 9569 // Error on DeclRefExprs referring to FieldDecls. 9570 ExprResult TransformDeclRefExpr(DeclRefExpr *E) { 9571 if (isa<FieldDecl>(E->getDecl()) && 9572 SemaRef.ExprEvalContexts.back().Context != Sema::Unevaluated) 9573 return SemaRef.Diag(E->getLocation(), 9574 diag::err_invalid_non_static_member_use) 9575 << E->getDecl() << E->getSourceRange(); 9576 9577 return BaseTransform::TransformDeclRefExpr(E); 9578 } 9579 9580 // Exception: filter out member pointer formation 9581 ExprResult TransformUnaryOperator(UnaryOperator *E) { 9582 if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType()) 9583 return E; 9584 9585 return BaseTransform::TransformUnaryOperator(E); 9586 } 9587 9588 ExprResult TransformLambdaExpr(LambdaExpr *E) { 9589 // Lambdas never need to be transformed. 9590 return E; 9591 } 9592 }; 9593 } 9594 9595 ExprResult Sema::TranformToPotentiallyEvaluated(Expr *E) { 9596 assert(ExprEvalContexts.back().Context == Unevaluated && 9597 "Should only transform unevaluated expressions"); 9598 ExprEvalContexts.back().Context = 9599 ExprEvalContexts[ExprEvalContexts.size()-2].Context; 9600 if (ExprEvalContexts.back().Context == Unevaluated) 9601 return E; 9602 return TransformToPE(*this).TransformExpr(E); 9603 } 9604 9605 void 9606 Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, 9607 Decl *LambdaContextDecl, 9608 bool IsDecltype) { 9609 ExprEvalContexts.push_back( 9610 ExpressionEvaluationContextRecord(NewContext, 9611 ExprCleanupObjects.size(), 9612 ExprNeedsCleanups, 9613 LambdaContextDecl, 9614 IsDecltype)); 9615 ExprNeedsCleanups = false; 9616 if (!MaybeODRUseExprs.empty()) 9617 std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs); 9618 } 9619 9620 void Sema::PopExpressionEvaluationContext() { 9621 ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back(); 9622 9623 if (!Rec.Lambdas.empty()) { 9624 if (Rec.Context == Unevaluated) { 9625 // C++11 [expr.prim.lambda]p2: 9626 // A lambda-expression shall not appear in an unevaluated operand 9627 // (Clause 5). 9628 for (unsigned I = 0, N = Rec.Lambdas.size(); I != N; ++I) 9629 Diag(Rec.Lambdas[I]->getLocStart(), 9630 diag::err_lambda_unevaluated_operand); 9631 } else { 9632 // Mark the capture expressions odr-used. This was deferred 9633 // during lambda expression creation. 9634 for (unsigned I = 0, N = Rec.Lambdas.size(); I != N; ++I) { 9635 LambdaExpr *Lambda = Rec.Lambdas[I]; 9636 for (LambdaExpr::capture_init_iterator 9637 C = Lambda->capture_init_begin(), 9638 CEnd = Lambda->capture_init_end(); 9639 C != CEnd; ++C) { 9640 MarkDeclarationsReferencedInExpr(*C); 9641 } 9642 } 9643 } 9644 } 9645 9646 // When are coming out of an unevaluated context, clear out any 9647 // temporaries that we may have created as part of the evaluation of 9648 // the expression in that context: they aren't relevant because they 9649 // will never be constructed. 9650 if (Rec.Context == Unevaluated || Rec.Context == ConstantEvaluated) { 9651 ExprCleanupObjects.erase(ExprCleanupObjects.begin() + Rec.NumCleanupObjects, 9652 ExprCleanupObjects.end()); 9653 ExprNeedsCleanups = Rec.ParentNeedsCleanups; 9654 CleanupVarDeclMarking(); 9655 std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs); 9656 // Otherwise, merge the contexts together. 9657 } else { 9658 ExprNeedsCleanups |= Rec.ParentNeedsCleanups; 9659 MaybeODRUseExprs.insert(Rec.SavedMaybeODRUseExprs.begin(), 9660 Rec.SavedMaybeODRUseExprs.end()); 9661 } 9662 9663 // Pop the current expression evaluation context off the stack. 9664 ExprEvalContexts.pop_back(); 9665 } 9666 9667 void Sema::DiscardCleanupsInEvaluationContext() { 9668 ExprCleanupObjects.erase( 9669 ExprCleanupObjects.begin() + ExprEvalContexts.back().NumCleanupObjects, 9670 ExprCleanupObjects.end()); 9671 ExprNeedsCleanups = false; 9672 MaybeODRUseExprs.clear(); 9673 } 9674 9675 ExprResult Sema::HandleExprEvaluationContextForTypeof(Expr *E) { 9676 if (!E->getType()->isVariablyModifiedType()) 9677 return E; 9678 return TranformToPotentiallyEvaluated(E); 9679 } 9680 9681 static bool IsPotentiallyEvaluatedContext(Sema &SemaRef) { 9682 // Do not mark anything as "used" within a dependent context; wait for 9683 // an instantiation. 9684 if (SemaRef.CurContext->isDependentContext()) 9685 return false; 9686 9687 switch (SemaRef.ExprEvalContexts.back().Context) { 9688 case Sema::Unevaluated: 9689 // We are in an expression that is not potentially evaluated; do nothing. 9690 // (Depending on how you read the standard, we actually do need to do 9691 // something here for null pointer constants, but the standard's 9692 // definition of a null pointer constant is completely crazy.) 9693 return false; 9694 9695 case Sema::ConstantEvaluated: 9696 case Sema::PotentiallyEvaluated: 9697 // We are in a potentially evaluated expression (or a constant-expression 9698 // in C++03); we need to do implicit template instantiation, implicitly 9699 // define class members, and mark most declarations as used. 9700 return true; 9701 9702 case Sema::PotentiallyEvaluatedIfUsed: 9703 // Referenced declarations will only be used if the construct in the 9704 // containing expression is used. 9705 return false; 9706 } 9707 llvm_unreachable("Invalid context"); 9708 } 9709 9710 /// \brief Mark a function referenced, and check whether it is odr-used 9711 /// (C++ [basic.def.odr]p2, C99 6.9p3) 9712 void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func) { 9713 assert(Func && "No function?"); 9714 9715 Func->setReferenced(); 9716 9717 // Don't mark this function as used multiple times, unless it's a constexpr 9718 // function which we need to instantiate. 9719 if (Func->isUsed(false) && 9720 !(Func->isConstexpr() && !Func->getBody() && 9721 Func->isImplicitlyInstantiable())) 9722 return; 9723 9724 if (!IsPotentiallyEvaluatedContext(*this)) 9725 return; 9726 9727 // Note that this declaration has been used. 9728 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Func)) { 9729 if (Constructor->isDefaulted() && !Constructor->isDeleted()) { 9730 if (Constructor->isDefaultConstructor()) { 9731 if (Constructor->isTrivial()) 9732 return; 9733 if (!Constructor->isUsed(false)) 9734 DefineImplicitDefaultConstructor(Loc, Constructor); 9735 } else if (Constructor->isCopyConstructor()) { 9736 if (!Constructor->isUsed(false)) 9737 DefineImplicitCopyConstructor(Loc, Constructor); 9738 } else if (Constructor->isMoveConstructor()) { 9739 if (!Constructor->isUsed(false)) 9740 DefineImplicitMoveConstructor(Loc, Constructor); 9741 } 9742 } 9743 9744 MarkVTableUsed(Loc, Constructor->getParent()); 9745 } else if (CXXDestructorDecl *Destructor = 9746 dyn_cast<CXXDestructorDecl>(Func)) { 9747 if (Destructor->isDefaulted() && !Destructor->isDeleted() && 9748 !Destructor->isUsed(false)) 9749 DefineImplicitDestructor(Loc, Destructor); 9750 if (Destructor->isVirtual()) 9751 MarkVTableUsed(Loc, Destructor->getParent()); 9752 } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(Func)) { 9753 if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted() && 9754 MethodDecl->isOverloadedOperator() && 9755 MethodDecl->getOverloadedOperator() == OO_Equal) { 9756 if (!MethodDecl->isUsed(false)) { 9757 if (MethodDecl->isCopyAssignmentOperator()) 9758 DefineImplicitCopyAssignment(Loc, MethodDecl); 9759 else 9760 DefineImplicitMoveAssignment(Loc, MethodDecl); 9761 } 9762 } else if (isa<CXXConversionDecl>(MethodDecl) && 9763 MethodDecl->getParent()->isLambda()) { 9764 CXXConversionDecl *Conversion = cast<CXXConversionDecl>(MethodDecl); 9765 if (Conversion->isLambdaToBlockPointerConversion()) 9766 DefineImplicitLambdaToBlockPointerConversion(Loc, Conversion); 9767 else 9768 DefineImplicitLambdaToFunctionPointerConversion(Loc, Conversion); 9769 } else if (MethodDecl->isVirtual()) 9770 MarkVTableUsed(Loc, MethodDecl->getParent()); 9771 } 9772 9773 // Recursive functions should be marked when used from another function. 9774 // FIXME: Is this really right? 9775 if (CurContext == Func) return; 9776 9777 // Instantiate the exception specification for any function which is 9778 // used: CodeGen will need it. 9779 const FunctionProtoType *FPT = Func->getType()->getAs<FunctionProtoType>(); 9780 if (FPT && FPT->getExceptionSpecType() == EST_Uninstantiated) 9781 InstantiateExceptionSpec(Loc, Func); 9782 9783 // Implicit instantiation of function templates and member functions of 9784 // class templates. 9785 if (Func->isImplicitlyInstantiable()) { 9786 bool AlreadyInstantiated = false; 9787 SourceLocation PointOfInstantiation = Loc; 9788 if (FunctionTemplateSpecializationInfo *SpecInfo 9789 = Func->getTemplateSpecializationInfo()) { 9790 if (SpecInfo->getPointOfInstantiation().isInvalid()) 9791 SpecInfo->setPointOfInstantiation(Loc); 9792 else if (SpecInfo->getTemplateSpecializationKind() 9793 == TSK_ImplicitInstantiation) { 9794 AlreadyInstantiated = true; 9795 PointOfInstantiation = SpecInfo->getPointOfInstantiation(); 9796 } 9797 } else if (MemberSpecializationInfo *MSInfo 9798 = Func->getMemberSpecializationInfo()) { 9799 if (MSInfo->getPointOfInstantiation().isInvalid()) 9800 MSInfo->setPointOfInstantiation(Loc); 9801 else if (MSInfo->getTemplateSpecializationKind() 9802 == TSK_ImplicitInstantiation) { 9803 AlreadyInstantiated = true; 9804 PointOfInstantiation = MSInfo->getPointOfInstantiation(); 9805 } 9806 } 9807 9808 if (!AlreadyInstantiated || Func->isConstexpr()) { 9809 if (isa<CXXRecordDecl>(Func->getDeclContext()) && 9810 cast<CXXRecordDecl>(Func->getDeclContext())->isLocalClass()) 9811 PendingLocalImplicitInstantiations.push_back( 9812 std::make_pair(Func, PointOfInstantiation)); 9813 else if (Func->isConstexpr()) 9814 // Do not defer instantiations of constexpr functions, to avoid the 9815 // expression evaluator needing to call back into Sema if it sees a 9816 // call to such a function. 9817 InstantiateFunctionDefinition(PointOfInstantiation, Func); 9818 else { 9819 PendingInstantiations.push_back(std::make_pair(Func, 9820 PointOfInstantiation)); 9821 // Notify the consumer that a function was implicitly instantiated. 9822 Consumer.HandleCXXImplicitFunctionInstantiation(Func); 9823 } 9824 } 9825 } else { 9826 // Walk redefinitions, as some of them may be instantiable. 9827 for (FunctionDecl::redecl_iterator i(Func->redecls_begin()), 9828 e(Func->redecls_end()); i != e; ++i) { 9829 if (!i->isUsed(false) && i->isImplicitlyInstantiable()) 9830 MarkFunctionReferenced(Loc, *i); 9831 } 9832 } 9833 9834 // Keep track of used but undefined functions. 9835 if (!Func->isPure() && !Func->hasBody() && 9836 Func->getLinkage() != ExternalLinkage) { 9837 SourceLocation &old = UndefinedInternals[Func->getCanonicalDecl()]; 9838 if (old.isInvalid()) old = Loc; 9839 } 9840 9841 Func->setUsed(true); 9842 } 9843 9844 static void 9845 diagnoseUncapturableValueReference(Sema &S, SourceLocation loc, 9846 VarDecl *var, DeclContext *DC) { 9847 DeclContext *VarDC = var->getDeclContext(); 9848 9849 // If the parameter still belongs to the translation unit, then 9850 // we're actually just using one parameter in the declaration of 9851 // the next. 9852 if (isa<ParmVarDecl>(var) && 9853 isa<TranslationUnitDecl>(VarDC)) 9854 return; 9855 9856 // For C code, don't diagnose about capture if we're not actually in code 9857 // right now; it's impossible to write a non-constant expression outside of 9858 // function context, so we'll get other (more useful) diagnostics later. 9859 // 9860 // For C++, things get a bit more nasty... it would be nice to suppress this 9861 // diagnostic for certain cases like using a local variable in an array bound 9862 // for a member of a local class, but the correct predicate is not obvious. 9863 if (!S.getLangOpts().CPlusPlus && !S.CurContext->isFunctionOrMethod()) 9864 return; 9865 9866 if (isa<CXXMethodDecl>(VarDC) && 9867 cast<CXXRecordDecl>(VarDC->getParent())->isLambda()) { 9868 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_lambda) 9869 << var->getIdentifier(); 9870 } else if (FunctionDecl *fn = dyn_cast<FunctionDecl>(VarDC)) { 9871 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_function) 9872 << var->getIdentifier() << fn->getDeclName(); 9873 } else if (isa<BlockDecl>(VarDC)) { 9874 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_block) 9875 << var->getIdentifier(); 9876 } else { 9877 // FIXME: Is there any other context where a local variable can be 9878 // declared? 9879 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_context) 9880 << var->getIdentifier(); 9881 } 9882 9883 S.Diag(var->getLocation(), diag::note_local_variable_declared_here) 9884 << var->getIdentifier(); 9885 9886 // FIXME: Add additional diagnostic info about class etc. which prevents 9887 // capture. 9888 } 9889 9890 /// \brief Capture the given variable in the given lambda expression. 9891 static ExprResult captureInLambda(Sema &S, LambdaScopeInfo *LSI, 9892 VarDecl *Var, QualType FieldType, 9893 QualType DeclRefType, 9894 SourceLocation Loc) { 9895 CXXRecordDecl *Lambda = LSI->Lambda; 9896 9897 // Build the non-static data member. 9898 FieldDecl *Field 9899 = FieldDecl::Create(S.Context, Lambda, Loc, Loc, 0, FieldType, 9900 S.Context.getTrivialTypeSourceInfo(FieldType, Loc), 9901 0, false, false); 9902 Field->setImplicit(true); 9903 Field->setAccess(AS_private); 9904 Lambda->addDecl(Field); 9905 9906 // C++11 [expr.prim.lambda]p21: 9907 // When the lambda-expression is evaluated, the entities that 9908 // are captured by copy are used to direct-initialize each 9909 // corresponding non-static data member of the resulting closure 9910 // object. (For array members, the array elements are 9911 // direct-initialized in increasing subscript order.) These 9912 // initializations are performed in the (unspecified) order in 9913 // which the non-static data members are declared. 9914 9915 // Introduce a new evaluation context for the initialization, so 9916 // that temporaries introduced as part of the capture are retained 9917 // to be re-"exported" from the lambda expression itself. 9918 S.PushExpressionEvaluationContext(Sema::PotentiallyEvaluated); 9919 9920 // C++ [expr.prim.labda]p12: 9921 // An entity captured by a lambda-expression is odr-used (3.2) in 9922 // the scope containing the lambda-expression. 9923 Expr *Ref = new (S.Context) DeclRefExpr(Var, false, DeclRefType, 9924 VK_LValue, Loc); 9925 Var->setReferenced(true); 9926 Var->setUsed(true); 9927 9928 // When the field has array type, create index variables for each 9929 // dimension of the array. We use these index variables to subscript 9930 // the source array, and other clients (e.g., CodeGen) will perform 9931 // the necessary iteration with these index variables. 9932 SmallVector<VarDecl *, 4> IndexVariables; 9933 QualType BaseType = FieldType; 9934 QualType SizeType = S.Context.getSizeType(); 9935 LSI->ArrayIndexStarts.push_back(LSI->ArrayIndexVars.size()); 9936 while (const ConstantArrayType *Array 9937 = S.Context.getAsConstantArrayType(BaseType)) { 9938 // Create the iteration variable for this array index. 9939 IdentifierInfo *IterationVarName = 0; 9940 { 9941 SmallString<8> Str; 9942 llvm::raw_svector_ostream OS(Str); 9943 OS << "__i" << IndexVariables.size(); 9944 IterationVarName = &S.Context.Idents.get(OS.str()); 9945 } 9946 VarDecl *IterationVar 9947 = VarDecl::Create(S.Context, S.CurContext, Loc, Loc, 9948 IterationVarName, SizeType, 9949 S.Context.getTrivialTypeSourceInfo(SizeType, Loc), 9950 SC_None, SC_None); 9951 IndexVariables.push_back(IterationVar); 9952 LSI->ArrayIndexVars.push_back(IterationVar); 9953 9954 // Create a reference to the iteration variable. 9955 ExprResult IterationVarRef 9956 = S.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc); 9957 assert(!IterationVarRef.isInvalid() && 9958 "Reference to invented variable cannot fail!"); 9959 IterationVarRef = S.DefaultLvalueConversion(IterationVarRef.take()); 9960 assert(!IterationVarRef.isInvalid() && 9961 "Conversion of invented variable cannot fail!"); 9962 9963 // Subscript the array with this iteration variable. 9964 ExprResult Subscript = S.CreateBuiltinArraySubscriptExpr( 9965 Ref, Loc, IterationVarRef.take(), Loc); 9966 if (Subscript.isInvalid()) { 9967 S.CleanupVarDeclMarking(); 9968 S.DiscardCleanupsInEvaluationContext(); 9969 S.PopExpressionEvaluationContext(); 9970 return ExprError(); 9971 } 9972 9973 Ref = Subscript.take(); 9974 BaseType = Array->getElementType(); 9975 } 9976 9977 // Construct the entity that we will be initializing. For an array, this 9978 // will be first element in the array, which may require several levels 9979 // of array-subscript entities. 9980 SmallVector<InitializedEntity, 4> Entities; 9981 Entities.reserve(1 + IndexVariables.size()); 9982 Entities.push_back( 9983 InitializedEntity::InitializeLambdaCapture(Var, Field, Loc)); 9984 for (unsigned I = 0, N = IndexVariables.size(); I != N; ++I) 9985 Entities.push_back(InitializedEntity::InitializeElement(S.Context, 9986 0, 9987 Entities.back())); 9988 9989 InitializationKind InitKind 9990 = InitializationKind::CreateDirect(Loc, Loc, Loc); 9991 InitializationSequence Init(S, Entities.back(), InitKind, &Ref, 1); 9992 ExprResult Result(true); 9993 if (!Init.Diagnose(S, Entities.back(), InitKind, &Ref, 1)) 9994 Result = Init.Perform(S, Entities.back(), InitKind, 9995 MultiExprArg(S, &Ref, 1)); 9996 9997 // If this initialization requires any cleanups (e.g., due to a 9998 // default argument to a copy constructor), note that for the 9999 // lambda. 10000 if (S.ExprNeedsCleanups) 10001 LSI->ExprNeedsCleanups = true; 10002 10003 // Exit the expression evaluation context used for the capture. 10004 S.CleanupVarDeclMarking(); 10005 S.DiscardCleanupsInEvaluationContext(); 10006 S.PopExpressionEvaluationContext(); 10007 return Result; 10008 } 10009 10010 bool Sema::tryCaptureVariable(VarDecl *Var, SourceLocation Loc, 10011 TryCaptureKind Kind, SourceLocation EllipsisLoc, 10012 bool BuildAndDiagnose, 10013 QualType &CaptureType, 10014 QualType &DeclRefType) { 10015 bool Nested = false; 10016 10017 DeclContext *DC = CurContext; 10018 if (Var->getDeclContext() == DC) return true; 10019 if (!Var->hasLocalStorage()) return true; 10020 10021 bool HasBlocksAttr = Var->hasAttr<BlocksAttr>(); 10022 10023 // Walk up the stack to determine whether we can capture the variable, 10024 // performing the "simple" checks that don't depend on type. We stop when 10025 // we've either hit the declared scope of the variable or find an existing 10026 // capture of that variable. 10027 CaptureType = Var->getType(); 10028 DeclRefType = CaptureType.getNonReferenceType(); 10029 bool Explicit = (Kind != TryCapture_Implicit); 10030 unsigned FunctionScopesIndex = FunctionScopes.size() - 1; 10031 do { 10032 // Only block literals and lambda expressions can capture; other 10033 // scopes don't work. 10034 DeclContext *ParentDC; 10035 if (isa<BlockDecl>(DC)) 10036 ParentDC = DC->getParent(); 10037 else if (isa<CXXMethodDecl>(DC) && 10038 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call && 10039 cast<CXXRecordDecl>(DC->getParent())->isLambda()) 10040 ParentDC = DC->getParent()->getParent(); 10041 else { 10042 if (BuildAndDiagnose) 10043 diagnoseUncapturableValueReference(*this, Loc, Var, DC); 10044 return true; 10045 } 10046 10047 CapturingScopeInfo *CSI = 10048 cast<CapturingScopeInfo>(FunctionScopes[FunctionScopesIndex]); 10049 10050 // Check whether we've already captured it. 10051 if (CSI->CaptureMap.count(Var)) { 10052 // If we found a capture, any subcaptures are nested. 10053 Nested = true; 10054 10055 // Retrieve the capture type for this variable. 10056 CaptureType = CSI->getCapture(Var).getCaptureType(); 10057 10058 // Compute the type of an expression that refers to this variable. 10059 DeclRefType = CaptureType.getNonReferenceType(); 10060 10061 const CapturingScopeInfo::Capture &Cap = CSI->getCapture(Var); 10062 if (Cap.isCopyCapture() && 10063 !(isa<LambdaScopeInfo>(CSI) && cast<LambdaScopeInfo>(CSI)->Mutable)) 10064 DeclRefType.addConst(); 10065 break; 10066 } 10067 10068 bool IsBlock = isa<BlockScopeInfo>(CSI); 10069 bool IsLambda = !IsBlock; 10070 10071 // Lambdas are not allowed to capture unnamed variables 10072 // (e.g. anonymous unions). 10073 // FIXME: The C++11 rule don't actually state this explicitly, but I'm 10074 // assuming that's the intent. 10075 if (IsLambda && !Var->getDeclName()) { 10076 if (BuildAndDiagnose) { 10077 Diag(Loc, diag::err_lambda_capture_anonymous_var); 10078 Diag(Var->getLocation(), diag::note_declared_at); 10079 } 10080 return true; 10081 } 10082 10083 // Prohibit variably-modified types; they're difficult to deal with. 10084 if (Var->getType()->isVariablyModifiedType()) { 10085 if (BuildAndDiagnose) { 10086 if (IsBlock) 10087 Diag(Loc, diag::err_ref_vm_type); 10088 else 10089 Diag(Loc, diag::err_lambda_capture_vm_type) << Var->getDeclName(); 10090 Diag(Var->getLocation(), diag::note_previous_decl) 10091 << Var->getDeclName(); 10092 } 10093 return true; 10094 } 10095 10096 // Lambdas are not allowed to capture __block variables; they don't 10097 // support the expected semantics. 10098 if (IsLambda && HasBlocksAttr) { 10099 if (BuildAndDiagnose) { 10100 Diag(Loc, diag::err_lambda_capture_block) 10101 << Var->getDeclName(); 10102 Diag(Var->getLocation(), diag::note_previous_decl) 10103 << Var->getDeclName(); 10104 } 10105 return true; 10106 } 10107 10108 if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None && !Explicit) { 10109 // No capture-default 10110 if (BuildAndDiagnose) { 10111 Diag(Loc, diag::err_lambda_impcap) << Var->getDeclName(); 10112 Diag(Var->getLocation(), diag::note_previous_decl) 10113 << Var->getDeclName(); 10114 Diag(cast<LambdaScopeInfo>(CSI)->Lambda->getLocStart(), 10115 diag::note_lambda_decl); 10116 } 10117 return true; 10118 } 10119 10120 FunctionScopesIndex--; 10121 DC = ParentDC; 10122 Explicit = false; 10123 } while (!Var->getDeclContext()->Equals(DC)); 10124 10125 // Walk back down the scope stack, computing the type of the capture at 10126 // each step, checking type-specific requirements, and adding captures if 10127 // requested. 10128 for (unsigned I = ++FunctionScopesIndex, N = FunctionScopes.size(); I != N; 10129 ++I) { 10130 CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[I]); 10131 10132 // Compute the type of the capture and of a reference to the capture within 10133 // this scope. 10134 if (isa<BlockScopeInfo>(CSI)) { 10135 Expr *CopyExpr = 0; 10136 bool ByRef = false; 10137 10138 // Blocks are not allowed to capture arrays. 10139 if (CaptureType->isArrayType()) { 10140 if (BuildAndDiagnose) { 10141 Diag(Loc, diag::err_ref_array_type); 10142 Diag(Var->getLocation(), diag::note_previous_decl) 10143 << Var->getDeclName(); 10144 } 10145 return true; 10146 } 10147 10148 // Forbid the block-capture of autoreleasing variables. 10149 if (CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) { 10150 if (BuildAndDiagnose) { 10151 Diag(Loc, diag::err_arc_autoreleasing_capture) 10152 << /*block*/ 0; 10153 Diag(Var->getLocation(), diag::note_previous_decl) 10154 << Var->getDeclName(); 10155 } 10156 return true; 10157 } 10158 10159 if (HasBlocksAttr || CaptureType->isReferenceType()) { 10160 // Block capture by reference does not change the capture or 10161 // declaration reference types. 10162 ByRef = true; 10163 } else { 10164 // Block capture by copy introduces 'const'. 10165 CaptureType = CaptureType.getNonReferenceType().withConst(); 10166 DeclRefType = CaptureType; 10167 10168 if (getLangOpts().CPlusPlus && BuildAndDiagnose) { 10169 if (const RecordType *Record = DeclRefType->getAs<RecordType>()) { 10170 // The capture logic needs the destructor, so make sure we mark it. 10171 // Usually this is unnecessary because most local variables have 10172 // their destructors marked at declaration time, but parameters are 10173 // an exception because it's technically only the call site that 10174 // actually requires the destructor. 10175 if (isa<ParmVarDecl>(Var)) 10176 FinalizeVarWithDestructor(Var, Record); 10177 10178 // According to the blocks spec, the capture of a variable from 10179 // the stack requires a const copy constructor. This is not true 10180 // of the copy/move done to move a __block variable to the heap. 10181 Expr *DeclRef = new (Context) DeclRefExpr(Var, false, 10182 DeclRefType.withConst(), 10183 VK_LValue, Loc); 10184 ExprResult Result 10185 = PerformCopyInitialization( 10186 InitializedEntity::InitializeBlock(Var->getLocation(), 10187 CaptureType, false), 10188 Loc, Owned(DeclRef)); 10189 10190 // Build a full-expression copy expression if initialization 10191 // succeeded and used a non-trivial constructor. Recover from 10192 // errors by pretending that the copy isn't necessary. 10193 if (!Result.isInvalid() && 10194 !cast<CXXConstructExpr>(Result.get())->getConstructor() 10195 ->isTrivial()) { 10196 Result = MaybeCreateExprWithCleanups(Result); 10197 CopyExpr = Result.take(); 10198 } 10199 } 10200 } 10201 } 10202 10203 // Actually capture the variable. 10204 if (BuildAndDiagnose) 10205 CSI->addCapture(Var, HasBlocksAttr, ByRef, Nested, Loc, 10206 SourceLocation(), CaptureType, CopyExpr); 10207 Nested = true; 10208 continue; 10209 } 10210 10211 LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI); 10212 10213 // Determine whether we are capturing by reference or by value. 10214 bool ByRef = false; 10215 if (I == N - 1 && Kind != TryCapture_Implicit) { 10216 ByRef = (Kind == TryCapture_ExplicitByRef); 10217 } else { 10218 ByRef = (LSI->ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByref); 10219 } 10220 10221 // Compute the type of the field that will capture this variable. 10222 if (ByRef) { 10223 // C++11 [expr.prim.lambda]p15: 10224 // An entity is captured by reference if it is implicitly or 10225 // explicitly captured but not captured by copy. It is 10226 // unspecified whether additional unnamed non-static data 10227 // members are declared in the closure type for entities 10228 // captured by reference. 10229 // 10230 // FIXME: It is not clear whether we want to build an lvalue reference 10231 // to the DeclRefType or to CaptureType.getNonReferenceType(). GCC appears 10232 // to do the former, while EDG does the latter. Core issue 1249 will 10233 // clarify, but for now we follow GCC because it's a more permissive and 10234 // easily defensible position. 10235 CaptureType = Context.getLValueReferenceType(DeclRefType); 10236 } else { 10237 // C++11 [expr.prim.lambda]p14: 10238 // For each entity captured by copy, an unnamed non-static 10239 // data member is declared in the closure type. The 10240 // declaration order of these members is unspecified. The type 10241 // of such a data member is the type of the corresponding 10242 // captured entity if the entity is not a reference to an 10243 // object, or the referenced type otherwise. [Note: If the 10244 // captured entity is a reference to a function, the 10245 // corresponding data member is also a reference to a 10246 // function. - end note ] 10247 if (const ReferenceType *RefType = CaptureType->getAs<ReferenceType>()){ 10248 if (!RefType->getPointeeType()->isFunctionType()) 10249 CaptureType = RefType->getPointeeType(); 10250 } 10251 10252 // Forbid the lambda copy-capture of autoreleasing variables. 10253 if (CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) { 10254 if (BuildAndDiagnose) { 10255 Diag(Loc, diag::err_arc_autoreleasing_capture) << /*lambda*/ 1; 10256 Diag(Var->getLocation(), diag::note_previous_decl) 10257 << Var->getDeclName(); 10258 } 10259 return true; 10260 } 10261 } 10262 10263 // Capture this variable in the lambda. 10264 Expr *CopyExpr = 0; 10265 if (BuildAndDiagnose) { 10266 ExprResult Result = captureInLambda(*this, LSI, Var, CaptureType, 10267 DeclRefType, Loc); 10268 if (!Result.isInvalid()) 10269 CopyExpr = Result.take(); 10270 } 10271 10272 // Compute the type of a reference to this captured variable. 10273 if (ByRef) 10274 DeclRefType = CaptureType.getNonReferenceType(); 10275 else { 10276 // C++ [expr.prim.lambda]p5: 10277 // The closure type for a lambda-expression has a public inline 10278 // function call operator [...]. This function call operator is 10279 // declared const (9.3.1) if and only if the lambda-expressions 10280 // parameter-declaration-clause is not followed by mutable. 10281 DeclRefType = CaptureType.getNonReferenceType(); 10282 if (!LSI->Mutable && !CaptureType->isReferenceType()) 10283 DeclRefType.addConst(); 10284 } 10285 10286 // Add the capture. 10287 if (BuildAndDiagnose) 10288 CSI->addCapture(Var, /*IsBlock=*/false, ByRef, Nested, Loc, 10289 EllipsisLoc, CaptureType, CopyExpr); 10290 Nested = true; 10291 } 10292 10293 return false; 10294 } 10295 10296 bool Sema::tryCaptureVariable(VarDecl *Var, SourceLocation Loc, 10297 TryCaptureKind Kind, SourceLocation EllipsisLoc) { 10298 QualType CaptureType; 10299 QualType DeclRefType; 10300 return tryCaptureVariable(Var, Loc, Kind, EllipsisLoc, 10301 /*BuildAndDiagnose=*/true, CaptureType, 10302 DeclRefType); 10303 } 10304 10305 QualType Sema::getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc) { 10306 QualType CaptureType; 10307 QualType DeclRefType; 10308 10309 // Determine whether we can capture this variable. 10310 if (tryCaptureVariable(Var, Loc, TryCapture_Implicit, SourceLocation(), 10311 /*BuildAndDiagnose=*/false, CaptureType, DeclRefType)) 10312 return QualType(); 10313 10314 return DeclRefType; 10315 } 10316 10317 static void MarkVarDeclODRUsed(Sema &SemaRef, VarDecl *Var, 10318 SourceLocation Loc) { 10319 // Keep track of used but undefined variables. 10320 // FIXME: We shouldn't suppress this warning for static data members. 10321 if (Var->hasDefinition(SemaRef.Context) == VarDecl::DeclarationOnly && 10322 Var->getLinkage() != ExternalLinkage && 10323 !(Var->isStaticDataMember() && Var->hasInit())) { 10324 SourceLocation &old = SemaRef.UndefinedInternals[Var->getCanonicalDecl()]; 10325 if (old.isInvalid()) old = Loc; 10326 } 10327 10328 SemaRef.tryCaptureVariable(Var, Loc); 10329 10330 Var->setUsed(true); 10331 } 10332 10333 void Sema::UpdateMarkingForLValueToRValue(Expr *E) { 10334 // Per C++11 [basic.def.odr], a variable is odr-used "unless it is 10335 // an object that satisfies the requirements for appearing in a 10336 // constant expression (5.19) and the lvalue-to-rvalue conversion (4.1) 10337 // is immediately applied." This function handles the lvalue-to-rvalue 10338 // conversion part. 10339 MaybeODRUseExprs.erase(E->IgnoreParens()); 10340 } 10341 10342 ExprResult Sema::ActOnConstantExpression(ExprResult Res) { 10343 if (!Res.isUsable()) 10344 return Res; 10345 10346 // If a constant-expression is a reference to a variable where we delay 10347 // deciding whether it is an odr-use, just assume we will apply the 10348 // lvalue-to-rvalue conversion. In the one case where this doesn't happen 10349 // (a non-type template argument), we have special handling anyway. 10350 UpdateMarkingForLValueToRValue(Res.get()); 10351 return Res; 10352 } 10353 10354 void Sema::CleanupVarDeclMarking() { 10355 for (llvm::SmallPtrSetIterator<Expr*> i = MaybeODRUseExprs.begin(), 10356 e = MaybeODRUseExprs.end(); 10357 i != e; ++i) { 10358 VarDecl *Var; 10359 SourceLocation Loc; 10360 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(*i)) { 10361 Var = cast<VarDecl>(DRE->getDecl()); 10362 Loc = DRE->getLocation(); 10363 } else if (MemberExpr *ME = dyn_cast<MemberExpr>(*i)) { 10364 Var = cast<VarDecl>(ME->getMemberDecl()); 10365 Loc = ME->getMemberLoc(); 10366 } else { 10367 llvm_unreachable("Unexpcted expression"); 10368 } 10369 10370 MarkVarDeclODRUsed(*this, Var, Loc); 10371 } 10372 10373 MaybeODRUseExprs.clear(); 10374 } 10375 10376 // Mark a VarDecl referenced, and perform the necessary handling to compute 10377 // odr-uses. 10378 static void DoMarkVarDeclReferenced(Sema &SemaRef, SourceLocation Loc, 10379 VarDecl *Var, Expr *E) { 10380 Var->setReferenced(); 10381 10382 if (!IsPotentiallyEvaluatedContext(SemaRef)) 10383 return; 10384 10385 // Implicit instantiation of static data members of class templates. 10386 if (Var->isStaticDataMember() && Var->getInstantiatedFromStaticDataMember()) { 10387 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo(); 10388 assert(MSInfo && "Missing member specialization information?"); 10389 bool AlreadyInstantiated = !MSInfo->getPointOfInstantiation().isInvalid(); 10390 if (MSInfo->getTemplateSpecializationKind() == TSK_ImplicitInstantiation && 10391 (!AlreadyInstantiated || 10392 Var->isUsableInConstantExpressions(SemaRef.Context))) { 10393 if (!AlreadyInstantiated) { 10394 // This is a modification of an existing AST node. Notify listeners. 10395 if (ASTMutationListener *L = SemaRef.getASTMutationListener()) 10396 L->StaticDataMemberInstantiated(Var); 10397 MSInfo->setPointOfInstantiation(Loc); 10398 } 10399 SourceLocation PointOfInstantiation = MSInfo->getPointOfInstantiation(); 10400 if (Var->isUsableInConstantExpressions(SemaRef.Context)) 10401 // Do not defer instantiations of variables which could be used in a 10402 // constant expression. 10403 SemaRef.InstantiateStaticDataMemberDefinition(PointOfInstantiation,Var); 10404 else 10405 SemaRef.PendingInstantiations.push_back( 10406 std::make_pair(Var, PointOfInstantiation)); 10407 } 10408 } 10409 10410 // Per C++11 [basic.def.odr], a variable is odr-used "unless it is 10411 // an object that satisfies the requirements for appearing in a 10412 // constant expression (5.19) and the lvalue-to-rvalue conversion (4.1) 10413 // is immediately applied." We check the first part here, and 10414 // Sema::UpdateMarkingForLValueToRValue deals with the second part. 10415 // Note that we use the C++11 definition everywhere because nothing in 10416 // C++03 depends on whether we get the C++03 version correct. This does not 10417 // apply to references, since they are not objects. 10418 const VarDecl *DefVD; 10419 if (E && !isa<ParmVarDecl>(Var) && !Var->getType()->isReferenceType() && 10420 Var->isUsableInConstantExpressions(SemaRef.Context) && 10421 Var->getAnyInitializer(DefVD) && DefVD->checkInitIsICE()) 10422 SemaRef.MaybeODRUseExprs.insert(E); 10423 else 10424 MarkVarDeclODRUsed(SemaRef, Var, Loc); 10425 } 10426 10427 /// \brief Mark a variable referenced, and check whether it is odr-used 10428 /// (C++ [basic.def.odr]p2, C99 6.9p3). Note that this should not be 10429 /// used directly for normal expressions referring to VarDecl. 10430 void Sema::MarkVariableReferenced(SourceLocation Loc, VarDecl *Var) { 10431 DoMarkVarDeclReferenced(*this, Loc, Var, 0); 10432 } 10433 10434 static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, 10435 Decl *D, Expr *E) { 10436 if (VarDecl *Var = dyn_cast<VarDecl>(D)) { 10437 DoMarkVarDeclReferenced(SemaRef, Loc, Var, E); 10438 return; 10439 } 10440 10441 SemaRef.MarkAnyDeclReferenced(Loc, D); 10442 } 10443 10444 /// \brief Perform reference-marking and odr-use handling for a DeclRefExpr. 10445 void Sema::MarkDeclRefReferenced(DeclRefExpr *E) { 10446 MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E); 10447 } 10448 10449 /// \brief Perform reference-marking and odr-use handling for a MemberExpr. 10450 void Sema::MarkMemberReferenced(MemberExpr *E) { 10451 MarkExprReferenced(*this, E->getMemberLoc(), E->getMemberDecl(), E); 10452 } 10453 10454 /// \brief Perform marking for a reference to an arbitrary declaration. It 10455 /// marks the declaration referenced, and performs odr-use checking for functions 10456 /// and variables. This method should not be used when building an normal 10457 /// expression which refers to a variable. 10458 void Sema::MarkAnyDeclReferenced(SourceLocation Loc, Decl *D) { 10459 if (VarDecl *VD = dyn_cast<VarDecl>(D)) 10460 MarkVariableReferenced(Loc, VD); 10461 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 10462 MarkFunctionReferenced(Loc, FD); 10463 else 10464 D->setReferenced(); 10465 } 10466 10467 namespace { 10468 // Mark all of the declarations referenced 10469 // FIXME: Not fully implemented yet! We need to have a better understanding 10470 // of when we're entering 10471 class MarkReferencedDecls : public RecursiveASTVisitor<MarkReferencedDecls> { 10472 Sema &S; 10473 SourceLocation Loc; 10474 10475 public: 10476 typedef RecursiveASTVisitor<MarkReferencedDecls> Inherited; 10477 10478 MarkReferencedDecls(Sema &S, SourceLocation Loc) : S(S), Loc(Loc) { } 10479 10480 bool TraverseTemplateArgument(const TemplateArgument &Arg); 10481 bool TraverseRecordType(RecordType *T); 10482 }; 10483 } 10484 10485 bool MarkReferencedDecls::TraverseTemplateArgument( 10486 const TemplateArgument &Arg) { 10487 if (Arg.getKind() == TemplateArgument::Declaration) { 10488 if (Decl *D = Arg.getAsDecl()) 10489 S.MarkAnyDeclReferenced(Loc, D); 10490 } 10491 10492 return Inherited::TraverseTemplateArgument(Arg); 10493 } 10494 10495 bool MarkReferencedDecls::TraverseRecordType(RecordType *T) { 10496 if (ClassTemplateSpecializationDecl *Spec 10497 = dyn_cast<ClassTemplateSpecializationDecl>(T->getDecl())) { 10498 const TemplateArgumentList &Args = Spec->getTemplateArgs(); 10499 return TraverseTemplateArguments(Args.data(), Args.size()); 10500 } 10501 10502 return true; 10503 } 10504 10505 void Sema::MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T) { 10506 MarkReferencedDecls Marker(*this, Loc); 10507 Marker.TraverseType(Context.getCanonicalType(T)); 10508 } 10509 10510 namespace { 10511 /// \brief Helper class that marks all of the declarations referenced by 10512 /// potentially-evaluated subexpressions as "referenced". 10513 class EvaluatedExprMarker : public EvaluatedExprVisitor<EvaluatedExprMarker> { 10514 Sema &S; 10515 bool SkipLocalVariables; 10516 10517 public: 10518 typedef EvaluatedExprVisitor<EvaluatedExprMarker> Inherited; 10519 10520 EvaluatedExprMarker(Sema &S, bool SkipLocalVariables) 10521 : Inherited(S.Context), S(S), SkipLocalVariables(SkipLocalVariables) { } 10522 10523 void VisitDeclRefExpr(DeclRefExpr *E) { 10524 // If we were asked not to visit local variables, don't. 10525 if (SkipLocalVariables) { 10526 if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) 10527 if (VD->hasLocalStorage()) 10528 return; 10529 } 10530 10531 S.MarkDeclRefReferenced(E); 10532 } 10533 10534 void VisitMemberExpr(MemberExpr *E) { 10535 S.MarkMemberReferenced(E); 10536 Inherited::VisitMemberExpr(E); 10537 } 10538 10539 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 10540 S.MarkFunctionReferenced(E->getLocStart(), 10541 const_cast<CXXDestructorDecl*>(E->getTemporary()->getDestructor())); 10542 Visit(E->getSubExpr()); 10543 } 10544 10545 void VisitCXXNewExpr(CXXNewExpr *E) { 10546 if (E->getOperatorNew()) 10547 S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorNew()); 10548 if (E->getOperatorDelete()) 10549 S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorDelete()); 10550 Inherited::VisitCXXNewExpr(E); 10551 } 10552 10553 void VisitCXXDeleteExpr(CXXDeleteExpr *E) { 10554 if (E->getOperatorDelete()) 10555 S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorDelete()); 10556 QualType Destroyed = S.Context.getBaseElementType(E->getDestroyedType()); 10557 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) { 10558 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl()); 10559 S.MarkFunctionReferenced(E->getLocStart(), 10560 S.LookupDestructor(Record)); 10561 } 10562 10563 Inherited::VisitCXXDeleteExpr(E); 10564 } 10565 10566 void VisitCXXConstructExpr(CXXConstructExpr *E) { 10567 S.MarkFunctionReferenced(E->getLocStart(), E->getConstructor()); 10568 Inherited::VisitCXXConstructExpr(E); 10569 } 10570 10571 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 10572 Visit(E->getExpr()); 10573 } 10574 10575 void VisitImplicitCastExpr(ImplicitCastExpr *E) { 10576 Inherited::VisitImplicitCastExpr(E); 10577 10578 if (E->getCastKind() == CK_LValueToRValue) 10579 S.UpdateMarkingForLValueToRValue(E->getSubExpr()); 10580 } 10581 }; 10582 } 10583 10584 /// \brief Mark any declarations that appear within this expression or any 10585 /// potentially-evaluated subexpressions as "referenced". 10586 /// 10587 /// \param SkipLocalVariables If true, don't mark local variables as 10588 /// 'referenced'. 10589 void Sema::MarkDeclarationsReferencedInExpr(Expr *E, 10590 bool SkipLocalVariables) { 10591 EvaluatedExprMarker(*this, SkipLocalVariables).Visit(E); 10592 } 10593 10594 /// \brief Emit a diagnostic that describes an effect on the run-time behavior 10595 /// of the program being compiled. 10596 /// 10597 /// This routine emits the given diagnostic when the code currently being 10598 /// type-checked is "potentially evaluated", meaning that there is a 10599 /// possibility that the code will actually be executable. Code in sizeof() 10600 /// expressions, code used only during overload resolution, etc., are not 10601 /// potentially evaluated. This routine will suppress such diagnostics or, 10602 /// in the absolutely nutty case of potentially potentially evaluated 10603 /// expressions (C++ typeid), queue the diagnostic to potentially emit it 10604 /// later. 10605 /// 10606 /// This routine should be used for all diagnostics that describe the run-time 10607 /// behavior of a program, such as passing a non-POD value through an ellipsis. 10608 /// Failure to do so will likely result in spurious diagnostics or failures 10609 /// during overload resolution or within sizeof/alignof/typeof/typeid. 10610 bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, 10611 const PartialDiagnostic &PD) { 10612 switch (ExprEvalContexts.back().Context) { 10613 case Unevaluated: 10614 // The argument will never be evaluated, so don't complain. 10615 break; 10616 10617 case ConstantEvaluated: 10618 // Relevant diagnostics should be produced by constant evaluation. 10619 break; 10620 10621 case PotentiallyEvaluated: 10622 case PotentiallyEvaluatedIfUsed: 10623 if (Statement && getCurFunctionOrMethodDecl()) { 10624 FunctionScopes.back()->PossiblyUnreachableDiags. 10625 push_back(sema::PossiblyUnreachableDiag(PD, Loc, Statement)); 10626 } 10627 else 10628 Diag(Loc, PD); 10629 10630 return true; 10631 } 10632 10633 return false; 10634 } 10635 10636 bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc, 10637 CallExpr *CE, FunctionDecl *FD) { 10638 if (ReturnType->isVoidType() || !ReturnType->isIncompleteType()) 10639 return false; 10640 10641 // If we're inside a decltype's expression, don't check for a valid return 10642 // type or construct temporaries until we know whether this is the last call. 10643 if (ExprEvalContexts.back().IsDecltype) { 10644 ExprEvalContexts.back().DelayedDecltypeCalls.push_back(CE); 10645 return false; 10646 } 10647 10648 PartialDiagnostic Note = 10649 FD ? PDiag(diag::note_function_with_incomplete_return_type_declared_here) 10650 << FD->getDeclName() : PDiag(); 10651 SourceLocation NoteLoc = FD ? FD->getLocation() : SourceLocation(); 10652 10653 if (RequireCompleteType(Loc, ReturnType, 10654 FD ? 10655 PDiag(diag::err_call_function_incomplete_return) 10656 << CE->getSourceRange() << FD->getDeclName() : 10657 PDiag(diag::err_call_incomplete_return) 10658 << CE->getSourceRange(), 10659 std::make_pair(NoteLoc, Note))) 10660 return true; 10661 10662 return false; 10663 } 10664 10665 // Diagnose the s/=/==/ and s/\|=/!=/ typos. Note that adding parentheses 10666 // will prevent this condition from triggering, which is what we want. 10667 void Sema::DiagnoseAssignmentAsCondition(Expr *E) { 10668 SourceLocation Loc; 10669 10670 unsigned diagnostic = diag::warn_condition_is_assignment; 10671 bool IsOrAssign = false; 10672 10673 if (BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) { 10674 if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign) 10675 return; 10676 10677 IsOrAssign = Op->getOpcode() == BO_OrAssign; 10678 10679 // Greylist some idioms by putting them into a warning subcategory. 10680 if (ObjCMessageExpr *ME 10681 = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) { 10682 Selector Sel = ME->getSelector(); 10683 10684 // self = [<foo> init...] 10685 if (isSelfExpr(Op->getLHS()) && Sel.getNameForSlot(0).startswith("init")) 10686 diagnostic = diag::warn_condition_is_idiomatic_assignment; 10687 10688 // <foo> = [<bar> nextObject] 10689 else if (Sel.isUnarySelector() && Sel.getNameForSlot(0) == "nextObject") 10690 diagnostic = diag::warn_condition_is_idiomatic_assignment; 10691 } 10692 10693 Loc = Op->getOperatorLoc(); 10694 } else if (CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) { 10695 if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual) 10696 return; 10697 10698 IsOrAssign = Op->getOperator() == OO_PipeEqual; 10699 Loc = Op->getOperatorLoc(); 10700 } else { 10701 // Not an assignment. 10702 return; 10703 } 10704 10705 Diag(Loc, diagnostic) << E->getSourceRange(); 10706 10707 SourceLocation Open = E->getLocStart(); 10708 SourceLocation Close = PP.getLocForEndOfToken(E->getSourceRange().getEnd()); 10709 Diag(Loc, diag::note_condition_assign_silence) 10710 << FixItHint::CreateInsertion(Open, "(") 10711 << FixItHint::CreateInsertion(Close, ")"); 10712 10713 if (IsOrAssign) 10714 Diag(Loc, diag::note_condition_or_assign_to_comparison) 10715 << FixItHint::CreateReplacement(Loc, "!="); 10716 else 10717 Diag(Loc, diag::note_condition_assign_to_comparison) 10718 << FixItHint::CreateReplacement(Loc, "=="); 10719 } 10720 10721 /// \brief Redundant parentheses over an equality comparison can indicate 10722 /// that the user intended an assignment used as condition. 10723 void Sema::DiagnoseEqualityWithExtraParens(ParenExpr *ParenE) { 10724 // Don't warn if the parens came from a macro. 10725 SourceLocation parenLoc = ParenE->getLocStart(); 10726 if (parenLoc.isInvalid() || parenLoc.isMacroID()) 10727 return; 10728 // Don't warn for dependent expressions. 10729 if (ParenE->isTypeDependent()) 10730 return; 10731 10732 Expr *E = ParenE->IgnoreParens(); 10733 10734 if (BinaryOperator *opE = dyn_cast<BinaryOperator>(E)) 10735 if (opE->getOpcode() == BO_EQ && 10736 opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context) 10737 == Expr::MLV_Valid) { 10738 SourceLocation Loc = opE->getOperatorLoc(); 10739 10740 Diag(Loc, diag::warn_equality_with_extra_parens) << E->getSourceRange(); 10741 SourceRange ParenERange = ParenE->getSourceRange(); 10742 Diag(Loc, diag::note_equality_comparison_silence) 10743 << FixItHint::CreateRemoval(ParenERange.getBegin()) 10744 << FixItHint::CreateRemoval(ParenERange.getEnd()); 10745 Diag(Loc, diag::note_equality_comparison_to_assign) 10746 << FixItHint::CreateReplacement(Loc, "="); 10747 } 10748 } 10749 10750 ExprResult Sema::CheckBooleanCondition(Expr *E, SourceLocation Loc) { 10751 DiagnoseAssignmentAsCondition(E); 10752 if (ParenExpr *parenE = dyn_cast<ParenExpr>(E)) 10753 DiagnoseEqualityWithExtraParens(parenE); 10754 10755 ExprResult result = CheckPlaceholderExpr(E); 10756 if (result.isInvalid()) return ExprError(); 10757 E = result.take(); 10758 10759 if (!E->isTypeDependent()) { 10760 if (getLangOpts().CPlusPlus) 10761 return CheckCXXBooleanCondition(E); // C++ 6.4p4 10762 10763 ExprResult ERes = DefaultFunctionArrayLvalueConversion(E); 10764 if (ERes.isInvalid()) 10765 return ExprError(); 10766 E = ERes.take(); 10767 10768 QualType T = E->getType(); 10769 if (!T->isScalarType()) { // C99 6.8.4.1p1 10770 Diag(Loc, diag::err_typecheck_statement_requires_scalar) 10771 << T << E->getSourceRange(); 10772 return ExprError(); 10773 } 10774 } 10775 10776 return Owned(E); 10777 } 10778 10779 ExprResult Sema::ActOnBooleanCondition(Scope *S, SourceLocation Loc, 10780 Expr *SubExpr) { 10781 if (!SubExpr) 10782 return ExprError(); 10783 10784 return CheckBooleanCondition(SubExpr, Loc); 10785 } 10786 10787 namespace { 10788 /// A visitor for rebuilding a call to an __unknown_any expression 10789 /// to have an appropriate type. 10790 struct RebuildUnknownAnyFunction 10791 : StmtVisitor<RebuildUnknownAnyFunction, ExprResult> { 10792 10793 Sema &S; 10794 10795 RebuildUnknownAnyFunction(Sema &S) : S(S) {} 10796 10797 ExprResult VisitStmt(Stmt *S) { 10798 llvm_unreachable("unexpected statement!"); 10799 } 10800 10801 ExprResult VisitExpr(Expr *E) { 10802 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_call) 10803 << E->getSourceRange(); 10804 return ExprError(); 10805 } 10806 10807 /// Rebuild an expression which simply semantically wraps another 10808 /// expression which it shares the type and value kind of. 10809 template <class T> ExprResult rebuildSugarExpr(T *E) { 10810 ExprResult SubResult = Visit(E->getSubExpr()); 10811 if (SubResult.isInvalid()) return ExprError(); 10812 10813 Expr *SubExpr = SubResult.take(); 10814 E->setSubExpr(SubExpr); 10815 E->setType(SubExpr->getType()); 10816 E->setValueKind(SubExpr->getValueKind()); 10817 assert(E->getObjectKind() == OK_Ordinary); 10818 return E; 10819 } 10820 10821 ExprResult VisitParenExpr(ParenExpr *E) { 10822 return rebuildSugarExpr(E); 10823 } 10824 10825 ExprResult VisitUnaryExtension(UnaryOperator *E) { 10826 return rebuildSugarExpr(E); 10827 } 10828 10829 ExprResult VisitUnaryAddrOf(UnaryOperator *E) { 10830 ExprResult SubResult = Visit(E->getSubExpr()); 10831 if (SubResult.isInvalid()) return ExprError(); 10832 10833 Expr *SubExpr = SubResult.take(); 10834 E->setSubExpr(SubExpr); 10835 E->setType(S.Context.getPointerType(SubExpr->getType())); 10836 assert(E->getValueKind() == VK_RValue); 10837 assert(E->getObjectKind() == OK_Ordinary); 10838 return E; 10839 } 10840 10841 ExprResult resolveDecl(Expr *E, ValueDecl *VD) { 10842 if (!isa<FunctionDecl>(VD)) return VisitExpr(E); 10843 10844 E->setType(VD->getType()); 10845 10846 assert(E->getValueKind() == VK_RValue); 10847 if (S.getLangOpts().CPlusPlus && 10848 !(isa<CXXMethodDecl>(VD) && 10849 cast<CXXMethodDecl>(VD)->isInstance())) 10850 E->setValueKind(VK_LValue); 10851 10852 return E; 10853 } 10854 10855 ExprResult VisitMemberExpr(MemberExpr *E) { 10856 return resolveDecl(E, E->getMemberDecl()); 10857 } 10858 10859 ExprResult VisitDeclRefExpr(DeclRefExpr *E) { 10860 return resolveDecl(E, E->getDecl()); 10861 } 10862 }; 10863 } 10864 10865 /// Given a function expression of unknown-any type, try to rebuild it 10866 /// to have a function type. 10867 static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *FunctionExpr) { 10868 ExprResult Result = RebuildUnknownAnyFunction(S).Visit(FunctionExpr); 10869 if (Result.isInvalid()) return ExprError(); 10870 return S.DefaultFunctionArrayConversion(Result.take()); 10871 } 10872 10873 namespace { 10874 /// A visitor for rebuilding an expression of type __unknown_anytype 10875 /// into one which resolves the type directly on the referring 10876 /// expression. Strict preservation of the original source 10877 /// structure is not a goal. 10878 struct RebuildUnknownAnyExpr 10879 : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> { 10880 10881 Sema &S; 10882 10883 /// The current destination type. 10884 QualType DestType; 10885 10886 RebuildUnknownAnyExpr(Sema &S, QualType CastType) 10887 : S(S), DestType(CastType) {} 10888 10889 ExprResult VisitStmt(Stmt *S) { 10890 llvm_unreachable("unexpected statement!"); 10891 } 10892 10893 ExprResult VisitExpr(Expr *E) { 10894 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr) 10895 << E->getSourceRange(); 10896 return ExprError(); 10897 } 10898 10899 ExprResult VisitCallExpr(CallExpr *E); 10900 ExprResult VisitObjCMessageExpr(ObjCMessageExpr *E); 10901 10902 /// Rebuild an expression which simply semantically wraps another 10903 /// expression which it shares the type and value kind of. 10904 template <class T> ExprResult rebuildSugarExpr(T *E) { 10905 ExprResult SubResult = Visit(E->getSubExpr()); 10906 if (SubResult.isInvalid()) return ExprError(); 10907 Expr *SubExpr = SubResult.take(); 10908 E->setSubExpr(SubExpr); 10909 E->setType(SubExpr->getType()); 10910 E->setValueKind(SubExpr->getValueKind()); 10911 assert(E->getObjectKind() == OK_Ordinary); 10912 return E; 10913 } 10914 10915 ExprResult VisitParenExpr(ParenExpr *E) { 10916 return rebuildSugarExpr(E); 10917 } 10918 10919 ExprResult VisitUnaryExtension(UnaryOperator *E) { 10920 return rebuildSugarExpr(E); 10921 } 10922 10923 ExprResult VisitUnaryAddrOf(UnaryOperator *E) { 10924 const PointerType *Ptr = DestType->getAs<PointerType>(); 10925 if (!Ptr) { 10926 S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof) 10927 << E->getSourceRange(); 10928 return ExprError(); 10929 } 10930 assert(E->getValueKind() == VK_RValue); 10931 assert(E->getObjectKind() == OK_Ordinary); 10932 E->setType(DestType); 10933 10934 // Build the sub-expression as if it were an object of the pointee type. 10935 DestType = Ptr->getPointeeType(); 10936 ExprResult SubResult = Visit(E->getSubExpr()); 10937 if (SubResult.isInvalid()) return ExprError(); 10938 E->setSubExpr(SubResult.take()); 10939 return E; 10940 } 10941 10942 ExprResult VisitImplicitCastExpr(ImplicitCastExpr *E); 10943 10944 ExprResult resolveDecl(Expr *E, ValueDecl *VD); 10945 10946 ExprResult VisitMemberExpr(MemberExpr *E) { 10947 return resolveDecl(E, E->getMemberDecl()); 10948 } 10949 10950 ExprResult VisitDeclRefExpr(DeclRefExpr *E) { 10951 return resolveDecl(E, E->getDecl()); 10952 } 10953 }; 10954 } 10955 10956 /// Rebuilds a call expression which yielded __unknown_anytype. 10957 ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) { 10958 Expr *CalleeExpr = E->getCallee(); 10959 10960 enum FnKind { 10961 FK_MemberFunction, 10962 FK_FunctionPointer, 10963 FK_BlockPointer 10964 }; 10965 10966 FnKind Kind; 10967 QualType CalleeType = CalleeExpr->getType(); 10968 if (CalleeType == S.Context.BoundMemberTy) { 10969 assert(isa<CXXMemberCallExpr>(E) || isa<CXXOperatorCallExpr>(E)); 10970 Kind = FK_MemberFunction; 10971 CalleeType = Expr::findBoundMemberType(CalleeExpr); 10972 } else if (const PointerType *Ptr = CalleeType->getAs<PointerType>()) { 10973 CalleeType = Ptr->getPointeeType(); 10974 Kind = FK_FunctionPointer; 10975 } else { 10976 CalleeType = CalleeType->castAs<BlockPointerType>()->getPointeeType(); 10977 Kind = FK_BlockPointer; 10978 } 10979 const FunctionType *FnType = CalleeType->castAs<FunctionType>(); 10980 10981 // Verify that this is a legal result type of a function. 10982 if (DestType->isArrayType() || DestType->isFunctionType()) { 10983 unsigned diagID = diag::err_func_returning_array_function; 10984 if (Kind == FK_BlockPointer) 10985 diagID = diag::err_block_returning_array_function; 10986 10987 S.Diag(E->getExprLoc(), diagID) 10988 << DestType->isFunctionType() << DestType; 10989 return ExprError(); 10990 } 10991 10992 // Otherwise, go ahead and set DestType as the call's result. 10993 E->setType(DestType.getNonLValueExprType(S.Context)); 10994 E->setValueKind(Expr::getValueKindForType(DestType)); 10995 assert(E->getObjectKind() == OK_Ordinary); 10996 10997 // Rebuild the function type, replacing the result type with DestType. 10998 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FnType)) 10999 DestType = S.Context.getFunctionType(DestType, 11000 Proto->arg_type_begin(), 11001 Proto->getNumArgs(), 11002 Proto->getExtProtoInfo()); 11003 else 11004 DestType = S.Context.getFunctionNoProtoType(DestType, 11005 FnType->getExtInfo()); 11006 11007 // Rebuild the appropriate pointer-to-function type. 11008 switch (Kind) { 11009 case FK_MemberFunction: 11010 // Nothing to do. 11011 break; 11012 11013 case FK_FunctionPointer: 11014 DestType = S.Context.getPointerType(DestType); 11015 break; 11016 11017 case FK_BlockPointer: 11018 DestType = S.Context.getBlockPointerType(DestType); 11019 break; 11020 } 11021 11022 // Finally, we can recurse. 11023 ExprResult CalleeResult = Visit(CalleeExpr); 11024 if (!CalleeResult.isUsable()) return ExprError(); 11025 E->setCallee(CalleeResult.take()); 11026 11027 // Bind a temporary if necessary. 11028 return S.MaybeBindToTemporary(E); 11029 } 11030 11031 ExprResult RebuildUnknownAnyExpr::VisitObjCMessageExpr(ObjCMessageExpr *E) { 11032 // Verify that this is a legal result type of a call. 11033 if (DestType->isArrayType() || DestType->isFunctionType()) { 11034 S.Diag(E->getExprLoc(), diag::err_func_returning_array_function) 11035 << DestType->isFunctionType() << DestType; 11036 return ExprError(); 11037 } 11038 11039 // Rewrite the method result type if available. 11040 if (ObjCMethodDecl *Method = E->getMethodDecl()) { 11041 assert(Method->getResultType() == S.Context.UnknownAnyTy); 11042 Method->setResultType(DestType); 11043 } 11044 11045 // Change the type of the message. 11046 E->setType(DestType.getNonReferenceType()); 11047 E->setValueKind(Expr::getValueKindForType(DestType)); 11048 11049 return S.MaybeBindToTemporary(E); 11050 } 11051 11052 ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *E) { 11053 // The only case we should ever see here is a function-to-pointer decay. 11054 if (E->getCastKind() == CK_FunctionToPointerDecay) { 11055 assert(E->getValueKind() == VK_RValue); 11056 assert(E->getObjectKind() == OK_Ordinary); 11057 11058 E->setType(DestType); 11059 11060 // Rebuild the sub-expression as the pointee (function) type. 11061 DestType = DestType->castAs<PointerType>()->getPointeeType(); 11062 11063 ExprResult Result = Visit(E->getSubExpr()); 11064 if (!Result.isUsable()) return ExprError(); 11065 11066 E->setSubExpr(Result.take()); 11067 return S.Owned(E); 11068 } else if (E->getCastKind() == CK_LValueToRValue) { 11069 assert(E->getValueKind() == VK_RValue); 11070 assert(E->getObjectKind() == OK_Ordinary); 11071 11072 assert(isa<BlockPointerType>(E->getType())); 11073 11074 E->setType(DestType); 11075 11076 // The sub-expression has to be a lvalue reference, so rebuild it as such. 11077 DestType = S.Context.getLValueReferenceType(DestType); 11078 11079 ExprResult Result = Visit(E->getSubExpr()); 11080 if (!Result.isUsable()) return ExprError(); 11081 11082 E->setSubExpr(Result.take()); 11083 return S.Owned(E); 11084 } else { 11085 llvm_unreachable("Unhandled cast type!"); 11086 } 11087 } 11088 11089 ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) { 11090 ExprValueKind ValueKind = VK_LValue; 11091 QualType Type = DestType; 11092 11093 // We know how to make this work for certain kinds of decls: 11094 11095 // - functions 11096 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(VD)) { 11097 if (const PointerType *Ptr = Type->getAs<PointerType>()) { 11098 DestType = Ptr->getPointeeType(); 11099 ExprResult Result = resolveDecl(E, VD); 11100 if (Result.isInvalid()) return ExprError(); 11101 return S.ImpCastExprToType(Result.take(), Type, 11102 CK_FunctionToPointerDecay, VK_RValue); 11103 } 11104 11105 if (!Type->isFunctionType()) { 11106 S.Diag(E->getExprLoc(), diag::err_unknown_any_function) 11107 << VD << E->getSourceRange(); 11108 return ExprError(); 11109 } 11110 11111 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) 11112 if (MD->isInstance()) { 11113 ValueKind = VK_RValue; 11114 Type = S.Context.BoundMemberTy; 11115 } 11116 11117 // Function references aren't l-values in C. 11118 if (!S.getLangOpts().CPlusPlus) 11119 ValueKind = VK_RValue; 11120 11121 // - variables 11122 } else if (isa<VarDecl>(VD)) { 11123 if (const ReferenceType *RefTy = Type->getAs<ReferenceType>()) { 11124 Type = RefTy->getPointeeType(); 11125 } else if (Type->isFunctionType()) { 11126 S.Diag(E->getExprLoc(), diag::err_unknown_any_var_function_type) 11127 << VD << E->getSourceRange(); 11128 return ExprError(); 11129 } 11130 11131 // - nothing else 11132 } else { 11133 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_decl) 11134 << VD << E->getSourceRange(); 11135 return ExprError(); 11136 } 11137 11138 VD->setType(DestType); 11139 E->setType(Type); 11140 E->setValueKind(ValueKind); 11141 return S.Owned(E); 11142 } 11143 11144 /// Check a cast of an unknown-any type. We intentionally only 11145 /// trigger this for C-style casts. 11146 ExprResult Sema::checkUnknownAnyCast(SourceRange TypeRange, QualType CastType, 11147 Expr *CastExpr, CastKind &CastKind, 11148 ExprValueKind &VK, CXXCastPath &Path) { 11149 // Rewrite the casted expression from scratch. 11150 ExprResult result = RebuildUnknownAnyExpr(*this, CastType).Visit(CastExpr); 11151 if (!result.isUsable()) return ExprError(); 11152 11153 CastExpr = result.take(); 11154 VK = CastExpr->getValueKind(); 11155 CastKind = CK_NoOp; 11156 11157 return CastExpr; 11158 } 11159 11160 ExprResult Sema::forceUnknownAnyToType(Expr *E, QualType ToType) { 11161 return RebuildUnknownAnyExpr(*this, ToType).Visit(E); 11162 } 11163 11164 static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) { 11165 Expr *orig = E; 11166 unsigned diagID = diag::err_uncasted_use_of_unknown_any; 11167 while (true) { 11168 E = E->IgnoreParenImpCasts(); 11169 if (CallExpr *call = dyn_cast<CallExpr>(E)) { 11170 E = call->getCallee(); 11171 diagID = diag::err_uncasted_call_of_unknown_any; 11172 } else { 11173 break; 11174 } 11175 } 11176 11177 SourceLocation loc; 11178 NamedDecl *d; 11179 if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) { 11180 loc = ref->getLocation(); 11181 d = ref->getDecl(); 11182 } else if (MemberExpr *mem = dyn_cast<MemberExpr>(E)) { 11183 loc = mem->getMemberLoc(); 11184 d = mem->getMemberDecl(); 11185 } else if (ObjCMessageExpr *msg = dyn_cast<ObjCMessageExpr>(E)) { 11186 diagID = diag::err_uncasted_call_of_unknown_any; 11187 loc = msg->getSelectorStartLoc(); 11188 d = msg->getMethodDecl(); 11189 if (!d) { 11190 S.Diag(loc, diag::err_uncasted_send_to_unknown_any_method) 11191 << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector() 11192 << orig->getSourceRange(); 11193 return ExprError(); 11194 } 11195 } else { 11196 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr) 11197 << E->getSourceRange(); 11198 return ExprError(); 11199 } 11200 11201 S.Diag(loc, diagID) << d << orig->getSourceRange(); 11202 11203 // Never recoverable. 11204 return ExprError(); 11205 } 11206 11207 /// Check for operands with placeholder types and complain if found. 11208 /// Returns true if there was an error and no recovery was possible. 11209 ExprResult Sema::CheckPlaceholderExpr(Expr *E) { 11210 const BuiltinType *placeholderType = E->getType()->getAsPlaceholderType(); 11211 if (!placeholderType) return Owned(E); 11212 11213 switch (placeholderType->getKind()) { 11214 11215 // Overloaded expressions. 11216 case BuiltinType::Overload: { 11217 // Try to resolve a single function template specialization. 11218 // This is obligatory. 11219 ExprResult result = Owned(E); 11220 if (ResolveAndFixSingleFunctionTemplateSpecialization(result, false)) { 11221 return result; 11222 11223 // If that failed, try to recover with a call. 11224 } else { 11225 tryToRecoverWithCall(result, PDiag(diag::err_ovl_unresolvable), 11226 /*complain*/ true); 11227 return result; 11228 } 11229 } 11230 11231 // Bound member functions. 11232 case BuiltinType::BoundMember: { 11233 ExprResult result = Owned(E); 11234 tryToRecoverWithCall(result, PDiag(diag::err_bound_member_function), 11235 /*complain*/ true); 11236 return result; 11237 } 11238 11239 // ARC unbridged casts. 11240 case BuiltinType::ARCUnbridgedCast: { 11241 Expr *realCast = stripARCUnbridgedCast(E); 11242 diagnoseARCUnbridgedCast(realCast); 11243 return Owned(realCast); 11244 } 11245 11246 // Expressions of unknown type. 11247 case BuiltinType::UnknownAny: 11248 return diagnoseUnknownAnyExpr(*this, E); 11249 11250 // Pseudo-objects. 11251 case BuiltinType::PseudoObject: 11252 return checkPseudoObjectRValue(E); 11253 11254 // Everything else should be impossible. 11255 #define BUILTIN_TYPE(Id, SingletonId) \ 11256 case BuiltinType::Id: 11257 #define PLACEHOLDER_TYPE(Id, SingletonId) 11258 #include "clang/AST/BuiltinTypes.def" 11259 break; 11260 } 11261 11262 llvm_unreachable("invalid placeholder type!"); 11263 } 11264 11265 bool Sema::CheckCaseExpression(Expr *E) { 11266 if (E->isTypeDependent()) 11267 return true; 11268 if (E->isValueDependent() || E->isIntegerConstantExpr(Context)) 11269 return E->getType()->isIntegralOrEnumerationType(); 11270 return false; 11271 } 11272 11273 /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals. 11274 ExprResult 11275 Sema::ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) { 11276 assert((Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) && 11277 "Unknown Objective-C Boolean value!"); 11278 return Owned(new (Context) ObjCBoolLiteralExpr(Kind == tok::kw___objc_yes, 11279 Context.ObjCBuiltinBoolTy, OpLoc)); 11280 } 11281