121 case AR_Deprecated: 122 if (S.getCurContextAvailability() != AR_Deprecated) 123 S.EmitAvailabilityWarning(Sema::AD_Deprecation, 124 D, Message, Loc, UnknownObjCClass, ObjCPDecl, 125 ObjCPropertyAccess); 126 break; 127 128 case AR_Unavailable: 129 if (S.getCurContextAvailability() != AR_Unavailable) 130 S.EmitAvailabilityWarning(Sema::AD_Unavailable, 131 D, Message, Loc, UnknownObjCClass, ObjCPDecl, 132 ObjCPropertyAccess); 133 break; 134 135 } 136 return Result; 137} 138 139/// \brief Emit a note explaining that this function is deleted. 140void Sema::NoteDeletedFunction(FunctionDecl *Decl) { 141 assert(Decl->isDeleted()); 142 143 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Decl); 144 145 if (Method && Method->isDeleted() && Method->isDefaulted()) { 146 // If the method was explicitly defaulted, point at that declaration. 147 if (!Method->isImplicit()) 148 Diag(Decl->getLocation(), diag::note_implicitly_deleted); 149 150 // Try to diagnose why this special member function was implicitly 151 // deleted. This might fail, if that reason no longer applies. 152 CXXSpecialMember CSM = getSpecialMember(Method); 153 if (CSM != CXXInvalid) 154 ShouldDeleteSpecialMember(Method, CSM, /*Diagnose=*/true); 155 156 return; 157 } 158 159 if (CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Decl)) { 160 if (CXXConstructorDecl *BaseCD = 161 const_cast<CXXConstructorDecl*>(CD->getInheritedConstructor())) { 162 Diag(Decl->getLocation(), diag::note_inherited_deleted_here); 163 if (BaseCD->isDeleted()) { 164 NoteDeletedFunction(BaseCD); 165 } else { 166 // FIXME: An explanation of why exactly it can't be inherited 167 // would be nice. 168 Diag(BaseCD->getLocation(), diag::note_cannot_inherit); 169 } 170 return; 171 } 172 } 173 174 Diag(Decl->getLocation(), diag::note_availability_specified_here) 175 << Decl << true; 176} 177 178/// \brief Determine whether a FunctionDecl was ever declared with an 179/// explicit storage class. 180static bool hasAnyExplicitStorageClass(const FunctionDecl *D) { 181 for (auto I : D->redecls()) { 182 if (I->getStorageClass() != SC_None) 183 return true; 184 } 185 return false; 186} 187 188/// \brief Check whether we're in an extern inline function and referring to a 189/// variable or function with internal linkage (C11 6.7.4p3). 190/// 191/// This is only a warning because we used to silently accept this code, but 192/// in many cases it will not behave correctly. This is not enabled in C++ mode 193/// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6) 194/// and so while there may still be user mistakes, most of the time we can't 195/// prove that there are errors. 196static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S, 197 const NamedDecl *D, 198 SourceLocation Loc) { 199 // This is disabled under C++; there are too many ways for this to fire in 200 // contexts where the warning is a false positive, or where it is technically 201 // correct but benign. 202 if (S.getLangOpts().CPlusPlus) 203 return; 204 205 // Check if this is an inlined function or method. 206 FunctionDecl *Current = S.getCurFunctionDecl(); 207 if (!Current) 208 return; 209 if (!Current->isInlined()) 210 return; 211 if (!Current->isExternallyVisible()) 212 return; 213 214 // Check if the decl has internal linkage. 215 if (D->getFormalLinkage() != InternalLinkage) 216 return; 217 218 // Downgrade from ExtWarn to Extension if 219 // (1) the supposedly external inline function is in the main file, 220 // and probably won't be included anywhere else. 221 // (2) the thing we're referencing is a pure function. 222 // (3) the thing we're referencing is another inline function. 223 // This last can give us false negatives, but it's better than warning on 224 // wrappers for simple C library functions. 225 const FunctionDecl *UsedFn = dyn_cast<FunctionDecl>(D); 226 bool DowngradeWarning = S.getSourceManager().isInMainFile(Loc); 227 if (!DowngradeWarning && UsedFn) 228 DowngradeWarning = UsedFn->isInlined() || UsedFn->hasAttr<ConstAttr>(); 229 230 S.Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet 231 : diag::ext_internal_in_extern_inline) 232 << /*IsVar=*/!UsedFn << D; 233 234 S.MaybeSuggestAddingStaticToDecl(Current); 235 236 S.Diag(D->getCanonicalDecl()->getLocation(), diag::note_entity_declared_at) 237 << D; 238} 239 240void Sema::MaybeSuggestAddingStaticToDecl(const FunctionDecl *Cur) { 241 const FunctionDecl *First = Cur->getFirstDecl(); 242 243 // Suggest "static" on the function, if possible. 244 if (!hasAnyExplicitStorageClass(First)) { 245 SourceLocation DeclBegin = First->getSourceRange().getBegin(); 246 Diag(DeclBegin, diag::note_convert_inline_to_static) 247 << Cur << FixItHint::CreateInsertion(DeclBegin, "static "); 248 } 249} 250 251/// \brief Determine whether the use of this declaration is valid, and 252/// emit any corresponding diagnostics. 253/// 254/// This routine diagnoses various problems with referencing 255/// declarations that can occur when using a declaration. For example, 256/// it might warn if a deprecated or unavailable declaration is being 257/// used, or produce an error (and return true) if a C++0x deleted 258/// function is being used. 259/// 260/// \returns true if there was an error (this declaration cannot be 261/// referenced), false otherwise. 262/// 263bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, 264 const ObjCInterfaceDecl *UnknownObjCClass, 265 bool ObjCPropertyAccess) { 266 if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) { 267 // If there were any diagnostics suppressed by template argument deduction, 268 // emit them now. 269 SuppressedDiagnosticsMap::iterator 270 Pos = SuppressedDiagnostics.find(D->getCanonicalDecl()); 271 if (Pos != SuppressedDiagnostics.end()) { 272 SmallVectorImpl<PartialDiagnosticAt> &Suppressed = Pos->second; 273 for (unsigned I = 0, N = Suppressed.size(); I != N; ++I) 274 Diag(Suppressed[I].first, Suppressed[I].second); 275 276 // Clear out the list of suppressed diagnostics, so that we don't emit 277 // them again for this specialization. However, we don't obsolete this 278 // entry from the table, because we want to avoid ever emitting these 279 // diagnostics again. 280 Suppressed.clear(); 281 } 282 283 // C++ [basic.start.main]p3: 284 // The function 'main' shall not be used within a program. 285 if (cast<FunctionDecl>(D)->isMain()) 286 Diag(Loc, diag::ext_main_used); 287 } 288 289 // See if this is an auto-typed variable whose initializer we are parsing. 290 if (ParsingInitForAutoVars.count(D)) { 291 Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer) 292 << D->getDeclName(); 293 return true; 294 } 295 296 // See if this is a deleted function. 297 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 298 if (FD->isDeleted()) { 299 Diag(Loc, diag::err_deleted_function_use); 300 NoteDeletedFunction(FD); 301 return true; 302 } 303 304 // If the function has a deduced return type, and we can't deduce it, 305 // then we can't use it either. 306 if (getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() && 307 DeduceReturnType(FD, Loc)) 308 return true; 309 } 310 DiagnoseAvailabilityOfDecl(*this, D, Loc, UnknownObjCClass, ObjCPropertyAccess); 311 312 DiagnoseUnusedOfDecl(*this, D, Loc); 313 314 diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc); 315 316 return false; 317} 318 319/// \brief Retrieve the message suffix that should be added to a 320/// diagnostic complaining about the given function being deleted or 321/// unavailable. 322std::string Sema::getDeletedOrUnavailableSuffix(const FunctionDecl *FD) { 323 std::string Message; 324 if (FD->getAvailability(&Message)) 325 return ": " + Message; 326 327 return std::string(); 328} 329 330/// DiagnoseSentinelCalls - This routine checks whether a call or 331/// message-send is to a declaration with the sentinel attribute, and 332/// if so, it checks that the requirements of the sentinel are 333/// satisfied. 334void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, 335 ArrayRef<Expr *> Args) { 336 const SentinelAttr *attr = D->getAttr<SentinelAttr>(); 337 if (!attr) 338 return; 339 340 // The number of formal parameters of the declaration. 341 unsigned numFormalParams; 342 343 // The kind of declaration. This is also an index into a %select in 344 // the diagnostic. 345 enum CalleeType { CT_Function, CT_Method, CT_Block } calleeType; 346 347 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 348 numFormalParams = MD->param_size(); 349 calleeType = CT_Method; 350 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 351 numFormalParams = FD->param_size(); 352 calleeType = CT_Function; 353 } else if (isa<VarDecl>(D)) { 354 QualType type = cast<ValueDecl>(D)->getType(); 355 const FunctionType *fn = nullptr; 356 if (const PointerType *ptr = type->getAs<PointerType>()) { 357 fn = ptr->getPointeeType()->getAs<FunctionType>(); 358 if (!fn) return; 359 calleeType = CT_Function; 360 } else if (const BlockPointerType *ptr = type->getAs<BlockPointerType>()) { 361 fn = ptr->getPointeeType()->castAs<FunctionType>(); 362 calleeType = CT_Block; 363 } else { 364 return; 365 } 366 367 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fn)) { 368 numFormalParams = proto->getNumParams(); 369 } else { 370 numFormalParams = 0; 371 } 372 } else { 373 return; 374 } 375 376 // "nullPos" is the number of formal parameters at the end which 377 // effectively count as part of the variadic arguments. This is 378 // useful if you would prefer to not have *any* formal parameters, 379 // but the language forces you to have at least one. 380 unsigned nullPos = attr->getNullPos(); 381 assert((nullPos == 0 || nullPos == 1) && "invalid null position on sentinel"); 382 numFormalParams = (nullPos > numFormalParams ? 0 : numFormalParams - nullPos); 383 384 // The number of arguments which should follow the sentinel. 385 unsigned numArgsAfterSentinel = attr->getSentinel(); 386 387 // If there aren't enough arguments for all the formal parameters, 388 // the sentinel, and the args after the sentinel, complain. 389 if (Args.size() < numFormalParams + numArgsAfterSentinel + 1) { 390 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName(); 391 Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType); 392 return; 393 } 394 395 // Otherwise, find the sentinel expression. 396 Expr *sentinelExpr = Args[Args.size() - numArgsAfterSentinel - 1]; 397 if (!sentinelExpr) return; 398 if (sentinelExpr->isValueDependent()) return; 399 if (Context.isSentinelNullExpr(sentinelExpr)) return; 400 401 // Pick a reasonable string to insert. Optimistically use 'nil', 'nullptr', 402 // or 'NULL' if those are actually defined in the context. Only use 403 // 'nil' for ObjC methods, where it's much more likely that the 404 // variadic arguments form a list of object pointers. 405 SourceLocation MissingNilLoc 406 = PP.getLocForEndOfToken(sentinelExpr->getLocEnd()); 407 std::string NullValue; 408 if (calleeType == CT_Method && 409 PP.getIdentifierInfo("nil")->hasMacroDefinition()) 410 NullValue = "nil"; 411 else if (getLangOpts().CPlusPlus11) 412 NullValue = "nullptr"; 413 else if (PP.getIdentifierInfo("NULL")->hasMacroDefinition()) 414 NullValue = "NULL"; 415 else 416 NullValue = "(void*) 0"; 417 418 if (MissingNilLoc.isInvalid()) 419 Diag(Loc, diag::warn_missing_sentinel) << int(calleeType); 420 else 421 Diag(MissingNilLoc, diag::warn_missing_sentinel) 422 << int(calleeType) 423 << FixItHint::CreateInsertion(MissingNilLoc, ", " + NullValue); 424 Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType); 425} 426 427SourceRange Sema::getExprRange(Expr *E) const { 428 return E ? E->getSourceRange() : SourceRange(); 429} 430 431//===----------------------------------------------------------------------===// 432// Standard Promotions and Conversions 433//===----------------------------------------------------------------------===// 434 435/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4). 436ExprResult Sema::DefaultFunctionArrayConversion(Expr *E) { 437 // Handle any placeholder expressions which made it here. 438 if (E->getType()->isPlaceholderType()) { 439 ExprResult result = CheckPlaceholderExpr(E); 440 if (result.isInvalid()) return ExprError(); 441 E = result.get(); 442 } 443 444 QualType Ty = E->getType(); 445 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type"); 446 447 if (Ty->isFunctionType()) { 448 // If we are here, we are not calling a function but taking 449 // its address (which is not allowed in OpenCL v1.0 s6.8.a.3). 450 if (getLangOpts().OpenCL) { 451 Diag(E->getExprLoc(), diag::err_opencl_taking_function_address); 452 return ExprError(); 453 } 454 E = ImpCastExprToType(E, Context.getPointerType(Ty), 455 CK_FunctionToPointerDecay).get(); 456 } else if (Ty->isArrayType()) { 457 // In C90 mode, arrays only promote to pointers if the array expression is 458 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has 459 // type 'array of type' is converted to an expression that has type 'pointer 460 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression 461 // that has type 'array of type' ...". The relevant change is "an lvalue" 462 // (C90) to "an expression" (C99). 463 // 464 // C++ 4.2p1: 465 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of 466 // T" can be converted to an rvalue of type "pointer to T". 467 // 468 if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue()) 469 E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty), 470 CK_ArrayToPointerDecay).get(); 471 } 472 return E; 473} 474 475static void CheckForNullPointerDereference(Sema &S, Expr *E) { 476 // Check to see if we are dereferencing a null pointer. If so, 477 // and if not volatile-qualified, this is undefined behavior that the 478 // optimizer will delete, so warn about it. People sometimes try to use this 479 // to get a deterministic trap and are surprised by clang's behavior. This 480 // only handles the pattern "*null", which is a very syntactic check. 481 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts())) 482 if (UO->getOpcode() == UO_Deref && 483 UO->getSubExpr()->IgnoreParenCasts()-> 484 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) && 485 !UO->getType().isVolatileQualified()) { 486 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 487 S.PDiag(diag::warn_indirection_through_null) 488 << UO->getSubExpr()->getSourceRange()); 489 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 490 S.PDiag(diag::note_indirection_through_null)); 491 } 492} 493 494static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE, 495 SourceLocation AssignLoc, 496 const Expr* RHS) { 497 const ObjCIvarDecl *IV = OIRE->getDecl(); 498 if (!IV) 499 return; 500 501 DeclarationName MemberName = IV->getDeclName(); 502 IdentifierInfo *Member = MemberName.getAsIdentifierInfo(); 503 if (!Member || !Member->isStr("isa")) 504 return; 505 506 const Expr *Base = OIRE->getBase(); 507 QualType BaseType = Base->getType(); 508 if (OIRE->isArrow()) 509 BaseType = BaseType->getPointeeType(); 510 if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) 511 if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) { 512 ObjCInterfaceDecl *ClassDeclared = nullptr; 513 ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared); 514 if (!ClassDeclared->getSuperClass() 515 && (*ClassDeclared->ivar_begin()) == IV) { 516 if (RHS) { 517 NamedDecl *ObjectSetClass = 518 S.LookupSingleName(S.TUScope, 519 &S.Context.Idents.get("object_setClass"), 520 SourceLocation(), S.LookupOrdinaryName); 521 if (ObjectSetClass) { 522 SourceLocation RHSLocEnd = S.PP.getLocForEndOfToken(RHS->getLocEnd()); 523 S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_assign) << 524 FixItHint::CreateInsertion(OIRE->getLocStart(), "object_setClass(") << 525 FixItHint::CreateReplacement(SourceRange(OIRE->getOpLoc(), 526 AssignLoc), ",") << 527 FixItHint::CreateInsertion(RHSLocEnd, ")"); 528 } 529 else 530 S.Diag(OIRE->getLocation(), diag::warn_objc_isa_assign); 531 } else { 532 NamedDecl *ObjectGetClass = 533 S.LookupSingleName(S.TUScope, 534 &S.Context.Idents.get("object_getClass"), 535 SourceLocation(), S.LookupOrdinaryName); 536 if (ObjectGetClass) 537 S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_use) << 538 FixItHint::CreateInsertion(OIRE->getLocStart(), "object_getClass(") << 539 FixItHint::CreateReplacement( 540 SourceRange(OIRE->getOpLoc(), 541 OIRE->getLocEnd()), ")"); 542 else 543 S.Diag(OIRE->getLocation(), diag::warn_objc_isa_use); 544 } 545 S.Diag(IV->getLocation(), diag::note_ivar_decl); 546 } 547 } 548} 549 550ExprResult Sema::DefaultLvalueConversion(Expr *E) { 551 // Handle any placeholder expressions which made it here. 552 if (E->getType()->isPlaceholderType()) { 553 ExprResult result = CheckPlaceholderExpr(E); 554 if (result.isInvalid()) return ExprError(); 555 E = result.get(); 556 } 557 558 // C++ [conv.lval]p1: 559 // A glvalue of a non-function, non-array type T can be 560 // converted to a prvalue. 561 if (!E->isGLValue()) return E; 562 563 QualType T = E->getType(); 564 assert(!T.isNull() && "r-value conversion on typeless expression?"); 565 566 // We don't want to throw lvalue-to-rvalue casts on top of 567 // expressions of certain types in C++. 568 if (getLangOpts().CPlusPlus && 569 (E->getType() == Context.OverloadTy || 570 T->isDependentType() || 571 T->isRecordType())) 572 return E; 573 574 // The C standard is actually really unclear on this point, and 575 // DR106 tells us what the result should be but not why. It's 576 // generally best to say that void types just doesn't undergo 577 // lvalue-to-rvalue at all. Note that expressions of unqualified 578 // 'void' type are never l-values, but qualified void can be. 579 if (T->isVoidType()) 580 return E; 581 582 // OpenCL usually rejects direct accesses to values of 'half' type. 583 if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp16 && 584 T->isHalfType()) { 585 Diag(E->getExprLoc(), diag::err_opencl_half_load_store) 586 << 0 << T; 587 return ExprError(); 588 } 589 590 CheckForNullPointerDereference(*this, E); 591 if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(E->IgnoreParenCasts())) { 592 NamedDecl *ObjectGetClass = LookupSingleName(TUScope, 593 &Context.Idents.get("object_getClass"), 594 SourceLocation(), LookupOrdinaryName); 595 if (ObjectGetClass) 596 Diag(E->getExprLoc(), diag::warn_objc_isa_use) << 597 FixItHint::CreateInsertion(OISA->getLocStart(), "object_getClass(") << 598 FixItHint::CreateReplacement( 599 SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()), ")"); 600 else 601 Diag(E->getExprLoc(), diag::warn_objc_isa_use); 602 } 603 else if (const ObjCIvarRefExpr *OIRE = 604 dyn_cast<ObjCIvarRefExpr>(E->IgnoreParenCasts())) 605 DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/nullptr); 606 607 // C++ [conv.lval]p1: 608 // [...] If T is a non-class type, the type of the prvalue is the 609 // cv-unqualified version of T. Otherwise, the type of the 610 // rvalue is T. 611 // 612 // C99 6.3.2.1p2: 613 // If the lvalue has qualified type, the value has the unqualified 614 // version of the type of the lvalue; otherwise, the value has the 615 // type of the lvalue. 616 if (T.hasQualifiers()) 617 T = T.getUnqualifiedType(); 618 619 UpdateMarkingForLValueToRValue(E); 620 621 // Loading a __weak object implicitly retains the value, so we need a cleanup to 622 // balance that. 623 if (getLangOpts().ObjCAutoRefCount && 624 E->getType().getObjCLifetime() == Qualifiers::OCL_Weak) 625 ExprNeedsCleanups = true; 626 627 ExprResult Res = ImplicitCastExpr::Create(Context, T, CK_LValueToRValue, E, 628 nullptr, VK_RValue); 629 630 // C11 6.3.2.1p2: 631 // ... if the lvalue has atomic type, the value has the non-atomic version 632 // of the type of the lvalue ... 633 if (const AtomicType *Atomic = T->getAs<AtomicType>()) { 634 T = Atomic->getValueType().getUnqualifiedType(); 635 Res = ImplicitCastExpr::Create(Context, T, CK_AtomicToNonAtomic, Res.get(), 636 nullptr, VK_RValue); 637 } 638 639 return Res; 640} 641 642ExprResult Sema::DefaultFunctionArrayLvalueConversion(Expr *E) { 643 ExprResult Res = DefaultFunctionArrayConversion(E); 644 if (Res.isInvalid()) 645 return ExprError(); 646 Res = DefaultLvalueConversion(Res.get()); 647 if (Res.isInvalid()) 648 return ExprError(); 649 return Res; 650} 651 652/// CallExprUnaryConversions - a special case of an unary conversion 653/// performed on a function designator of a call expression. 654ExprResult Sema::CallExprUnaryConversions(Expr *E) { 655 QualType Ty = E->getType(); 656 ExprResult Res = E; 657 // Only do implicit cast for a function type, but not for a pointer 658 // to function type. 659 if (Ty->isFunctionType()) { 660 Res = ImpCastExprToType(E, Context.getPointerType(Ty), 661 CK_FunctionToPointerDecay).get(); 662 if (Res.isInvalid()) 663 return ExprError(); 664 } 665 Res = DefaultLvalueConversion(Res.get()); 666 if (Res.isInvalid()) 667 return ExprError(); 668 return Res.get(); 669} 670 671/// UsualUnaryConversions - Performs various conversions that are common to most 672/// operators (C99 6.3). The conversions of array and function types are 673/// sometimes suppressed. For example, the array->pointer conversion doesn't 674/// apply if the array is an argument to the sizeof or address (&) operators. 675/// In these instances, this routine should *not* be called. 676ExprResult Sema::UsualUnaryConversions(Expr *E) { 677 // First, convert to an r-value. 678 ExprResult Res = DefaultFunctionArrayLvalueConversion(E); 679 if (Res.isInvalid()) 680 return ExprError(); 681 E = Res.get(); 682 683 QualType Ty = E->getType(); 684 assert(!Ty.isNull() && "UsualUnaryConversions - missing type"); 685 686 // Half FP have to be promoted to float unless it is natively supported 687 if (Ty->isHalfType() && !getLangOpts().NativeHalfType) 688 return ImpCastExprToType(Res.get(), Context.FloatTy, CK_FloatingCast); 689 690 // Try to perform integral promotions if the object has a theoretically 691 // promotable type. 692 if (Ty->isIntegralOrUnscopedEnumerationType()) { 693 // C99 6.3.1.1p2: 694 // 695 // The following may be used in an expression wherever an int or 696 // unsigned int may be used: 697 // - an object or expression with an integer type whose integer 698 // conversion rank is less than or equal to the rank of int 699 // and unsigned int. 700 // - A bit-field of type _Bool, int, signed int, or unsigned int. 701 // 702 // If an int can represent all values of the original type, the 703 // value is converted to an int; otherwise, it is converted to an 704 // unsigned int. These are called the integer promotions. All 705 // other types are unchanged by the integer promotions. 706 707 QualType PTy = Context.isPromotableBitField(E); 708 if (!PTy.isNull()) { 709 E = ImpCastExprToType(E, PTy, CK_IntegralCast).get(); 710 return E; 711 } 712 if (Ty->isPromotableIntegerType()) { 713 QualType PT = Context.getPromotedIntegerType(Ty); 714 E = ImpCastExprToType(E, PT, CK_IntegralCast).get(); 715 return E; 716 } 717 } 718 return E; 719} 720 721/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that 722/// do not have a prototype. Arguments that have type float or __fp16 723/// are promoted to double. All other argument types are converted by 724/// UsualUnaryConversions(). 725ExprResult Sema::DefaultArgumentPromotion(Expr *E) { 726 QualType Ty = E->getType(); 727 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type"); 728 729 ExprResult Res = UsualUnaryConversions(E); 730 if (Res.isInvalid()) 731 return ExprError(); 732 E = Res.get(); 733 734 // If this is a 'float' or '__fp16' (CVR qualified or typedef) promote to 735 // double. 736 const BuiltinType *BTy = Ty->getAs<BuiltinType>(); 737 if (BTy && (BTy->getKind() == BuiltinType::Half || 738 BTy->getKind() == BuiltinType::Float)) 739 E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).get(); 740 741 // C++ performs lvalue-to-rvalue conversion as a default argument 742 // promotion, even on class types, but note: 743 // C++11 [conv.lval]p2: 744 // When an lvalue-to-rvalue conversion occurs in an unevaluated 745 // operand or a subexpression thereof the value contained in the 746 // referenced object is not accessed. Otherwise, if the glvalue 747 // has a class type, the conversion copy-initializes a temporary 748 // of type T from the glvalue and the result of the conversion 749 // is a prvalue for the temporary. 750 // FIXME: add some way to gate this entire thing for correctness in 751 // potentially potentially evaluated contexts. 752 if (getLangOpts().CPlusPlus && E->isGLValue() && !isUnevaluatedContext()) { 753 ExprResult Temp = PerformCopyInitialization( 754 InitializedEntity::InitializeTemporary(E->getType()), 755 E->getExprLoc(), E); 756 if (Temp.isInvalid()) 757 return ExprError(); 758 E = Temp.get(); 759 } 760 761 return E; 762} 763 764/// Determine the degree of POD-ness for an expression. 765/// Incomplete types are considered POD, since this check can be performed 766/// when we're in an unevaluated context. 767Sema::VarArgKind Sema::isValidVarArgType(const QualType &Ty) { 768 if (Ty->isIncompleteType()) { 769 // C++11 [expr.call]p7: 770 // After these conversions, if the argument does not have arithmetic, 771 // enumeration, pointer, pointer to member, or class type, the program 772 // is ill-formed. 773 // 774 // Since we've already performed array-to-pointer and function-to-pointer 775 // decay, the only such type in C++ is cv void. This also handles 776 // initializer lists as variadic arguments. 777 if (Ty->isVoidType()) 778 return VAK_Invalid; 779 780 if (Ty->isObjCObjectType()) 781 return VAK_Invalid; 782 return VAK_Valid; 783 } 784 785 if (Ty.isCXX98PODType(Context)) 786 return VAK_Valid; 787 788 // C++11 [expr.call]p7: 789 // Passing a potentially-evaluated argument of class type (Clause 9) 790 // having a non-trivial copy constructor, a non-trivial move constructor, 791 // or a non-trivial destructor, with no corresponding parameter, 792 // is conditionally-supported with implementation-defined semantics. 793 if (getLangOpts().CPlusPlus11 && !Ty->isDependentType()) 794 if (CXXRecordDecl *Record = Ty->getAsCXXRecordDecl()) 795 if (!Record->hasNonTrivialCopyConstructor() && 796 !Record->hasNonTrivialMoveConstructor() && 797 !Record->hasNonTrivialDestructor()) 798 return VAK_ValidInCXX11; 799 800 if (getLangOpts().ObjCAutoRefCount && Ty->isObjCLifetimeType()) 801 return VAK_Valid; 802 803 if (Ty->isObjCObjectType()) 804 return VAK_Invalid; 805 806 if (getLangOpts().MSVCCompat) 807 return VAK_MSVCUndefined; 808 809 // FIXME: In C++11, these cases are conditionally-supported, meaning we're 810 // permitted to reject them. We should consider doing so. 811 return VAK_Undefined; 812} 813 814void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) { 815 // Don't allow one to pass an Objective-C interface to a vararg. 816 const QualType &Ty = E->getType(); 817 VarArgKind VAK = isValidVarArgType(Ty); 818 819 // Complain about passing non-POD types through varargs. 820 switch (VAK) { 821 case VAK_ValidInCXX11: 822 DiagRuntimeBehavior( 823 E->getLocStart(), nullptr, 824 PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) 825 << Ty << CT); 826 // Fall through. 827 case VAK_Valid: 828 if (Ty->isRecordType()) { 829 // This is unlikely to be what the user intended. If the class has a 830 // 'c_str' member function, the user probably meant to call that. 831 DiagRuntimeBehavior(E->getLocStart(), nullptr, 832 PDiag(diag::warn_pass_class_arg_to_vararg) 833 << Ty << CT << hasCStrMethod(E) << ".c_str()"); 834 } 835 break; 836 837 case VAK_Undefined: 838 case VAK_MSVCUndefined: 839 DiagRuntimeBehavior( 840 E->getLocStart(), nullptr, 841 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg) 842 << getLangOpts().CPlusPlus11 << Ty << CT); 843 break; 844 845 case VAK_Invalid: 846 if (Ty->isObjCObjectType()) 847 DiagRuntimeBehavior( 848 E->getLocStart(), nullptr, 849 PDiag(diag::err_cannot_pass_objc_interface_to_vararg) 850 << Ty << CT); 851 else 852 Diag(E->getLocStart(), diag::err_cannot_pass_to_vararg) 853 << isa<InitListExpr>(E) << Ty << CT; 854 break; 855 } 856} 857 858/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but 859/// will create a trap if the resulting type is not a POD type. 860ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, 861 FunctionDecl *FDecl) { 862 if (const BuiltinType *PlaceholderTy = E->getType()->getAsPlaceholderType()) { 863 // Strip the unbridged-cast placeholder expression off, if applicable. 864 if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast && 865 (CT == VariadicMethod || 866 (FDecl && FDecl->hasAttr<CFAuditedTransferAttr>()))) { 867 E = stripARCUnbridgedCast(E); 868 869 // Otherwise, do normal placeholder checking. 870 } else { 871 ExprResult ExprRes = CheckPlaceholderExpr(E); 872 if (ExprRes.isInvalid()) 873 return ExprError(); 874 E = ExprRes.get(); 875 } 876 } 877 878 ExprResult ExprRes = DefaultArgumentPromotion(E); 879 if (ExprRes.isInvalid()) 880 return ExprError(); 881 E = ExprRes.get(); 882 883 // Diagnostics regarding non-POD argument types are 884 // emitted along with format string checking in Sema::CheckFunctionCall(). 885 if (isValidVarArgType(E->getType()) == VAK_Undefined) { 886 // Turn this into a trap. 887 CXXScopeSpec SS; 888 SourceLocation TemplateKWLoc; 889 UnqualifiedId Name; 890 Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"), 891 E->getLocStart()); 892 ExprResult TrapFn = ActOnIdExpression(TUScope, SS, TemplateKWLoc, 893 Name, true, false); 894 if (TrapFn.isInvalid()) 895 return ExprError(); 896 897 ExprResult Call = ActOnCallExpr(TUScope, TrapFn.get(), 898 E->getLocStart(), None, 899 E->getLocEnd()); 900 if (Call.isInvalid()) 901 return ExprError(); 902 903 ExprResult Comma = ActOnBinOp(TUScope, E->getLocStart(), tok::comma, 904 Call.get(), E); 905 if (Comma.isInvalid()) 906 return ExprError(); 907 return Comma.get(); 908 } 909 910 if (!getLangOpts().CPlusPlus && 911 RequireCompleteType(E->getExprLoc(), E->getType(), 912 diag::err_call_incomplete_argument)) 913 return ExprError(); 914 915 return E; 916} 917 918/// \brief Converts an integer to complex float type. Helper function of 919/// UsualArithmeticConversions() 920/// 921/// \return false if the integer expression is an integer type and is 922/// successfully converted to the complex type. 923static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &IntExpr, 924 ExprResult &ComplexExpr, 925 QualType IntTy, 926 QualType ComplexTy, 927 bool SkipCast) { 928 if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true; 929 if (SkipCast) return false; 930 if (IntTy->isIntegerType()) { 931 QualType fpTy = cast<ComplexType>(ComplexTy)->getElementType(); 932 IntExpr = S.ImpCastExprToType(IntExpr.get(), fpTy, CK_IntegralToFloating); 933 IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy, 934 CK_FloatingRealToComplex); 935 } else { 936 assert(IntTy->isComplexIntegerType()); 937 IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy, 938 CK_IntegralComplexToFloatingComplex); 939 } 940 return false; 941} 942 943/// \brief Handle arithmetic conversion with complex types. Helper function of 944/// UsualArithmeticConversions() 945static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS, 946 ExprResult &RHS, QualType LHSType, 947 QualType RHSType, 948 bool IsCompAssign) { 949 // if we have an integer operand, the result is the complex type. 950 if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType, 951 /*skipCast*/false)) 952 return LHSType; 953 if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType, 954 /*skipCast*/IsCompAssign)) 955 return RHSType; 956 957 // This handles complex/complex, complex/float, or float/complex. 958 // When both operands are complex, the shorter operand is converted to the 959 // type of the longer, and that is the type of the result. This corresponds 960 // to what is done when combining two real floating-point operands. 961 // The fun begins when size promotion occur across type domains. 962 // From H&S 6.3.4: When one operand is complex and the other is a real 963 // floating-point type, the less precise type is converted, within it's 964 // real or complex domain, to the precision of the other type. For example, 965 // when combining a "long double" with a "double _Complex", the 966 // "double _Complex" is promoted to "long double _Complex". 967 968 // Compute the rank of the two types, regardless of whether they are complex. 969 int Order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 970 971 auto *LHSComplexType = dyn_cast<ComplexType>(LHSType); 972 auto *RHSComplexType = dyn_cast<ComplexType>(RHSType); 973 QualType LHSElementType = 974 LHSComplexType ? LHSComplexType->getElementType() : LHSType; 975 QualType RHSElementType = 976 RHSComplexType ? RHSComplexType->getElementType() : RHSType; 977 978 QualType ResultType = S.Context.getComplexType(LHSElementType); 979 if (Order < 0) { 980 // Promote the precision of the LHS if not an assignment. 981 ResultType = S.Context.getComplexType(RHSElementType); 982 if (!IsCompAssign) { 983 if (LHSComplexType) 984 LHS = 985 S.ImpCastExprToType(LHS.get(), ResultType, CK_FloatingComplexCast); 986 else 987 LHS = S.ImpCastExprToType(LHS.get(), RHSElementType, CK_FloatingCast); 988 } 989 } else if (Order > 0) { 990 // Promote the precision of the RHS. 991 if (RHSComplexType) 992 RHS = S.ImpCastExprToType(RHS.get(), ResultType, CK_FloatingComplexCast); 993 else 994 RHS = S.ImpCastExprToType(RHS.get(), LHSElementType, CK_FloatingCast); 995 } 996 return ResultType; 997} 998 999/// \brief Hande arithmetic conversion from integer to float. Helper function 1000/// of UsualArithmeticConversions() 1001static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, 1002 ExprResult &IntExpr, 1003 QualType FloatTy, QualType IntTy, 1004 bool ConvertFloat, bool ConvertInt) { 1005 if (IntTy->isIntegerType()) { 1006 if (ConvertInt) 1007 // Convert intExpr to the lhs floating point type. 1008 IntExpr = S.ImpCastExprToType(IntExpr.get(), FloatTy, 1009 CK_IntegralToFloating); 1010 return FloatTy; 1011 } 1012 1013 // Convert both sides to the appropriate complex float. 1014 assert(IntTy->isComplexIntegerType()); 1015 QualType result = S.Context.getComplexType(FloatTy); 1016 1017 // _Complex int -> _Complex float 1018 if (ConvertInt) 1019 IntExpr = S.ImpCastExprToType(IntExpr.get(), result, 1020 CK_IntegralComplexToFloatingComplex); 1021 1022 // float -> _Complex float 1023 if (ConvertFloat) 1024 FloatExpr = S.ImpCastExprToType(FloatExpr.get(), result, 1025 CK_FloatingRealToComplex); 1026 1027 return result; 1028} 1029 1030/// \brief Handle arithmethic conversion with floating point types. Helper 1031/// function of UsualArithmeticConversions() 1032static QualType handleFloatConversion(Sema &S, ExprResult &LHS, 1033 ExprResult &RHS, QualType LHSType, 1034 QualType RHSType, bool IsCompAssign) { 1035 bool LHSFloat = LHSType->isRealFloatingType(); 1036 bool RHSFloat = RHSType->isRealFloatingType(); 1037 1038 // If we have two real floating types, convert the smaller operand 1039 // to the bigger result. 1040 if (LHSFloat && RHSFloat) { 1041 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 1042 if (order > 0) { 1043 RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FloatingCast); 1044 return LHSType; 1045 } 1046 1047 assert(order < 0 && "illegal float comparison"); 1048 if (!IsCompAssign) 1049 LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FloatingCast); 1050 return RHSType; 1051 } 1052 1053 if (LHSFloat) 1054 return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType, 1055 /*convertFloat=*/!IsCompAssign, 1056 /*convertInt=*/ true); 1057 assert(RHSFloat); 1058 return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType, 1059 /*convertInt=*/ true, 1060 /*convertFloat=*/!IsCompAssign); 1061} 1062 1063typedef ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType); 1064 1065namespace { 1066/// These helper callbacks are placed in an anonymous namespace to 1067/// permit their use as function template parameters. 1068ExprResult doIntegralCast(Sema &S, Expr *op, QualType toType) { 1069 return S.ImpCastExprToType(op, toType, CK_IntegralCast); 1070} 1071 1072ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) { 1073 return S.ImpCastExprToType(op, S.Context.getComplexType(toType), 1074 CK_IntegralComplexCast); 1075} 1076} 1077 1078/// \brief Handle integer arithmetic conversions. Helper function of 1079/// UsualArithmeticConversions() 1080template <PerformCastFn doLHSCast, PerformCastFn doRHSCast> 1081static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, 1082 ExprResult &RHS, QualType LHSType, 1083 QualType RHSType, bool IsCompAssign) { 1084 // The rules for this case are in C99 6.3.1.8 1085 int order = S.Context.getIntegerTypeOrder(LHSType, RHSType); 1086 bool LHSSigned = LHSType->hasSignedIntegerRepresentation(); 1087 bool RHSSigned = RHSType->hasSignedIntegerRepresentation(); 1088 if (LHSSigned == RHSSigned) { 1089 // Same signedness; use the higher-ranked type 1090 if (order >= 0) { 1091 RHS = (*doRHSCast)(S, RHS.get(), LHSType); 1092 return LHSType; 1093 } else if (!IsCompAssign) 1094 LHS = (*doLHSCast)(S, LHS.get(), RHSType); 1095 return RHSType; 1096 } else if (order != (LHSSigned ? 1 : -1)) { 1097 // The unsigned type has greater than or equal rank to the 1098 // signed type, so use the unsigned type 1099 if (RHSSigned) { 1100 RHS = (*doRHSCast)(S, RHS.get(), LHSType); 1101 return LHSType; 1102 } else if (!IsCompAssign) 1103 LHS = (*doLHSCast)(S, LHS.get(), RHSType); 1104 return RHSType; 1105 } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) { 1106 // The two types are different widths; if we are here, that 1107 // means the signed type is larger than the unsigned type, so 1108 // use the signed type. 1109 if (LHSSigned) { 1110 RHS = (*doRHSCast)(S, RHS.get(), LHSType); 1111 return LHSType; 1112 } else if (!IsCompAssign) 1113 LHS = (*doLHSCast)(S, LHS.get(), RHSType); 1114 return RHSType; 1115 } else { 1116 // The signed type is higher-ranked than the unsigned type, 1117 // but isn't actually any bigger (like unsigned int and long 1118 // on most 32-bit systems). Use the unsigned type corresponding 1119 // to the signed type. 1120 QualType result = 1121 S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType); 1122 RHS = (*doRHSCast)(S, RHS.get(), result); 1123 if (!IsCompAssign) 1124 LHS = (*doLHSCast)(S, LHS.get(), result); 1125 return result; 1126 } 1127} 1128 1129/// \brief Handle conversions with GCC complex int extension. Helper function 1130/// of UsualArithmeticConversions() 1131static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS, 1132 ExprResult &RHS, QualType LHSType, 1133 QualType RHSType, 1134 bool IsCompAssign) { 1135 const ComplexType *LHSComplexInt = LHSType->getAsComplexIntegerType(); 1136 const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType(); 1137 1138 if (LHSComplexInt && RHSComplexInt) { 1139 QualType LHSEltType = LHSComplexInt->getElementType(); 1140 QualType RHSEltType = RHSComplexInt->getElementType(); 1141 QualType ScalarType = 1142 handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast> 1143 (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign); 1144 1145 return S.Context.getComplexType(ScalarType); 1146 } 1147 1148 if (LHSComplexInt) { 1149 QualType LHSEltType = LHSComplexInt->getElementType(); 1150 QualType ScalarType = 1151 handleIntegerConversion<doComplexIntegralCast, doIntegralCast> 1152 (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign); 1153 QualType ComplexType = S.Context.getComplexType(ScalarType); 1154 RHS = S.ImpCastExprToType(RHS.get(), ComplexType, 1155 CK_IntegralRealToComplex); 1156 1157 return ComplexType; 1158 } 1159 1160 assert(RHSComplexInt); 1161 1162 QualType RHSEltType = RHSComplexInt->getElementType(); 1163 QualType ScalarType = 1164 handleIntegerConversion<doIntegralCast, doComplexIntegralCast> 1165 (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign); 1166 QualType ComplexType = S.Context.getComplexType(ScalarType); 1167 1168 if (!IsCompAssign) 1169 LHS = S.ImpCastExprToType(LHS.get(), ComplexType, 1170 CK_IntegralRealToComplex); 1171 return ComplexType; 1172} 1173 1174/// UsualArithmeticConversions - Performs various conversions that are common to 1175/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this 1176/// routine returns the first non-arithmetic type found. The client is 1177/// responsible for emitting appropriate error diagnostics. 1178QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, 1179 bool IsCompAssign) { 1180 if (!IsCompAssign) { 1181 LHS = UsualUnaryConversions(LHS.get()); 1182 if (LHS.isInvalid()) 1183 return QualType(); 1184 } 1185 1186 RHS = UsualUnaryConversions(RHS.get()); 1187 if (RHS.isInvalid()) 1188 return QualType(); 1189 1190 // For conversion purposes, we ignore any qualifiers. 1191 // For example, "const float" and "float" are equivalent. 1192 QualType LHSType = 1193 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType(); 1194 QualType RHSType = 1195 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType(); 1196 1197 // For conversion purposes, we ignore any atomic qualifier on the LHS. 1198 if (const AtomicType *AtomicLHS = LHSType->getAs<AtomicType>()) 1199 LHSType = AtomicLHS->getValueType(); 1200 1201 // If both types are identical, no conversion is needed. 1202 if (LHSType == RHSType) 1203 return LHSType; 1204 1205 // If either side is a non-arithmetic type (e.g. a pointer), we are done. 1206 // The caller can deal with this (e.g. pointer + int). 1207 if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType()) 1208 return QualType(); 1209 1210 // Apply unary and bitfield promotions to the LHS's type. 1211 QualType LHSUnpromotedType = LHSType; 1212 if (LHSType->isPromotableIntegerType()) 1213 LHSType = Context.getPromotedIntegerType(LHSType); 1214 QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get()); 1215 if (!LHSBitfieldPromoteTy.isNull()) 1216 LHSType = LHSBitfieldPromoteTy; 1217 if (LHSType != LHSUnpromotedType && !IsCompAssign) 1218 LHS = ImpCastExprToType(LHS.get(), LHSType, CK_IntegralCast); 1219 1220 // If both types are identical, no conversion is needed. 1221 if (LHSType == RHSType) 1222 return LHSType; 1223 1224 // At this point, we have two different arithmetic types. 1225 1226 // Handle complex types first (C99 6.3.1.8p1). 1227 if (LHSType->isComplexType() || RHSType->isComplexType()) 1228 return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType, 1229 IsCompAssign); 1230 1231 // Now handle "real" floating types (i.e. float, double, long double). 1232 if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType()) 1233 return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType, 1234 IsCompAssign); 1235 1236 // Handle GCC complex int extension. 1237 if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType()) 1238 return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType, 1239 IsCompAssign); 1240 1241 // Finally, we have two differing integer types. 1242 return handleIntegerConversion<doIntegralCast, doIntegralCast> 1243 (*this, LHS, RHS, LHSType, RHSType, IsCompAssign); 1244} 1245 1246 1247//===----------------------------------------------------------------------===// 1248// Semantic Analysis for various Expression Types 1249//===----------------------------------------------------------------------===// 1250 1251 1252ExprResult 1253Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc, 1254 SourceLocation DefaultLoc, 1255 SourceLocation RParenLoc, 1256 Expr *ControllingExpr, 1257 ArrayRef<ParsedType> ArgTypes, 1258 ArrayRef<Expr *> ArgExprs) { 1259 unsigned NumAssocs = ArgTypes.size(); 1260 assert(NumAssocs == ArgExprs.size()); 1261 1262 TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs]; 1263 for (unsigned i = 0; i < NumAssocs; ++i) { 1264 if (ArgTypes[i]) 1265 (void) GetTypeFromParser(ArgTypes[i], &Types[i]); 1266 else 1267 Types[i] = nullptr; 1268 } 1269 1270 ExprResult ER = CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, 1271 ControllingExpr, 1272 llvm::makeArrayRef(Types, NumAssocs), 1273 ArgExprs); 1274 delete [] Types; 1275 return ER; 1276} 1277 1278ExprResult 1279Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc, 1280 SourceLocation DefaultLoc, 1281 SourceLocation RParenLoc, 1282 Expr *ControllingExpr, 1283 ArrayRef<TypeSourceInfo *> Types, 1284 ArrayRef<Expr *> Exprs) { 1285 unsigned NumAssocs = Types.size(); 1286 assert(NumAssocs == Exprs.size()); 1287 if (ControllingExpr->getType()->isPlaceholderType()) { 1288 ExprResult result = CheckPlaceholderExpr(ControllingExpr); 1289 if (result.isInvalid()) return ExprError(); 1290 ControllingExpr = result.get(); 1291 } 1292 1293 // The controlling expression is an unevaluated operand, so side effects are 1294 // likely unintended. 1295 if (ActiveTemplateInstantiations.empty() && 1296 ControllingExpr->HasSideEffects(Context, false)) 1297 Diag(ControllingExpr->getExprLoc(), 1298 diag::warn_side_effects_unevaluated_context); 1299 1300 bool TypeErrorFound = false, 1301 IsResultDependent = ControllingExpr->isTypeDependent(), 1302 ContainsUnexpandedParameterPack 1303 = ControllingExpr->containsUnexpandedParameterPack(); 1304 1305 for (unsigned i = 0; i < NumAssocs; ++i) { 1306 if (Exprs[i]->containsUnexpandedParameterPack()) 1307 ContainsUnexpandedParameterPack = true; 1308 1309 if (Types[i]) { 1310 if (Types[i]->getType()->containsUnexpandedParameterPack()) 1311 ContainsUnexpandedParameterPack = true; 1312 1313 if (Types[i]->getType()->isDependentType()) { 1314 IsResultDependent = true; 1315 } else { 1316 // C11 6.5.1.1p2 "The type name in a generic association shall specify a 1317 // complete object type other than a variably modified type." 1318 unsigned D = 0; 1319 if (Types[i]->getType()->isIncompleteType()) 1320 D = diag::err_assoc_type_incomplete; 1321 else if (!Types[i]->getType()->isObjectType()) 1322 D = diag::err_assoc_type_nonobject; 1323 else if (Types[i]->getType()->isVariablyModifiedType()) 1324 D = diag::err_assoc_type_variably_modified; 1325 1326 if (D != 0) { 1327 Diag(Types[i]->getTypeLoc().getBeginLoc(), D) 1328 << Types[i]->getTypeLoc().getSourceRange() 1329 << Types[i]->getType(); 1330 TypeErrorFound = true; 1331 } 1332 1333 // C11 6.5.1.1p2 "No two generic associations in the same generic 1334 // selection shall specify compatible types." 1335 for (unsigned j = i+1; j < NumAssocs; ++j) 1336 if (Types[j] && !Types[j]->getType()->isDependentType() && 1337 Context.typesAreCompatible(Types[i]->getType(), 1338 Types[j]->getType())) { 1339 Diag(Types[j]->getTypeLoc().getBeginLoc(), 1340 diag::err_assoc_compatible_types) 1341 << Types[j]->getTypeLoc().getSourceRange() 1342 << Types[j]->getType() 1343 << Types[i]->getType(); 1344 Diag(Types[i]->getTypeLoc().getBeginLoc(), 1345 diag::note_compat_assoc) 1346 << Types[i]->getTypeLoc().getSourceRange() 1347 << Types[i]->getType(); 1348 TypeErrorFound = true; 1349 } 1350 } 1351 } 1352 } 1353 if (TypeErrorFound) 1354 return ExprError(); 1355 1356 // If we determined that the generic selection is result-dependent, don't 1357 // try to compute the result expression. 1358 if (IsResultDependent) 1359 return new (Context) GenericSelectionExpr( 1360 Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc, 1361 ContainsUnexpandedParameterPack); 1362 1363 SmallVector<unsigned, 1> CompatIndices; 1364 unsigned DefaultIndex = -1U; 1365 for (unsigned i = 0; i < NumAssocs; ++i) { 1366 if (!Types[i]) 1367 DefaultIndex = i; 1368 else if (Context.typesAreCompatible(ControllingExpr->getType(), 1369 Types[i]->getType())) 1370 CompatIndices.push_back(i); 1371 } 1372 1373 // C11 6.5.1.1p2 "The controlling expression of a generic selection shall have 1374 // type compatible with at most one of the types named in its generic 1375 // association list." 1376 if (CompatIndices.size() > 1) { 1377 // We strip parens here because the controlling expression is typically 1378 // parenthesized in macro definitions. 1379 ControllingExpr = ControllingExpr->IgnoreParens(); 1380 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_multi_match) 1381 << ControllingExpr->getSourceRange() << ControllingExpr->getType() 1382 << (unsigned) CompatIndices.size(); 1383 for (SmallVectorImpl<unsigned>::iterator I = CompatIndices.begin(), 1384 E = CompatIndices.end(); I != E; ++I) { 1385 Diag(Types[*I]->getTypeLoc().getBeginLoc(), 1386 diag::note_compat_assoc) 1387 << Types[*I]->getTypeLoc().getSourceRange() 1388 << Types[*I]->getType(); 1389 } 1390 return ExprError(); 1391 } 1392 1393 // C11 6.5.1.1p2 "If a generic selection has no default generic association, 1394 // its controlling expression shall have type compatible with exactly one of 1395 // the types named in its generic association list." 1396 if (DefaultIndex == -1U && CompatIndices.size() == 0) { 1397 // We strip parens here because the controlling expression is typically 1398 // parenthesized in macro definitions. 1399 ControllingExpr = ControllingExpr->IgnoreParens(); 1400 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_no_match) 1401 << ControllingExpr->getSourceRange() << ControllingExpr->getType(); 1402 return ExprError(); 1403 } 1404 1405 // C11 6.5.1.1p3 "If a generic selection has a generic association with a 1406 // type name that is compatible with the type of the controlling expression, 1407 // then the result expression of the generic selection is the expression 1408 // in that generic association. Otherwise, the result expression of the 1409 // generic selection is the expression in the default generic association." 1410 unsigned ResultIndex = 1411 CompatIndices.size() ? CompatIndices[0] : DefaultIndex; 1412 1413 return new (Context) GenericSelectionExpr( 1414 Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc, 1415 ContainsUnexpandedParameterPack, ResultIndex); 1416} 1417 1418/// getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the 1419/// location of the token and the offset of the ud-suffix within it. 1420static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc, 1421 unsigned Offset) { 1422 return Lexer::AdvanceToTokenCharacter(TokLoc, Offset, S.getSourceManager(), 1423 S.getLangOpts()); 1424} 1425 1426/// BuildCookedLiteralOperatorCall - A user-defined literal was found. Look up 1427/// the corresponding cooked (non-raw) literal operator, and build a call to it. 1428static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope, 1429 IdentifierInfo *UDSuffix, 1430 SourceLocation UDSuffixLoc, 1431 ArrayRef<Expr*> Args, 1432 SourceLocation LitEndLoc) { 1433 assert(Args.size() <= 2 && "too many arguments for literal operator"); 1434 1435 QualType ArgTy[2]; 1436 for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) { 1437 ArgTy[ArgIdx] = Args[ArgIdx]->getType(); 1438 if (ArgTy[ArgIdx]->isArrayType()) 1439 ArgTy[ArgIdx] = S.Context.getArrayDecayedType(ArgTy[ArgIdx]); 1440 } 1441 1442 DeclarationName OpName = 1443 S.Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 1444 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 1445 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 1446 1447 LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName); 1448 if (S.LookupLiteralOperator(Scope, R, llvm::makeArrayRef(ArgTy, Args.size()), 1449 /*AllowRaw*/false, /*AllowTemplate*/false, 1450 /*AllowStringTemplate*/false) == Sema::LOLR_Error) 1451 return ExprError(); 1452 1453 return S.BuildLiteralOperatorCall(R, OpNameInfo, Args, LitEndLoc); 1454} 1455 1456/// ActOnStringLiteral - The specified tokens were lexed as pasted string 1457/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string 1458/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from 1459/// multiple tokens. However, the common case is that StringToks points to one 1460/// string. 1461/// 1462ExprResult 1463Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) { 1464 assert(!StringToks.empty() && "Must have at least one string!"); 1465 1466 StringLiteralParser Literal(StringToks, PP); 1467 if (Literal.hadError) 1468 return ExprError(); 1469 1470 SmallVector<SourceLocation, 4> StringTokLocs; 1471 for (unsigned i = 0; i != StringToks.size(); ++i) 1472 StringTokLocs.push_back(StringToks[i].getLocation()); 1473 1474 QualType CharTy = Context.CharTy; 1475 StringLiteral::StringKind Kind = StringLiteral::Ascii; 1476 if (Literal.isWide()) { 1477 CharTy = Context.getWideCharType(); 1478 Kind = StringLiteral::Wide; 1479 } else if (Literal.isUTF8()) { 1480 Kind = StringLiteral::UTF8; 1481 } else if (Literal.isUTF16()) { 1482 CharTy = Context.Char16Ty; 1483 Kind = StringLiteral::UTF16; 1484 } else if (Literal.isUTF32()) { 1485 CharTy = Context.Char32Ty; 1486 Kind = StringLiteral::UTF32; 1487 } else if (Literal.isPascal()) { 1488 CharTy = Context.UnsignedCharTy; 1489 } 1490 1491 QualType CharTyConst = CharTy; 1492 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1). 1493 if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings) 1494 CharTyConst.addConst(); 1495 1496 // Get an array type for the string, according to C99 6.4.5. This includes 1497 // the nul terminator character as well as the string length for pascal 1498 // strings. 1499 QualType StrTy = Context.getConstantArrayType(CharTyConst, 1500 llvm::APInt(32, Literal.GetNumStringChars()+1), 1501 ArrayType::Normal, 0); 1502 1503 // OpenCL v1.1 s6.5.3: a string literal is in the constant address space. 1504 if (getLangOpts().OpenCL) { 1505 StrTy = Context.getAddrSpaceQualType(StrTy, LangAS::opencl_constant); 1506 } 1507 1508 // Pass &StringTokLocs[0], StringTokLocs.size() to factory! 1509 StringLiteral *Lit = StringLiteral::Create(Context, Literal.GetString(), 1510 Kind, Literal.Pascal, StrTy, 1511 &StringTokLocs[0], 1512 StringTokLocs.size()); 1513 if (Literal.getUDSuffix().empty()) 1514 return Lit; 1515 1516 // We're building a user-defined literal. 1517 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 1518 SourceLocation UDSuffixLoc = 1519 getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()], 1520 Literal.getUDSuffixOffset()); 1521 1522 // Make sure we're allowed user-defined literals here. 1523 if (!UDLScope) 1524 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_string_udl)); 1525 1526 // C++11 [lex.ext]p5: The literal L is treated as a call of the form 1527 // operator "" X (str, len) 1528 QualType SizeType = Context.getSizeType(); 1529 1530 DeclarationName OpName = 1531 Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 1532 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 1533 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 1534 1535 QualType ArgTy[] = { 1536 Context.getArrayDecayedType(StrTy), SizeType 1537 }; 1538 1539 LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName); 1540 switch (LookupLiteralOperator(UDLScope, R, ArgTy, 1541 /*AllowRaw*/false, /*AllowTemplate*/false, 1542 /*AllowStringTemplate*/true)) { 1543 1544 case LOLR_Cooked: { 1545 llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars()); 1546 IntegerLiteral *LenArg = IntegerLiteral::Create(Context, Len, SizeType, 1547 StringTokLocs[0]); 1548 Expr *Args[] = { Lit, LenArg }; 1549 1550 return BuildLiteralOperatorCall(R, OpNameInfo, Args, StringTokLocs.back()); 1551 } 1552 1553 case LOLR_StringTemplate: { 1554 TemplateArgumentListInfo ExplicitArgs; 1555 1556 unsigned CharBits = Context.getIntWidth(CharTy); 1557 bool CharIsUnsigned = CharTy->isUnsignedIntegerType(); 1558 llvm::APSInt Value(CharBits, CharIsUnsigned); 1559 1560 TemplateArgument TypeArg(CharTy); 1561 TemplateArgumentLocInfo TypeArgInfo(Context.getTrivialTypeSourceInfo(CharTy)); 1562 ExplicitArgs.addArgument(TemplateArgumentLoc(TypeArg, TypeArgInfo)); 1563 1564 for (unsigned I = 0, N = Lit->getLength(); I != N; ++I) { 1565 Value = Lit->getCodeUnit(I); 1566 TemplateArgument Arg(Context, Value, CharTy); 1567 TemplateArgumentLocInfo ArgInfo; 1568 ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo)); 1569 } 1570 return BuildLiteralOperatorCall(R, OpNameInfo, None, StringTokLocs.back(), 1571 &ExplicitArgs); 1572 } 1573 case LOLR_Raw: 1574 case LOLR_Template: 1575 llvm_unreachable("unexpected literal operator lookup result"); 1576 case LOLR_Error: 1577 return ExprError(); 1578 } 1579 llvm_unreachable("unexpected literal operator lookup result"); 1580} 1581 1582ExprResult 1583Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1584 SourceLocation Loc, 1585 const CXXScopeSpec *SS) { 1586 DeclarationNameInfo NameInfo(D->getDeclName(), Loc); 1587 return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS); 1588} 1589 1590/// BuildDeclRefExpr - Build an expression that references a 1591/// declaration that does not require a closure capture. 1592ExprResult 1593Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1594 const DeclarationNameInfo &NameInfo, 1595 const CXXScopeSpec *SS, NamedDecl *FoundD, 1596 const TemplateArgumentListInfo *TemplateArgs) { 1597 if (getLangOpts().CUDA) 1598 if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext)) 1599 if (const FunctionDecl *Callee = dyn_cast<FunctionDecl>(D)) { 1600 if (CheckCUDATarget(Caller, Callee)) { 1601 Diag(NameInfo.getLoc(), diag::err_ref_bad_target) 1602 << IdentifyCUDATarget(Callee) << D->getIdentifier() 1603 << IdentifyCUDATarget(Caller); 1604 Diag(D->getLocation(), diag::note_previous_decl) 1605 << D->getIdentifier(); 1606 return ExprError(); 1607 } 1608 } 1609 1610 bool RefersToCapturedVariable = 1611 isa<VarDecl>(D) && 1612 NeedToCaptureVariable(cast<VarDecl>(D), NameInfo.getLoc()); 1613 1614 DeclRefExpr *E; 1615 if (isa<VarTemplateSpecializationDecl>(D)) { 1616 VarTemplateSpecializationDecl *VarSpec = 1617 cast<VarTemplateSpecializationDecl>(D); 1618 1619 E = DeclRefExpr::Create(Context, SS ? SS->getWithLocInContext(Context) 1620 : NestedNameSpecifierLoc(), 1621 VarSpec->getTemplateKeywordLoc(), D, 1622 RefersToCapturedVariable, NameInfo.getLoc(), Ty, VK, 1623 FoundD, TemplateArgs); 1624 } else { 1625 assert(!TemplateArgs && "No template arguments for non-variable" 1626 " template specialization references"); 1627 E = DeclRefExpr::Create(Context, SS ? SS->getWithLocInContext(Context) 1628 : NestedNameSpecifierLoc(), 1629 SourceLocation(), D, RefersToCapturedVariable, 1630 NameInfo, Ty, VK, FoundD); 1631 } 1632 1633 MarkDeclRefReferenced(E); 1634 1635 if (getLangOpts().ObjCARCWeak && isa<VarDecl>(D) && 1636 Ty.getObjCLifetime() == Qualifiers::OCL_Weak && 1637 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, E->getLocStart())) 1638 recordUseOfEvaluatedWeak(E); 1639 1640 // Just in case we're building an illegal pointer-to-member. 1641 FieldDecl *FD = dyn_cast<FieldDecl>(D); 1642 if (FD && FD->isBitField()) 1643 E->setObjectKind(OK_BitField); 1644 1645 return E; 1646} 1647 1648/// Decomposes the given name into a DeclarationNameInfo, its location, and 1649/// possibly a list of template arguments. 1650/// 1651/// If this produces template arguments, it is permitted to call 1652/// DecomposeTemplateName. 1653/// 1654/// This actually loses a lot of source location information for 1655/// non-standard name kinds; we should consider preserving that in 1656/// some way. 1657void 1658Sema::DecomposeUnqualifiedId(const UnqualifiedId &Id, 1659 TemplateArgumentListInfo &Buffer, 1660 DeclarationNameInfo &NameInfo, 1661 const TemplateArgumentListInfo *&TemplateArgs) { 1662 if (Id.getKind() == UnqualifiedId::IK_TemplateId) { 1663 Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc); 1664 Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc); 1665 1666 ASTTemplateArgsPtr TemplateArgsPtr(Id.TemplateId->getTemplateArgs(), 1667 Id.TemplateId->NumArgs); 1668 translateTemplateArguments(TemplateArgsPtr, Buffer); 1669 1670 TemplateName TName = Id.TemplateId->Template.get(); 1671 SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc; 1672 NameInfo = Context.getNameForTemplate(TName, TNameLoc); 1673 TemplateArgs = &Buffer; 1674 } else { 1675 NameInfo = GetNameFromUnqualifiedId(Id); 1676 TemplateArgs = nullptr; 1677 } 1678} 1679 1680static void emitEmptyLookupTypoDiagnostic( 1681 const TypoCorrection &TC, Sema &SemaRef, const CXXScopeSpec &SS, 1682 DeclarationName Typo, SourceLocation TypoLoc, ArrayRef<Expr *> Args, 1683 unsigned DiagnosticID, unsigned DiagnosticSuggestID) { 1684 DeclContext *Ctx = 1685 SS.isEmpty() ? nullptr : SemaRef.computeDeclContext(SS, false); 1686 if (!TC) { 1687 // Emit a special diagnostic for failed member lookups. 1688 // FIXME: computing the declaration context might fail here (?) 1689 if (Ctx) 1690 SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << Ctx 1691 << SS.getRange(); 1692 else 1693 SemaRef.Diag(TypoLoc, DiagnosticID) << Typo; 1694 return; 1695 } 1696 1697 std::string CorrectedStr = TC.getAsString(SemaRef.getLangOpts()); 1698 bool DroppedSpecifier = 1699 TC.WillReplaceSpecifier() && Typo.getAsString() == CorrectedStr; 1700 unsigned NoteID = 1701 (TC.getCorrectionDecl() && isa<ImplicitParamDecl>(TC.getCorrectionDecl())) 1702 ? diag::note_implicit_param_decl 1703 : diag::note_previous_decl; 1704 if (!Ctx) 1705 SemaRef.diagnoseTypo(TC, SemaRef.PDiag(DiagnosticSuggestID) << Typo, 1706 SemaRef.PDiag(NoteID)); 1707 else 1708 SemaRef.diagnoseTypo(TC, SemaRef.PDiag(diag::err_no_member_suggest) 1709 << Typo << Ctx << DroppedSpecifier 1710 << SS.getRange(), 1711 SemaRef.PDiag(NoteID)); 1712} 1713 1714/// Diagnose an empty lookup. 1715/// 1716/// \return false if new lookup candidates were found 1717bool 1718Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, 1719 std::unique_ptr<CorrectionCandidateCallback> CCC, 1720 TemplateArgumentListInfo *ExplicitTemplateArgs, 1721 ArrayRef<Expr *> Args, TypoExpr **Out) { 1722 DeclarationName Name = R.getLookupName(); 1723 1724 unsigned diagnostic = diag::err_undeclared_var_use; 1725 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest; 1726 if (Name.getNameKind() == DeclarationName::CXXOperatorName || 1727 Name.getNameKind() == DeclarationName::CXXLiteralOperatorName || 1728 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 1729 diagnostic = diag::err_undeclared_use; 1730 diagnostic_suggest = diag::err_undeclared_use_suggest; 1731 } 1732 1733 // If the original lookup was an unqualified lookup, fake an 1734 // unqualified lookup. This is useful when (for example) the 1735 // original lookup would not have found something because it was a 1736 // dependent name. 1737 DeclContext *DC = (SS.isEmpty() && !CallsUndergoingInstantiation.empty()) 1738 ? CurContext : nullptr; 1739 while (DC) { 1740 if (isa<CXXRecordDecl>(DC)) { 1741 LookupQualifiedName(R, DC); 1742 1743 if (!R.empty()) { 1744 // Don't give errors about ambiguities in this lookup. 1745 R.suppressDiagnostics(); 1746 1747 // During a default argument instantiation the CurContext points 1748 // to a CXXMethodDecl; but we can't apply a this-> fixit inside a 1749 // function parameter list, hence add an explicit check. 1750 bool isDefaultArgument = !ActiveTemplateInstantiations.empty() && 1751 ActiveTemplateInstantiations.back().Kind == 1752 ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation; 1753 CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext); 1754 bool isInstance = CurMethod && 1755 CurMethod->isInstance() && 1756 DC == CurMethod->getParent() && !isDefaultArgument; 1757 1758 1759 // Give a code modification hint to insert 'this->'. 1760 // TODO: fixit for inserting 'Base<T>::' in the other cases. 1761 // Actually quite difficult! 1762 if (getLangOpts().MSVCCompat) 1763 diagnostic = diag::ext_found_via_dependent_bases_lookup; 1764 if (isInstance) { 1765 Diag(R.getNameLoc(), diagnostic) << Name 1766 << FixItHint::CreateInsertion(R.getNameLoc(), "this->"); 1767 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>( 1768 CallsUndergoingInstantiation.back()->getCallee()); 1769 1770 CXXMethodDecl *DepMethod; 1771 if (CurMethod->isDependentContext()) 1772 DepMethod = CurMethod; 1773 else if (CurMethod->getTemplatedKind() == 1774 FunctionDecl::TK_FunctionTemplateSpecialization) 1775 DepMethod = cast<CXXMethodDecl>(CurMethod->getPrimaryTemplate()-> 1776 getInstantiatedFromMemberTemplate()->getTemplatedDecl()); 1777 else 1778 DepMethod = cast<CXXMethodDecl>( 1779 CurMethod->getInstantiatedFromMemberFunction()); 1780 assert(DepMethod && "No template pattern found"); 1781 1782 QualType DepThisType = DepMethod->getThisType(Context); 1783 CheckCXXThisCapture(R.getNameLoc()); 1784 CXXThisExpr *DepThis = new (Context) CXXThisExpr( 1785 R.getNameLoc(), DepThisType, false); 1786 TemplateArgumentListInfo TList; 1787 if (ULE->hasExplicitTemplateArgs()) 1788 ULE->copyTemplateArgumentsInto(TList); 1789 1790 CXXScopeSpec SS; 1791 SS.Adopt(ULE->getQualifierLoc()); 1792 CXXDependentScopeMemberExpr *DepExpr = 1793 CXXDependentScopeMemberExpr::Create( 1794 Context, DepThis, DepThisType, true, SourceLocation(), 1795 SS.getWithLocInContext(Context), 1796 ULE->getTemplateKeywordLoc(), nullptr, 1797 R.getLookupNameInfo(), 1798 ULE->hasExplicitTemplateArgs() ? &TList : nullptr); 1799 CallsUndergoingInstantiation.back()->setCallee(DepExpr); 1800 } else { 1801 Diag(R.getNameLoc(), diagnostic) << Name; 1802 } 1803 1804 // Do we really want to note all of these? 1805 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) 1806 Diag((*I)->getLocation(), diag::note_dependent_var_use); 1807 1808 // Return true if we are inside a default argument instantiation 1809 // and the found name refers to an instance member function, otherwise 1810 // the function calling DiagnoseEmptyLookup will try to create an 1811 // implicit member call and this is wrong for default argument. 1812 if (isDefaultArgument && ((*R.begin())->isCXXInstanceMember())) { 1813 Diag(R.getNameLoc(), diag::err_member_call_without_object); 1814 return true; 1815 } 1816 1817 // Tell the callee to try to recover. 1818 return false; 1819 } 1820 1821 R.clear(); 1822 } 1823 1824 // In Microsoft mode, if we are performing lookup from within a friend 1825 // function definition declared at class scope then we must set 1826 // DC to the lexical parent to be able to search into the parent 1827 // class. 1828 if (getLangOpts().MSVCCompat && isa<FunctionDecl>(DC) && 1829 cast<FunctionDecl>(DC)->getFriendObjectKind() && 1830 DC->getLexicalParent()->isRecord()) 1831 DC = DC->getLexicalParent(); 1832 else 1833 DC = DC->getParent(); 1834 } 1835 1836 // We didn't find anything, so try to correct for a typo. 1837 TypoCorrection Corrected; 1838 if (S && Out) { 1839 SourceLocation TypoLoc = R.getNameLoc(); 1840 assert(!ExplicitTemplateArgs && 1841 "Diagnosing an empty lookup with explicit template args!"); 1842 *Out = CorrectTypoDelayed( 1843 R.getLookupNameInfo(), R.getLookupKind(), S, &SS, std::move(CCC), 1844 [=](const TypoCorrection &TC) { 1845 emitEmptyLookupTypoDiagnostic(TC, *this, SS, Name, TypoLoc, Args, 1846 diagnostic, diagnostic_suggest); 1847 }, 1848 nullptr, CTK_ErrorRecovery); 1849 if (*Out) 1850 return true; 1851 } else if (S && (Corrected = 1852 CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, 1853 &SS, std::move(CCC), CTK_ErrorRecovery))) { 1854 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 1855 bool DroppedSpecifier = 1856 Corrected.WillReplaceSpecifier() && Name.getAsString() == CorrectedStr; 1857 R.setLookupName(Corrected.getCorrection()); 1858 1859 bool AcceptableWithRecovery = false; 1860 bool AcceptableWithoutRecovery = false; 1861 NamedDecl *ND = Corrected.getCorrectionDecl(); 1862 if (ND) { 1863 if (Corrected.isOverloaded()) { 1864 OverloadCandidateSet OCS(R.getNameLoc(), 1865 OverloadCandidateSet::CSK_Normal); 1866 OverloadCandidateSet::iterator Best; 1867 for (TypoCorrection::decl_iterator CD = Corrected.begin(), 1868 CDEnd = Corrected.end(); 1869 CD != CDEnd; ++CD) { 1870 if (FunctionTemplateDecl *FTD = 1871 dyn_cast<FunctionTemplateDecl>(*CD)) 1872 AddTemplateOverloadCandidate( 1873 FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs, 1874 Args, OCS); 1875 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD)) 1876 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0) 1877 AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), 1878 Args, OCS); 1879 } 1880 switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) { 1881 case OR_Success: 1882 ND = Best->Function; 1883 Corrected.setCorrectionDecl(ND); 1884 break; 1885 default: 1886 // FIXME: Arbitrarily pick the first declaration for the note. 1887 Corrected.setCorrectionDecl(ND); 1888 break; 1889 } 1890 } 1891 R.addDecl(ND); 1892 if (getLangOpts().CPlusPlus && ND->isCXXClassMember()) { 1893 CXXRecordDecl *Record = nullptr; 1894 if (Corrected.getCorrectionSpecifier()) { 1895 const Type *Ty = Corrected.getCorrectionSpecifier()->getAsType(); 1896 Record = Ty->getAsCXXRecordDecl(); 1897 } 1898 if (!Record) 1899 Record = cast<CXXRecordDecl>( 1900 ND->getDeclContext()->getRedeclContext()); 1901 R.setNamingClass(Record); 1902 } 1903 1904 AcceptableWithRecovery = 1905 isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND); 1906 // FIXME: If we ended up with a typo for a type name or 1907 // Objective-C class name, we're in trouble because the parser 1908 // is in the wrong place to recover. Suggest the typo 1909 // correction, but don't make it a fix-it since we're not going 1910 // to recover well anyway. 1911 AcceptableWithoutRecovery = 1912 isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND); 1913 } else { 1914 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it 1915 // because we aren't able to recover. 1916 AcceptableWithoutRecovery = true; 1917 } 1918 1919 if (AcceptableWithRecovery || AcceptableWithoutRecovery) { 1920 unsigned NoteID = (Corrected.getCorrectionDecl() && 1921 isa<ImplicitParamDecl>(Corrected.getCorrectionDecl())) 1922 ? diag::note_implicit_param_decl 1923 : diag::note_previous_decl; 1924 if (SS.isEmpty()) 1925 diagnoseTypo(Corrected, PDiag(diagnostic_suggest) << Name, 1926 PDiag(NoteID), AcceptableWithRecovery); 1927 else 1928 diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest) 1929 << Name << computeDeclContext(SS, false) 1930 << DroppedSpecifier << SS.getRange(), 1931 PDiag(NoteID), AcceptableWithRecovery); 1932 1933 // Tell the callee whether to try to recover. 1934 return !AcceptableWithRecovery; 1935 } 1936 } 1937 R.clear(); 1938 1939 // Emit a special diagnostic for failed member lookups. 1940 // FIXME: computing the declaration context might fail here (?) 1941 if (!SS.isEmpty()) { 1942 Diag(R.getNameLoc(), diag::err_no_member) 1943 << Name << computeDeclContext(SS, false) 1944 << SS.getRange(); 1945 return true; 1946 } 1947 1948 // Give up, we can't recover. 1949 Diag(R.getNameLoc(), diagnostic) << Name; 1950 return true; 1951} 1952 1953/// In Microsoft mode, if we are inside a template class whose parent class has 1954/// dependent base classes, and we can't resolve an unqualified identifier, then 1955/// assume the identifier is a member of a dependent base class. We can only 1956/// recover successfully in static methods, instance methods, and other contexts 1957/// where 'this' is available. This doesn't precisely match MSVC's 1958/// instantiation model, but it's close enough. 1959static Expr * 1960recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context, 1961 DeclarationNameInfo &NameInfo, 1962 SourceLocation TemplateKWLoc, 1963 const TemplateArgumentListInfo *TemplateArgs) { 1964 // Only try to recover from lookup into dependent bases in static methods or 1965 // contexts where 'this' is available. 1966 QualType ThisType = S.getCurrentThisType(); 1967 const CXXRecordDecl *RD = nullptr; 1968 if (!ThisType.isNull()) 1969 RD = ThisType->getPointeeType()->getAsCXXRecordDecl(); 1970 else if (auto *MD = dyn_cast<CXXMethodDecl>(S.CurContext)) 1971 RD = MD->getParent(); 1972 if (!RD || !RD->hasAnyDependentBases()) 1973 return nullptr; 1974 1975 // Diagnose this as unqualified lookup into a dependent base class. If 'this' 1976 // is available, suggest inserting 'this->' as a fixit. 1977 SourceLocation Loc = NameInfo.getLoc(); 1978 auto DB = S.Diag(Loc, diag::ext_undeclared_unqual_id_with_dependent_base); 1979 DB << NameInfo.getName() << RD; 1980 1981 if (!ThisType.isNull()) { 1982 DB << FixItHint::CreateInsertion(Loc, "this->"); 1983 return CXXDependentScopeMemberExpr::Create( 1984 Context, /*This=*/nullptr, ThisType, /*IsArrow=*/true, 1985 /*Op=*/SourceLocation(), NestedNameSpecifierLoc(), TemplateKWLoc, 1986 /*FirstQualifierInScope=*/nullptr, NameInfo, TemplateArgs); 1987 } 1988 1989 // Synthesize a fake NNS that points to the derived class. This will 1990 // perform name lookup during template instantiation. 1991 CXXScopeSpec SS; 1992 auto *NNS = 1993 NestedNameSpecifier::Create(Context, nullptr, true, RD->getTypeForDecl()); 1994 SS.MakeTrivial(Context, NNS, SourceRange(Loc, Loc)); 1995 return DependentScopeDeclRefExpr::Create( 1996 Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo, 1997 TemplateArgs); 1998} 1999 2000ExprResult 2001Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS, 2002 SourceLocation TemplateKWLoc, UnqualifiedId &Id, 2003 bool HasTrailingLParen, bool IsAddressOfOperand, 2004 std::unique_ptr<CorrectionCandidateCallback> CCC, 2005 bool IsInlineAsmIdentifier, Token *KeywordReplacement) { 2006 assert(!(IsAddressOfOperand && HasTrailingLParen) && 2007 "cannot be direct & operand and have a trailing lparen"); 2008 if (SS.isInvalid()) 2009 return ExprError(); 2010 2011 TemplateArgumentListInfo TemplateArgsBuffer; 2012 2013 // Decompose the UnqualifiedId into the following data. 2014 DeclarationNameInfo NameInfo; 2015 const TemplateArgumentListInfo *TemplateArgs; 2016 DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs); 2017 2018 DeclarationName Name = NameInfo.getName(); 2019 IdentifierInfo *II = Name.getAsIdentifierInfo(); 2020 SourceLocation NameLoc = NameInfo.getLoc(); 2021 2022 // C++ [temp.dep.expr]p3: 2023 // An id-expression is type-dependent if it contains: 2024 // -- an identifier that was declared with a dependent type, 2025 // (note: handled after lookup) 2026 // -- a template-id that is dependent, 2027 // (note: handled in BuildTemplateIdExpr) 2028 // -- a conversion-function-id that specifies a dependent type, 2029 // -- a nested-name-specifier that contains a class-name that 2030 // names a dependent type. 2031 // Determine whether this is a member of an unknown specialization; 2032 // we need to handle these differently. 2033 bool DependentID = false; 2034 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName && 2035 Name.getCXXNameType()->isDependentType()) { 2036 DependentID = true; 2037 } else if (SS.isSet()) { 2038 if (DeclContext *DC = computeDeclContext(SS, false)) { 2039 if (RequireCompleteDeclContext(SS, DC)) 2040 return ExprError(); 2041 } else { 2042 DependentID = true; 2043 } 2044 } 2045 2046 if (DependentID) 2047 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 2048 IsAddressOfOperand, TemplateArgs); 2049 2050 // Perform the required lookup. 2051 LookupResult R(*this, NameInfo, 2052 (Id.getKind() == UnqualifiedId::IK_ImplicitSelfParam) 2053 ? LookupObjCImplicitSelfParam : LookupOrdinaryName); 2054 if (TemplateArgs) { 2055 // Lookup the template name again to correctly establish the context in 2056 // which it was found. This is really unfortunate as we already did the 2057 // lookup to determine that it was a template name in the first place. If 2058 // this becomes a performance hit, we can work harder to preserve those 2059 // results until we get here but it's likely not worth it. 2060 bool MemberOfUnknownSpecialization; 2061 LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false, 2062 MemberOfUnknownSpecialization); 2063 2064 if (MemberOfUnknownSpecialization || 2065 (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)) 2066 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 2067 IsAddressOfOperand, TemplateArgs); 2068 } else { 2069 bool IvarLookupFollowUp = II && !SS.isSet() && getCurMethodDecl(); 2070 LookupParsedName(R, S, &SS, !IvarLookupFollowUp); 2071 2072 // If the result might be in a dependent base class, this is a dependent 2073 // id-expression. 2074 if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation) 2075 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 2076 IsAddressOfOperand, TemplateArgs); 2077 2078 // If this reference is in an Objective-C method, then we need to do 2079 // some special Objective-C lookup, too. 2080 if (IvarLookupFollowUp) { 2081 ExprResult E(LookupInObjCMethod(R, S, II, true)); 2082 if (E.isInvalid()) 2083 return ExprError(); 2084 2085 if (Expr *Ex = E.getAs<Expr>()) 2086 return Ex; 2087 } 2088 } 2089 2090 if (R.isAmbiguous()) 2091 return ExprError(); 2092 2093 // This could be an implicitly declared function reference (legal in C90, 2094 // extension in C99, forbidden in C++). 2095 if (R.empty() && HasTrailingLParen && II && !getLangOpts().CPlusPlus) { 2096 NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S); 2097 if (D) R.addDecl(D); 2098 } 2099 2100 // Determine whether this name might be a candidate for 2101 // argument-dependent lookup. 2102 bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen); 2103 2104 if (R.empty() && !ADL) { 2105 if (SS.isEmpty() && getLangOpts().MSVCCompat) { 2106 if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo, 2107 TemplateKWLoc, TemplateArgs)) 2108 return E; 2109 } 2110 2111 // Don't diagnose an empty lookup for inline assembly. 2112 if (IsInlineAsmIdentifier) 2113 return ExprError(); 2114 2115 // If this name wasn't predeclared and if this is not a function 2116 // call, diagnose the problem. 2117 TypoExpr *TE = nullptr; 2118 auto DefaultValidator = llvm::make_unique<CorrectionCandidateCallback>( 2119 II, SS.isValid() ? SS.getScopeRep() : nullptr); 2120 DefaultValidator->IsAddressOfOperand = IsAddressOfOperand; 2121 assert((!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) && 2122 "Typo correction callback misconfigured"); 2123 if (CCC) { 2124 // Make sure the callback knows what the typo being diagnosed is. 2125 CCC->setTypoName(II); 2126 if (SS.isValid()) 2127 CCC->setTypoNNS(SS.getScopeRep()); 2128 } 2129 if (DiagnoseEmptyLookup(S, SS, R, 2130 CCC ? std::move(CCC) : std::move(DefaultValidator), 2131 nullptr, None, &TE)) { 2132 if (TE && KeywordReplacement) { 2133 auto &State = getTypoExprState(TE); 2134 auto BestTC = State.Consumer->getNextCorrection(); 2135 if (BestTC.isKeyword()) { 2136 auto *II = BestTC.getCorrectionAsIdentifierInfo(); 2137 if (State.DiagHandler) 2138 State.DiagHandler(BestTC); 2139 KeywordReplacement->startToken(); 2140 KeywordReplacement->setKind(II->getTokenID()); 2141 KeywordReplacement->setIdentifierInfo(II); 2142 KeywordReplacement->setLocation(BestTC.getCorrectionRange().getBegin()); 2143 // Clean up the state associated with the TypoExpr, since it has 2144 // now been diagnosed (without a call to CorrectDelayedTyposInExpr). 2145 clearDelayedTypo(TE); 2146 // Signal that a correction to a keyword was performed by returning a 2147 // valid-but-null ExprResult. 2148 return (Expr*)nullptr; 2149 } 2150 State.Consumer->resetCorrectionStream(); 2151 } 2152 return TE ? TE : ExprError(); 2153 } 2154 2155 assert(!R.empty() && 2156 "DiagnoseEmptyLookup returned false but added no results"); 2157 2158 // If we found an Objective-C instance variable, let 2159 // LookupInObjCMethod build the appropriate expression to 2160 // reference the ivar. 2161 if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) { 2162 R.clear(); 2163 ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier())); 2164 // In a hopelessly buggy code, Objective-C instance variable 2165 // lookup fails and no expression will be built to reference it. 2166 if (!E.isInvalid() && !E.get()) 2167 return ExprError(); 2168 return E; 2169 } 2170 } 2171 2172 // This is guaranteed from this point on. 2173 assert(!R.empty() || ADL); 2174 2175 // Check whether this might be a C++ implicit instance member access. 2176 // C++ [class.mfct.non-static]p3: 2177 // When an id-expression that is not part of a class member access 2178 // syntax and not used to form a pointer to member is used in the 2179 // body of a non-static member function of class X, if name lookup 2180 // resolves the name in the id-expression to a non-static non-type 2181 // member of some class C, the id-expression is transformed into a 2182 // class member access expression using (*this) as the 2183 // postfix-expression to the left of the . operator. 2184 // 2185 // But we don't actually need to do this for '&' operands if R 2186 // resolved to a function or overloaded function set, because the 2187 // expression is ill-formed if it actually works out to be a 2188 // non-static member function: 2189 // 2190 // C++ [expr.ref]p4: 2191 // Otherwise, if E1.E2 refers to a non-static member function. . . 2192 // [t]he expression can be used only as the left-hand operand of a 2193 // member function call. 2194 // 2195 // There are other safeguards against such uses, but it's important 2196 // to get this right here so that we don't end up making a 2197 // spuriously dependent expression if we're inside a dependent 2198 // instance method. 2199 if (!R.empty() && (*R.begin())->isCXXClassMember()) { 2200 bool MightBeImplicitMember; 2201 if (!IsAddressOfOperand) 2202 MightBeImplicitMember = true; 2203 else if (!SS.isEmpty()) 2204 MightBeImplicitMember = false; 2205 else if (R.isOverloadedResult()) 2206 MightBeImplicitMember = false; 2207 else if (R.isUnresolvableResult()) 2208 MightBeImplicitMember = true; 2209 else 2210 MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) || 2211 isa<IndirectFieldDecl>(R.getFoundDecl()) || 2212 isa<MSPropertyDecl>(R.getFoundDecl()); 2213 2214 if (MightBeImplicitMember) 2215 return BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, 2216 R, TemplateArgs); 2217 } 2218 2219 if (TemplateArgs || TemplateKWLoc.isValid()) { 2220 2221 // In C++1y, if this is a variable template id, then check it 2222 // in BuildTemplateIdExpr(). 2223 // The single lookup result must be a variable template declaration. 2224 if (Id.getKind() == UnqualifiedId::IK_TemplateId && Id.TemplateId && 2225 Id.TemplateId->Kind == TNK_Var_template) { 2226 assert(R.getAsSingle<VarTemplateDecl>() && 2227 "There should only be one declaration found."); 2228 } 2229 2230 return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs); 2231 } 2232 2233 return BuildDeclarationNameExpr(SS, R, ADL); 2234} 2235 2236/// BuildQualifiedDeclarationNameExpr - Build a C++ qualified 2237/// declaration name, generally during template instantiation. 2238/// There's a large number of things which don't need to be done along 2239/// this path. 2240ExprResult 2241Sema::BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, 2242 const DeclarationNameInfo &NameInfo, 2243 bool IsAddressOfOperand, 2244 TypeSourceInfo **RecoveryTSI) { 2245 DeclContext *DC = computeDeclContext(SS, false); 2246 if (!DC) 2247 return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(), 2248 NameInfo, /*TemplateArgs=*/nullptr); 2249 2250 if (RequireCompleteDeclContext(SS, DC)) 2251 return ExprError(); 2252 2253 LookupResult R(*this, NameInfo, LookupOrdinaryName); 2254 LookupQualifiedName(R, DC); 2255 2256 if (R.isAmbiguous()) 2257 return ExprError(); 2258 2259 if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation) 2260 return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(), 2261 NameInfo, /*TemplateArgs=*/nullptr); 2262 2263 if (R.empty()) { 2264 Diag(NameInfo.getLoc(), diag::err_no_member) 2265 << NameInfo.getName() << DC << SS.getRange(); 2266 return ExprError(); 2267 } 2268 2269 if (const TypeDecl *TD = R.getAsSingle<TypeDecl>()) { 2270 // Diagnose a missing typename if this resolved unambiguously to a type in 2271 // a dependent context. If we can recover with a type, downgrade this to 2272 // a warning in Microsoft compatibility mode. 2273 unsigned DiagID = diag::err_typename_missing; 2274 if (RecoveryTSI && getLangOpts().MSVCCompat) 2275 DiagID = diag::ext_typename_missing; 2276 SourceLocation Loc = SS.getBeginLoc(); 2277 auto D = Diag(Loc, DiagID); 2278 D << SS.getScopeRep() << NameInfo.getName().getAsString() 2279 << SourceRange(Loc, NameInfo.getEndLoc()); 2280 2281 // Don't recover if the caller isn't expecting us to or if we're in a SFINAE 2282 // context. 2283 if (!RecoveryTSI) 2284 return ExprError(); 2285 2286 // Only issue the fixit if we're prepared to recover. 2287 D << FixItHint::CreateInsertion(Loc, "typename "); 2288 2289 // Recover by pretending this was an elaborated type. 2290 QualType Ty = Context.getTypeDeclType(TD); 2291 TypeLocBuilder TLB; 2292 TLB.pushTypeSpec(Ty).setNameLoc(NameInfo.getLoc()); 2293 2294 QualType ET = getElaboratedType(ETK_None, SS, Ty); 2295 ElaboratedTypeLoc QTL = TLB.push<ElaboratedTypeLoc>(ET); 2296 QTL.setElaboratedKeywordLoc(SourceLocation()); 2297 QTL.setQualifierLoc(SS.getWithLocInContext(Context)); 2298 2299 *RecoveryTSI = TLB.getTypeSourceInfo(Context, ET); 2300 2301 return ExprEmpty(); 2302 } 2303 2304 // Defend against this resolving to an implicit member access. We usually 2305 // won't get here if this might be a legitimate a class member (we end up in 2306 // BuildMemberReferenceExpr instead), but this can be valid if we're forming 2307 // a pointer-to-member or in an unevaluated context in C++11. 2308 if (!R.empty() && (*R.begin())->isCXXClassMember() && !IsAddressOfOperand) 2309 return BuildPossibleImplicitMemberExpr(SS, 2310 /*TemplateKWLoc=*/SourceLocation(), 2311 R, /*TemplateArgs=*/nullptr); 2312 2313 return BuildDeclarationNameExpr(SS, R, /* ADL */ false); 2314} 2315 2316/// LookupInObjCMethod - The parser has read a name in, and Sema has 2317/// detected that we're currently inside an ObjC method. Perform some 2318/// additional lookup. 2319/// 2320/// Ideally, most of this would be done by lookup, but there's 2321/// actually quite a lot of extra work involved. 2322/// 2323/// Returns a null sentinel to indicate trivial success. 2324ExprResult 2325Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S, 2326 IdentifierInfo *II, bool AllowBuiltinCreation) { 2327 SourceLocation Loc = Lookup.getNameLoc(); 2328 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 2329 2330 // Check for error condition which is already reported. 2331 if (!CurMethod) 2332 return ExprError(); 2333 2334 // There are two cases to handle here. 1) scoped lookup could have failed, 2335 // in which case we should look for an ivar. 2) scoped lookup could have 2336 // found a decl, but that decl is outside the current instance method (i.e. 2337 // a global variable). In these two cases, we do a lookup for an ivar with 2338 // this name, if the lookup sucedes, we replace it our current decl. 2339 2340 // If we're in a class method, we don't normally want to look for 2341 // ivars. But if we don't find anything else, and there's an 2342 // ivar, that's an error. 2343 bool IsClassMethod = CurMethod->isClassMethod(); 2344 2345 bool LookForIvars; 2346 if (Lookup.empty()) 2347 LookForIvars = true; 2348 else if (IsClassMethod) 2349 LookForIvars = false; 2350 else 2351 LookForIvars = (Lookup.isSingleResult() && 2352 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()); 2353 ObjCInterfaceDecl *IFace = nullptr; 2354 if (LookForIvars) { 2355 IFace = CurMethod->getClassInterface(); 2356 ObjCInterfaceDecl *ClassDeclared; 2357 ObjCIvarDecl *IV = nullptr; 2358 if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) { 2359 // Diagnose using an ivar in a class method. 2360 if (IsClassMethod) 2361 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 2362 << IV->getDeclName()); 2363 2364 // If we're referencing an invalid decl, just return this as a silent 2365 // error node. The error diagnostic was already emitted on the decl. 2366 if (IV->isInvalidDecl()) 2367 return ExprError(); 2368 2369 // Check if referencing a field with __attribute__((deprecated)). 2370 if (DiagnoseUseOfDecl(IV, Loc)) 2371 return ExprError(); 2372 2373 // Diagnose the use of an ivar outside of the declaring class. 2374 if (IV->getAccessControl() == ObjCIvarDecl::Private && 2375 !declaresSameEntity(ClassDeclared, IFace) && 2376 !getLangOpts().DebuggerSupport) 2377 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName(); 2378 2379 // FIXME: This should use a new expr for a direct reference, don't 2380 // turn this into Self->ivar, just return a BareIVarExpr or something. 2381 IdentifierInfo &II = Context.Idents.get("self"); 2382 UnqualifiedId SelfName; 2383 SelfName.setIdentifier(&II, SourceLocation()); 2384 SelfName.setKind(UnqualifiedId::IK_ImplicitSelfParam); 2385 CXXScopeSpec SelfScopeSpec; 2386 SourceLocation TemplateKWLoc; 2387 ExprResult SelfExpr = ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc, 2388 SelfName, false, false); 2389 if (SelfExpr.isInvalid()) 2390 return ExprError(); 2391 2392 SelfExpr = DefaultLvalueConversion(SelfExpr.get()); 2393 if (SelfExpr.isInvalid()) 2394 return ExprError(); 2395 2396 MarkAnyDeclReferenced(Loc, IV, true); 2397 2398 ObjCMethodFamily MF = CurMethod->getMethodFamily(); 2399 if (MF != OMF_init && MF != OMF_dealloc && MF != OMF_finalize && 2400 !IvarBacksCurrentMethodAccessor(IFace, CurMethod, IV)) 2401 Diag(Loc, diag::warn_direct_ivar_access) << IV->getDeclName(); 2402 2403 ObjCIvarRefExpr *Result = new (Context) 2404 ObjCIvarRefExpr(IV, IV->getType(), Loc, IV->getLocation(), 2405 SelfExpr.get(), true, true); 2406 2407 if (getLangOpts().ObjCAutoRefCount) { 2408 if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) { 2409 if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, Loc)) 2410 recordUseOfEvaluatedWeak(Result); 2411 } 2412 if (CurContext->isClosure()) 2413 Diag(Loc, diag::warn_implicitly_retains_self) 2414 << FixItHint::CreateInsertion(Loc, "self->"); 2415 } 2416 2417 return Result; 2418 } 2419 } else if (CurMethod->isInstanceMethod()) { 2420 // We should warn if a local variable hides an ivar. 2421 if (ObjCInterfaceDecl *IFace = CurMethod->getClassInterface()) { 2422 ObjCInterfaceDecl *ClassDeclared; 2423 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) { 2424 if (IV->getAccessControl() != ObjCIvarDecl::Private || 2425 declaresSameEntity(IFace, ClassDeclared)) 2426 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName(); 2427 } 2428 } 2429 } else if (Lookup.isSingleResult() && 2430 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()) { 2431 // If accessing a stand-alone ivar in a class method, this is an error. 2432 if (const ObjCIvarDecl *IV = dyn_cast<ObjCIvarDecl>(Lookup.getFoundDecl())) 2433 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 2434 << IV->getDeclName()); 2435 } 2436 2437 if (Lookup.empty() && II && AllowBuiltinCreation) { 2438 // FIXME. Consolidate this with similar code in LookupName. 2439 if (unsigned BuiltinID = II->getBuiltinID()) { 2440 if (!(getLangOpts().CPlusPlus && 2441 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) { 2442 NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID, 2443 S, Lookup.isForRedeclaration(), 2444 Lookup.getNameLoc()); 2445 if (D) Lookup.addDecl(D); 2446 } 2447 } 2448 } 2449 // Sentinel value saying that we didn't do anything special. 2450 return ExprResult((Expr *)nullptr); 2451} 2452 2453/// \brief Cast a base object to a member's actual type. 2454/// 2455/// Logically this happens in three phases: 2456/// 2457/// * First we cast from the base type to the naming class. 2458/// The naming class is the class into which we were looking 2459/// when we found the member; it's the qualifier type if a 2460/// qualifier was provided, and otherwise it's the base type. 2461/// 2462/// * Next we cast from the naming class to the declaring class. 2463/// If the member we found was brought into a class's scope by 2464/// a using declaration, this is that class; otherwise it's 2465/// the class declaring the member. 2466/// 2467/// * Finally we cast from the declaring class to the "true" 2468/// declaring class of the member. This conversion does not 2469/// obey access control. 2470ExprResult 2471Sema::PerformObjectMemberConversion(Expr *From, 2472 NestedNameSpecifier *Qualifier, 2473 NamedDecl *FoundDecl, 2474 NamedDecl *Member) { 2475 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext()); 2476 if (!RD) 2477 return From; 2478 2479 QualType DestRecordType; 2480 QualType DestType; 2481 QualType FromRecordType; 2482 QualType FromType = From->getType(); 2483 bool PointerConversions = false; 2484 if (isa<FieldDecl>(Member)) { 2485 DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD)); 2486 2487 if (FromType->getAs<PointerType>()) { 2488 DestType = Context.getPointerType(DestRecordType); 2489 FromRecordType = FromType->getPointeeType(); 2490 PointerConversions = true; 2491 } else { 2492 DestType = DestRecordType; 2493 FromRecordType = FromType; 2494 } 2495 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) { 2496 if (Method->isStatic()) 2497 return From; 2498 2499 DestType = Method->getThisType(Context); 2500 DestRecordType = DestType->getPointeeType(); 2501 2502 if (FromType->getAs<PointerType>()) { 2503 FromRecordType = FromType->getPointeeType(); 2504 PointerConversions = true; 2505 } else { 2506 FromRecordType = FromType; 2507 DestType = DestRecordType; 2508 } 2509 } else { 2510 // No conversion necessary. 2511 return From; 2512 } 2513 2514 if (DestType->isDependentType() || FromType->isDependentType()) 2515 return From; 2516 2517 // If the unqualified types are the same, no conversion is necessary. 2518 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 2519 return From; 2520 2521 SourceRange FromRange = From->getSourceRange(); 2522 SourceLocation FromLoc = FromRange.getBegin(); 2523 2524 ExprValueKind VK = From->getValueKind(); 2525 2526 // C++ [class.member.lookup]p8: 2527 // [...] Ambiguities can often be resolved by qualifying a name with its 2528 // class name. 2529 // 2530 // If the member was a qualified name and the qualified referred to a 2531 // specific base subobject type, we'll cast to that intermediate type 2532 // first and then to the object in which the member is declared. That allows 2533 // one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as: 2534 // 2535 // class Base { public: int x; }; 2536 // class Derived1 : public Base { }; 2537 // class Derived2 : public Base { }; 2538 // class VeryDerived : public Derived1, public Derived2 { void f(); }; 2539 // 2540 // void VeryDerived::f() { 2541 // x = 17; // error: ambiguous base subobjects 2542 // Derived1::x = 17; // okay, pick the Base subobject of Derived1 2543 // } 2544 if (Qualifier && Qualifier->getAsType()) { 2545 QualType QType = QualType(Qualifier->getAsType(), 0); 2546 assert(QType->isRecordType() && "lookup done with non-record type"); 2547 2548 QualType QRecordType = QualType(QType->getAs<RecordType>(), 0); 2549 2550 // In C++98, the qualifier type doesn't actually have to be a base 2551 // type of the object type, in which case we just ignore it. 2552 // Otherwise build the appropriate casts. 2553 if (IsDerivedFrom(FromRecordType, QRecordType)) { 2554 CXXCastPath BasePath; 2555 if (CheckDerivedToBaseConversion(FromRecordType, QRecordType, 2556 FromLoc, FromRange, &BasePath)) 2557 return ExprError(); 2558 2559 if (PointerConversions) 2560 QType = Context.getPointerType(QType); 2561 From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase, 2562 VK, &BasePath).get(); 2563 2564 FromType = QType; 2565 FromRecordType = QRecordType; 2566 2567 // If the qualifier type was the same as the destination type, 2568 // we're done. 2569 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 2570 return From; 2571 } 2572 } 2573 2574 bool IgnoreAccess = false; 2575 2576 // If we actually found the member through a using declaration, cast 2577 // down to the using declaration's type. 2578 // 2579 // Pointer equality is fine here because only one declaration of a 2580 // class ever has member declarations. 2581 if (FoundDecl->getDeclContext() != Member->getDeclContext()) { 2582 assert(isa<UsingShadowDecl>(FoundDecl)); 2583 QualType URecordType = Context.getTypeDeclType( 2584 cast<CXXRecordDecl>(FoundDecl->getDeclContext())); 2585 2586 // We only need to do this if the naming-class to declaring-class 2587 // conversion is non-trivial. 2588 if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) { 2589 assert(IsDerivedFrom(FromRecordType, URecordType)); 2590 CXXCastPath BasePath; 2591 if (CheckDerivedToBaseConversion(FromRecordType, URecordType, 2592 FromLoc, FromRange, &BasePath)) 2593 return ExprError(); 2594 2595 QualType UType = URecordType; 2596 if (PointerConversions) 2597 UType = Context.getPointerType(UType); 2598 From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase, 2599 VK, &BasePath).get(); 2600 FromType = UType; 2601 FromRecordType = URecordType; 2602 } 2603 2604 // We don't do access control for the conversion from the 2605 // declaring class to the true declaring class. 2606 IgnoreAccess = true; 2607 } 2608 2609 CXXCastPath BasePath; 2610 if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType, 2611 FromLoc, FromRange, &BasePath, 2612 IgnoreAccess)) 2613 return ExprError(); 2614 2615 return ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase, 2616 VK, &BasePath); 2617} 2618 2619bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS, 2620 const LookupResult &R, 2621 bool HasTrailingLParen) { 2622 // Only when used directly as the postfix-expression of a call. 2623 if (!HasTrailingLParen) 2624 return false; 2625 2626 // Never if a scope specifier was provided. 2627 if (SS.isSet()) 2628 return false; 2629 2630 // Only in C++ or ObjC++. 2631 if (!getLangOpts().CPlusPlus) 2632 return false; 2633 2634 // Turn off ADL when we find certain kinds of declarations during 2635 // normal lookup: 2636 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { 2637 NamedDecl *D = *I; 2638 2639 // C++0x [basic.lookup.argdep]p3: 2640 // -- a declaration of a class member 2641 // Since using decls preserve this property, we check this on the 2642 // original decl. 2643 if (D->isCXXClassMember()) 2644 return false; 2645 2646 // C++0x [basic.lookup.argdep]p3: 2647 // -- a block-scope function declaration that is not a 2648 // using-declaration 2649 // NOTE: we also trigger this for function templates (in fact, we 2650 // don't check the decl type at all, since all other decl types 2651 // turn off ADL anyway). 2652 if (isa<UsingShadowDecl>(D)) 2653 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 2654 else if (D->getLexicalDeclContext()->isFunctionOrMethod()) 2655 return false; 2656 2657 // C++0x [basic.lookup.argdep]p3: 2658 // -- a declaration that is neither a function or a function 2659 // template 2660 // And also for builtin functions. 2661 if (isa<FunctionDecl>(D)) { 2662 FunctionDecl *FDecl = cast<FunctionDecl>(D); 2663 2664 // But also builtin functions. 2665 if (FDecl->getBuiltinID() && FDecl->isImplicit()) 2666 return false; 2667 } else if (!isa<FunctionTemplateDecl>(D)) 2668 return false; 2669 } 2670 2671 return true; 2672} 2673 2674 2675/// Diagnoses obvious problems with the use of the given declaration 2676/// as an expression. This is only actually called for lookups that 2677/// were not overloaded, and it doesn't promise that the declaration 2678/// will in fact be used. 2679static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) { 2680 if (isa<TypedefNameDecl>(D)) { 2681 S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName(); 2682 return true; 2683 } 2684 2685 if (isa<ObjCInterfaceDecl>(D)) { 2686 S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName(); 2687 return true; 2688 } 2689 2690 if (isa<NamespaceDecl>(D)) { 2691 S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName(); 2692 return true; 2693 } 2694 2695 return false; 2696} 2697 2698ExprResult Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2699 LookupResult &R, bool NeedsADL, 2700 bool AcceptInvalidDecl) { 2701 // If this is a single, fully-resolved result and we don't need ADL, 2702 // just build an ordinary singleton decl ref. 2703 if (!NeedsADL && R.isSingleResult() && !R.getAsSingle<FunctionTemplateDecl>()) 2704 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), R.getFoundDecl(), 2705 R.getRepresentativeDecl(), nullptr, 2706 AcceptInvalidDecl); 2707 2708 // We only need to check the declaration if there's exactly one 2709 // result, because in the overloaded case the results can only be 2710 // functions and function templates. 2711 if (R.isSingleResult() && 2712 CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl())) 2713 return ExprError(); 2714 2715 // Otherwise, just build an unresolved lookup expression. Suppress 2716 // any lookup-related diagnostics; we'll hash these out later, when 2717 // we've picked a target. 2718 R.suppressDiagnostics(); 2719 2720 UnresolvedLookupExpr *ULE 2721 = UnresolvedLookupExpr::Create(Context, R.getNamingClass(), 2722 SS.getWithLocInContext(Context), 2723 R.getLookupNameInfo(), 2724 NeedsADL, R.isOverloadedResult(), 2725 R.begin(), R.end()); 2726 2727 return ULE; 2728} 2729 2730/// \brief Complete semantic analysis for a reference to the given declaration. 2731ExprResult Sema::BuildDeclarationNameExpr( 2732 const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D, 2733 NamedDecl *FoundD, const TemplateArgumentListInfo *TemplateArgs, 2734 bool AcceptInvalidDecl) { 2735 assert(D && "Cannot refer to a NULL declaration"); 2736 assert(!isa<FunctionTemplateDecl>(D) && 2737 "Cannot refer unambiguously to a function template"); 2738 2739 SourceLocation Loc = NameInfo.getLoc(); 2740 if (CheckDeclInExpr(*this, Loc, D)) 2741 return ExprError(); 2742 2743 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) { 2744 // Specifically diagnose references to class templates that are missing 2745 // a template argument list. 2746 Diag(Loc, diag::err_template_decl_ref) << (isa<VarTemplateDecl>(D) ? 1 : 0) 2747 << Template << SS.getRange(); 2748 Diag(Template->getLocation(), diag::note_template_decl_here); 2749 return ExprError(); 2750 } 2751 2752 // Make sure that we're referring to a value. 2753 ValueDecl *VD = dyn_cast<ValueDecl>(D); 2754 if (!VD) { 2755 Diag(Loc, diag::err_ref_non_value) 2756 << D << SS.getRange(); 2757 Diag(D->getLocation(), diag::note_declared_at); 2758 return ExprError(); 2759 } 2760 2761 // Check whether this declaration can be used. Note that we suppress 2762 // this check when we're going to perform argument-dependent lookup 2763 // on this function name, because this might not be the function 2764 // that overload resolution actually selects. 2765 if (DiagnoseUseOfDecl(VD, Loc)) 2766 return ExprError(); 2767 2768 // Only create DeclRefExpr's for valid Decl's. 2769 if (VD->isInvalidDecl() && !AcceptInvalidDecl) 2770 return ExprError(); 2771 2772 // Handle members of anonymous structs and unions. If we got here, 2773 // and the reference is to a class member indirect field, then this 2774 // must be the subject of a pointer-to-member expression. 2775 if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD)) 2776 if (!indirectField->isCXXClassMember()) 2777 return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(), 2778 indirectField); 2779 2780 { 2781 QualType type = VD->getType(); 2782 ExprValueKind valueKind = VK_RValue; 2783 2784 switch (D->getKind()) { 2785 // Ignore all the non-ValueDecl kinds. 2786#define ABSTRACT_DECL(kind) 2787#define VALUE(type, base) 2788#define DECL(type, base) \ 2789 case Decl::type: 2790#include "clang/AST/DeclNodes.inc" 2791 llvm_unreachable("invalid value decl kind"); 2792 2793 // These shouldn't make it here. 2794 case Decl::ObjCAtDefsField: 2795 case Decl::ObjCIvar: 2796 llvm_unreachable("forming non-member reference to ivar?"); 2797 2798 // Enum constants are always r-values and never references. 2799 // Unresolved using declarations are dependent. 2800 case Decl::EnumConstant: 2801 case Decl::UnresolvedUsingValue: 2802 valueKind = VK_RValue; 2803 break; 2804 2805 // Fields and indirect fields that got here must be for 2806 // pointer-to-member expressions; we just call them l-values for 2807 // internal consistency, because this subexpression doesn't really 2808 // exist in the high-level semantics. 2809 case Decl::Field: 2810 case Decl::IndirectField: 2811 assert(getLangOpts().CPlusPlus && 2812 "building reference to field in C?"); 2813 2814 // These can't have reference type in well-formed programs, but 2815 // for internal consistency we do this anyway. 2816 type = type.getNonReferenceType(); 2817 valueKind = VK_LValue; 2818 break; 2819 2820 // Non-type template parameters are either l-values or r-values 2821 // depending on the type. 2822 case Decl::NonTypeTemplateParm: { 2823 if (const ReferenceType *reftype = type->getAs<ReferenceType>()) { 2824 type = reftype->getPointeeType(); 2825 valueKind = VK_LValue; // even if the parameter is an r-value reference 2826 break; 2827 } 2828 2829 // For non-references, we need to strip qualifiers just in case 2830 // the template parameter was declared as 'const int' or whatever. 2831 valueKind = VK_RValue; 2832 type = type.getUnqualifiedType(); 2833 break; 2834 } 2835 2836 case Decl::Var: 2837 case Decl::VarTemplateSpecialization: 2838 case Decl::VarTemplatePartialSpecialization: 2839 // In C, "extern void blah;" is valid and is an r-value. 2840 if (!getLangOpts().CPlusPlus && 2841 !type.hasQualifiers() && 2842 type->isVoidType()) { 2843 valueKind = VK_RValue; 2844 break; 2845 } 2846 // fallthrough 2847 2848 case Decl::ImplicitParam: 2849 case Decl::ParmVar: { 2850 // These are always l-values. 2851 valueKind = VK_LValue; 2852 type = type.getNonReferenceType(); 2853 2854 // FIXME: Does the addition of const really only apply in 2855 // potentially-evaluated contexts? Since the variable isn't actually 2856 // captured in an unevaluated context, it seems that the answer is no. 2857 if (!isUnevaluatedContext()) { 2858 QualType CapturedType = getCapturedDeclRefType(cast<VarDecl>(VD), Loc); 2859 if (!CapturedType.isNull()) 2860 type = CapturedType; 2861 } 2862 2863 break; 2864 } 2865 2866 case Decl::Function: { 2867 if (unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) { 2868 if (!Context.BuiltinInfo.isPredefinedLibFunction(BID)) { 2869 type = Context.BuiltinFnTy; 2870 valueKind = VK_RValue; 2871 break; 2872 } 2873 } 2874 2875 const FunctionType *fty = type->castAs<FunctionType>(); 2876 2877 // If we're referring to a function with an __unknown_anytype 2878 // result type, make the entire expression __unknown_anytype. 2879 if (fty->getReturnType() == Context.UnknownAnyTy) { 2880 type = Context.UnknownAnyTy; 2881 valueKind = VK_RValue; 2882 break; 2883 } 2884 2885 // Functions are l-values in C++. 2886 if (getLangOpts().CPlusPlus) { 2887 valueKind = VK_LValue; 2888 break; 2889 } 2890 2891 // C99 DR 316 says that, if a function type comes from a 2892 // function definition (without a prototype), that type is only 2893 // used for checking compatibility. Therefore, when referencing 2894 // the function, we pretend that we don't have the full function 2895 // type. 2896 if (!cast<FunctionDecl>(VD)->hasPrototype() && 2897 isa<FunctionProtoType>(fty)) 2898 type = Context.getFunctionNoProtoType(fty->getReturnType(), 2899 fty->getExtInfo()); 2900 2901 // Functions are r-values in C. 2902 valueKind = VK_RValue; 2903 break; 2904 } 2905 2906 case Decl::MSProperty: 2907 valueKind = VK_LValue; 2908 break; 2909 2910 case Decl::CXXMethod: 2911 // If we're referring to a method with an __unknown_anytype 2912 // result type, make the entire expression __unknown_anytype. 2913 // This should only be possible with a type written directly. 2914 if (const FunctionProtoType *proto 2915 = dyn_cast<FunctionProtoType>(VD->getType())) 2916 if (proto->getReturnType() == Context.UnknownAnyTy) { 2917 type = Context.UnknownAnyTy; 2918 valueKind = VK_RValue; 2919 break; 2920 } 2921 2922 // C++ methods are l-values if static, r-values if non-static. 2923 if (cast<CXXMethodDecl>(VD)->isStatic()) { 2924 valueKind = VK_LValue; 2925 break; 2926 } 2927 // fallthrough 2928 2929 case Decl::CXXConversion: 2930 case Decl::CXXDestructor: 2931 case Decl::CXXConstructor: 2932 valueKind = VK_RValue; 2933 break; 2934 } 2935 2936 return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD, 2937 TemplateArgs); 2938 } 2939} 2940 2941static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source, 2942 SmallString<32> &Target) { 2943 Target.resize(CharByteWidth * (Source.size() + 1)); 2944 char *ResultPtr = &Target[0]; 2945 const UTF8 *ErrorPtr; 2946 bool success = ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr); 2947 (void)success; 2948 assert(success); 2949 Target.resize(ResultPtr - &Target[0]); 2950} 2951 2952ExprResult Sema::BuildPredefinedExpr(SourceLocation Loc, 2953 PredefinedExpr::IdentType IT) { 2954 // Pick the current block, lambda, captured statement or function. 2955 Decl *currentDecl = nullptr; 2956 if (const BlockScopeInfo *BSI = getCurBlock()) 2957 currentDecl = BSI->TheDecl; 2958 else if (const LambdaScopeInfo *LSI = getCurLambda()) 2959 currentDecl = LSI->CallOperator; 2960 else if (const CapturedRegionScopeInfo *CSI = getCurCapturedRegion()) 2961 currentDecl = CSI->TheCapturedDecl; 2962 else 2963 currentDecl = getCurFunctionOrMethodDecl(); 2964 2965 if (!currentDecl) { 2966 Diag(Loc, diag::ext_predef_outside_function); 2967 currentDecl = Context.getTranslationUnitDecl(); 2968 } 2969 2970 QualType ResTy; 2971 StringLiteral *SL = nullptr; 2972 if (cast<DeclContext>(currentDecl)->isDependentContext()) 2973 ResTy = Context.DependentTy; 2974 else { 2975 // Pre-defined identifiers are of type char[x], where x is the length of 2976 // the string. 2977 auto Str = PredefinedExpr::ComputeName(IT, currentDecl); 2978 unsigned Length = Str.length(); 2979 2980 llvm::APInt LengthI(32, Length + 1); 2981 if (IT == PredefinedExpr::LFunction) { 2982 ResTy = Context.WideCharTy.withConst(); 2983 SmallString<32> RawChars; 2984 ConvertUTF8ToWideString(Context.getTypeSizeInChars(ResTy).getQuantity(), 2985 Str, RawChars); 2986 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 2987 /*IndexTypeQuals*/ 0); 2988 SL = StringLiteral::Create(Context, RawChars, StringLiteral::Wide, 2989 /*Pascal*/ false, ResTy, Loc); 2990 } else { 2991 ResTy = Context.CharTy.withConst(); 2992 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 2993 /*IndexTypeQuals*/ 0); 2994 SL = StringLiteral::Create(Context, Str, StringLiteral::Ascii, 2995 /*Pascal*/ false, ResTy, Loc); 2996 } 2997 } 2998 2999 return new (Context) PredefinedExpr(Loc, ResTy, IT, SL); 3000} 3001 3002ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) { 3003 PredefinedExpr::IdentType IT; 3004 3005 switch (Kind) { 3006 default: llvm_unreachable("Unknown simple primary expr!"); 3007 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2] 3008 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break; 3009 case tok::kw___FUNCDNAME__: IT = PredefinedExpr::FuncDName; break; // [MS] 3010 case tok::kw___FUNCSIG__: IT = PredefinedExpr::FuncSig; break; // [MS] 3011 case tok::kw_L__FUNCTION__: IT = PredefinedExpr::LFunction; break; 3012 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break; 3013 } 3014 3015 return BuildPredefinedExpr(Loc, IT); 3016} 3017 3018ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) { 3019 SmallString<16> CharBuffer; 3020 bool Invalid = false; 3021 StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid); 3022 if (Invalid) 3023 return ExprError(); 3024 3025 CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(), 3026 PP, Tok.getKind()); 3027 if (Literal.hadError()) 3028 return ExprError(); 3029 3030 QualType Ty; 3031 if (Literal.isWide()) 3032 Ty = Context.WideCharTy; // L'x' -> wchar_t in C and C++. 3033 else if (Literal.isUTF16()) 3034 Ty = Context.Char16Ty; // u'x' -> char16_t in C11 and C++11. 3035 else if (Literal.isUTF32()) 3036 Ty = Context.Char32Ty; // U'x' -> char32_t in C11 and C++11. 3037 else if (!getLangOpts().CPlusPlus || Literal.isMultiChar()) 3038 Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++. 3039 else 3040 Ty = Context.CharTy; // 'x' -> char in C++ 3041 3042 CharacterLiteral::CharacterKind Kind = CharacterLiteral::Ascii; 3043 if (Literal.isWide()) 3044 Kind = CharacterLiteral::Wide; 3045 else if (Literal.isUTF16()) 3046 Kind = CharacterLiteral::UTF16; 3047 else if (Literal.isUTF32()) 3048 Kind = CharacterLiteral::UTF32; 3049 3050 Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty, 3051 Tok.getLocation()); 3052 3053 if (Literal.getUDSuffix().empty()) 3054 return Lit; 3055 3056 // We're building a user-defined literal. 3057 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 3058 SourceLocation UDSuffixLoc = 3059 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset()); 3060 3061 // Make sure we're allowed user-defined literals here. 3062 if (!UDLScope) 3063 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_character_udl)); 3064 3065 // C++11 [lex.ext]p6: The literal L is treated as a call of the form 3066 // operator "" X (ch) 3067 return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc, 3068 Lit, Tok.getLocation()); 3069} 3070 3071ExprResult Sema::ActOnIntegerConstant(SourceLocation Loc, uint64_t Val) { 3072 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 3073 return IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val), 3074 Context.IntTy, Loc); 3075} 3076 3077static Expr *BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal, 3078 QualType Ty, SourceLocation Loc) { 3079 const llvm::fltSemantics &Format = S.Context.getFloatTypeSemantics(Ty); 3080 3081 using llvm::APFloat; 3082 APFloat Val(Format); 3083 3084 APFloat::opStatus result = Literal.GetFloatValue(Val); 3085 3086 // Overflow is always an error, but underflow is only an error if 3087 // we underflowed to zero (APFloat reports denormals as underflow). 3088 if ((result & APFloat::opOverflow) || 3089 ((result & APFloat::opUnderflow) && Val.isZero())) { 3090 unsigned diagnostic; 3091 SmallString<20> buffer; 3092 if (result & APFloat::opOverflow) { 3093 diagnostic = diag::warn_float_overflow; 3094 APFloat::getLargest(Format).toString(buffer); 3095 } else { 3096 diagnostic = diag::warn_float_underflow; 3097 APFloat::getSmallest(Format).toString(buffer); 3098 } 3099 3100 S.Diag(Loc, diagnostic) 3101 << Ty 3102 << StringRef(buffer.data(), buffer.size()); 3103 } 3104 3105 bool isExact = (result == APFloat::opOK); 3106 return FloatingLiteral::Create(S.Context, Val, isExact, Ty, Loc); 3107} 3108 3109bool Sema::CheckLoopHintExpr(Expr *E, SourceLocation Loc) { 3110 assert(E && "Invalid expression"); 3111 3112 if (E->isValueDependent()) 3113 return false; 3114 3115 QualType QT = E->getType(); 3116 if (!QT->isIntegerType() || QT->isBooleanType() || QT->isCharType()) { 3117 Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_type) << QT; 3118 return true; 3119 } 3120 3121 llvm::APSInt ValueAPS; 3122 ExprResult R = VerifyIntegerConstantExpression(E, &ValueAPS); 3123 3124 if (R.isInvalid()) 3125 return true; 3126 3127 bool ValueIsPositive = ValueAPS.isStrictlyPositive(); 3128 if (!ValueIsPositive || ValueAPS.getActiveBits() > 31) { 3129 Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_value) 3130 << ValueAPS.toString(10) << ValueIsPositive; 3131 return true; 3132 } 3133 3134 return false; 3135} 3136 3137ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) { 3138 // Fast path for a single digit (which is quite common). A single digit 3139 // cannot have a trigraph, escaped newline, radix prefix, or suffix. 3140 if (Tok.getLength() == 1) { 3141 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok); 3142 return ActOnIntegerConstant(Tok.getLocation(), Val-'0'); 3143 } 3144 3145 SmallString<128> SpellingBuffer; 3146 // NumericLiteralParser wants to overread by one character. Add padding to 3147 // the buffer in case the token is copied to the buffer. If getSpelling() 3148 // returns a StringRef to the memory buffer, it should have a null char at 3149 // the EOF, so it is also safe. 3150 SpellingBuffer.resize(Tok.getLength() + 1); 3151 3152 // Get the spelling of the token, which eliminates trigraphs, etc. 3153 bool Invalid = false; 3154 StringRef TokSpelling = PP.getSpelling(Tok, SpellingBuffer, &Invalid); 3155 if (Invalid) 3156 return ExprError(); 3157 3158 NumericLiteralParser Literal(TokSpelling, Tok.getLocation(), PP); 3159 if (Literal.hadError) 3160 return ExprError(); 3161 3162 if (Literal.hasUDSuffix()) { 3163 // We're building a user-defined literal. 3164 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 3165 SourceLocation UDSuffixLoc = 3166 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset()); 3167 3168 // Make sure we're allowed user-defined literals here. 3169 if (!UDLScope) 3170 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_numeric_udl)); 3171 3172 QualType CookedTy; 3173 if (Literal.isFloatingLiteral()) { 3174 // C++11 [lex.ext]p4: If S contains a literal operator with parameter type 3175 // long double, the literal is treated as a call of the form 3176 // operator "" X (f L) 3177 CookedTy = Context.LongDoubleTy; 3178 } else { 3179 // C++11 [lex.ext]p3: If S contains a literal operator with parameter type 3180 // unsigned long long, the literal is treated as a call of the form 3181 // operator "" X (n ULL) 3182 CookedTy = Context.UnsignedLongLongTy; 3183 } 3184 3185 DeclarationName OpName = 3186 Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 3187 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 3188 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 3189 3190 SourceLocation TokLoc = Tok.getLocation(); 3191 3192 // Perform literal operator lookup to determine if we're building a raw 3193 // literal or a cooked one. 3194 LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName); 3195 switch (LookupLiteralOperator(UDLScope, R, CookedTy, 3196 /*AllowRaw*/true, /*AllowTemplate*/true, 3197 /*AllowStringTemplate*/false)) { 3198 case LOLR_Error: 3199 return ExprError(); 3200 3201 case LOLR_Cooked: { 3202 Expr *Lit; 3203 if (Literal.isFloatingLiteral()) { 3204 Lit = BuildFloatingLiteral(*this, Literal, CookedTy, Tok.getLocation()); 3205 } else { 3206 llvm::APInt ResultVal(Context.getTargetInfo().getLongLongWidth(), 0); 3207 if (Literal.GetIntegerValue(ResultVal)) 3208 Diag(Tok.getLocation(), diag::err_integer_literal_too_large) 3209 << /* Unsigned */ 1; 3210 Lit = IntegerLiteral::Create(Context, ResultVal, CookedTy, 3211 Tok.getLocation()); 3212 } 3213 return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc); 3214 } 3215 3216 case LOLR_Raw: { 3217 // C++11 [lit.ext]p3, p4: If S contains a raw literal operator, the 3218 // literal is treated as a call of the form 3219 // operator "" X ("n") 3220 unsigned Length = Literal.getUDSuffixOffset(); 3221 QualType StrTy = Context.getConstantArrayType( 3222 Context.CharTy.withConst(), llvm::APInt(32, Length + 1), 3223 ArrayType::Normal, 0); 3224 Expr *Lit = StringLiteral::Create( 3225 Context, StringRef(TokSpelling.data(), Length), StringLiteral::Ascii, 3226 /*Pascal*/false, StrTy, &TokLoc, 1); 3227 return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc); 3228 } 3229 3230 case LOLR_Template: { 3231 // C++11 [lit.ext]p3, p4: Otherwise (S contains a literal operator 3232 // template), L is treated as a call fo the form 3233 // operator "" X <'c1', 'c2', ... 'ck'>() 3234 // where n is the source character sequence c1 c2 ... ck. 3235 TemplateArgumentListInfo ExplicitArgs; 3236 unsigned CharBits = Context.getIntWidth(Context.CharTy); 3237 bool CharIsUnsigned = Context.CharTy->isUnsignedIntegerType(); 3238 llvm::APSInt Value(CharBits, CharIsUnsigned); 3239 for (unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) { 3240 Value = TokSpelling[I]; 3241 TemplateArgument Arg(Context, Value, Context.CharTy); 3242 TemplateArgumentLocInfo ArgInfo; 3243 ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo)); 3244 } 3245 return BuildLiteralOperatorCall(R, OpNameInfo, None, TokLoc, 3246 &ExplicitArgs); 3247 } 3248 case LOLR_StringTemplate: 3249 llvm_unreachable("unexpected literal operator lookup result"); 3250 } 3251 } 3252 3253 Expr *Res; 3254 3255 if (Literal.isFloatingLiteral()) { 3256 QualType Ty; 3257 if (Literal.isFloat) 3258 Ty = Context.FloatTy; 3259 else if (!Literal.isLong) 3260 Ty = Context.DoubleTy; 3261 else 3262 Ty = Context.LongDoubleTy; 3263 3264 Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation()); 3265 3266 if (Ty == Context.DoubleTy) { 3267 if (getLangOpts().SinglePrecisionConstants) { 3268 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get(); 3269 } else if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp64) { 3270 Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64); 3271 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get(); 3272 } 3273 } 3274 } else if (!Literal.isIntegerLiteral()) { 3275 return ExprError(); 3276 } else { 3277 QualType Ty; 3278 3279 // 'long long' is a C99 or C++11 feature. 3280 if (!getLangOpts().C99 && Literal.isLongLong) { 3281 if (getLangOpts().CPlusPlus) 3282 Diag(Tok.getLocation(), 3283 getLangOpts().CPlusPlus11 ? 3284 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong); 3285 else 3286 Diag(Tok.getLocation(), diag::ext_c99_longlong); 3287 } 3288 3289 // Get the value in the widest-possible width. 3290 unsigned MaxWidth = Context.getTargetInfo().getIntMaxTWidth(); 3291 // The microsoft literal suffix extensions support 128-bit literals, which 3292 // may be wider than [u]intmax_t. 3293 // FIXME: Actually, they don't. We seem to have accidentally invented the 3294 // i128 suffix. 3295 if (Literal.MicrosoftInteger == 128 && MaxWidth < 128 && 3296 Context.getTargetInfo().hasInt128Type()) 3297 MaxWidth = 128; 3298 llvm::APInt ResultVal(MaxWidth, 0); 3299 3300 if (Literal.GetIntegerValue(ResultVal)) { 3301 // If this value didn't fit into uintmax_t, error and force to ull. 3302 Diag(Tok.getLocation(), diag::err_integer_literal_too_large) 3303 << /* Unsigned */ 1; 3304 Ty = Context.UnsignedLongLongTy; 3305 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() && 3306 "long long is not intmax_t?"); 3307 } else { 3308 // If this value fits into a ULL, try to figure out what else it fits into 3309 // according to the rules of C99 6.4.4.1p5. 3310 3311 // Octal, Hexadecimal, and integers with a U suffix are allowed to 3312 // be an unsigned int. 3313 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10; 3314 3315 // Check from smallest to largest, picking the smallest type we can. 3316 unsigned Width = 0; 3317 3318 // Microsoft specific integer suffixes are explicitly sized. 3319 if (Literal.MicrosoftInteger) { 3320 if (Literal.MicrosoftInteger > MaxWidth) { 3321 // If this target doesn't support __int128, error and force to ull. 3322 Diag(Tok.getLocation(), diag::err_int128_unsupported); 3323 Width = MaxWidth; 3324 Ty = Context.getIntMaxType(); 3325 } else { 3326 Width = Literal.MicrosoftInteger; 3327 Ty = Context.getIntTypeForBitwidth(Width, 3328 /*Signed=*/!Literal.isUnsigned); 3329 } 3330 } 3331 3332 if (Ty.isNull() && !Literal.isLong && !Literal.isLongLong) { 3333 // Are int/unsigned possibilities? 3334 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 3335 3336 // Does it fit in a unsigned int? 3337 if (ResultVal.isIntN(IntSize)) { 3338 // Does it fit in a signed int? 3339 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0) 3340 Ty = Context.IntTy; 3341 else if (AllowUnsigned) 3342 Ty = Context.UnsignedIntTy; 3343 Width = IntSize; 3344 } 3345 } 3346 3347 // Are long/unsigned long possibilities? 3348 if (Ty.isNull() && !Literal.isLongLong) { 3349 unsigned LongSize = Context.getTargetInfo().getLongWidth(); 3350 3351 // Does it fit in a unsigned long? 3352 if (ResultVal.isIntN(LongSize)) { 3353 // Does it fit in a signed long? 3354 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0) 3355 Ty = Context.LongTy; 3356 else if (AllowUnsigned) 3357 Ty = Context.UnsignedLongTy; 3358 Width = LongSize; 3359 } 3360 } 3361 3362 // Check long long if needed. 3363 if (Ty.isNull()) { 3364 unsigned LongLongSize = Context.getTargetInfo().getLongLongWidth(); 3365 3366 // Does it fit in a unsigned long long? 3367 if (ResultVal.isIntN(LongLongSize)) { 3368 // Does it fit in a signed long long? 3369 // To be compatible with MSVC, hex integer literals ending with the 3370 // LL or i64 suffix are always signed in Microsoft mode. 3371 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 || 3372 (getLangOpts().MicrosoftExt && Literal.isLongLong))) 3373 Ty = Context.LongLongTy; 3374 else if (AllowUnsigned) 3375 Ty = Context.UnsignedLongLongTy; 3376 Width = LongLongSize; 3377 } 3378 } 3379 3380 // If we still couldn't decide a type, we probably have something that 3381 // does not fit in a signed long long, but has no U suffix. 3382 if (Ty.isNull()) { 3383 Diag(Tok.getLocation(), diag::ext_integer_literal_too_large_for_signed); 3384 Ty = Context.UnsignedLongLongTy; 3385 Width = Context.getTargetInfo().getLongLongWidth(); 3386 } 3387 3388 if (ResultVal.getBitWidth() != Width) 3389 ResultVal = ResultVal.trunc(Width); 3390 } 3391 Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation()); 3392 } 3393 3394 // If this is an imaginary literal, create the ImaginaryLiteral wrapper. 3395 if (Literal.isImaginary) 3396 Res = new (Context) ImaginaryLiteral(Res, 3397 Context.getComplexType(Res->getType())); 3398 3399 return Res; 3400} 3401 3402ExprResult Sema::ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E) { 3403 assert(E && "ActOnParenExpr() missing expr"); 3404 return new (Context) ParenExpr(L, R, E); 3405} 3406 3407static bool CheckVecStepTraitOperandType(Sema &S, QualType T, 3408 SourceLocation Loc, 3409 SourceRange ArgRange) { 3410 // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in 3411 // scalar or vector data type argument..." 3412 // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic 3413 // type (C99 6.2.5p18) or void. 3414 if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) { 3415 S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type) 3416 << T << ArgRange; 3417 return true; 3418 } 3419 3420 assert((T->isVoidType() || !T->isIncompleteType()) && 3421 "Scalar types should always be complete"); 3422 return false; 3423} 3424 3425static bool CheckExtensionTraitOperandType(Sema &S, QualType T, 3426 SourceLocation Loc, 3427 SourceRange ArgRange, 3428 UnaryExprOrTypeTrait TraitKind) { 3429 // Invalid types must be hard errors for SFINAE in C++. 3430 if (S.LangOpts.CPlusPlus) 3431 return true; 3432 3433 // C99 6.5.3.4p1: 3434 if (T->isFunctionType() && 3435 (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf)) { 3436 // sizeof(function)/alignof(function) is allowed as an extension. 3437 S.Diag(Loc, diag::ext_sizeof_alignof_function_type) 3438 << TraitKind << ArgRange; 3439 return false; 3440 } 3441 3442 // Allow sizeof(void)/alignof(void) as an extension, unless in OpenCL where 3443 // this is an error (OpenCL v1.1 s6.3.k) 3444 if (T->isVoidType()) { 3445 unsigned DiagID = S.LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type 3446 : diag::ext_sizeof_alignof_void_type; 3447 S.Diag(Loc, DiagID) << TraitKind << ArgRange; 3448 return false; 3449 } 3450 3451 return true; 3452} 3453 3454static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, 3455 SourceLocation Loc, 3456 SourceRange ArgRange, 3457 UnaryExprOrTypeTrait TraitKind) { 3458 // Reject sizeof(interface) and sizeof(interface<proto>) if the 3459 // runtime doesn't allow it. 3460 if (!S.LangOpts.ObjCRuntime.allowsSizeofAlignof() && T->isObjCObjectType()) { 3461 S.Diag(Loc, diag::err_sizeof_nonfragile_interface) 3462 << T << (TraitKind == UETT_SizeOf) 3463 << ArgRange; 3464 return true; 3465 } 3466 3467 return false; 3468} 3469 3470/// \brief Check whether E is a pointer from a decayed array type (the decayed 3471/// pointer type is equal to T) and emit a warning if it is. 3472static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T, 3473 Expr *E) { 3474 // Don't warn if the operation changed the type. 3475 if (T != E->getType()) 3476 return; 3477 3478 // Now look for array decays. 3479 ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E); 3480 if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay) 3481 return; 3482 3483 S.Diag(Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange() 3484 << ICE->getType() 3485 << ICE->getSubExpr()->getType(); 3486} 3487 3488/// \brief Check the constraints on expression operands to unary type expression 3489/// and type traits. 3490/// 3491/// Completes any types necessary and validates the constraints on the operand 3492/// expression. The logic mostly mirrors the type-based overload, but may modify 3493/// the expression as it completes the type for that expression through template 3494/// instantiation, etc. 3495bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E, 3496 UnaryExprOrTypeTrait ExprKind) { 3497 QualType ExprTy = E->getType(); 3498 assert(!ExprTy->isReferenceType()); 3499 3500 if (ExprKind == UETT_VecStep) 3501 return CheckVecStepTraitOperandType(*this, ExprTy, E->getExprLoc(), 3502 E->getSourceRange()); 3503 3504 // Whitelist some types as extensions 3505 if (!CheckExtensionTraitOperandType(*this, ExprTy, E->getExprLoc(), 3506 E->getSourceRange(), ExprKind)) 3507 return false; 3508 3509 // 'alignof' applied to an expression only requires the base element type of 3510 // the expression to be complete. 'sizeof' requires the expression's type to 3511 // be complete (and will attempt to complete it if it's an array of unknown 3512 // bound). 3513 if (ExprKind == UETT_AlignOf) { 3514 if (RequireCompleteType(E->getExprLoc(), 3515 Context.getBaseElementType(E->getType()), 3516 diag::err_sizeof_alignof_incomplete_type, ExprKind, 3517 E->getSourceRange())) 3518 return true; 3519 } else { 3520 if (RequireCompleteExprType(E, diag::err_sizeof_alignof_incomplete_type, 3521 ExprKind, E->getSourceRange())) 3522 return true; 3523 } 3524 3525 // Completing the expression's type may have changed it. 3526 ExprTy = E->getType(); 3527 assert(!ExprTy->isReferenceType()); 3528 3529 if (ExprTy->isFunctionType()) { 3530 Diag(E->getExprLoc(), diag::err_sizeof_alignof_function_type) 3531 << ExprKind << E->getSourceRange(); 3532 return true; 3533 } 3534 3535 // The operand for sizeof and alignof is in an unevaluated expression context, 3536 // so side effects could result in unintended consequences. 3537 if ((ExprKind == UETT_SizeOf || ExprKind == UETT_AlignOf) && 3538 ActiveTemplateInstantiations.empty() && E->HasSideEffects(Context, false)) 3539 Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context); 3540 3541 if (CheckObjCTraitOperandConstraints(*this, ExprTy, E->getExprLoc(), 3542 E->getSourceRange(), ExprKind)) 3543 return true; 3544 3545 if (ExprKind == UETT_SizeOf) { 3546 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E->IgnoreParens())) { 3547 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) { 3548 QualType OType = PVD->getOriginalType(); 3549 QualType Type = PVD->getType(); 3550 if (Type->isPointerType() && OType->isArrayType()) { 3551 Diag(E->getExprLoc(), diag::warn_sizeof_array_param) 3552 << Type << OType; 3553 Diag(PVD->getLocation(), diag::note_declared_at); 3554 } 3555 } 3556 } 3557 3558 // Warn on "sizeof(array op x)" and "sizeof(x op array)", where the array 3559 // decays into a pointer and returns an unintended result. This is most 3560 // likely a typo for "sizeof(array) op x". 3561 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E->IgnoreParens())) { 3562 warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(), 3563 BO->getLHS()); 3564 warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(), 3565 BO->getRHS()); 3566 } 3567 } 3568 3569 return false; 3570} 3571 3572/// \brief Check the constraints on operands to unary expression and type 3573/// traits. 3574/// 3575/// This will complete any types necessary, and validate the various constraints 3576/// on those operands. 3577/// 3578/// The UsualUnaryConversions() function is *not* called by this routine. 3579/// C99 6.3.2.1p[2-4] all state: 3580/// Except when it is the operand of the sizeof operator ... 3581/// 3582/// C++ [expr.sizeof]p4 3583/// The lvalue-to-rvalue, array-to-pointer, and function-to-pointer 3584/// standard conversions are not applied to the operand of sizeof. 3585/// 3586/// This policy is followed for all of the unary trait expressions. 3587bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType, 3588 SourceLocation OpLoc, 3589 SourceRange ExprRange, 3590 UnaryExprOrTypeTrait ExprKind) { 3591 if (ExprType->isDependentType()) 3592 return false; 3593 3594 // C++ [expr.sizeof]p2: 3595 // When applied to a reference or a reference type, the result 3596 // is the size of the referenced type. 3597 // C++11 [expr.alignof]p3: 3598 // When alignof is applied to a reference type, the result 3599 // shall be the alignment of the referenced type. 3600 if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>()) 3601 ExprType = Ref->getPointeeType(); 3602 3603 // C11 6.5.3.4/3, C++11 [expr.alignof]p3: 3604 // When alignof or _Alignof is applied to an array type, the result 3605 // is the alignment of the element type. 3606 if (ExprKind == UETT_AlignOf) 3607 ExprType = Context.getBaseElementType(ExprType); 3608 3609 if (ExprKind == UETT_VecStep) 3610 return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange); 3611 3612 // Whitelist some types as extensions 3613 if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange, 3614 ExprKind)) 3615 return false; 3616 3617 if (RequireCompleteType(OpLoc, ExprType, 3618 diag::err_sizeof_alignof_incomplete_type, 3619 ExprKind, ExprRange)) 3620 return true; 3621 3622 if (ExprType->isFunctionType()) { 3623 Diag(OpLoc, diag::err_sizeof_alignof_function_type) 3624 << ExprKind << ExprRange; 3625 return true; 3626 } 3627 3628 if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange, 3629 ExprKind)) 3630 return true; 3631 3632 return false; 3633} 3634 3635static bool CheckAlignOfExpr(Sema &S, Expr *E) { 3636 E = E->IgnoreParens(); 3637 3638 // Cannot know anything else if the expression is dependent. 3639 if (E->isTypeDependent()) 3640 return false; 3641 3642 if (E->getObjectKind() == OK_BitField) { 3643 S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) 3644 << 1 << E->getSourceRange(); 3645 return true; 3646 } 3647 3648 ValueDecl *D = nullptr; 3649 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 3650 D = DRE->getDecl(); 3651 } else if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 3652 D = ME->getMemberDecl(); 3653 } 3654 3655 // If it's a field, require the containing struct to have a 3656 // complete definition so that we can compute the layout. 3657 // 3658 // This can happen in C++11 onwards, either by naming the member 3659 // in a way that is not transformed into a member access expression 3660 // (in an unevaluated operand, for instance), or by naming the member 3661 // in a trailing-return-type. 3662 // 3663 // For the record, since __alignof__ on expressions is a GCC 3664 // extension, GCC seems to permit this but always gives the 3665 // nonsensical answer 0. 3666 // 3667 // We don't really need the layout here --- we could instead just 3668 // directly check for all the appropriate alignment-lowing 3669 // attributes --- but that would require duplicating a lot of 3670 // logic that just isn't worth duplicating for such a marginal 3671 // use-case. 3672 if (FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) { 3673 // Fast path this check, since we at least know the record has a 3674 // definition if we can find a member of it. 3675 if (!FD->getParent()->isCompleteDefinition()) { 3676 S.Diag(E->getExprLoc(), diag::err_alignof_member_of_incomplete_type) 3677 << E->getSourceRange(); 3678 return true; 3679 } 3680 3681 // Otherwise, if it's a field, and the field doesn't have 3682 // reference type, then it must have a complete type (or be a 3683 // flexible array member, which we explicitly want to 3684 // white-list anyway), which makes the following checks trivial. 3685 if (!FD->getType()->isReferenceType()) 3686 return false; 3687 } 3688 3689 return S.CheckUnaryExprOrTypeTraitOperand(E, UETT_AlignOf); 3690} 3691 3692bool Sema::CheckVecStepExpr(Expr *E) { 3693 E = E->IgnoreParens(); 3694 3695 // Cannot know anything else if the expression is dependent. 3696 if (E->isTypeDependent()) 3697 return false; 3698 3699 return CheckUnaryExprOrTypeTraitOperand(E, UETT_VecStep); 3700} 3701 3702/// \brief Build a sizeof or alignof expression given a type operand. 3703ExprResult 3704Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, 3705 SourceLocation OpLoc, 3706 UnaryExprOrTypeTrait ExprKind, 3707 SourceRange R) { 3708 if (!TInfo) 3709 return ExprError(); 3710 3711 QualType T = TInfo->getType(); 3712 3713 if (!T->isDependentType() && 3714 CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind)) 3715 return ExprError(); 3716 3717 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 3718 return new (Context) UnaryExprOrTypeTraitExpr( 3719 ExprKind, TInfo, Context.getSizeType(), OpLoc, R.getEnd()); 3720} 3721 3722/// \brief Build a sizeof or alignof expression given an expression 3723/// operand. 3724ExprResult 3725Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc, 3726 UnaryExprOrTypeTrait ExprKind) { 3727 ExprResult PE = CheckPlaceholderExpr(E); 3728 if (PE.isInvalid()) 3729 return ExprError(); 3730 3731 E = PE.get(); 3732 3733 // Verify that the operand is valid. 3734 bool isInvalid = false; 3735 if (E->isTypeDependent()) { 3736 // Delay type-checking for type-dependent expressions. 3737 } else if (ExprKind == UETT_AlignOf) { 3738 isInvalid = CheckAlignOfExpr(*this, E); 3739 } else if (ExprKind == UETT_VecStep) { 3740 isInvalid = CheckVecStepExpr(E); 3741 } else if (E->refersToBitField()) { // C99 6.5.3.4p1. 3742 Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) << 0; 3743 isInvalid = true; 3744 } else { 3745 isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf); 3746 } 3747 3748 if (isInvalid) 3749 return ExprError(); 3750 3751 if (ExprKind == UETT_SizeOf && E->getType()->isVariableArrayType()) { 3752 PE = TransformToPotentiallyEvaluated(E); 3753 if (PE.isInvalid()) return ExprError(); 3754 E = PE.get(); 3755 } 3756 3757 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 3758 return new (Context) UnaryExprOrTypeTraitExpr( 3759 ExprKind, E, Context.getSizeType(), OpLoc, E->getSourceRange().getEnd()); 3760} 3761 3762/// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c 3763/// expr and the same for @c alignof and @c __alignof 3764/// Note that the ArgRange is invalid if isType is false. 3765ExprResult 3766Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, 3767 UnaryExprOrTypeTrait ExprKind, bool IsType, 3768 void *TyOrEx, const SourceRange &ArgRange) { 3769 // If error parsing type, ignore. 3770 if (!TyOrEx) return ExprError(); 3771 3772 if (IsType) { 3773 TypeSourceInfo *TInfo; 3774 (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo); 3775 return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange); 3776 } 3777 3778 Expr *ArgEx = (Expr *)TyOrEx; 3779 ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind); 3780 return Result; 3781} 3782 3783static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, 3784 bool IsReal) { 3785 if (V.get()->isTypeDependent()) 3786 return S.Context.DependentTy; 3787 3788 // _Real and _Imag are only l-values for normal l-values. 3789 if (V.get()->getObjectKind() != OK_Ordinary) { 3790 V = S.DefaultLvalueConversion(V.get()); 3791 if (V.isInvalid()) 3792 return QualType(); 3793 } 3794 3795 // These operators return the element type of a complex type. 3796 if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>()) 3797 return CT->getElementType(); 3798 3799 // Otherwise they pass through real integer and floating point types here. 3800 if (V.get()->getType()->isArithmeticType()) 3801 return V.get()->getType(); 3802 3803 // Test for placeholders. 3804 ExprResult PR = S.CheckPlaceholderExpr(V.get()); 3805 if (PR.isInvalid()) return QualType(); 3806 if (PR.get() != V.get()) { 3807 V = PR; 3808 return CheckRealImagOperand(S, V, Loc, IsReal); 3809 } 3810 3811 // Reject anything else. 3812 S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType() 3813 << (IsReal ? "__real" : "__imag"); 3814 return QualType(); 3815} 3816 3817 3818 3819ExprResult 3820Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, 3821 tok::TokenKind Kind, Expr *Input) { 3822 UnaryOperatorKind Opc; 3823 switch (Kind) { 3824 default: llvm_unreachable("Unknown unary op!"); 3825 case tok::plusplus: Opc = UO_PostInc; break; 3826 case tok::minusminus: Opc = UO_PostDec; break; 3827 } 3828 3829 // Since this might is a postfix expression, get rid of ParenListExprs. 3830 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input); 3831 if (Result.isInvalid()) return ExprError(); 3832 Input = Result.get(); 3833 3834 return BuildUnaryOp(S, OpLoc, Opc, Input); 3835} 3836 3837/// \brief Diagnose if arithmetic on the given ObjC pointer is illegal. 3838/// 3839/// \return true on error 3840static bool checkArithmeticOnObjCPointer(Sema &S, 3841 SourceLocation opLoc, 3842 Expr *op) { 3843 assert(op->getType()->isObjCObjectPointerType()); 3844 if (S.LangOpts.ObjCRuntime.allowsPointerArithmetic() && 3845 !S.LangOpts.ObjCSubscriptingLegacyRuntime) 3846 return false; 3847 3848 S.Diag(opLoc, diag::err_arithmetic_nonfragile_interface) 3849 << op->getType()->castAs<ObjCObjectPointerType>()->getPointeeType() 3850 << op->getSourceRange(); 3851 return true; 3852} 3853 3854ExprResult 3855Sema::ActOnArraySubscriptExpr(Scope *S, Expr *base, SourceLocation lbLoc, 3856 Expr *idx, SourceLocation rbLoc) { 3857 // Since this might be a postfix expression, get rid of ParenListExprs. 3858 if (isa<ParenListExpr>(base)) { 3859 ExprResult result = MaybeConvertParenListExprToParenExpr(S, base); 3860 if (result.isInvalid()) return ExprError(); 3861 base = result.get(); 3862 } 3863 3864 // Handle any non-overload placeholder types in the base and index 3865 // expressions. We can't handle overloads here because the other 3866 // operand might be an overloadable type, in which case the overload 3867 // resolution for the operator overload should get the first crack 3868 // at the overload. 3869 if (base->getType()->isNonOverloadPlaceholderType()) { 3870 ExprResult result = CheckPlaceholderExpr(base); 3871 if (result.isInvalid()) return ExprError(); 3872 base = result.get(); 3873 } 3874 if (idx->getType()->isNonOverloadPlaceholderType()) { 3875 ExprResult result = CheckPlaceholderExpr(idx); 3876 if (result.isInvalid()) return ExprError(); 3877 idx = result.get(); 3878 } 3879 3880 // Build an unanalyzed expression if either operand is type-dependent. 3881 if (getLangOpts().CPlusPlus && 3882 (base->isTypeDependent() || idx->isTypeDependent())) { 3883 return new (Context) ArraySubscriptExpr(base, idx, Context.DependentTy, 3884 VK_LValue, OK_Ordinary, rbLoc); 3885 } 3886 3887 // Use C++ overloaded-operator rules if either operand has record 3888 // type. The spec says to do this if either type is *overloadable*, 3889 // but enum types can't declare subscript operators or conversion 3890 // operators, so there's nothing interesting for overload resolution 3891 // to do if there aren't any record types involved. 3892 // 3893 // ObjC pointers have their own subscripting logic that is not tied 3894 // to overload resolution and so should not take this path. 3895 if (getLangOpts().CPlusPlus && 3896 (base->getType()->isRecordType() || 3897 (!base->getType()->isObjCObjectPointerType() && 3898 idx->getType()->isRecordType()))) { 3899 return CreateOverloadedArraySubscriptExpr(lbLoc, rbLoc, base, idx); 3900 } 3901 3902 return CreateBuiltinArraySubscriptExpr(base, lbLoc, idx, rbLoc); 3903} 3904 3905ExprResult 3906Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, 3907 Expr *Idx, SourceLocation RLoc) { 3908 Expr *LHSExp = Base; 3909 Expr *RHSExp = Idx; 3910 3911 // Perform default conversions. 3912 if (!LHSExp->getType()->getAs<VectorType>()) { 3913 ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp); 3914 if (Result.isInvalid()) 3915 return ExprError(); 3916 LHSExp = Result.get(); 3917 } 3918 ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp); 3919 if (Result.isInvalid()) 3920 return ExprError(); 3921 RHSExp = Result.get(); 3922 3923 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType(); 3924 ExprValueKind VK = VK_LValue; 3925 ExprObjectKind OK = OK_Ordinary; 3926 3927 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent 3928 // to the expression *((e1)+(e2)). This means the array "Base" may actually be 3929 // in the subscript position. As a result, we need to derive the array base 3930 // and index from the expression types. 3931 Expr *BaseExpr, *IndexExpr; 3932 QualType ResultType; 3933 if (LHSTy->isDependentType() || RHSTy->isDependentType()) { 3934 BaseExpr = LHSExp; 3935 IndexExpr = RHSExp; 3936 ResultType = Context.DependentTy; 3937 } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) { 3938 BaseExpr = LHSExp; 3939 IndexExpr = RHSExp; 3940 ResultType = PTy->getPointeeType(); 3941 } else if (const ObjCObjectPointerType *PTy = 3942 LHSTy->getAs<ObjCObjectPointerType>()) { 3943 BaseExpr = LHSExp; 3944 IndexExpr = RHSExp; 3945 3946 // Use custom logic if this should be the pseudo-object subscript 3947 // expression. 3948 if (!LangOpts.isSubscriptPointerArithmetic()) 3949 return BuildObjCSubscriptExpression(RLoc, BaseExpr, IndexExpr, nullptr, 3950 nullptr); 3951 3952 ResultType = PTy->getPointeeType(); 3953 } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) { 3954 // Handle the uncommon case of "123[Ptr]". 3955 BaseExpr = RHSExp; 3956 IndexExpr = LHSExp; 3957 ResultType = PTy->getPointeeType(); 3958 } else if (const ObjCObjectPointerType *PTy = 3959 RHSTy->getAs<ObjCObjectPointerType>()) { 3960 // Handle the uncommon case of "123[Ptr]". 3961 BaseExpr = RHSExp; 3962 IndexExpr = LHSExp; 3963 ResultType = PTy->getPointeeType(); 3964 if (!LangOpts.isSubscriptPointerArithmetic()) { 3965 Diag(LLoc, diag::err_subscript_nonfragile_interface) 3966 << ResultType << BaseExpr->getSourceRange(); 3967 return ExprError(); 3968 } 3969 } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) { 3970 BaseExpr = LHSExp; // vectors: V[123] 3971 IndexExpr = RHSExp; 3972 VK = LHSExp->getValueKind(); 3973 if (VK != VK_RValue) 3974 OK = OK_VectorComponent; 3975 3976 // FIXME: need to deal with const... 3977 ResultType = VTy->getElementType(); 3978 } else if (LHSTy->isArrayType()) { 3979 // If we see an array that wasn't promoted by 3980 // DefaultFunctionArrayLvalueConversion, it must be an array that 3981 // wasn't promoted because of the C90 rule that doesn't 3982 // allow promoting non-lvalue arrays. Warn, then 3983 // force the promotion here. 3984 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3985 LHSExp->getSourceRange(); 3986 LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy), 3987 CK_ArrayToPointerDecay).get(); 3988 LHSTy = LHSExp->getType(); 3989 3990 BaseExpr = LHSExp; 3991 IndexExpr = RHSExp; 3992 ResultType = LHSTy->getAs<PointerType>()->getPointeeType(); 3993 } else if (RHSTy->isArrayType()) { 3994 // Same as previous, except for 123[f().a] case 3995 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3996 RHSExp->getSourceRange(); 3997 RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy), 3998 CK_ArrayToPointerDecay).get(); 3999 RHSTy = RHSExp->getType(); 4000 4001 BaseExpr = RHSExp; 4002 IndexExpr = LHSExp; 4003 ResultType = RHSTy->getAs<PointerType>()->getPointeeType(); 4004 } else { 4005 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value) 4006 << LHSExp->getSourceRange() << RHSExp->getSourceRange()); 4007 } 4008 // C99 6.5.2.1p1 4009 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent()) 4010 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer) 4011 << IndexExpr->getSourceRange()); 4012 4013 if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) || 4014 IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U)) 4015 && !IndexExpr->isTypeDependent()) 4016 Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange(); 4017 4018 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly, 4019 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object 4020 // type. Note that Functions are not objects, and that (in C99 parlance) 4021 // incomplete types are not object types. 4022 if (ResultType->isFunctionType()) { 4023 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type) 4024 << ResultType << BaseExpr->getSourceRange(); 4025 return ExprError(); 4026 } 4027 4028 if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) { 4029 // GNU extension: subscripting on pointer to void 4030 Diag(LLoc, diag::ext_gnu_subscript_void_type) 4031 << BaseExpr->getSourceRange(); 4032 4033 // C forbids expressions of unqualified void type from being l-values. 4034 // See IsCForbiddenLValueType. 4035 if (!ResultType.hasQualifiers()) VK = VK_RValue; 4036 } else if (!ResultType->isDependentType() && 4037 RequireCompleteType(LLoc, ResultType, 4038 diag::err_subscript_incomplete_type, BaseExpr)) 4039 return ExprError(); 4040 4041 assert(VK == VK_RValue || LangOpts.CPlusPlus || 4042 !ResultType.isCForbiddenLValueType()); 4043 4044 return new (Context) 4045 ArraySubscriptExpr(LHSExp, RHSExp, ResultType, VK, OK, RLoc); 4046} 4047 4048ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc, 4049 FunctionDecl *FD, 4050 ParmVarDecl *Param) { 4051 if (Param->hasUnparsedDefaultArg()) { 4052 Diag(CallLoc, 4053 diag::err_use_of_default_argument_to_function_declared_later) << 4054 FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName(); 4055 Diag(UnparsedDefaultArgLocs[Param], 4056 diag::note_default_argument_declared_here); 4057 return ExprError(); 4058 } 4059 4060 if (Param->hasUninstantiatedDefaultArg()) { 4061 Expr *UninstExpr = Param->getUninstantiatedDefaultArg(); 4062 4063 EnterExpressionEvaluationContext EvalContext(*this, PotentiallyEvaluated, 4064 Param); 4065 4066 // Instantiate the expression. 4067 MultiLevelTemplateArgumentList MutiLevelArgList 4068 = getTemplateInstantiationArgs(FD, nullptr, /*RelativeToPrimary=*/true); 4069 4070 InstantiatingTemplate Inst(*this, CallLoc, Param, 4071 MutiLevelArgList.getInnermost()); 4072 if (Inst.isInvalid()) 4073 return ExprError(); 4074 4075 ExprResult Result; 4076 { 4077 // C++ [dcl.fct.default]p5: 4078 // The names in the [default argument] expression are bound, and 4079 // the semantic constraints are checked, at the point where the 4080 // default argument expression appears. 4081 ContextRAII SavedContext(*this, FD); 4082 LocalInstantiationScope Local(*this); 4083 Result = SubstExpr(UninstExpr, MutiLevelArgList); 4084 } 4085 if (Result.isInvalid()) 4086 return ExprError(); 4087 4088 // Check the expression as an initializer for the parameter. 4089 InitializedEntity Entity 4090 = InitializedEntity::InitializeParameter(Context, Param); 4091 InitializationKind Kind 4092 = InitializationKind::CreateCopy(Param->getLocation(), 4093 /*FIXME:EqualLoc*/UninstExpr->getLocStart()); 4094 Expr *ResultE = Result.getAs<Expr>(); 4095 4096 InitializationSequence InitSeq(*this, Entity, Kind, ResultE); 4097 Result = InitSeq.Perform(*this, Entity, Kind, ResultE); 4098 if (Result.isInvalid()) 4099 return ExprError(); 4100 4101 Expr *Arg = Result.getAs<Expr>(); 4102 CheckCompletedExpr(Arg, Param->getOuterLocStart()); 4103 // Build the default argument expression. 4104 return CXXDefaultArgExpr::Create(Context, CallLoc, Param, Arg); 4105 } 4106 4107 // If the default expression creates temporaries, we need to 4108 // push them to the current stack of expression temporaries so they'll 4109 // be properly destroyed. 4110 // FIXME: We should really be rebuilding the default argument with new 4111 // bound temporaries; see the comment in PR5810. 4112 // We don't need to do that with block decls, though, because 4113 // blocks in default argument expression can never capture anything. 4114 if (isa<ExprWithCleanups>(Param->getInit())) { 4115 // Set the "needs cleanups" bit regardless of whether there are 4116 // any explicit objects. 4117 ExprNeedsCleanups = true; 4118 4119 // Append all the objects to the cleanup list. Right now, this 4120 // should always be a no-op, because blocks in default argument 4121 // expressions should never be able to capture anything. 4122 assert(!cast<ExprWithCleanups>(Param->getInit())->getNumObjects() && 4123 "default argument expression has capturing blocks?"); 4124 } 4125 4126 // We already type-checked the argument, so we know it works. 4127 // Just mark all of the declarations in this potentially-evaluated expression 4128 // as being "referenced". 4129 MarkDeclarationsReferencedInExpr(Param->getDefaultArg(), 4130 /*SkipLocalVariables=*/true); 4131 return CXXDefaultArgExpr::Create(Context, CallLoc, Param); 4132} 4133 4134 4135Sema::VariadicCallType 4136Sema::getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto, 4137 Expr *Fn) { 4138 if (Proto && Proto->isVariadic()) { 4139 if (dyn_cast_or_null<CXXConstructorDecl>(FDecl)) 4140 return VariadicConstructor; 4141 else if (Fn && Fn->getType()->isBlockPointerType()) 4142 return VariadicBlock; 4143 else if (FDecl) { 4144 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl)) 4145 if (Method->isInstance()) 4146 return VariadicMethod; 4147 } else if (Fn && Fn->getType() == Context.BoundMemberTy) 4148 return VariadicMethod; 4149 return VariadicFunction; 4150 } 4151 return VariadicDoesNotApply; 4152} 4153 4154namespace { 4155class FunctionCallCCC : public FunctionCallFilterCCC { 4156public: 4157 FunctionCallCCC(Sema &SemaRef, const IdentifierInfo *FuncName, 4158 unsigned NumArgs, MemberExpr *ME) 4159 : FunctionCallFilterCCC(SemaRef, NumArgs, false, ME), 4160 FunctionName(FuncName) {} 4161 4162 bool ValidateCandidate(const TypoCorrection &candidate) override { 4163 if (!candidate.getCorrectionSpecifier() || 4164 candidate.getCorrectionAsIdentifierInfo() != FunctionName) { 4165 return false; 4166 } 4167 4168 return FunctionCallFilterCCC::ValidateCandidate(candidate); 4169 } 4170 4171private: 4172 const IdentifierInfo *const FunctionName; 4173}; 4174} 4175 4176static TypoCorrection TryTypoCorrectionForCall(Sema &S, Expr *Fn, 4177 FunctionDecl *FDecl, 4178 ArrayRef<Expr *> Args) { 4179 MemberExpr *ME = dyn_cast<MemberExpr>(Fn); 4180 DeclarationName FuncName = FDecl->getDeclName(); 4181 SourceLocation NameLoc = ME ? ME->getMemberLoc() : Fn->getLocStart(); 4182 4183 if (TypoCorrection Corrected = S.CorrectTypo( 4184 DeclarationNameInfo(FuncName, NameLoc), Sema::LookupOrdinaryName, 4185 S.getScopeForContext(S.CurContext), nullptr, 4186 llvm::make_unique<FunctionCallCCC>(S, FuncName.getAsIdentifierInfo(), 4187 Args.size(), ME), 4188 Sema::CTK_ErrorRecovery)) { 4189 if (NamedDecl *ND = Corrected.getCorrectionDecl()) { 4190 if (Corrected.isOverloaded()) { 4191 OverloadCandidateSet OCS(NameLoc, OverloadCandidateSet::CSK_Normal); 4192 OverloadCandidateSet::iterator Best; 4193 for (TypoCorrection::decl_iterator CD = Corrected.begin(), 4194 CDEnd = Corrected.end(); 4195 CD != CDEnd; ++CD) { 4196 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD)) 4197 S.AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), Args, 4198 OCS); 4199 } 4200 switch (OCS.BestViableFunction(S, NameLoc, Best)) { 4201 case OR_Success: 4202 ND = Best->Function; 4203 Corrected.setCorrectionDecl(ND); 4204 break; 4205 default: 4206 break; 4207 } 4208 } 4209 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) { 4210 return Corrected; 4211 } 4212 } 4213 } 4214 return TypoCorrection(); 4215} 4216 4217/// ConvertArgumentsForCall - Converts the arguments specified in 4218/// Args/NumArgs to the parameter types of the function FDecl with 4219/// function prototype Proto. Call is the call expression itself, and 4220/// Fn is the function expression. For a C++ member function, this 4221/// routine does not attempt to convert the object argument. Returns 4222/// true if the call is ill-formed. 4223bool 4224Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, 4225 FunctionDecl *FDecl, 4226 const FunctionProtoType *Proto, 4227 ArrayRef<Expr *> Args, 4228 SourceLocation RParenLoc, 4229 bool IsExecConfig) { 4230 // Bail out early if calling a builtin with custom typechecking. 4231 // We don't need to do this in the 4232 if (FDecl) 4233 if (unsigned ID = FDecl->getBuiltinID()) 4234 if (Context.BuiltinInfo.hasCustomTypechecking(ID)) 4235 return false; 4236 4237 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by 4238 // assignment, to the types of the corresponding parameter, ... 4239 unsigned NumParams = Proto->getNumParams(); 4240 bool Invalid = false; 4241 unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumParams; 4242 unsigned FnKind = Fn->getType()->isBlockPointerType() 4243 ? 1 /* block */ 4244 : (IsExecConfig ? 3 /* kernel function (exec config) */ 4245 : 0 /* function */); 4246 4247 // If too few arguments are available (and we don't have default 4248 // arguments for the remaining parameters), don't make the call. 4249 if (Args.size() < NumParams) { 4250 if (Args.size() < MinArgs) { 4251 TypoCorrection TC; 4252 if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) { 4253 unsigned diag_id = 4254 MinArgs == NumParams && !Proto->isVariadic() 4255 ? diag::err_typecheck_call_too_few_args_suggest 4256 : diag::err_typecheck_call_too_few_args_at_least_suggest; 4257 diagnoseTypo(TC, PDiag(diag_id) << FnKind << MinArgs 4258 << static_cast<unsigned>(Args.size()) 4259 << TC.getCorrectionRange()); 4260 } else if (MinArgs == 1 && FDecl && FDecl->getParamDecl(0)->getDeclName()) 4261 Diag(RParenLoc, 4262 MinArgs == NumParams && !Proto->isVariadic() 4263 ? diag::err_typecheck_call_too_few_args_one 4264 : diag::err_typecheck_call_too_few_args_at_least_one) 4265 << FnKind << FDecl->getParamDecl(0) << Fn->getSourceRange(); 4266 else 4267 Diag(RParenLoc, MinArgs == NumParams && !Proto->isVariadic() 4268 ? diag::err_typecheck_call_too_few_args 4269 : diag::err_typecheck_call_too_few_args_at_least) 4270 << FnKind << MinArgs << static_cast<unsigned>(Args.size()) 4271 << Fn->getSourceRange(); 4272 4273 // Emit the location of the prototype. 4274 if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig) 4275 Diag(FDecl->getLocStart(), diag::note_callee_decl) 4276 << FDecl; 4277 4278 return true; 4279 } 4280 Call->setNumArgs(Context, NumParams); 4281 } 4282 4283 // If too many are passed and not variadic, error on the extras and drop 4284 // them. 4285 if (Args.size() > NumParams) { 4286 if (!Proto->isVariadic()) { 4287 TypoCorrection TC; 4288 if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) { 4289 unsigned diag_id = 4290 MinArgs == NumParams && !Proto->isVariadic() 4291 ? diag::err_typecheck_call_too_many_args_suggest 4292 : diag::err_typecheck_call_too_many_args_at_most_suggest; 4293 diagnoseTypo(TC, PDiag(diag_id) << FnKind << NumParams 4294 << static_cast<unsigned>(Args.size()) 4295 << TC.getCorrectionRange()); 4296 } else if (NumParams == 1 && FDecl && 4297 FDecl->getParamDecl(0)->getDeclName()) 4298 Diag(Args[NumParams]->getLocStart(), 4299 MinArgs == NumParams 4300 ? diag::err_typecheck_call_too_many_args_one 4301 : diag::err_typecheck_call_too_many_args_at_most_one) 4302 << FnKind << FDecl->getParamDecl(0) 4303 << static_cast<unsigned>(Args.size()) << Fn->getSourceRange() 4304 << SourceRange(Args[NumParams]->getLocStart(), 4305 Args.back()->getLocEnd()); 4306 else 4307 Diag(Args[NumParams]->getLocStart(), 4308 MinArgs == NumParams 4309 ? diag::err_typecheck_call_too_many_args 4310 : diag::err_typecheck_call_too_many_args_at_most) 4311 << FnKind << NumParams << static_cast<unsigned>(Args.size()) 4312 << Fn->getSourceRange() 4313 << SourceRange(Args[NumParams]->getLocStart(), 4314 Args.back()->getLocEnd()); 4315 4316 // Emit the location of the prototype. 4317 if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig) 4318 Diag(FDecl->getLocStart(), diag::note_callee_decl) 4319 << FDecl; 4320 4321 // This deletes the extra arguments. 4322 Call->setNumArgs(Context, NumParams); 4323 return true; 4324 } 4325 } 4326 SmallVector<Expr *, 8> AllArgs; 4327 VariadicCallType CallType = getVariadicCallType(FDecl, Proto, Fn); 4328 4329 Invalid = GatherArgumentsForCall(Call->getLocStart(), FDecl, 4330 Proto, 0, Args, AllArgs, CallType); 4331 if (Invalid) 4332 return true; 4333 unsigned TotalNumArgs = AllArgs.size(); 4334 for (unsigned i = 0; i < TotalNumArgs; ++i) 4335 Call->setArg(i, AllArgs[i]); 4336 4337 return false; 4338} 4339 4340bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, 4341 const FunctionProtoType *Proto, 4342 unsigned FirstParam, ArrayRef<Expr *> Args, 4343 SmallVectorImpl<Expr *> &AllArgs, 4344 VariadicCallType CallType, bool AllowExplicit, 4345 bool IsListInitialization) { 4346 unsigned NumParams = Proto->getNumParams(); 4347 bool Invalid = false; 4348 unsigned ArgIx = 0; 4349 // Continue to check argument types (even if we have too few/many args). 4350 for (unsigned i = FirstParam; i < NumParams; i++) { 4351 QualType ProtoArgType = Proto->getParamType(i); 4352 4353 Expr *Arg; 4354 ParmVarDecl *Param = FDecl ? FDecl->getParamDecl(i) : nullptr; 4355 if (ArgIx < Args.size()) { 4356 Arg = Args[ArgIx++]; 4357 4358 if (RequireCompleteType(Arg->getLocStart(), 4359 ProtoArgType, 4360 diag::err_call_incomplete_argument, Arg)) 4361 return true; 4362 4363 // Strip the unbridged-cast placeholder expression off, if applicable. 4364 bool CFAudited = false; 4365 if (Arg->getType() == Context.ARCUnbridgedCastTy && 4366 FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() && 4367 (!Param || !Param->hasAttr<CFConsumedAttr>())) 4368 Arg = stripARCUnbridgedCast(Arg); 4369 else if (getLangOpts().ObjCAutoRefCount && 4370 FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() && 4371 (!Param || !Param->hasAttr<CFConsumedAttr>())) 4372 CFAudited = true; 4373 4374 InitializedEntity Entity = 4375 Param ? InitializedEntity::InitializeParameter(Context, Param, 4376 ProtoArgType) 4377 : InitializedEntity::InitializeParameter( 4378 Context, ProtoArgType, Proto->isParamConsumed(i)); 4379 4380 // Remember that parameter belongs to a CF audited API. 4381 if (CFAudited) 4382 Entity.setParameterCFAudited(); 4383 4384 ExprResult ArgE = PerformCopyInitialization( 4385 Entity, SourceLocation(), Arg, IsListInitialization, AllowExplicit); 4386 if (ArgE.isInvalid()) 4387 return true; 4388 4389 Arg = ArgE.getAs<Expr>(); 4390 } else { 4391 assert(Param && "can't use default arguments without a known callee"); 4392 4393 ExprResult ArgExpr = 4394 BuildCXXDefaultArgExpr(CallLoc, FDecl, Param); 4395 if (ArgExpr.isInvalid()) 4396 return true; 4397 4398 Arg = ArgExpr.getAs<Expr>(); 4399 } 4400 4401 // Check for array bounds violations for each argument to the call. This 4402 // check only triggers warnings when the argument isn't a more complex Expr 4403 // with its own checking, such as a BinaryOperator. 4404 CheckArrayAccess(Arg); 4405 4406 // Check for violations of C99 static array rules (C99 6.7.5.3p7). 4407 CheckStaticArrayArgument(CallLoc, Param, Arg); 4408 4409 AllArgs.push_back(Arg); 4410 } 4411 4412 // If this is a variadic call, handle args passed through "...". 4413 if (CallType != VariadicDoesNotApply) { 4414 // Assume that extern "C" functions with variadic arguments that 4415 // return __unknown_anytype aren't *really* variadic. 4416 if (Proto->getReturnType() == Context.UnknownAnyTy && FDecl && 4417 FDecl->isExternC()) { 4418 for (unsigned i = ArgIx, e = Args.size(); i != e; ++i) { 4419 QualType paramType; // ignored 4420 ExprResult arg = checkUnknownAnyArg(CallLoc, Args[i], paramType); 4421 Invalid |= arg.isInvalid(); 4422 AllArgs.push_back(arg.get()); 4423 } 4424 4425 // Otherwise do argument promotion, (C99 6.5.2.2p7). 4426 } else { 4427 for (unsigned i = ArgIx, e = Args.size(); i != e; ++i) { 4428 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], CallType, 4429 FDecl); 4430 Invalid |= Arg.isInvalid(); 4431 AllArgs.push_back(Arg.get()); 4432 } 4433 } 4434 4435 // Check for array bounds violations. 4436 for (unsigned i = ArgIx, e = Args.size(); i != e; ++i) 4437 CheckArrayAccess(Args[i]); 4438 } 4439 return Invalid; 4440} 4441 4442static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD) { 4443 TypeLoc TL = PVD->getTypeSourceInfo()->getTypeLoc(); 4444 if (DecayedTypeLoc DTL = TL.getAs<DecayedTypeLoc>()) 4445 TL = DTL.getOriginalLoc(); 4446 if (ArrayTypeLoc ATL = TL.getAs<ArrayTypeLoc>()) 4447 S.Diag(PVD->getLocation(), diag::note_callee_static_array) 4448 << ATL.getLocalSourceRange(); 4449} 4450 4451/// CheckStaticArrayArgument - If the given argument corresponds to a static 4452/// array parameter, check that it is non-null, and that if it is formed by 4453/// array-to-pointer decay, the underlying array is sufficiently large. 4454/// 4455/// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the 4456/// array type derivation, then for each call to the function, the value of the 4457/// corresponding actual argument shall provide access to the first element of 4458/// an array with at least as many elements as specified by the size expression. 4459void 4460Sema::CheckStaticArrayArgument(SourceLocation CallLoc, 4461 ParmVarDecl *Param, 4462 const Expr *ArgExpr) { 4463 // Static array parameters are not supported in C++. 4464 if (!Param || getLangOpts().CPlusPlus) 4465 return; 4466 4467 QualType OrigTy = Param->getOriginalType(); 4468 4469 const ArrayType *AT = Context.getAsArrayType(OrigTy); 4470 if (!AT || AT->getSizeModifier() != ArrayType::Static) 4471 return; 4472 4473 if (ArgExpr->isNullPointerConstant(Context, 4474 Expr::NPC_NeverValueDependent)) { 4475 Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange(); 4476 DiagnoseCalleeStaticArrayParam(*this, Param); 4477 return; 4478 } 4479 4480 const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT); 4481 if (!CAT) 4482 return; 4483 4484 const ConstantArrayType *ArgCAT = 4485 Context.getAsConstantArrayType(ArgExpr->IgnoreParenImpCasts()->getType()); 4486 if (!ArgCAT) 4487 return; 4488 4489 if (ArgCAT->getSize().ult(CAT->getSize())) { 4490 Diag(CallLoc, diag::warn_static_array_too_small) 4491 << ArgExpr->getSourceRange() 4492 << (unsigned) ArgCAT->getSize().getZExtValue() 4493 << (unsigned) CAT->getSize().getZExtValue(); 4494 DiagnoseCalleeStaticArrayParam(*this, Param); 4495 } 4496} 4497 4498/// Given a function expression of unknown-any type, try to rebuild it 4499/// to have a function type. 4500static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn); 4501 4502/// Is the given type a placeholder that we need to lower out 4503/// immediately during argument processing? 4504static bool isPlaceholderToRemoveAsArg(QualType type) { 4505 // Placeholders are never sugared. 4506 const BuiltinType *placeholder = dyn_cast<BuiltinType>(type); 4507 if (!placeholder) return false; 4508 4509 switch (placeholder->getKind()) { 4510 // Ignore all the non-placeholder types. 4511#define PLACEHOLDER_TYPE(ID, SINGLETON_ID) 4512#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID: 4513#include "clang/AST/BuiltinTypes.def" 4514 return false; 4515 4516 // We cannot lower out overload sets; they might validly be resolved 4517 // by the call machinery. 4518 case BuiltinType::Overload: 4519 return false; 4520 4521 // Unbridged casts in ARC can be handled in some call positions and 4522 // should be left in place. 4523 case BuiltinType::ARCUnbridgedCast: 4524 return false; 4525 4526 // Pseudo-objects should be converted as soon as possible. 4527 case BuiltinType::PseudoObject: 4528 return true; 4529 4530 // The debugger mode could theoretically but currently does not try 4531 // to resolve unknown-typed arguments based on known parameter types. 4532 case BuiltinType::UnknownAny: 4533 return true; 4534 4535 // These are always invalid as call arguments and should be reported. 4536 case BuiltinType::BoundMember: 4537 case BuiltinType::BuiltinFn: 4538 return true; 4539 } 4540 llvm_unreachable("bad builtin type kind"); 4541} 4542 4543/// Check an argument list for placeholders that we won't try to 4544/// handle later. 4545static bool checkArgsForPlaceholders(Sema &S, MultiExprArg args) { 4546 // Apply this processing to all the arguments at once instead of 4547 // dying at the first failure. 4548 bool hasInvalid = false; 4549 for (size_t i = 0, e = args.size(); i != e; i++) { 4550 if (isPlaceholderToRemoveAsArg(args[i]->getType())) { 4551 ExprResult result = S.CheckPlaceholderExpr(args[i]); 4552 if (result.isInvalid()) hasInvalid = true; 4553 else args[i] = result.get(); 4554 } else if (hasInvalid) { 4555 (void)S.CorrectDelayedTyposInExpr(args[i]); 4556 } 4557 } 4558 return hasInvalid; 4559} 4560 4561/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments. 4562/// This provides the location of the left/right parens and a list of comma 4563/// locations. 4564ExprResult 4565Sema::ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, 4566 MultiExprArg ArgExprs, SourceLocation RParenLoc, 4567 Expr *ExecConfig, bool IsExecConfig) { 4568 // Since this might be a postfix expression, get rid of ParenListExprs. 4569 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn); 4570 if (Result.isInvalid()) return ExprError(); 4571 Fn = Result.get(); 4572 4573 if (checkArgsForPlaceholders(*this, ArgExprs)) 4574 return ExprError(); 4575 4576 if (getLangOpts().CPlusPlus) { 4577 // If this is a pseudo-destructor expression, build the call immediately. 4578 if (isa<CXXPseudoDestructorExpr>(Fn)) { 4579 if (!ArgExprs.empty()) { 4580 // Pseudo-destructor calls should not have any arguments. 4581 Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args) 4582 << FixItHint::CreateRemoval( 4583 SourceRange(ArgExprs[0]->getLocStart(), 4584 ArgExprs.back()->getLocEnd())); 4585 } 4586 4587 return new (Context) 4588 CallExpr(Context, Fn, None, Context.VoidTy, VK_RValue, RParenLoc); 4589 } 4590 if (Fn->getType() == Context.PseudoObjectTy) { 4591 ExprResult result = CheckPlaceholderExpr(Fn); 4592 if (result.isInvalid()) return ExprError(); 4593 Fn = result.get(); 4594 } 4595 4596 // Determine whether this is a dependent call inside a C++ template, 4597 // in which case we won't do any semantic analysis now. 4598 // FIXME: Will need to cache the results of name lookup (including ADL) in 4599 // Fn. 4600 bool Dependent = false; 4601 if (Fn->isTypeDependent()) 4602 Dependent = true; 4603 else if (Expr::hasAnyTypeDependentArguments(ArgExprs)) 4604 Dependent = true; 4605 4606 if (Dependent) { 4607 if (ExecConfig) { 4608 return new (Context) CUDAKernelCallExpr( 4609 Context, Fn, cast<CallExpr>(ExecConfig), ArgExprs, 4610 Context.DependentTy, VK_RValue, RParenLoc); 4611 } else { 4612 return new (Context) CallExpr( 4613 Context, Fn, ArgExprs, Context.DependentTy, VK_RValue, RParenLoc); 4614 } 4615 } 4616 4617 // Determine whether this is a call to an object (C++ [over.call.object]). 4618 if (Fn->getType()->isRecordType()) 4619 return BuildCallToObjectOfClassType(S, Fn, LParenLoc, ArgExprs, 4620 RParenLoc); 4621 4622 if (Fn->getType() == Context.UnknownAnyTy) { 4623 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 4624 if (result.isInvalid()) return ExprError(); 4625 Fn = result.get(); 4626 } 4627 4628 if (Fn->getType() == Context.BoundMemberTy) { 4629 return BuildCallToMemberFunction(S, Fn, LParenLoc, ArgExprs, RParenLoc); 4630 } 4631 } 4632 4633 // Check for overloaded calls. This can happen even in C due to extensions. 4634 if (Fn->getType() == Context.OverloadTy) { 4635 OverloadExpr::FindResult find = OverloadExpr::find(Fn); 4636 4637 // We aren't supposed to apply this logic for if there's an '&' involved. 4638 if (!find.HasFormOfMemberPointer) { 4639 OverloadExpr *ovl = find.Expression; 4640 if (isa<UnresolvedLookupExpr>(ovl)) { 4641 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(ovl); 4642 return BuildOverloadedCallExpr(S, Fn, ULE, LParenLoc, ArgExprs, 4643 RParenLoc, ExecConfig); 4644 } else { 4645 return BuildCallToMemberFunction(S, Fn, LParenLoc, ArgExprs, 4646 RParenLoc); 4647 } 4648 } 4649 } 4650 4651 // If we're directly calling a function, get the appropriate declaration. 4652 if (Fn->getType() == Context.UnknownAnyTy) { 4653 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 4654 if (result.isInvalid()) return ExprError(); 4655 Fn = result.get(); 4656 } 4657 4658 Expr *NakedFn = Fn->IgnoreParens(); 4659 4660 NamedDecl *NDecl = nullptr; 4661 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) 4662 if (UnOp->getOpcode() == UO_AddrOf) 4663 NakedFn = UnOp->getSubExpr()->IgnoreParens(); 4664 4665 if (isa<DeclRefExpr>(NakedFn)) 4666 NDecl = cast<DeclRefExpr>(NakedFn)->getDecl(); 4667 else if (isa<MemberExpr>(NakedFn)) 4668 NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl(); 4669 4670 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) { 4671 if (FD->hasAttr<EnableIfAttr>()) { 4672 if (const EnableIfAttr *Attr = CheckEnableIf(FD, ArgExprs, true)) { 4673 Diag(Fn->getLocStart(), 4674 isa<CXXMethodDecl>(FD) ? 4675 diag::err_ovl_no_viable_member_function_in_call : 4676 diag::err_ovl_no_viable_function_in_call) 4677 << FD << FD->getSourceRange(); 4678 Diag(FD->getLocation(), 4679 diag::note_ovl_candidate_disabled_by_enable_if_attr) 4680 << Attr->getCond()->getSourceRange() << Attr->getMessage(); 4681 } 4682 } 4683 } 4684 4685 return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc, 4686 ExecConfig, IsExecConfig); 4687} 4688 4689/// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments. 4690/// 4691/// __builtin_astype( value, dst type ) 4692/// 4693ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, 4694 SourceLocation BuiltinLoc, 4695 SourceLocation RParenLoc) { 4696 ExprValueKind VK = VK_RValue; 4697 ExprObjectKind OK = OK_Ordinary; 4698 QualType DstTy = GetTypeFromParser(ParsedDestTy); 4699 QualType SrcTy = E->getType(); 4700 if (Context.getTypeSize(DstTy) != Context.getTypeSize(SrcTy)) 4701 return ExprError(Diag(BuiltinLoc, 4702 diag::err_invalid_astype_of_different_size) 4703 << DstTy 4704 << SrcTy 4705 << E->getSourceRange()); 4706 return new (Context) AsTypeExpr(E, DstTy, VK, OK, BuiltinLoc, RParenLoc); 4707} 4708 4709/// ActOnConvertVectorExpr - create a new convert-vector expression from the 4710/// provided arguments. 4711/// 4712/// __builtin_convertvector( value, dst type ) 4713/// 4714ExprResult Sema::ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy, 4715 SourceLocation BuiltinLoc, 4716 SourceLocation RParenLoc) { 4717 TypeSourceInfo *TInfo; 4718 GetTypeFromParser(ParsedDestTy, &TInfo); 4719 return SemaConvertVectorExpr(E, TInfo, BuiltinLoc, RParenLoc); 4720} 4721 4722/// BuildResolvedCallExpr - Build a call to a resolved expression, 4723/// i.e. an expression not of \p OverloadTy. The expression should 4724/// unary-convert to an expression of function-pointer or 4725/// block-pointer type. 4726/// 4727/// \param NDecl the declaration being called, if available 4728ExprResult 4729Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, 4730 SourceLocation LParenLoc, 4731 ArrayRef<Expr *> Args, 4732 SourceLocation RParenLoc, 4733 Expr *Config, bool IsExecConfig) { 4734 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl); 4735 unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0); 4736 4737 // Promote the function operand. 4738 // We special-case function promotion here because we only allow promoting 4739 // builtin functions to function pointers in the callee of a call. 4740 ExprResult Result; 4741 if (BuiltinID && 4742 Fn->getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn)) { 4743 Result = ImpCastExprToType(Fn, Context.getPointerType(FDecl->getType()), 4744 CK_BuiltinFnToFnPtr).get(); 4745 } else { 4746 Result = CallExprUnaryConversions(Fn); 4747 } 4748 if (Result.isInvalid()) 4749 return ExprError(); 4750 Fn = Result.get(); 4751 4752 // Make the call expr early, before semantic checks. This guarantees cleanup 4753 // of arguments and function on error. 4754 CallExpr *TheCall; 4755 if (Config) 4756 TheCall = new (Context) CUDAKernelCallExpr(Context, Fn, 4757 cast<CallExpr>(Config), Args, 4758 Context.BoolTy, VK_RValue, 4759 RParenLoc); 4760 else 4761 TheCall = new (Context) CallExpr(Context, Fn, Args, Context.BoolTy, 4762 VK_RValue, RParenLoc); 4763 4764 // Bail out early if calling a builtin with custom typechecking. 4765 if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID)) 4766 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall); 4767 4768 retry: 4769 const FunctionType *FuncT; 4770 if (const PointerType *PT = Fn->getType()->getAs<PointerType>()) { 4771 // C99 6.5.2.2p1 - "The expression that denotes the called function shall 4772 // have type pointer to function". 4773 FuncT = PT->getPointeeType()->getAs<FunctionType>(); 4774 if (!FuncT) 4775 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 4776 << Fn->getType() << Fn->getSourceRange()); 4777 } else if (const BlockPointerType *BPT = 4778 Fn->getType()->getAs<BlockPointerType>()) { 4779 FuncT = BPT->getPointeeType()->castAs<FunctionType>(); 4780 } else { 4781 // Handle calls to expressions of unknown-any type. 4782 if (Fn->getType() == Context.UnknownAnyTy) { 4783 ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn); 4784 if (rewrite.isInvalid()) return ExprError(); 4785 Fn = rewrite.get(); 4786 TheCall->setCallee(Fn); 4787 goto retry; 4788 } 4789 4790 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 4791 << Fn->getType() << Fn->getSourceRange()); 4792 } 4793 4794 if (getLangOpts().CUDA) { 4795 if (Config) { 4796 // CUDA: Kernel calls must be to global functions 4797 if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>()) 4798 return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function) 4799 << FDecl->getName() << Fn->getSourceRange()); 4800 4801 // CUDA: Kernel function must have 'void' return type 4802 if (!FuncT->getReturnType()->isVoidType()) 4803 return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return) 4804 << Fn->getType() << Fn->getSourceRange()); 4805 } else { 4806 // CUDA: Calls to global functions must be configured 4807 if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>()) 4808 return ExprError(Diag(LParenLoc, diag::err_global_call_not_config) 4809 << FDecl->getName() << Fn->getSourceRange()); 4810 } 4811 } 4812 4813 // Check for a valid return type 4814 if (CheckCallReturnType(FuncT->getReturnType(), Fn->getLocStart(), TheCall, 4815 FDecl)) 4816 return ExprError(); 4817 4818 // We know the result type of the call, set it. 4819 TheCall->setType(FuncT->getCallResultType(Context)); 4820 TheCall->setValueKind(Expr::getValueKindForType(FuncT->getReturnType())); 4821 4822 const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT); 4823 if (Proto) { 4824 if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, RParenLoc, 4825 IsExecConfig)) 4826 return ExprError(); 4827 } else { 4828 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!"); 4829 4830 if (FDecl) { 4831 // Check if we have too few/too many template arguments, based 4832 // on our knowledge of the function definition. 4833 const FunctionDecl *Def = nullptr; 4834 if (FDecl->hasBody(Def) && Args.size() != Def->param_size()) { 4835 Proto = Def->getType()->getAs<FunctionProtoType>(); 4836 if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->param_size())) 4837 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments) 4838 << (Args.size() > Def->param_size()) << FDecl << Fn->getSourceRange(); 4839 } 4840 4841 // If the function we're calling isn't a function prototype, but we have 4842 // a function prototype from a prior declaratiom, use that prototype. 4843 if (!FDecl->hasPrototype()) 4844 Proto = FDecl->getType()->getAs<FunctionProtoType>(); 4845 } 4846 4847 // Promote the arguments (C99 6.5.2.2p6). 4848 for (unsigned i = 0, e = Args.size(); i != e; i++) { 4849 Expr *Arg = Args[i]; 4850 4851 if (Proto && i < Proto->getNumParams()) { 4852 InitializedEntity Entity = InitializedEntity::InitializeParameter( 4853 Context, Proto->getParamType(i), Proto->isParamConsumed(i)); 4854 ExprResult ArgE = 4855 PerformCopyInitialization(Entity, SourceLocation(), Arg); 4856 if (ArgE.isInvalid()) 4857 return true; 4858 4859 Arg = ArgE.getAs<Expr>(); 4860 4861 } else { 4862 ExprResult ArgE = DefaultArgumentPromotion(Arg); 4863 4864 if (ArgE.isInvalid()) 4865 return true; 4866 4867 Arg = ArgE.getAs<Expr>(); 4868 } 4869 4870 if (RequireCompleteType(Arg->getLocStart(), 4871 Arg->getType(), 4872 diag::err_call_incomplete_argument, Arg)) 4873 return ExprError(); 4874 4875 TheCall->setArg(i, Arg); 4876 } 4877 } 4878 4879 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl)) 4880 if (!Method->isStatic()) 4881 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object) 4882 << Fn->getSourceRange()); 4883 4884 // Check for sentinels 4885 if (NDecl) 4886 DiagnoseSentinelCalls(NDecl, LParenLoc, Args); 4887 4888 // Do special checking on direct calls to functions. 4889 if (FDecl) { 4890 if (CheckFunctionCall(FDecl, TheCall, Proto)) 4891 return ExprError(); 4892 4893 if (BuiltinID) 4894 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall); 4895 } else if (NDecl) { 4896 if (CheckPointerCall(NDecl, TheCall, Proto)) 4897 return ExprError(); 4898 } else { 4899 if (CheckOtherCall(TheCall, Proto)) 4900 return ExprError(); 4901 } 4902 4903 return MaybeBindToTemporary(TheCall); 4904} 4905 4906ExprResult 4907Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, 4908 SourceLocation RParenLoc, Expr *InitExpr) { 4909 assert(Ty && "ActOnCompoundLiteral(): missing type"); 4910 // FIXME: put back this assert when initializers are worked out. 4911 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression"); 4912 4913 TypeSourceInfo *TInfo; 4914 QualType literalType = GetTypeFromParser(Ty, &TInfo); 4915 if (!TInfo) 4916 TInfo = Context.getTrivialTypeSourceInfo(literalType); 4917 4918 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr); 4919} 4920 4921ExprResult 4922Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, 4923 SourceLocation RParenLoc, Expr *LiteralExpr) { 4924 QualType literalType = TInfo->getType(); 4925 4926 if (literalType->isArrayType()) { 4927 if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType), 4928 diag::err_illegal_decl_array_incomplete_type, 4929 SourceRange(LParenLoc, 4930 LiteralExpr->getSourceRange().getEnd()))) 4931 return ExprError(); 4932 if (literalType->isVariableArrayType()) 4933 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init) 4934 << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())); 4935 } else if (!literalType->isDependentType() && 4936 RequireCompleteType(LParenLoc, literalType, 4937 diag::err_typecheck_decl_incomplete_type, 4938 SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd()))) 4939 return ExprError(); 4940 4941 InitializedEntity Entity 4942 = InitializedEntity::InitializeCompoundLiteralInit(TInfo); 4943 InitializationKind Kind 4944 = InitializationKind::CreateCStyleCast(LParenLoc, 4945 SourceRange(LParenLoc, RParenLoc), 4946 /*InitList=*/true); 4947 InitializationSequence InitSeq(*this, Entity, Kind, LiteralExpr); 4948 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, LiteralExpr, 4949 &literalType); 4950 if (Result.isInvalid()) 4951 return ExprError(); 4952 LiteralExpr = Result.get(); 4953 4954 bool isFileScope = getCurFunctionOrMethodDecl() == nullptr; 4955 if (isFileScope && 4956 !LiteralExpr->isTypeDependent() && 4957 !LiteralExpr->isValueDependent() && 4958 !literalType->isDependentType()) { // 6.5.2.5p3 4959 if (CheckForConstantInitializer(LiteralExpr, literalType)) 4960 return ExprError(); 4961 } 4962 4963 // In C, compound literals are l-values for some reason. 4964 ExprValueKind VK = getLangOpts().CPlusPlus ? VK_RValue : VK_LValue; 4965 4966 return MaybeBindToTemporary( 4967 new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType, 4968 VK, LiteralExpr, isFileScope)); 4969} 4970 4971ExprResult 4972Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, 4973 SourceLocation RBraceLoc) { 4974 // Immediately handle non-overload placeholders. Overloads can be 4975 // resolved contextually, but everything else here can't. 4976 for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) { 4977 if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) { 4978 ExprResult result = CheckPlaceholderExpr(InitArgList[I]); 4979 4980 // Ignore failures; dropping the entire initializer list because 4981 // of one failure would be terrible for indexing/etc. 4982 if (result.isInvalid()) continue; 4983 4984 InitArgList[I] = result.get(); 4985 } 4986 } 4987 4988 // Semantic analysis for initializers is done by ActOnDeclarator() and 4989 // CheckInitializer() - it requires knowledge of the object being intialized. 4990 4991 InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList, 4992 RBraceLoc); 4993 E->setType(Context.VoidTy); // FIXME: just a place holder for now. 4994 return E; 4995} 4996 4997/// Do an explicit extend of the given block pointer if we're in ARC. 4998static void maybeExtendBlockObject(Sema &S, ExprResult &E) { 4999 assert(E.get()->getType()->isBlockPointerType()); 5000 assert(E.get()->isRValue()); 5001 5002 // Only do this in an r-value context. 5003 if (!S.getLangOpts().ObjCAutoRefCount) return; 5004 5005 E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), 5006 CK_ARCExtendBlockObject, E.get(), 5007 /*base path*/ nullptr, VK_RValue); 5008 S.ExprNeedsCleanups = true; 5009} 5010 5011/// Prepare a conversion of the given expression to an ObjC object 5012/// pointer type. 5013CastKind Sema::PrepareCastToObjCObjectPointer(ExprResult &E) { 5014 QualType type = E.get()->getType(); 5015 if (type->isObjCObjectPointerType()) { 5016 return CK_BitCast; 5017 } else if (type->isBlockPointerType()) { 5018 maybeExtendBlockObject(*this, E); 5019 return CK_BlockPointerToObjCPointerCast; 5020 } else { 5021 assert(type->isPointerType()); 5022 return CK_CPointerToObjCPointerCast; 5023 } 5024} 5025 5026/// Prepares for a scalar cast, performing all the necessary stages 5027/// except the final cast and returning the kind required. 5028CastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) { 5029 // Both Src and Dest are scalar types, i.e. arithmetic or pointer. 5030 // Also, callers should have filtered out the invalid cases with 5031 // pointers. Everything else should be possible. 5032 5033 QualType SrcTy = Src.get()->getType(); 5034 if (Context.hasSameUnqualifiedType(SrcTy, DestTy)) 5035 return CK_NoOp; 5036 5037 switch (Type::ScalarTypeKind SrcKind = SrcTy->getScalarTypeKind()) { 5038 case Type::STK_MemberPointer: 5039 llvm_unreachable("member pointer type in C"); 5040 5041 case Type::STK_CPointer: 5042 case Type::STK_BlockPointer: 5043 case Type::STK_ObjCObjectPointer: 5044 switch (DestTy->getScalarTypeKind()) { 5045 case Type::STK_CPointer: { 5046 unsigned SrcAS = SrcTy->getPointeeType().getAddressSpace(); 5047 unsigned DestAS = DestTy->getPointeeType().getAddressSpace(); 5048 if (SrcAS != DestAS) 5049 return CK_AddressSpaceConversion; 5050 return CK_BitCast; 5051 } 5052 case Type::STK_BlockPointer: 5053 return (SrcKind == Type::STK_BlockPointer 5054 ? CK_BitCast : CK_AnyPointerToBlockPointerCast); 5055 case Type::STK_ObjCObjectPointer: 5056 if (SrcKind == Type::STK_ObjCObjectPointer) 5057 return CK_BitCast; 5058 if (SrcKind == Type::STK_CPointer) 5059 return CK_CPointerToObjCPointerCast; 5060 maybeExtendBlockObject(*this, Src); 5061 return CK_BlockPointerToObjCPointerCast; 5062 case Type::STK_Bool: 5063 return CK_PointerToBoolean; 5064 case Type::STK_Integral: 5065 return CK_PointerToIntegral; 5066 case Type::STK_Floating: 5067 case Type::STK_FloatingComplex: 5068 case Type::STK_IntegralComplex: 5069 case Type::STK_MemberPointer: 5070 llvm_unreachable("illegal cast from pointer"); 5071 } 5072 llvm_unreachable("Should have returned before this"); 5073 5074 case Type::STK_Bool: // casting from bool is like casting from an integer 5075 case Type::STK_Integral: 5076 switch (DestTy->getScalarTypeKind()) { 5077 case Type::STK_CPointer: 5078 case Type::STK_ObjCObjectPointer: 5079 case Type::STK_BlockPointer: 5080 if (Src.get()->isNullPointerConstant(Context, 5081 Expr::NPC_ValueDependentIsNull)) 5082 return CK_NullToPointer; 5083 return CK_IntegralToPointer; 5084 case Type::STK_Bool: 5085 return CK_IntegralToBoolean; 5086 case Type::STK_Integral: 5087 return CK_IntegralCast; 5088 case Type::STK_Floating: 5089 return CK_IntegralToFloating; 5090 case Type::STK_IntegralComplex: 5091 Src = ImpCastExprToType(Src.get(), 5092 DestTy->castAs<ComplexType>()->getElementType(), 5093 CK_IntegralCast); 5094 return CK_IntegralRealToComplex; 5095 case Type::STK_FloatingComplex: 5096 Src = ImpCastExprToType(Src.get(), 5097 DestTy->castAs<ComplexType>()->getElementType(), 5098 CK_IntegralToFloating); 5099 return CK_FloatingRealToComplex; 5100 case Type::STK_MemberPointer: 5101 llvm_unreachable("member pointer type in C"); 5102 } 5103 llvm_unreachable("Should have returned before this"); 5104 5105 case Type::STK_Floating: 5106 switch (DestTy->getScalarTypeKind()) { 5107 case Type::STK_Floating: 5108 return CK_FloatingCast; 5109 case Type::STK_Bool: 5110 return CK_FloatingToBoolean; 5111 case Type::STK_Integral: 5112 return CK_FloatingToIntegral; 5113 case Type::STK_FloatingComplex: 5114 Src = ImpCastExprToType(Src.get(), 5115 DestTy->castAs<ComplexType>()->getElementType(), 5116 CK_FloatingCast); 5117 return CK_FloatingRealToComplex; 5118 case Type::STK_IntegralComplex: 5119 Src = ImpCastExprToType(Src.get(), 5120 DestTy->castAs<ComplexType>()->getElementType(), 5121 CK_FloatingToIntegral); 5122 return CK_IntegralRealToComplex; 5123 case Type::STK_CPointer: 5124 case Type::STK_ObjCObjectPointer: 5125 case Type::STK_BlockPointer: 5126 llvm_unreachable("valid float->pointer cast?"); 5127 case Type::STK_MemberPointer: 5128 llvm_unreachable("member pointer type in C"); 5129 } 5130 llvm_unreachable("Should have returned before this"); 5131 5132 case Type::STK_FloatingComplex: 5133 switch (DestTy->getScalarTypeKind()) { 5134 case Type::STK_FloatingComplex: 5135 return CK_FloatingComplexCast; 5136 case Type::STK_IntegralComplex: 5137 return CK_FloatingComplexToIntegralComplex; 5138 case Type::STK_Floating: { 5139 QualType ET = SrcTy->castAs<ComplexType>()->getElementType(); 5140 if (Context.hasSameType(ET, DestTy)) 5141 return CK_FloatingComplexToReal; 5142 Src = ImpCastExprToType(Src.get(), ET, CK_FloatingComplexToReal); 5143 return CK_FloatingCast; 5144 } 5145 case Type::STK_Bool: 5146 return CK_FloatingComplexToBoolean; 5147 case Type::STK_Integral: 5148 Src = ImpCastExprToType(Src.get(), 5149 SrcTy->castAs<ComplexType>()->getElementType(), 5150 CK_FloatingComplexToReal); 5151 return CK_FloatingToIntegral; 5152 case Type::STK_CPointer: 5153 case Type::STK_ObjCObjectPointer: 5154 case Type::STK_BlockPointer: 5155 llvm_unreachable("valid complex float->pointer cast?"); 5156 case Type::STK_MemberPointer: 5157 llvm_unreachable("member pointer type in C"); 5158 } 5159 llvm_unreachable("Should have returned before this"); 5160 5161 case Type::STK_IntegralComplex: 5162 switch (DestTy->getScalarTypeKind()) { 5163 case Type::STK_FloatingComplex: 5164 return CK_IntegralComplexToFloatingComplex; 5165 case Type::STK_IntegralComplex: 5166 return CK_IntegralComplexCast; 5167 case Type::STK_Integral: { 5168 QualType ET = SrcTy->castAs<ComplexType>()->getElementType(); 5169 if (Context.hasSameType(ET, DestTy)) 5170 return CK_IntegralComplexToReal; 5171 Src = ImpCastExprToType(Src.get(), ET, CK_IntegralComplexToReal); 5172 return CK_IntegralCast; 5173 } 5174 case Type::STK_Bool: 5175 return CK_IntegralComplexToBoolean; 5176 case Type::STK_Floating: 5177 Src = ImpCastExprToType(Src.get(), 5178 SrcTy->castAs<ComplexType>()->getElementType(), 5179 CK_IntegralComplexToReal); 5180 return CK_IntegralToFloating; 5181 case Type::STK_CPointer: 5182 case Type::STK_ObjCObjectPointer: 5183 case Type::STK_BlockPointer: 5184 llvm_unreachable("valid complex int->pointer cast?"); 5185 case Type::STK_MemberPointer: 5186 llvm_unreachable("member pointer type in C"); 5187 } 5188 llvm_unreachable("Should have returned before this"); 5189 } 5190 5191 llvm_unreachable("Unhandled scalar cast"); 5192} 5193 5194static bool breakDownVectorType(QualType type, uint64_t &len, 5195 QualType &eltType) { 5196 // Vectors are simple. 5197 if (const VectorType *vecType = type->getAs<VectorType>()) { 5198 len = vecType->getNumElements(); 5199 eltType = vecType->getElementType(); 5200 assert(eltType->isScalarType()); 5201 return true; 5202 } 5203 5204 // We allow lax conversion to and from non-vector types, but only if 5205 // they're real types (i.e. non-complex, non-pointer scalar types). 5206 if (!type->isRealType()) return false; 5207 5208 len = 1; 5209 eltType = type; 5210 return true; 5211} 5212 5213static bool VectorTypesMatch(Sema &S, QualType srcTy, QualType destTy) { 5214 uint64_t srcLen, destLen; 5215 QualType srcElt, destElt; 5216 if (!breakDownVectorType(srcTy, srcLen, srcElt)) return false; 5217 if (!breakDownVectorType(destTy, destLen, destElt)) return false; 5218 5219 // ASTContext::getTypeSize will return the size rounded up to a 5220 // power of 2, so instead of using that, we need to use the raw 5221 // element size multiplied by the element count. 5222 uint64_t srcEltSize = S.Context.getTypeSize(srcElt); 5223 uint64_t destEltSize = S.Context.getTypeSize(destElt); 5224 5225 return (srcLen * srcEltSize == destLen * destEltSize); 5226} 5227 5228/// Is this a legal conversion between two known vector types? 5229bool Sema::isLaxVectorConversion(QualType srcTy, QualType destTy) { 5230 assert(destTy->isVectorType() || srcTy->isVectorType()); 5231 5232 if (!Context.getLangOpts().LaxVectorConversions) 5233 return false; 5234 return VectorTypesMatch(*this, srcTy, destTy); 5235} 5236 5237bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, 5238 CastKind &Kind) { 5239 assert(VectorTy->isVectorType() && "Not a vector type!"); 5240 5241 if (Ty->isVectorType() || Ty->isIntegerType()) { 5242 if (!VectorTypesMatch(*this, Ty, VectorTy)) 5243 return Diag(R.getBegin(), 5244 Ty->isVectorType() ? 5245 diag::err_invalid_conversion_between_vectors : 5246 diag::err_invalid_conversion_between_vector_and_integer) 5247 << VectorTy << Ty << R; 5248 } else 5249 return Diag(R.getBegin(), 5250 diag::err_invalid_conversion_between_vector_and_scalar) 5251 << VectorTy << Ty << R; 5252 5253 Kind = CK_BitCast; 5254 return false; 5255} 5256 5257ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy, 5258 Expr *CastExpr, CastKind &Kind) { 5259 assert(DestTy->isExtVectorType() && "Not an extended vector type!"); 5260 5261 QualType SrcTy = CastExpr->getType(); 5262 5263 // If SrcTy is a VectorType, the total size must match to explicitly cast to 5264 // an ExtVectorType. 5265 // In OpenCL, casts between vectors of different types are not allowed. 5266 // (See OpenCL 6.2). 5267 if (SrcTy->isVectorType()) { 5268 if (!VectorTypesMatch(*this, SrcTy, DestTy) 5269 || (getLangOpts().OpenCL && 5270 (DestTy.getCanonicalType() != SrcTy.getCanonicalType()))) { 5271 Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors) 5272 << DestTy << SrcTy << R; 5273 return ExprError(); 5274 } 5275 Kind = CK_BitCast; 5276 return CastExpr; 5277 } 5278 5279 // All non-pointer scalars can be cast to ExtVector type. The appropriate 5280 // conversion will take place first from scalar to elt type, and then 5281 // splat from elt type to vector. 5282 if (SrcTy->isPointerType()) 5283 return Diag(R.getBegin(), 5284 diag::err_invalid_conversion_between_vector_and_scalar) 5285 << DestTy << SrcTy << R; 5286 5287 QualType DestElemTy = DestTy->getAs<ExtVectorType>()->getElementType(); 5288 ExprResult CastExprRes = CastExpr; 5289 CastKind CK = PrepareScalarCast(CastExprRes, DestElemTy); 5290 if (CastExprRes.isInvalid()) 5291 return ExprError(); 5292 CastExpr = ImpCastExprToType(CastExprRes.get(), DestElemTy, CK).get(); 5293 5294 Kind = CK_VectorSplat; 5295 return CastExpr; 5296} 5297 5298ExprResult 5299Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, 5300 Declarator &D, ParsedType &Ty, 5301 SourceLocation RParenLoc, Expr *CastExpr) { 5302 assert(!D.isInvalidType() && (CastExpr != nullptr) && 5303 "ActOnCastExpr(): missing type or expr"); 5304 5305 TypeSourceInfo *castTInfo = GetTypeForDeclaratorCast(D, CastExpr->getType()); 5306 if (D.isInvalidType()) 5307 return ExprError(); 5308 5309 if (getLangOpts().CPlusPlus) { 5310 // Check that there are no default arguments (C++ only). 5311 CheckExtraCXXDefaultArguments(D); 5312 } else { 5313 // Make sure any TypoExprs have been dealt with. 5314 ExprResult Res = CorrectDelayedTyposInExpr(CastExpr); 5315 if (!Res.isUsable()) 5316 return ExprError(); 5317 CastExpr = Res.get(); 5318 } 5319 5320 checkUnusedDeclAttributes(D); 5321 5322 QualType castType = castTInfo->getType(); 5323 Ty = CreateParsedType(castType, castTInfo); 5324 5325 bool isVectorLiteral = false; 5326 5327 // Check for an altivec or OpenCL literal, 5328 // i.e. all the elements are integer constants. 5329 ParenExpr *PE = dyn_cast<ParenExpr>(CastExpr); 5330 ParenListExpr *PLE = dyn_cast<ParenListExpr>(CastExpr); 5331 if ((getLangOpts().AltiVec || getLangOpts().OpenCL) 5332 && castType->isVectorType() && (PE || PLE)) { 5333 if (PLE && PLE->getNumExprs() == 0) { 5334 Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer); 5335 return ExprError(); 5336 } 5337 if (PE || PLE->getNumExprs() == 1) { 5338 Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0)); 5339 if (!E->getType()->isVectorType()) 5340 isVectorLiteral = true; 5341 } 5342 else 5343 isVectorLiteral = true; 5344 } 5345 5346 // If this is a vector initializer, '(' type ')' '(' init, ..., init ')' 5347 // then handle it as such. 5348 if (isVectorLiteral) 5349 return BuildVectorLiteral(LParenLoc, RParenLoc, CastExpr, castTInfo); 5350 5351 // If the Expr being casted is a ParenListExpr, handle it specially. 5352 // This is not an AltiVec-style cast, so turn the ParenListExpr into a 5353 // sequence of BinOp comma operators. 5354 if (isa<ParenListExpr>(CastExpr)) { 5355 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr); 5356 if (Result.isInvalid()) return ExprError(); 5357 CastExpr = Result.get(); 5358 } 5359 5360 if (getLangOpts().CPlusPlus && !castType->isVoidType() && 5361 !getSourceManager().isInSystemMacro(LParenLoc)) 5362 Diag(LParenLoc, diag::warn_old_style_cast) << CastExpr->getSourceRange(); 5363 5364 CheckTollFreeBridgeCast(castType, CastExpr); 5365 5366 CheckObjCBridgeRelatedCast(castType, CastExpr); 5367 5368 return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, CastExpr); 5369} 5370 5371ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc, 5372 SourceLocation RParenLoc, Expr *E, 5373 TypeSourceInfo *TInfo) { 5374 assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) && 5375 "Expected paren or paren list expression"); 5376 5377 Expr **exprs; 5378 unsigned numExprs; 5379 Expr *subExpr; 5380 SourceLocation LiteralLParenLoc, LiteralRParenLoc; 5381 if (ParenListExpr *PE = dyn_cast<ParenListExpr>(E)) { 5382 LiteralLParenLoc = PE->getLParenLoc(); 5383 LiteralRParenLoc = PE->getRParenLoc(); 5384 exprs = PE->getExprs(); 5385 numExprs = PE->getNumExprs(); 5386 } else { // isa<ParenExpr> by assertion at function entrance 5387 LiteralLParenLoc = cast<ParenExpr>(E)->getLParen(); 5388 LiteralRParenLoc = cast<ParenExpr>(E)->getRParen(); 5389 subExpr = cast<ParenExpr>(E)->getSubExpr(); 5390 exprs = &subExpr; 5391 numExprs = 1; 5392 } 5393 5394 QualType Ty = TInfo->getType(); 5395 assert(Ty->isVectorType() && "Expected vector type"); 5396 5397 SmallVector<Expr *, 8> initExprs; 5398 const VectorType *VTy = Ty->getAs<VectorType>(); 5399 unsigned numElems = Ty->getAs<VectorType>()->getNumElements(); 5400 5401 // '(...)' form of vector initialization in AltiVec: the number of 5402 // initializers must be one or must match the size of the vector. 5403 // If a single value is specified in the initializer then it will be 5404 // replicated to all the components of the vector 5405 if (VTy->getVectorKind() == VectorType::AltiVecVector) { 5406 // The number of initializers must be one or must match the size of the 5407 // vector. If a single value is specified in the initializer then it will 5408 // be replicated to all the components of the vector 5409 if (numExprs == 1) { 5410 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 5411 ExprResult Literal = DefaultLvalueConversion(exprs[0]); 5412 if (Literal.isInvalid()) 5413 return ExprError(); 5414 Literal = ImpCastExprToType(Literal.get(), ElemTy, 5415 PrepareScalarCast(Literal, ElemTy)); 5416 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get()); 5417 } 5418 else if (numExprs < numElems) { 5419 Diag(E->getExprLoc(), 5420 diag::err_incorrect_number_of_vector_initializers); 5421 return ExprError(); 5422 } 5423 else 5424 initExprs.append(exprs, exprs + numExprs); 5425 } 5426 else { 5427 // For OpenCL, when the number of initializers is a single value, 5428 // it will be replicated to all components of the vector. 5429 if (getLangOpts().OpenCL && 5430 VTy->getVectorKind() == VectorType::GenericVector && 5431 numExprs == 1) { 5432 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 5433 ExprResult Literal = DefaultLvalueConversion(exprs[0]); 5434 if (Literal.isInvalid()) 5435 return ExprError(); 5436 Literal = ImpCastExprToType(Literal.get(), ElemTy, 5437 PrepareScalarCast(Literal, ElemTy)); 5438 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get()); 5439 } 5440 5441 initExprs.append(exprs, exprs + numExprs); 5442 } 5443 // FIXME: This means that pretty-printing the final AST will produce curly 5444 // braces instead of the original commas. 5445 InitListExpr *initE = new (Context) InitListExpr(Context, LiteralLParenLoc, 5446 initExprs, LiteralRParenLoc); 5447 initE->setType(Ty); 5448 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE); 5449} 5450 5451/// This is not an AltiVec-style cast or or C++ direct-initialization, so turn 5452/// the ParenListExpr into a sequence of comma binary operators. 5453ExprResult 5454Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *OrigExpr) { 5455 ParenListExpr *E = dyn_cast<ParenListExpr>(OrigExpr); 5456 if (!E) 5457 return OrigExpr; 5458 5459 ExprResult Result(E->getExpr(0)); 5460 5461 for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i) 5462 Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(), 5463 E->getExpr(i)); 5464 5465 if (Result.isInvalid()) return ExprError(); 5466 5467 return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get()); 5468} 5469 5470ExprResult Sema::ActOnParenListExpr(SourceLocation L, 5471 SourceLocation R, 5472 MultiExprArg Val) { 5473 Expr *expr = new (Context) ParenListExpr(Context, L, Val, R); 5474 return expr; 5475} 5476 5477/// \brief Emit a specialized diagnostic when one expression is a null pointer 5478/// constant and the other is not a pointer. Returns true if a diagnostic is 5479/// emitted. 5480bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, 5481 SourceLocation QuestionLoc) { 5482 Expr *NullExpr = LHSExpr; 5483 Expr *NonPointerExpr = RHSExpr; 5484 Expr::NullPointerConstantKind NullKind = 5485 NullExpr->isNullPointerConstant(Context, 5486 Expr::NPC_ValueDependentIsNotNull); 5487 5488 if (NullKind == Expr::NPCK_NotNull) { 5489 NullExpr = RHSExpr; 5490 NonPointerExpr = LHSExpr; 5491 NullKind = 5492 NullExpr->isNullPointerConstant(Context, 5493 Expr::NPC_ValueDependentIsNotNull); 5494 } 5495 5496 if (NullKind == Expr::NPCK_NotNull) 5497 return false; 5498 5499 if (NullKind == Expr::NPCK_ZeroExpression) 5500 return false; 5501 5502 if (NullKind == Expr::NPCK_ZeroLiteral) { 5503 // In this case, check to make sure that we got here from a "NULL" 5504 // string in the source code. 5505 NullExpr = NullExpr->IgnoreParenImpCasts(); 5506 SourceLocation loc = NullExpr->getExprLoc(); 5507 if (!findMacroSpelling(loc, "NULL")) 5508 return false; 5509 } 5510 5511 int DiagType = (NullKind == Expr::NPCK_CXX11_nullptr); 5512 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null) 5513 << NonPointerExpr->getType() << DiagType 5514 << NonPointerExpr->getSourceRange(); 5515 return true; 5516} 5517 5518/// \brief Return false if the condition expression is valid, true otherwise. 5519static bool checkCondition(Sema &S, Expr *Cond) { 5520 QualType CondTy = Cond->getType(); 5521 5522 // C99 6.5.15p2 5523 if (CondTy->isScalarType()) return false; 5524 5525 // OpenCL v1.1 s6.3.i says the condition is allowed to be a vector or scalar. 5526 if (S.getLangOpts().OpenCL && CondTy->isVectorType()) 5527 return false; 5528 5529 // Emit the proper error message. 5530 S.Diag(Cond->getLocStart(), S.getLangOpts().OpenCL ? 5531 diag::err_typecheck_cond_expect_scalar : 5532 diag::err_typecheck_cond_expect_scalar_or_vector) 5533 << CondTy; 5534 return true; 5535} 5536 5537/// \brief Return false if the two expressions can be converted to a vector, 5538/// true otherwise 5539static bool checkConditionalConvertScalarsToVectors(Sema &S, ExprResult &LHS, 5540 ExprResult &RHS, 5541 QualType CondTy) { 5542 // Both operands should be of scalar type. 5543 if (!LHS.get()->getType()->isScalarType()) { 5544 S.Diag(LHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 5545 << CondTy; 5546 return true; 5547 } 5548 if (!RHS.get()->getType()->isScalarType()) { 5549 S.Diag(RHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 5550 << CondTy; 5551 return true; 5552 } 5553 5554 // Implicity convert these scalars to the type of the condition. 5555 LHS = S.ImpCastExprToType(LHS.get(), CondTy, CK_IntegralCast); 5556 RHS = S.ImpCastExprToType(RHS.get(), CondTy, CK_IntegralCast); 5557 return false; 5558} 5559 5560/// \brief Handle when one or both operands are void type. 5561static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS, 5562 ExprResult &RHS) { 5563 Expr *LHSExpr = LHS.get(); 5564 Expr *RHSExpr = RHS.get(); 5565 5566 if (!LHSExpr->getType()->isVoidType()) 5567 S.Diag(RHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 5568 << RHSExpr->getSourceRange(); 5569 if (!RHSExpr->getType()->isVoidType()) 5570 S.Diag(LHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 5571 << LHSExpr->getSourceRange(); 5572 LHS = S.ImpCastExprToType(LHS.get(), S.Context.VoidTy, CK_ToVoid); 5573 RHS = S.ImpCastExprToType(RHS.get(), S.Context.VoidTy, CK_ToVoid); 5574 return S.Context.VoidTy; 5575} 5576 5577/// \brief Return false if the NullExpr can be promoted to PointerTy, 5578/// true otherwise. 5579static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, 5580 QualType PointerTy) { 5581 if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) || 5582 !NullExpr.get()->isNullPointerConstant(S.Context, 5583 Expr::NPC_ValueDependentIsNull)) 5584 return true; 5585 5586 NullExpr = S.ImpCastExprToType(NullExpr.get(), PointerTy, CK_NullToPointer); 5587 return false; 5588} 5589 5590/// \brief Checks compatibility between two pointers and return the resulting 5591/// type. 5592static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, 5593 ExprResult &RHS, 5594 SourceLocation Loc) { 5595 QualType LHSTy = LHS.get()->getType(); 5596 QualType RHSTy = RHS.get()->getType(); 5597 5598 if (S.Context.hasSameType(LHSTy, RHSTy)) { 5599 // Two identical pointers types are always compatible. 5600 return LHSTy; 5601 } 5602 5603 QualType lhptee, rhptee; 5604 5605 // Get the pointee types. 5606 bool IsBlockPointer = false; 5607 if (const BlockPointerType *LHSBTy = LHSTy->getAs<BlockPointerType>()) { 5608 lhptee = LHSBTy->getPointeeType(); 5609 rhptee = RHSTy->castAs<BlockPointerType>()->getPointeeType(); 5610 IsBlockPointer = true; 5611 } else { 5612 lhptee = LHSTy->castAs<PointerType>()->getPointeeType(); 5613 rhptee = RHSTy->castAs<PointerType>()->getPointeeType(); 5614 } 5615 5616 // C99 6.5.15p6: If both operands are pointers to compatible types or to 5617 // differently qualified versions of compatible types, the result type is 5618 // a pointer to an appropriately qualified version of the composite 5619 // type. 5620 5621 // Only CVR-qualifiers exist in the standard, and the differently-qualified 5622 // clause doesn't make sense for our extensions. E.g. address space 2 should 5623 // be incompatible with address space 3: they may live on different devices or 5624 // anything. 5625 Qualifiers lhQual = lhptee.getQualifiers(); 5626 Qualifiers rhQual = rhptee.getQualifiers(); 5627 5628 unsigned MergedCVRQual = lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers(); 5629 lhQual.removeCVRQualifiers(); 5630 rhQual.removeCVRQualifiers(); 5631 5632 lhptee = S.Context.getQualifiedType(lhptee.getUnqualifiedType(), lhQual); 5633 rhptee = S.Context.getQualifiedType(rhptee.getUnqualifiedType(), rhQual); 5634 5635 QualType CompositeTy = S.Context.mergeTypes(lhptee, rhptee); 5636 5637 if (CompositeTy.isNull()) { 5638 S.Diag(Loc, diag::ext_typecheck_cond_incompatible_pointers) 5639 << LHSTy << RHSTy << LHS.get()->getSourceRange() 5640 << RHS.get()->getSourceRange(); 5641 // In this situation, we assume void* type. No especially good 5642 // reason, but this is what gcc does, and we do have to pick 5643 // to get a consistent AST. 5644 QualType incompatTy = S.Context.getPointerType(S.Context.VoidTy); 5645 LHS = S.ImpCastExprToType(LHS.get(), incompatTy, CK_BitCast); 5646 RHS = S.ImpCastExprToType(RHS.get(), incompatTy, CK_BitCast); 5647 return incompatTy; 5648 } 5649 5650 // The pointer types are compatible. 5651 QualType ResultTy = CompositeTy.withCVRQualifiers(MergedCVRQual); 5652 if (IsBlockPointer) 5653 ResultTy = S.Context.getBlockPointerType(ResultTy); 5654 else 5655 ResultTy = S.Context.getPointerType(ResultTy); 5656 5657 LHS = S.ImpCastExprToType(LHS.get(), ResultTy, CK_BitCast); 5658 RHS = S.ImpCastExprToType(RHS.get(), ResultTy, CK_BitCast); 5659 return ResultTy; 5660} 5661 5662/// \brief Returns true if QT is quelified-id and implements 'NSObject' and/or 5663/// 'NSCopying' protocols (and nothing else); or QT is an NSObject and optionally 5664/// implements 'NSObject' and/or NSCopying' protocols (and nothing else). 5665static bool isObjCPtrBlockCompatible(Sema &S, ASTContext &C, QualType QT) { 5666 if (QT->isObjCIdType()) 5667 return true; 5668 5669 const ObjCObjectPointerType *OPT = QT->getAs<ObjCObjectPointerType>(); 5670 if (!OPT) 5671 return false; 5672 5673 if (ObjCInterfaceDecl *ID = OPT->getInterfaceDecl()) 5674 if (ID->getIdentifier() != &C.Idents.get("NSObject")) 5675 return false; 5676 5677 ObjCProtocolDecl* PNSCopying = 5678 S.LookupProtocol(&C.Idents.get("NSCopying"), SourceLocation()); 5679 ObjCProtocolDecl* PNSObject = 5680 S.LookupProtocol(&C.Idents.get("NSObject"), SourceLocation()); 5681 5682 for (auto *Proto : OPT->quals()) { 5683 if ((PNSCopying && declaresSameEntity(Proto, PNSCopying)) || 5684 (PNSObject && declaresSameEntity(Proto, PNSObject))) 5685 ; 5686 else 5687 return false; 5688 } 5689 return true; 5690} 5691 5692/// \brief Return the resulting type when the operands are both block pointers. 5693static QualType checkConditionalBlockPointerCompatibility(Sema &S, 5694 ExprResult &LHS, 5695 ExprResult &RHS, 5696 SourceLocation Loc) { 5697 QualType LHSTy = LHS.get()->getType(); 5698 QualType RHSTy = RHS.get()->getType(); 5699 5700 if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) { 5701 if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) { 5702 QualType destType = S.Context.getPointerType(S.Context.VoidTy); 5703 LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast); 5704 RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast); 5705 return destType; 5706 } 5707 S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 5708 << LHSTy << RHSTy << LHS.get()->getSourceRange() 5709 << RHS.get()->getSourceRange(); 5710 return QualType(); 5711 } 5712 5713 // We have 2 block pointer types. 5714 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 5715} 5716 5717/// \brief Return the resulting type when the operands are both pointers. 5718static QualType 5719checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, 5720 ExprResult &RHS, 5721 SourceLocation Loc) { 5722 // get the pointer types 5723 QualType LHSTy = LHS.get()->getType(); 5724 QualType RHSTy = RHS.get()->getType(); 5725 5726 // get the "pointed to" types 5727 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 5728 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 5729 5730 // ignore qualifiers on void (C99 6.5.15p3, clause 6) 5731 if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) { 5732 // Figure out necessary qualifiers (C99 6.5.15p6) 5733 QualType destPointee 5734 = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 5735 QualType destType = S.Context.getPointerType(destPointee); 5736 // Add qualifiers if necessary. 5737 LHS = S.ImpCastExprToType(LHS.get(), destType, CK_NoOp); 5738 // Promote to void*. 5739 RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast); 5740 return destType; 5741 } 5742 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) { 5743 QualType destPointee 5744 = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 5745 QualType destType = S.Context.getPointerType(destPointee); 5746 // Add qualifiers if necessary. 5747 RHS = S.ImpCastExprToType(RHS.get(), destType, CK_NoOp); 5748 // Promote to void*. 5749 LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast); 5750 return destType; 5751 } 5752 5753 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 5754} 5755 5756/// \brief Return false if the first expression is not an integer and the second 5757/// expression is not a pointer, true otherwise. 5758static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, 5759 Expr* PointerExpr, SourceLocation Loc, 5760 bool IsIntFirstExpr) { 5761 if (!PointerExpr->getType()->isPointerType() || 5762 !Int.get()->getType()->isIntegerType()) 5763 return false; 5764 5765 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr; 5766 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get(); 5767 5768 S.Diag(Loc, diag::ext_typecheck_cond_pointer_integer_mismatch) 5769 << Expr1->getType() << Expr2->getType() 5770 << Expr1->getSourceRange() << Expr2->getSourceRange(); 5771 Int = S.ImpCastExprToType(Int.get(), PointerExpr->getType(), 5772 CK_IntegralToPointer); 5773 return true; 5774} 5775 5776/// Note that LHS is not null here, even if this is the gnu "x ?: y" extension. 5777/// In that case, LHS = cond. 5778/// C99 6.5.15 5779QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, 5780 ExprResult &RHS, ExprValueKind &VK, 5781 ExprObjectKind &OK, 5782 SourceLocation QuestionLoc) { 5783 5784 ExprResult LHSResult = CheckPlaceholderExpr(LHS.get()); 5785 if (!LHSResult.isUsable()) return QualType(); 5786 LHS = LHSResult; 5787 5788 ExprResult RHSResult = CheckPlaceholderExpr(RHS.get()); 5789 if (!RHSResult.isUsable()) return QualType(); 5790 RHS = RHSResult; 5791 5792 // C++ is sufficiently different to merit its own checker. 5793 if (getLangOpts().CPlusPlus) 5794 return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc); 5795 5796 VK = VK_RValue; 5797 OK = OK_Ordinary; 5798 5799 // First, check the condition. 5800 Cond = UsualUnaryConversions(Cond.get()); 5801 if (Cond.isInvalid()) 5802 return QualType(); 5803 if (checkCondition(*this, Cond.get())) 5804 return QualType(); 5805 5806 // Now check the two expressions. 5807 if (LHS.get()->getType()->isVectorType() || 5808 RHS.get()->getType()->isVectorType()) 5809 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false); 5810 5811 QualType ResTy = UsualArithmeticConversions(LHS, RHS); 5812 if (LHS.isInvalid() || RHS.isInvalid()) 5813 return QualType(); 5814 5815 QualType CondTy = Cond.get()->getType(); 5816 QualType LHSTy = LHS.get()->getType(); 5817 QualType RHSTy = RHS.get()->getType(); 5818 5819 // If the condition is a vector, and both operands are scalar, 5820 // attempt to implicity convert them to the vector type to act like the 5821 // built in select. (OpenCL v1.1 s6.3.i) 5822 if (getLangOpts().OpenCL && CondTy->isVectorType()) 5823 if (checkConditionalConvertScalarsToVectors(*this, LHS, RHS, CondTy)) 5824 return QualType(); 5825 5826 // If both operands have arithmetic type, do the usual arithmetic conversions 5827 // to find a common type: C99 6.5.15p3,5. 5828 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) { 5829 LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy)); 5830 RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy)); 5831 5832 return ResTy; 5833 } 5834 5835 // If both operands are the same structure or union type, the result is that 5836 // type. 5837 if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3 5838 if (const RecordType *RHSRT = RHSTy->getAs<RecordType>()) 5839 if (LHSRT->getDecl() == RHSRT->getDecl()) 5840 // "If both the operands have structure or union type, the result has 5841 // that type." This implies that CV qualifiers are dropped. 5842 return LHSTy.getUnqualifiedType(); 5843 // FIXME: Type of conditional expression must be complete in C mode. 5844 } 5845 5846 // C99 6.5.15p5: "If both operands have void type, the result has void type." 5847 // The following || allows only one side to be void (a GCC-ism). 5848 if (LHSTy->isVoidType() || RHSTy->isVoidType()) { 5849 return checkConditionalVoidType(*this, LHS, RHS); 5850 } 5851 5852 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has 5853 // the type of the other operand." 5854 if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy; 5855 if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy; 5856 5857 // All objective-c pointer type analysis is done here. 5858 QualType compositeType = FindCompositeObjCPointerType(LHS, RHS, 5859 QuestionLoc); 5860 if (LHS.isInvalid() || RHS.isInvalid()) 5861 return QualType(); 5862 if (!compositeType.isNull()) 5863 return compositeType; 5864 5865 5866 // Handle block pointer types. 5867 if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) 5868 return checkConditionalBlockPointerCompatibility(*this, LHS, RHS, 5869 QuestionLoc); 5870 5871 // Check constraints for C object pointers types (C99 6.5.15p3,6). 5872 if (LHSTy->isPointerType() && RHSTy->isPointerType()) 5873 return checkConditionalObjectPointersCompatibility(*this, LHS, RHS, 5874 QuestionLoc); 5875 5876 // GCC compatibility: soften pointer/integer mismatch. Note that 5877 // null pointers have been filtered out by this point. 5878 if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc, 5879 /*isIntFirstExpr=*/true)) 5880 return RHSTy; 5881 if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc, 5882 /*isIntFirstExpr=*/false)) 5883 return LHSTy; 5884 5885 // Emit a better diagnostic if one of the expressions is a null pointer 5886 // constant and the other is not a pointer type. In this case, the user most 5887 // likely forgot to take the address of the other expression. 5888 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc)) 5889 return QualType(); 5890 5891 // Otherwise, the operands are not compatible. 5892 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 5893 << LHSTy << RHSTy << LHS.get()->getSourceRange() 5894 << RHS.get()->getSourceRange(); 5895 return QualType(); 5896} 5897 5898/// FindCompositeObjCPointerType - Helper method to find composite type of 5899/// two objective-c pointer types of the two input expressions. 5900QualType Sema::FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, 5901 SourceLocation QuestionLoc) { 5902 QualType LHSTy = LHS.get()->getType(); 5903 QualType RHSTy = RHS.get()->getType(); 5904 5905 // Handle things like Class and struct objc_class*. Here we case the result 5906 // to the pseudo-builtin, because that will be implicitly cast back to the 5907 // redefinition type if an attempt is made to access its fields. 5908 if (LHSTy->isObjCClassType() && 5909 (Context.hasSameType(RHSTy, Context.getObjCClassRedefinitionType()))) { 5910 RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast); 5911 return LHSTy; 5912 } 5913 if (RHSTy->isObjCClassType() && 5914 (Context.hasSameType(LHSTy, Context.getObjCClassRedefinitionType()))) { 5915 LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast); 5916 return RHSTy; 5917 } 5918 // And the same for struct objc_object* / id 5919 if (LHSTy->isObjCIdType() && 5920 (Context.hasSameType(RHSTy, Context.getObjCIdRedefinitionType()))) { 5921 RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast); 5922 return LHSTy; 5923 } 5924 if (RHSTy->isObjCIdType() && 5925 (Context.hasSameType(LHSTy, Context.getObjCIdRedefinitionType()))) { 5926 LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast); 5927 return RHSTy; 5928 } 5929 // And the same for struct objc_selector* / SEL 5930 if (Context.isObjCSelType(LHSTy) && 5931 (Context.hasSameType(RHSTy, Context.getObjCSelRedefinitionType()))) { 5932 RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_BitCast); 5933 return LHSTy; 5934 } 5935 if (Context.isObjCSelType(RHSTy) && 5936 (Context.hasSameType(LHSTy, Context.getObjCSelRedefinitionType()))) { 5937 LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_BitCast); 5938 return RHSTy; 5939 } 5940 // Check constraints for Objective-C object pointers types. 5941 if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) { 5942 5943 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) { 5944 // Two identical object pointer types are always compatible. 5945 return LHSTy; 5946 } 5947 const ObjCObjectPointerType *LHSOPT = LHSTy->castAs<ObjCObjectPointerType>(); 5948 const ObjCObjectPointerType *RHSOPT = RHSTy->castAs<ObjCObjectPointerType>(); 5949 QualType compositeType = LHSTy; 5950 5951 // If both operands are interfaces and either operand can be 5952 // assigned to the other, use that type as the composite 5953 // type. This allows 5954 // xxx ? (A*) a : (B*) b 5955 // where B is a subclass of A. 5956 // 5957 // Additionally, as for assignment, if either type is 'id' 5958 // allow silent coercion. Finally, if the types are 5959 // incompatible then make sure to use 'id' as the composite 5960 // type so the result is acceptable for sending messages to. 5961 5962 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'. 5963 // It could return the composite type. 5964 if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) { 5965 compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy; 5966 } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) { 5967 compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy; 5968 } else if ((LHSTy->isObjCQualifiedIdType() || 5969 RHSTy->isObjCQualifiedIdType()) && 5970 Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) { 5971 // Need to handle "id<xx>" explicitly. 5972 // GCC allows qualified id and any Objective-C type to devolve to 5973 // id. Currently localizing to here until clear this should be 5974 // part of ObjCQualifiedIdTypesAreCompatible. 5975 compositeType = Context.getObjCIdType(); 5976 } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) { 5977 compositeType = Context.getObjCIdType(); 5978 } else if (!(compositeType = 5979 Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull()) 5980 ; 5981 else { 5982 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands) 5983 << LHSTy << RHSTy 5984 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5985 QualType incompatTy = Context.getObjCIdType(); 5986 LHS = ImpCastExprToType(LHS.get(), incompatTy, CK_BitCast); 5987 RHS = ImpCastExprToType(RHS.get(), incompatTy, CK_BitCast); 5988 return incompatTy; 5989 } 5990 // The object pointer types are compatible. 5991 LHS = ImpCastExprToType(LHS.get(), compositeType, CK_BitCast); 5992 RHS = ImpCastExprToType(RHS.get(), compositeType, CK_BitCast); 5993 return compositeType; 5994 } 5995 // Check Objective-C object pointer types and 'void *' 5996 if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) { 5997 if (getLangOpts().ObjCAutoRefCount) { 5998 // ARC forbids the implicit conversion of object pointers to 'void *', 5999 // so these types are not compatible. 6000 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy 6001 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6002 LHS = RHS = true; 6003 return QualType(); 6004 } 6005 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 6006 QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 6007 QualType destPointee 6008 = Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 6009 QualType destType = Context.getPointerType(destPointee); 6010 // Add qualifiers if necessary. 6011 LHS = ImpCastExprToType(LHS.get(), destType, CK_NoOp); 6012 // Promote to void*. 6013 RHS = ImpCastExprToType(RHS.get(), destType, CK_BitCast); 6014 return destType; 6015 } 6016 if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) { 6017 if (getLangOpts().ObjCAutoRefCount) { 6018 // ARC forbids the implicit conversion of object pointers to 'void *', 6019 // so these types are not compatible. 6020 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy 6021 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6022 LHS = RHS = true; 6023 return QualType(); 6024 } 6025 QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 6026 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 6027 QualType destPointee 6028 = Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 6029 QualType destType = Context.getPointerType(destPointee); 6030 // Add qualifiers if necessary. 6031 RHS = ImpCastExprToType(RHS.get(), destType, CK_NoOp); 6032 // Promote to void*. 6033 LHS = ImpCastExprToType(LHS.get(), destType, CK_BitCast); 6034 return destType; 6035 } 6036 return QualType(); 6037} 6038 6039/// SuggestParentheses - Emit a note with a fixit hint that wraps 6040/// ParenRange in parentheses. 6041static void SuggestParentheses(Sema &Self, SourceLocation Loc, 6042 const PartialDiagnostic &Note, 6043 SourceRange ParenRange) { 6044 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(ParenRange.getEnd()); 6045 if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() && 6046 EndLoc.isValid()) { 6047 Self.Diag(Loc, Note) 6048 << FixItHint::CreateInsertion(ParenRange.getBegin(), "(") 6049 << FixItHint::CreateInsertion(EndLoc, ")"); 6050 } else { 6051 // We can't display the parentheses, so just show the bare note. 6052 Self.Diag(Loc, Note) << ParenRange; 6053 } 6054} 6055 6056static bool IsArithmeticOp(BinaryOperatorKind Opc) { 6057 return Opc >= BO_Mul && Opc <= BO_Shr; 6058} 6059 6060/// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary 6061/// expression, either using a built-in or overloaded operator, 6062/// and sets *OpCode to the opcode and *RHSExprs to the right-hand side 6063/// expression. 6064static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode, 6065 Expr **RHSExprs) { 6066 // Don't strip parenthesis: we should not warn if E is in parenthesis. 6067 E = E->IgnoreImpCasts(); 6068 E = E->IgnoreConversionOperator(); 6069 E = E->IgnoreImpCasts(); 6070 6071 // Built-in binary operator. 6072 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) { 6073 if (IsArithmeticOp(OP->getOpcode())) { 6074 *Opcode = OP->getOpcode(); 6075 *RHSExprs = OP->getRHS(); 6076 return true; 6077 } 6078 } 6079 6080 // Overloaded operator. 6081 if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(E)) { 6082 if (Call->getNumArgs() != 2) 6083 return false; 6084 6085 // Make sure this is really a binary operator that is safe to pass into 6086 // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op. 6087 OverloadedOperatorKind OO = Call->getOperator(); 6088 if (OO < OO_Plus || OO > OO_Arrow || 6089 OO == OO_PlusPlus || OO == OO_MinusMinus) 6090 return false; 6091 6092 BinaryOperatorKind OpKind = BinaryOperator::getOverloadedOpcode(OO); 6093 if (IsArithmeticOp(OpKind)) { 6094 *Opcode = OpKind; 6095 *RHSExprs = Call->getArg(1); 6096 return true; 6097 } 6098 } 6099 6100 return false; 6101} 6102 6103static bool IsLogicOp(BinaryOperatorKind Opc) { 6104 return (Opc >= BO_LT && Opc <= BO_NE) || (Opc >= BO_LAnd && Opc <= BO_LOr); 6105} 6106 6107/// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type 6108/// or is a logical expression such as (x==y) which has int type, but is 6109/// commonly interpreted as boolean. 6110static bool ExprLooksBoolean(Expr *E) { 6111 E = E->IgnoreParenImpCasts(); 6112 6113 if (E->getType()->isBooleanType()) 6114 return true; 6115 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) 6116 return IsLogicOp(OP->getOpcode()); 6117 if (UnaryOperator *OP = dyn_cast<UnaryOperator>(E)) 6118 return OP->getOpcode() == UO_LNot; 6119 6120 return false; 6121} 6122 6123/// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator 6124/// and binary operator are mixed in a way that suggests the programmer assumed 6125/// the conditional operator has higher precedence, for example: 6126/// "int x = a + someBinaryCondition ? 1 : 2". 6127static void DiagnoseConditionalPrecedence(Sema &Self, 6128 SourceLocation OpLoc, 6129 Expr *Condition, 6130 Expr *LHSExpr, 6131 Expr *RHSExpr) { 6132 BinaryOperatorKind CondOpcode; 6133 Expr *CondRHS; 6134 6135 if (!IsArithmeticBinaryExpr(Condition, &CondOpcode, &CondRHS)) 6136 return; 6137 if (!ExprLooksBoolean(CondRHS)) 6138 return; 6139 6140 // The condition is an arithmetic binary expression, with a right- 6141 // hand side that looks boolean, so warn. 6142 6143 Self.Diag(OpLoc, diag::warn_precedence_conditional) 6144 << Condition->getSourceRange() 6145 << BinaryOperator::getOpcodeStr(CondOpcode); 6146 6147 SuggestParentheses(Self, OpLoc, 6148 Self.PDiag(diag::note_precedence_silence) 6149 << BinaryOperator::getOpcodeStr(CondOpcode), 6150 SourceRange(Condition->getLocStart(), Condition->getLocEnd())); 6151 6152 SuggestParentheses(Self, OpLoc, 6153 Self.PDiag(diag::note_precedence_conditional_first), 6154 SourceRange(CondRHS->getLocStart(), RHSExpr->getLocEnd())); 6155} 6156 6157/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null 6158/// in the case of a the GNU conditional expr extension. 6159ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc, 6160 SourceLocation ColonLoc, 6161 Expr *CondExpr, Expr *LHSExpr, 6162 Expr *RHSExpr) { 6163 if (!getLangOpts().CPlusPlus) { 6164 // C cannot handle TypoExpr nodes in the condition because it 6165 // doesn't handle dependent types properly, so make sure any TypoExprs have 6166 // been dealt with before checking the operands. 6167 ExprResult CondResult = CorrectDelayedTyposInExpr(CondExpr); 6168 if (!CondResult.isUsable()) return ExprError(); 6169 CondExpr = CondResult.get(); 6170 } 6171 6172 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS 6173 // was the condition. 6174 OpaqueValueExpr *opaqueValue = nullptr; 6175 Expr *commonExpr = nullptr; 6176 if (!LHSExpr) { 6177 commonExpr = CondExpr; 6178 // Lower out placeholder types first. This is important so that we don't 6179 // try to capture a placeholder. This happens in few cases in C++; such 6180 // as Objective-C++'s dictionary subscripting syntax. 6181 if (commonExpr->hasPlaceholderType()) { 6182 ExprResult result = CheckPlaceholderExpr(commonExpr); 6183 if (!result.isUsable()) return ExprError(); 6184 commonExpr = result.get(); 6185 } 6186 // We usually want to apply unary conversions *before* saving, except 6187 // in the special case of a C++ l-value conditional. 6188 if (!(getLangOpts().CPlusPlus 6189 && !commonExpr->isTypeDependent() 6190 && commonExpr->getValueKind() == RHSExpr->getValueKind() 6191 && commonExpr->isGLValue() 6192 && commonExpr->isOrdinaryOrBitFieldObject() 6193 && RHSExpr->isOrdinaryOrBitFieldObject() 6194 && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) { 6195 ExprResult commonRes = UsualUnaryConversions(commonExpr); 6196 if (commonRes.isInvalid()) 6197 return ExprError(); 6198 commonExpr = commonRes.get(); 6199 } 6200 6201 opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(), 6202 commonExpr->getType(), 6203 commonExpr->getValueKind(), 6204 commonExpr->getObjectKind(), 6205 commonExpr); 6206 LHSExpr = CondExpr = opaqueValue; 6207 } 6208 6209 ExprValueKind VK = VK_RValue; 6210 ExprObjectKind OK = OK_Ordinary; 6211 ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr; 6212 QualType result = CheckConditionalOperands(Cond, LHS, RHS, 6213 VK, OK, QuestionLoc); 6214 if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() || 6215 RHS.isInvalid()) 6216 return ExprError(); 6217 6218 DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(), 6219 RHS.get()); 6220 6221 if (!commonExpr) 6222 return new (Context) 6223 ConditionalOperator(Cond.get(), QuestionLoc, LHS.get(), ColonLoc, 6224 RHS.get(), result, VK, OK); 6225 6226 return new (Context) BinaryConditionalOperator( 6227 commonExpr, opaqueValue, Cond.get(), LHS.get(), RHS.get(), QuestionLoc, 6228 ColonLoc, result, VK, OK); 6229} 6230 6231// checkPointerTypesForAssignment - This is a very tricky routine (despite 6232// being closely modeled after the C99 spec:-). The odd characteristic of this 6233// routine is it effectively iqnores the qualifiers on the top level pointee. 6234// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3]. 6235// FIXME: add a couple examples in this comment. 6236static Sema::AssignConvertType 6237checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) { 6238 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 6239 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 6240 6241 // get the "pointed to" type (ignoring qualifiers at the top level) 6242 const Type *lhptee, *rhptee; 6243 Qualifiers lhq, rhq; 6244 std::tie(lhptee, lhq) = 6245 cast<PointerType>(LHSType)->getPointeeType().split().asPair(); 6246 std::tie(rhptee, rhq) = 6247 cast<PointerType>(RHSType)->getPointeeType().split().asPair(); 6248 6249 Sema::AssignConvertType ConvTy = Sema::Compatible; 6250 6251 // C99 6.5.16.1p1: This following citation is common to constraints 6252 // 3 & 4 (below). ...and the type *pointed to* by the left has all the 6253 // qualifiers of the type *pointed to* by the right; 6254 6255 // As a special case, 'non-__weak A *' -> 'non-__weak const *' is okay. 6256 if (lhq.getObjCLifetime() != rhq.getObjCLifetime() && 6257 lhq.compatiblyIncludesObjCLifetime(rhq)) { 6258 // Ignore lifetime for further calculation. 6259 lhq.removeObjCLifetime(); 6260 rhq.removeObjCLifetime(); 6261 } 6262 6263 if (!lhq.compatiblyIncludes(rhq)) { 6264 // Treat address-space mismatches as fatal. TODO: address subspaces 6265 if (!lhq.isAddressSpaceSupersetOf(rhq)) 6266 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 6267 6268 // It's okay to add or remove GC or lifetime qualifiers when converting to 6269 // and from void*. 6270 else if (lhq.withoutObjCGCAttr().withoutObjCLifetime() 6271 .compatiblyIncludes( 6272 rhq.withoutObjCGCAttr().withoutObjCLifetime()) 6273 && (lhptee->isVoidType() || rhptee->isVoidType())) 6274 ; // keep old 6275 6276 // Treat lifetime mismatches as fatal. 6277 else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) 6278 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 6279 6280 // For GCC compatibility, other qualifier mismatches are treated 6281 // as still compatible in C. 6282 else ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 6283 } 6284 6285 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or 6286 // incomplete type and the other is a pointer to a qualified or unqualified 6287 // version of void... 6288 if (lhptee->isVoidType()) { 6289 if (rhptee->isIncompleteOrObjectType()) 6290 return ConvTy; 6291 6292 // As an extension, we allow cast to/from void* to function pointer. 6293 assert(rhptee->isFunctionType()); 6294 return Sema::FunctionVoidPointer; 6295 } 6296 6297 if (rhptee->isVoidType()) { 6298 if (lhptee->isIncompleteOrObjectType()) 6299 return ConvTy; 6300 6301 // As an extension, we allow cast to/from void* to function pointer. 6302 assert(lhptee->isFunctionType()); 6303 return Sema::FunctionVoidPointer; 6304 } 6305 6306 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or 6307 // unqualified versions of compatible types, ... 6308 QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0); 6309 if (!S.Context.typesAreCompatible(ltrans, rtrans)) { 6310 // Check if the pointee types are compatible ignoring the sign. 6311 // We explicitly check for char so that we catch "char" vs 6312 // "unsigned char" on systems where "char" is unsigned. 6313 if (lhptee->isCharType()) 6314 ltrans = S.Context.UnsignedCharTy; 6315 else if (lhptee->hasSignedIntegerRepresentation()) 6316 ltrans = S.Context.getCorrespondingUnsignedType(ltrans); 6317 6318 if (rhptee->isCharType()) 6319 rtrans = S.Context.UnsignedCharTy; 6320 else if (rhptee->hasSignedIntegerRepresentation()) 6321 rtrans = S.Context.getCorrespondingUnsignedType(rtrans); 6322 6323 if (ltrans == rtrans) { 6324 // Types are compatible ignoring the sign. Qualifier incompatibility 6325 // takes priority over sign incompatibility because the sign 6326 // warning can be disabled. 6327 if (ConvTy != Sema::Compatible) 6328 return ConvTy; 6329 6330 return Sema::IncompatiblePointerSign; 6331 } 6332 6333 // If we are a multi-level pointer, it's possible that our issue is simply 6334 // one of qualification - e.g. char ** -> const char ** is not allowed. If 6335 // the eventual target type is the same and the pointers have the same 6336 // level of indirection, this must be the issue. 6337 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) { 6338 do { 6339 lhptee = cast<PointerType>(lhptee)->getPointeeType().getTypePtr(); 6340 rhptee = cast<PointerType>(rhptee)->getPointeeType().getTypePtr(); 6341 } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)); 6342 6343 if (lhptee == rhptee) 6344 return Sema::IncompatibleNestedPointerQualifiers; 6345 } 6346 6347 // General pointer incompatibility takes priority over qualifiers. 6348 return Sema::IncompatiblePointer; 6349 } 6350 if (!S.getLangOpts().CPlusPlus && 6351 S.IsNoReturnConversion(ltrans, rtrans, ltrans)) 6352 return Sema::IncompatiblePointer; 6353 return ConvTy; 6354} 6355 6356/// checkBlockPointerTypesForAssignment - This routine determines whether two 6357/// block pointer types are compatible or whether a block and normal pointer 6358/// are compatible. It is more restrict than comparing two function pointer 6359// types. 6360static Sema::AssignConvertType 6361checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType, 6362 QualType RHSType) { 6363 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 6364 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 6365 6366 QualType lhptee, rhptee; 6367 6368 // get the "pointed to" type (ignoring qualifiers at the top level) 6369 lhptee = cast<BlockPointerType>(LHSType)->getPointeeType(); 6370 rhptee = cast<BlockPointerType>(RHSType)->getPointeeType(); 6371 6372 // In C++, the types have to match exactly. 6373 if (S.getLangOpts().CPlusPlus) 6374 return Sema::IncompatibleBlockPointer; 6375 6376 Sema::AssignConvertType ConvTy = Sema::Compatible; 6377 6378 // For blocks we enforce that qualifiers are identical. 6379 if (lhptee.getLocalQualifiers() != rhptee.getLocalQualifiers()) 6380 ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 6381 6382 if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType)) 6383 return Sema::IncompatibleBlockPointer; 6384 6385 return ConvTy; 6386} 6387 6388/// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types 6389/// for assignment compatibility. 6390static Sema::AssignConvertType 6391checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType, 6392 QualType RHSType) { 6393 assert(LHSType.isCanonical() && "LHS was not canonicalized!"); 6394 assert(RHSType.isCanonical() && "RHS was not canonicalized!"); 6395 6396 if (LHSType->isObjCBuiltinType()) { 6397 // Class is not compatible with ObjC object pointers. 6398 if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() && 6399 !RHSType->isObjCQualifiedClassType()) 6400 return Sema::IncompatiblePointer; 6401 return Sema::Compatible; 6402 } 6403 if (RHSType->isObjCBuiltinType()) { 6404 if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() && 6405 !LHSType->isObjCQualifiedClassType()) 6406 return Sema::IncompatiblePointer; 6407 return Sema::Compatible; 6408 } 6409 QualType lhptee = LHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 6410 QualType rhptee = RHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 6411 6412 if (!lhptee.isAtLeastAsQualifiedAs(rhptee) && 6413 // make an exception for id<P> 6414 !LHSType->isObjCQualifiedIdType()) 6415 return Sema::CompatiblePointerDiscardsQualifiers; 6416 6417 if (S.Context.typesAreCompatible(LHSType, RHSType)) 6418 return Sema::Compatible; 6419 if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType()) 6420 return Sema::IncompatibleObjCQualifiedId; 6421 return Sema::IncompatiblePointer; 6422} 6423 6424Sema::AssignConvertType 6425Sema::CheckAssignmentConstraints(SourceLocation Loc, 6426 QualType LHSType, QualType RHSType) { 6427 // Fake up an opaque expression. We don't actually care about what 6428 // cast operations are required, so if CheckAssignmentConstraints 6429 // adds casts to this they'll be wasted, but fortunately that doesn't 6430 // usually happen on valid code. 6431 OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue); 6432 ExprResult RHSPtr = &RHSExpr; 6433 CastKind K = CK_Invalid; 6434 6435 return CheckAssignmentConstraints(LHSType, RHSPtr, K); 6436} 6437 6438/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently 6439/// has code to accommodate several GCC extensions when type checking 6440/// pointers. Here are some objectionable examples that GCC considers warnings: 6441/// 6442/// int a, *pint; 6443/// short *pshort; 6444/// struct foo *pfoo; 6445/// 6446/// pint = pshort; // warning: assignment from incompatible pointer type 6447/// a = pint; // warning: assignment makes integer from pointer without a cast 6448/// pint = a; // warning: assignment makes pointer from integer without a cast 6449/// pint = pfoo; // warning: assignment from incompatible pointer type 6450/// 6451/// As a result, the code for dealing with pointers is more complex than the 6452/// C99 spec dictates. 6453/// 6454/// Sets 'Kind' for any result kind except Incompatible. 6455Sema::AssignConvertType 6456Sema::CheckAssignmentConstraints(QualType LHSType, ExprResult &RHS, 6457 CastKind &Kind) { 6458 QualType RHSType = RHS.get()->getType(); 6459 QualType OrigLHSType = LHSType; 6460 6461 // Get canonical types. We're not formatting these types, just comparing 6462 // them. 6463 LHSType = Context.getCanonicalType(LHSType).getUnqualifiedType(); 6464 RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType(); 6465 6466 // Common case: no conversion required. 6467 if (LHSType == RHSType) { 6468 Kind = CK_NoOp; 6469 return Compatible; 6470 } 6471 6472 // If we have an atomic type, try a non-atomic assignment, then just add an 6473 // atomic qualification step. 6474 if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) { 6475 Sema::AssignConvertType result = 6476 CheckAssignmentConstraints(AtomicTy->getValueType(), RHS, Kind); 6477 if (result != Compatible) 6478 return result; 6479 if (Kind != CK_NoOp) 6480 RHS = ImpCastExprToType(RHS.get(), AtomicTy->getValueType(), Kind); 6481 Kind = CK_NonAtomicToAtomic; 6482 return Compatible; 6483 } 6484 6485 // If the left-hand side is a reference type, then we are in a 6486 // (rare!) case where we've allowed the use of references in C, 6487 // e.g., as a parameter type in a built-in function. In this case, 6488 // just make sure that the type referenced is compatible with the 6489 // right-hand side type. The caller is responsible for adjusting 6490 // LHSType so that the resulting expression does not have reference 6491 // type. 6492 if (const ReferenceType *LHSTypeRef = LHSType->getAs<ReferenceType>()) { 6493 if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) { 6494 Kind = CK_LValueBitCast; 6495 return Compatible; 6496 } 6497 return Incompatible; 6498 } 6499 6500 // Allow scalar to ExtVector assignments, and assignments of an ExtVector type 6501 // to the same ExtVector type. 6502 if (LHSType->isExtVectorType()) { 6503 if (RHSType->isExtVectorType()) 6504 return Incompatible; 6505 if (RHSType->isArithmeticType()) { 6506 // CK_VectorSplat does T -> vector T, so first cast to the 6507 // element type. 6508 QualType elType = cast<ExtVectorType>(LHSType)->getElementType(); 6509 if (elType != RHSType) { 6510 Kind = PrepareScalarCast(RHS, elType); 6511 RHS = ImpCastExprToType(RHS.get(), elType, Kind); 6512 } 6513 Kind = CK_VectorSplat; 6514 return Compatible; 6515 } 6516 } 6517 6518 // Conversions to or from vector type. 6519 if (LHSType->isVectorType() || RHSType->isVectorType()) { 6520 if (LHSType->isVectorType() && RHSType->isVectorType()) { 6521 // Allow assignments of an AltiVec vector type to an equivalent GCC 6522 // vector type and vice versa 6523 if (Context.areCompatibleVectorTypes(LHSType, RHSType)) { 6524 Kind = CK_BitCast; 6525 return Compatible; 6526 } 6527 6528 // If we are allowing lax vector conversions, and LHS and RHS are both 6529 // vectors, the total size only needs to be the same. This is a bitcast; 6530 // no bits are changed but the result type is different. 6531 if (isLaxVectorConversion(RHSType, LHSType)) { 6532 Kind = CK_BitCast; 6533 return IncompatibleVectors; 6534 } 6535 } 6536 return Incompatible; 6537 } 6538 6539 // Arithmetic conversions. 6540 if (LHSType->isArithmeticType() && RHSType->isArithmeticType() && 6541 !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) { 6542 Kind = PrepareScalarCast(RHS, LHSType); 6543 return Compatible; 6544 } 6545 6546 // Conversions to normal pointers. 6547 if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) { 6548 // U* -> T* 6549 if (isa<PointerType>(RHSType)) { 6550 unsigned AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace(); 6551 unsigned AddrSpaceR = RHSType->getPointeeType().getAddressSpace(); 6552 Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast; 6553 return checkPointerTypesForAssignment(*this, LHSType, RHSType); 6554 } 6555 6556 // int -> T* 6557 if (RHSType->isIntegerType()) { 6558 Kind = CK_IntegralToPointer; // FIXME: null? 6559 return IntToPointer; 6560 } 6561 6562 // C pointers are not compatible with ObjC object pointers, 6563 // with two exceptions: 6564 if (isa<ObjCObjectPointerType>(RHSType)) { 6565 // - conversions to void* 6566 if (LHSPointer->getPointeeType()->isVoidType()) { 6567 Kind = CK_BitCast; 6568 return Compatible; 6569 } 6570 6571 // - conversions from 'Class' to the redefinition type 6572 if (RHSType->isObjCClassType() && 6573 Context.hasSameType(LHSType, 6574 Context.getObjCClassRedefinitionType())) { 6575 Kind = CK_BitCast; 6576 return Compatible; 6577 } 6578 6579 Kind = CK_BitCast; 6580 return IncompatiblePointer; 6581 } 6582 6583 // U^ -> void* 6584 if (RHSType->getAs<BlockPointerType>()) { 6585 if (LHSPointer->getPointeeType()->isVoidType()) { 6586 Kind = CK_BitCast; 6587 return Compatible; 6588 } 6589 } 6590 6591 return Incompatible; 6592 } 6593 6594 // Conversions to block pointers. 6595 if (isa<BlockPointerType>(LHSType)) { 6596 // U^ -> T^ 6597 if (RHSType->isBlockPointerType()) { 6598 Kind = CK_BitCast; 6599 return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType); 6600 } 6601 6602 // int or null -> T^ 6603 if (RHSType->isIntegerType()) { 6604 Kind = CK_IntegralToPointer; // FIXME: null 6605 return IntToBlockPointer; 6606 } 6607 6608 // id -> T^ 6609 if (getLangOpts().ObjC1 && RHSType->isObjCIdType()) { 6610 Kind = CK_AnyPointerToBlockPointerCast; 6611 return Compatible; 6612 } 6613 6614 // void* -> T^ 6615 if (const PointerType *RHSPT = RHSType->getAs<PointerType>()) 6616 if (RHSPT->getPointeeType()->isVoidType()) { 6617 Kind = CK_AnyPointerToBlockPointerCast; 6618 return Compatible; 6619 } 6620 6621 return Incompatible; 6622 } 6623 6624 // Conversions to Objective-C pointers. 6625 if (isa<ObjCObjectPointerType>(LHSType)) { 6626 // A* -> B* 6627 if (RHSType->isObjCObjectPointerType()) { 6628 Kind = CK_BitCast; 6629 Sema::AssignConvertType result = 6630 checkObjCPointerTypesForAssignment(*this, LHSType, RHSType); 6631 if (getLangOpts().ObjCAutoRefCount && 6632 result == Compatible && 6633 !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType)) 6634 result = IncompatibleObjCWeakRef; 6635 return result; 6636 } 6637 6638 // int or null -> A* 6639 if (RHSType->isIntegerType()) { 6640 Kind = CK_IntegralToPointer; // FIXME: null 6641 return IntToPointer; 6642 } 6643 6644 // In general, C pointers are not compatible with ObjC object pointers, 6645 // with two exceptions: 6646 if (isa<PointerType>(RHSType)) { 6647 Kind = CK_CPointerToObjCPointerCast; 6648 6649 // - conversions from 'void*' 6650 if (RHSType->isVoidPointerType()) { 6651 return Compatible; 6652 } 6653 6654 // - conversions to 'Class' from its redefinition type 6655 if (LHSType->isObjCClassType() && 6656 Context.hasSameType(RHSType, 6657 Context.getObjCClassRedefinitionType())) { 6658 return Compatible; 6659 } 6660 6661 return IncompatiblePointer; 6662 } 6663 6664 // Only under strict condition T^ is compatible with an Objective-C pointer. 6665 if (RHSType->isBlockPointerType() && 6666 isObjCPtrBlockCompatible(*this, Context, LHSType)) { 6667 maybeExtendBlockObject(*this, RHS); 6668 Kind = CK_BlockPointerToObjCPointerCast; 6669 return Compatible; 6670 } 6671 6672 return Incompatible; 6673 } 6674 6675 // Conversions from pointers that are not covered by the above. 6676 if (isa<PointerType>(RHSType)) { 6677 // T* -> _Bool 6678 if (LHSType == Context.BoolTy) { 6679 Kind = CK_PointerToBoolean; 6680 return Compatible; 6681 } 6682 6683 // T* -> int 6684 if (LHSType->isIntegerType()) { 6685 Kind = CK_PointerToIntegral; 6686 return PointerToInt; 6687 } 6688 6689 return Incompatible; 6690 } 6691 6692 // Conversions from Objective-C pointers that are not covered by the above. 6693 if (isa<ObjCObjectPointerType>(RHSType)) { 6694 // T* -> _Bool 6695 if (LHSType == Context.BoolTy) { 6696 Kind = CK_PointerToBoolean; 6697 return Compatible; 6698 } 6699 6700 // T* -> int 6701 if (LHSType->isIntegerType()) { 6702 Kind = CK_PointerToIntegral; 6703 return PointerToInt; 6704 } 6705 6706 return Incompatible; 6707 } 6708 6709 // struct A -> struct B 6710 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) { 6711 if (Context.typesAreCompatible(LHSType, RHSType)) { 6712 Kind = CK_NoOp; 6713 return Compatible; 6714 } 6715 } 6716 6717 return Incompatible; 6718} 6719 6720/// \brief Constructs a transparent union from an expression that is 6721/// used to initialize the transparent union. 6722static void ConstructTransparentUnion(Sema &S, ASTContext &C, 6723 ExprResult &EResult, QualType UnionType, 6724 FieldDecl *Field) { 6725 // Build an initializer list that designates the appropriate member 6726 // of the transparent union. 6727 Expr *E = EResult.get(); 6728 InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(), 6729 E, SourceLocation()); 6730 Initializer->setType(UnionType); 6731 Initializer->setInitializedFieldInUnion(Field); 6732 6733 // Build a compound literal constructing a value of the transparent 6734 // union type from this initializer list. 6735 TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType); 6736 EResult = new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType, 6737 VK_RValue, Initializer, false); 6738} 6739 6740Sema::AssignConvertType 6741Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, 6742 ExprResult &RHS) { 6743 QualType RHSType = RHS.get()->getType(); 6744 6745 // If the ArgType is a Union type, we want to handle a potential 6746 // transparent_union GCC extension. 6747 const RecordType *UT = ArgType->getAsUnionType(); 6748 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>()) 6749 return Incompatible; 6750 6751 // The field to initialize within the transparent union. 6752 RecordDecl *UD = UT->getDecl(); 6753 FieldDecl *InitField = nullptr; 6754 // It's compatible if the expression matches any of the fields. 6755 for (auto *it : UD->fields()) { 6756 if (it->getType()->isPointerType()) { 6757 // If the transparent union contains a pointer type, we allow: 6758 // 1) void pointer 6759 // 2) null pointer constant 6760 if (RHSType->isPointerType()) 6761 if (RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) { 6762 RHS = ImpCastExprToType(RHS.get(), it->getType(), CK_BitCast); 6763 InitField = it; 6764 break; 6765 } 6766 6767 if (RHS.get()->isNullPointerConstant(Context, 6768 Expr::NPC_ValueDependentIsNull)) { 6769 RHS = ImpCastExprToType(RHS.get(), it->getType(), 6770 CK_NullToPointer); 6771 InitField = it; 6772 break; 6773 } 6774 } 6775 6776 CastKind Kind = CK_Invalid; 6777 if (CheckAssignmentConstraints(it->getType(), RHS, Kind) 6778 == Compatible) { 6779 RHS = ImpCastExprToType(RHS.get(), it->getType(), Kind); 6780 InitField = it; 6781 break; 6782 } 6783 } 6784 6785 if (!InitField) 6786 return Incompatible; 6787 6788 ConstructTransparentUnion(*this, Context, RHS, ArgType, InitField); 6789 return Compatible; 6790} 6791 6792Sema::AssignConvertType 6793Sema::CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, 6794 bool Diagnose, 6795 bool DiagnoseCFAudited) { 6796 if (getLangOpts().CPlusPlus) { 6797 if (!LHSType->isRecordType() && !LHSType->isAtomicType()) { 6798 // C++ 5.17p3: If the left operand is not of class type, the 6799 // expression is implicitly converted (C++ 4) to the 6800 // cv-unqualified type of the left operand. 6801 ExprResult Res; 6802 if (Diagnose) { 6803 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 6804 AA_Assigning); 6805 } else { 6806 ImplicitConversionSequence ICS = 6807 TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 6808 /*SuppressUserConversions=*/false, 6809 /*AllowExplicit=*/false, 6810 /*InOverloadResolution=*/false, 6811 /*CStyle=*/false, 6812 /*AllowObjCWritebackConversion=*/false); 6813 if (ICS.isFailure()) 6814 return Incompatible; 6815 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 6816 ICS, AA_Assigning); 6817 } 6818 if (Res.isInvalid()) 6819 return Incompatible; 6820 Sema::AssignConvertType result = Compatible; 6821 if (getLangOpts().ObjCAutoRefCount && 6822 !CheckObjCARCUnavailableWeakConversion(LHSType, 6823 RHS.get()->getType())) 6824 result = IncompatibleObjCWeakRef; 6825 RHS = Res; 6826 return result; 6827 } 6828 6829 // FIXME: Currently, we fall through and treat C++ classes like C 6830 // structures. 6831 // FIXME: We also fall through for atomics; not sure what should 6832 // happen there, though. 6833 } 6834 6835 // C99 6.5.16.1p1: the left operand is a pointer and the right is 6836 // a null pointer constant. 6837 if ((LHSType->isPointerType() || LHSType->isObjCObjectPointerType() || 6838 LHSType->isBlockPointerType()) && 6839 RHS.get()->isNullPointerConstant(Context, 6840 Expr::NPC_ValueDependentIsNull)) { 6841 CastKind Kind; 6842 CXXCastPath Path; 6843 CheckPointerConversion(RHS.get(), LHSType, Kind, Path, false); 6844 RHS = ImpCastExprToType(RHS.get(), LHSType, Kind, VK_RValue, &Path); 6845 return Compatible; 6846 } 6847 6848 // This check seems unnatural, however it is necessary to ensure the proper 6849 // conversion of functions/arrays. If the conversion were done for all 6850 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary 6851 // expressions that suppress this implicit conversion (&, sizeof). 6852 // 6853 // Suppress this for references: C++ 8.5.3p5. 6854 if (!LHSType->isReferenceType()) { 6855 RHS = DefaultFunctionArrayLvalueConversion(RHS.get()); 6856 if (RHS.isInvalid()) 6857 return Incompatible; 6858 } 6859 6860 Expr *PRE = RHS.get()->IgnoreParenCasts(); 6861 if (ObjCProtocolExpr *OPE = dyn_cast<ObjCProtocolExpr>(PRE)) { 6862 ObjCProtocolDecl *PDecl = OPE->getProtocol(); 6863 if (PDecl && !PDecl->hasDefinition()) { 6864 Diag(PRE->getExprLoc(), diag::warn_atprotocol_protocol) << PDecl->getName(); 6865 Diag(PDecl->getLocation(), diag::note_entity_declared_at) << PDecl; 6866 } 6867 } 6868 6869 CastKind Kind = CK_Invalid; 6870 Sema::AssignConvertType result = 6871 CheckAssignmentConstraints(LHSType, RHS, Kind); 6872 6873 // C99 6.5.16.1p2: The value of the right operand is converted to the 6874 // type of the assignment expression. 6875 // CheckAssignmentConstraints allows the left-hand side to be a reference, 6876 // so that we can use references in built-in functions even in C. 6877 // The getNonReferenceType() call makes sure that the resulting expression 6878 // does not have reference type. 6879 if (result != Incompatible && RHS.get()->getType() != LHSType) { 6880 QualType Ty = LHSType.getNonLValueExprType(Context); 6881 Expr *E = RHS.get(); 6882 if (getLangOpts().ObjCAutoRefCount) 6883 CheckObjCARCConversion(SourceRange(), Ty, E, CCK_ImplicitConversion, 6884 DiagnoseCFAudited); 6885 if (getLangOpts().ObjC1 && 6886 (CheckObjCBridgeRelatedConversions(E->getLocStart(), 6887 LHSType, E->getType(), E) || 6888 ConversionToObjCStringLiteralCheck(LHSType, E))) { 6889 RHS = E; 6890 return Compatible; 6891 } 6892 6893 RHS = ImpCastExprToType(E, Ty, Kind); 6894 } 6895 return result; 6896} 6897 6898QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &LHS, 6899 ExprResult &RHS) { 6900 Diag(Loc, diag::err_typecheck_invalid_operands) 6901 << LHS.get()->getType() << RHS.get()->getType() 6902 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6903 return QualType(); 6904} 6905 6906/// Try to convert a value of non-vector type to a vector type by converting 6907/// the type to the element type of the vector and then performing a splat. 6908/// If the language is OpenCL, we only use conversions that promote scalar 6909/// rank; for C, Obj-C, and C++ we allow any real scalar conversion except 6910/// for float->int. 6911/// 6912/// \param scalar - if non-null, actually perform the conversions 6913/// \return true if the operation fails (but without diagnosing the failure) 6914static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar, 6915 QualType scalarTy, 6916 QualType vectorEltTy, 6917 QualType vectorTy) { 6918 // The conversion to apply to the scalar before splatting it, 6919 // if necessary. 6920 CastKind scalarCast = CK_Invalid; 6921 6922 if (vectorEltTy->isIntegralType(S.Context)) { 6923 if (!scalarTy->isIntegralType(S.Context)) 6924 return true; 6925 if (S.getLangOpts().OpenCL && 6926 S.Context.getIntegerTypeOrder(vectorEltTy, scalarTy) < 0) 6927 return true; 6928 scalarCast = CK_IntegralCast; 6929 } else if (vectorEltTy->isRealFloatingType()) { 6930 if (scalarTy->isRealFloatingType()) { 6931 if (S.getLangOpts().OpenCL && 6932 S.Context.getFloatingTypeOrder(vectorEltTy, scalarTy) < 0) 6933 return true; 6934 scalarCast = CK_FloatingCast; 6935 } 6936 else if (scalarTy->isIntegralType(S.Context)) 6937 scalarCast = CK_IntegralToFloating; 6938 else 6939 return true; 6940 } else { 6941 return true; 6942 } 6943 6944 // Adjust scalar if desired. 6945 if (scalar) { 6946 if (scalarCast != CK_Invalid) 6947 *scalar = S.ImpCastExprToType(scalar->get(), vectorEltTy, scalarCast); 6948 *scalar = S.ImpCastExprToType(scalar->get(), vectorTy, CK_VectorSplat); 6949 } 6950 return false; 6951} 6952 6953QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, 6954 SourceLocation Loc, bool IsCompAssign) { 6955 if (!IsCompAssign) { 6956 LHS = DefaultFunctionArrayLvalueConversion(LHS.get()); 6957 if (LHS.isInvalid()) 6958 return QualType(); 6959 } 6960 RHS = DefaultFunctionArrayLvalueConversion(RHS.get()); 6961 if (RHS.isInvalid()) 6962 return QualType(); 6963 6964 // For conversion purposes, we ignore any qualifiers. 6965 // For example, "const float" and "float" are equivalent. 6966 QualType LHSType = LHS.get()->getType().getUnqualifiedType(); 6967 QualType RHSType = RHS.get()->getType().getUnqualifiedType(); 6968 6969 // If the vector types are identical, return. 6970 if (Context.hasSameType(LHSType, RHSType)) 6971 return LHSType; 6972 6973 const VectorType *LHSVecType = LHSType->getAs<VectorType>(); 6974 const VectorType *RHSVecType = RHSType->getAs<VectorType>(); 6975 assert(LHSVecType || RHSVecType); 6976 6977 // If we have compatible AltiVec and GCC vector types, use the AltiVec type. 6978 if (LHSVecType && RHSVecType && 6979 Context.areCompatibleVectorTypes(LHSType, RHSType)) { 6980 if (isa<ExtVectorType>(LHSVecType)) { 6981 RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); 6982 return LHSType; 6983 } 6984 6985 if (!IsCompAssign) 6986 LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast); 6987 return RHSType; 6988 } 6989 6990 // If there's an ext-vector type and a scalar, try to convert the scalar to 6991 // the vector element type and splat. 6992 if (!RHSVecType && isa<ExtVectorType>(LHSVecType)) { 6993 if (!tryVectorConvertAndSplat(*this, &RHS, RHSType, 6994 LHSVecType->getElementType(), LHSType)) 6995 return LHSType; 6996 } 6997 if (!LHSVecType && isa<ExtVectorType>(RHSVecType)) { 6998 if (!tryVectorConvertAndSplat(*this, (IsCompAssign ? nullptr : &LHS), 6999 LHSType, RHSVecType->getElementType(), 7000 RHSType)) 7001 return RHSType; 7002 } 7003 7004 // If we're allowing lax vector conversions, only the total (data) size 7005 // needs to be the same. 7006 // FIXME: Should we really be allowing this? 7007 // FIXME: We really just pick the LHS type arbitrarily? 7008 if (isLaxVectorConversion(RHSType, LHSType)) { 7009 QualType resultType = LHSType; 7010 RHS = ImpCastExprToType(RHS.get(), resultType, CK_BitCast); 7011 return resultType; 7012 } 7013 7014 // Okay, the expression is invalid. 7015 7016 // If there's a non-vector, non-real operand, diagnose that. 7017 if ((!RHSVecType && !RHSType->isRealType()) || 7018 (!LHSVecType && !LHSType->isRealType())) { 7019 Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar) 7020 << LHSType << RHSType 7021 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7022 return QualType(); 7023 } 7024 7025 // Otherwise, use the generic diagnostic. 7026 Diag(Loc, diag::err_typecheck_vector_not_convertable) 7027 << LHSType << RHSType 7028 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7029 return QualType(); 7030} 7031 7032// checkArithmeticNull - Detect when a NULL constant is used improperly in an 7033// expression. These are mainly cases where the null pointer is used as an 7034// integer instead of a pointer. 7035static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, 7036 SourceLocation Loc, bool IsCompare) { 7037 // The canonical way to check for a GNU null is with isNullPointerConstant, 7038 // but we use a bit of a hack here for speed; this is a relatively 7039 // hot path, and isNullPointerConstant is slow. 7040 bool LHSNull = isa<GNUNullExpr>(LHS.get()->IgnoreParenImpCasts()); 7041 bool RHSNull = isa<GNUNullExpr>(RHS.get()->IgnoreParenImpCasts()); 7042 7043 QualType NonNullType = LHSNull ? RHS.get()->getType() : LHS.get()->getType(); 7044 7045 // Avoid analyzing cases where the result will either be invalid (and 7046 // diagnosed as such) or entirely valid and not something to warn about. 7047 if ((!LHSNull && !RHSNull) || NonNullType->isBlockPointerType() || 7048 NonNullType->isMemberPointerType() || NonNullType->isFunctionType()) 7049 return; 7050 7051 // Comparison operations would not make sense with a null pointer no matter 7052 // what the other expression is. 7053 if (!IsCompare) { 7054 S.Diag(Loc, diag::warn_null_in_arithmetic_operation) 7055 << (LHSNull ? LHS.get()->getSourceRange() : SourceRange()) 7056 << (RHSNull ? RHS.get()->getSourceRange() : SourceRange()); 7057 return; 7058 } 7059 7060 // The rest of the operations only make sense with a null pointer 7061 // if the other expression is a pointer. 7062 if (LHSNull == RHSNull || NonNullType->isAnyPointerType() || 7063 NonNullType->canDecayToPointerType()) 7064 return; 7065 7066 S.Diag(Loc, diag::warn_null_in_comparison_operation) 7067 << LHSNull /* LHS is NULL */ << NonNullType 7068 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7069} 7070 7071QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS, 7072 SourceLocation Loc, 7073 bool IsCompAssign, bool IsDiv) { 7074 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7075 7076 if (LHS.get()->getType()->isVectorType() || 7077 RHS.get()->getType()->isVectorType()) 7078 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 7079 7080 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign); 7081 if (LHS.isInvalid() || RHS.isInvalid()) 7082 return QualType(); 7083 7084 7085 if (compType.isNull() || !compType->isArithmeticType()) 7086 return InvalidOperands(Loc, LHS, RHS); 7087 7088 // Check for division by zero. 7089 llvm::APSInt RHSValue; 7090 if (IsDiv && !RHS.get()->isValueDependent() && 7091 RHS.get()->EvaluateAsInt(RHSValue, Context) && RHSValue == 0) 7092 DiagRuntimeBehavior(Loc, RHS.get(), 7093 PDiag(diag::warn_division_by_zero) 7094 << RHS.get()->getSourceRange()); 7095 7096 return compType; 7097} 7098 7099QualType Sema::CheckRemainderOperands( 7100 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { 7101 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7102 7103 if (LHS.get()->getType()->isVectorType() || 7104 RHS.get()->getType()->isVectorType()) { 7105 if (LHS.get()->getType()->hasIntegerRepresentation() && 7106 RHS.get()->getType()->hasIntegerRepresentation()) 7107 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 7108 return InvalidOperands(Loc, LHS, RHS); 7109 } 7110 7111 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign); 7112 if (LHS.isInvalid() || RHS.isInvalid()) 7113 return QualType(); 7114 7115 if (compType.isNull() || !compType->isIntegerType()) 7116 return InvalidOperands(Loc, LHS, RHS); 7117 7118 // Check for remainder by zero. 7119 llvm::APSInt RHSValue; 7120 if (!RHS.get()->isValueDependent() && 7121 RHS.get()->EvaluateAsInt(RHSValue, Context) && RHSValue == 0) 7122 DiagRuntimeBehavior(Loc, RHS.get(), 7123 PDiag(diag::warn_remainder_by_zero) 7124 << RHS.get()->getSourceRange()); 7125 7126 return compType; 7127} 7128 7129/// \brief Diagnose invalid arithmetic on two void pointers. 7130static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, 7131 Expr *LHSExpr, Expr *RHSExpr) { 7132 S.Diag(Loc, S.getLangOpts().CPlusPlus 7133 ? diag::err_typecheck_pointer_arith_void_type 7134 : diag::ext_gnu_void_ptr) 7135 << 1 /* two pointers */ << LHSExpr->getSourceRange() 7136 << RHSExpr->getSourceRange(); 7137} 7138 7139/// \brief Diagnose invalid arithmetic on a void pointer. 7140static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, 7141 Expr *Pointer) { 7142 S.Diag(Loc, S.getLangOpts().CPlusPlus 7143 ? diag::err_typecheck_pointer_arith_void_type 7144 : diag::ext_gnu_void_ptr) 7145 << 0 /* one pointer */ << Pointer->getSourceRange(); 7146} 7147 7148/// \brief Diagnose invalid arithmetic on two function pointers. 7149static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, 7150 Expr *LHS, Expr *RHS) { 7151 assert(LHS->getType()->isAnyPointerType()); 7152 assert(RHS->getType()->isAnyPointerType()); 7153 S.Diag(Loc, S.getLangOpts().CPlusPlus 7154 ? diag::err_typecheck_pointer_arith_function_type 7155 : diag::ext_gnu_ptr_func_arith) 7156 << 1 /* two pointers */ << LHS->getType()->getPointeeType() 7157 // We only show the second type if it differs from the first. 7158 << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(), 7159 RHS->getType()) 7160 << RHS->getType()->getPointeeType() 7161 << LHS->getSourceRange() << RHS->getSourceRange(); 7162} 7163 7164/// \brief Diagnose invalid arithmetic on a function pointer. 7165static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, 7166 Expr *Pointer) { 7167 assert(Pointer->getType()->isAnyPointerType()); 7168 S.Diag(Loc, S.getLangOpts().CPlusPlus 7169 ? diag::err_typecheck_pointer_arith_function_type 7170 : diag::ext_gnu_ptr_func_arith) 7171 << 0 /* one pointer */ << Pointer->getType()->getPointeeType() 7172 << 0 /* one pointer, so only one type */ 7173 << Pointer->getSourceRange(); 7174} 7175 7176/// \brief Emit error if Operand is incomplete pointer type 7177/// 7178/// \returns True if pointer has incomplete type 7179static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, 7180 Expr *Operand) { 7181 assert(Operand->getType()->isAnyPointerType() && 7182 !Operand->getType()->isDependentType()); 7183 QualType PointeeTy = Operand->getType()->getPointeeType(); 7184 return S.RequireCompleteType(Loc, PointeeTy, 7185 diag::err_typecheck_arithmetic_incomplete_type, 7186 PointeeTy, Operand->getSourceRange()); 7187} 7188 7189/// \brief Check the validity of an arithmetic pointer operand. 7190/// 7191/// If the operand has pointer type, this code will check for pointer types 7192/// which are invalid in arithmetic operations. These will be diagnosed 7193/// appropriately, including whether or not the use is supported as an 7194/// extension. 7195/// 7196/// \returns True when the operand is valid to use (even if as an extension). 7197static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc, 7198 Expr *Operand) { 7199 if (!Operand->getType()->isAnyPointerType()) return true; 7200 7201 QualType PointeeTy = Operand->getType()->getPointeeType(); 7202 if (PointeeTy->isVoidType()) { 7203 diagnoseArithmeticOnVoidPointer(S, Loc, Operand); 7204 return !S.getLangOpts().CPlusPlus; 7205 } 7206 if (PointeeTy->isFunctionType()) { 7207 diagnoseArithmeticOnFunctionPointer(S, Loc, Operand); 7208 return !S.getLangOpts().CPlusPlus; 7209 } 7210 7211 if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false; 7212 7213 return true; 7214} 7215 7216/// \brief Check the validity of a binary arithmetic operation w.r.t. pointer 7217/// operands. 7218/// 7219/// This routine will diagnose any invalid arithmetic on pointer operands much 7220/// like \see checkArithmeticOpPointerOperand. However, it has special logic 7221/// for emitting a single diagnostic even for operations where both LHS and RHS 7222/// are (potentially problematic) pointers. 7223/// 7224/// \returns True when the operand is valid to use (even if as an extension). 7225static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc, 7226 Expr *LHSExpr, Expr *RHSExpr) { 7227 bool isLHSPointer = LHSExpr->getType()->isAnyPointerType(); 7228 bool isRHSPointer = RHSExpr->getType()->isAnyPointerType(); 7229 if (!isLHSPointer && !isRHSPointer) return true; 7230 7231 QualType LHSPointeeTy, RHSPointeeTy; 7232 if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType(); 7233 if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType(); 7234 7235 // if both are pointers check if operation is valid wrt address spaces 7236 if (isLHSPointer && isRHSPointer) { 7237 const PointerType *lhsPtr = LHSExpr->getType()->getAs<PointerType>(); 7238 const PointerType *rhsPtr = RHSExpr->getType()->getAs<PointerType>(); 7239 if (!lhsPtr->isAddressSpaceOverlapping(*rhsPtr)) { 7240 S.Diag(Loc, 7241 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers) 7242 << LHSExpr->getType() << RHSExpr->getType() << 1 /*arithmetic op*/ 7243 << LHSExpr->getSourceRange() << RHSExpr->getSourceRange(); 7244 return false; 7245 } 7246 } 7247 7248 // Check for arithmetic on pointers to incomplete types. 7249 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType(); 7250 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType(); 7251 if (isLHSVoidPtr || isRHSVoidPtr) { 7252 if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr); 7253 else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr); 7254 else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr); 7255 7256 return !S.getLangOpts().CPlusPlus; 7257 } 7258 7259 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType(); 7260 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType(); 7261 if (isLHSFuncPtr || isRHSFuncPtr) { 7262 if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr); 7263 else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, 7264 RHSExpr); 7265 else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr); 7266 7267 return !S.getLangOpts().CPlusPlus; 7268 } 7269 7270 if (isLHSPointer && checkArithmeticIncompletePointerType(S, Loc, LHSExpr)) 7271 return false; 7272 if (isRHSPointer && checkArithmeticIncompletePointerType(S, Loc, RHSExpr)) 7273 return false; 7274 7275 return true; 7276} 7277 7278/// diagnoseStringPlusInt - Emit a warning when adding an integer to a string 7279/// literal. 7280static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc, 7281 Expr *LHSExpr, Expr *RHSExpr) { 7282 StringLiteral* StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts()); 7283 Expr* IndexExpr = RHSExpr; 7284 if (!StrExpr) { 7285 StrExpr = dyn_cast<StringLiteral>(RHSExpr->IgnoreImpCasts()); 7286 IndexExpr = LHSExpr; 7287 } 7288 7289 bool IsStringPlusInt = StrExpr && 7290 IndexExpr->getType()->isIntegralOrUnscopedEnumerationType(); 7291 if (!IsStringPlusInt || IndexExpr->isValueDependent()) 7292 return; 7293 7294 llvm::APSInt index; 7295 if (IndexExpr->EvaluateAsInt(index, Self.getASTContext())) { 7296 unsigned StrLenWithNull = StrExpr->getLength() + 1; 7297 if (index.isNonNegative() && 7298 index <= llvm::APSInt(llvm::APInt(index.getBitWidth(), StrLenWithNull), 7299 index.isUnsigned())) 7300 return; 7301 } 7302 7303 SourceRange DiagRange(LHSExpr->getLocStart(), RHSExpr->getLocEnd()); 7304 Self.Diag(OpLoc, diag::warn_string_plus_int) 7305 << DiagRange << IndexExpr->IgnoreImpCasts()->getType(); 7306 7307 // Only print a fixit for "str" + int, not for int + "str". 7308 if (IndexExpr == RHSExpr) { 7309 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(RHSExpr->getLocEnd()); 7310 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence) 7311 << FixItHint::CreateInsertion(LHSExpr->getLocStart(), "&") 7312 << FixItHint::CreateReplacement(SourceRange(OpLoc), "[") 7313 << FixItHint::CreateInsertion(EndLoc, "]"); 7314 } else 7315 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence); 7316} 7317 7318/// \brief Emit a warning when adding a char literal to a string. 7319static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc, 7320 Expr *LHSExpr, Expr *RHSExpr) { 7321 const Expr *StringRefExpr = LHSExpr; 7322 const CharacterLiteral *CharExpr = 7323 dyn_cast<CharacterLiteral>(RHSExpr->IgnoreImpCasts()); 7324 7325 if (!CharExpr) { 7326 CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->IgnoreImpCasts()); 7327 StringRefExpr = RHSExpr; 7328 } 7329 7330 if (!CharExpr || !StringRefExpr) 7331 return; 7332 7333 const QualType StringType = StringRefExpr->getType(); 7334 7335 // Return if not a PointerType. 7336 if (!StringType->isAnyPointerType()) 7337 return; 7338 7339 // Return if not a CharacterType. 7340 if (!StringType->getPointeeType()->isAnyCharacterType()) 7341 return; 7342 7343 ASTContext &Ctx = Self.getASTContext(); 7344 SourceRange DiagRange(LHSExpr->getLocStart(), RHSExpr->getLocEnd()); 7345 7346 const QualType CharType = CharExpr->getType(); 7347 if (!CharType->isAnyCharacterType() && 7348 CharType->isIntegerType() && 7349 llvm::isUIntN(Ctx.getCharWidth(), CharExpr->getValue())) { 7350 Self.Diag(OpLoc, diag::warn_string_plus_char) 7351 << DiagRange << Ctx.CharTy; 7352 } else { 7353 Self.Diag(OpLoc, diag::warn_string_plus_char) 7354 << DiagRange << CharExpr->getType(); 7355 } 7356 7357 // Only print a fixit for str + char, not for char + str. 7358 if (isa<CharacterLiteral>(RHSExpr->IgnoreImpCasts())) { 7359 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(RHSExpr->getLocEnd()); 7360 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence) 7361 << FixItHint::CreateInsertion(LHSExpr->getLocStart(), "&") 7362 << FixItHint::CreateReplacement(SourceRange(OpLoc), "[") 7363 << FixItHint::CreateInsertion(EndLoc, "]"); 7364 } else { 7365 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence); 7366 } 7367} 7368 7369/// \brief Emit error when two pointers are incompatible. 7370static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, 7371 Expr *LHSExpr, Expr *RHSExpr) { 7372 assert(LHSExpr->getType()->isAnyPointerType()); 7373 assert(RHSExpr->getType()->isAnyPointerType()); 7374 S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible) 7375 << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange() 7376 << RHSExpr->getSourceRange(); 7377} 7378 7379QualType Sema::CheckAdditionOperands( // C99 6.5.6 7380 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc, 7381 QualType* CompLHSTy) { 7382 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7383 7384 if (LHS.get()->getType()->isVectorType() || 7385 RHS.get()->getType()->isVectorType()) { 7386 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy); 7387 if (CompLHSTy) *CompLHSTy = compType; 7388 return compType; 7389 } 7390 7391 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy); 7392 if (LHS.isInvalid() || RHS.isInvalid()) 7393 return QualType(); 7394 7395 // Diagnose "string literal" '+' int and string '+' "char literal". 7396 if (Opc == BO_Add) { 7397 diagnoseStringPlusInt(*this, Loc, LHS.get(), RHS.get()); 7398 diagnoseStringPlusChar(*this, Loc, LHS.get(), RHS.get()); 7399 } 7400 7401 // handle the common case first (both operands are arithmetic). 7402 if (!compType.isNull() && compType->isArithmeticType()) { 7403 if (CompLHSTy) *CompLHSTy = compType; 7404 return compType; 7405 } 7406 7407 // Type-checking. Ultimately the pointer's going to be in PExp; 7408 // note that we bias towards the LHS being the pointer. 7409 Expr *PExp = LHS.get(), *IExp = RHS.get(); 7410 7411 bool isObjCPointer; 7412 if (PExp->getType()->isPointerType()) { 7413 isObjCPointer = false; 7414 } else if (PExp->getType()->isObjCObjectPointerType()) { 7415 isObjCPointer = true; 7416 } else { 7417 std::swap(PExp, IExp); 7418 if (PExp->getType()->isPointerType()) { 7419 isObjCPointer = false; 7420 } else if (PExp->getType()->isObjCObjectPointerType()) { 7421 isObjCPointer = true; 7422 } else { 7423 return InvalidOperands(Loc, LHS, RHS); 7424 } 7425 } 7426 assert(PExp->getType()->isAnyPointerType()); 7427 7428 if (!IExp->getType()->isIntegerType()) 7429 return InvalidOperands(Loc, LHS, RHS); 7430 7431 if (!checkArithmeticOpPointerOperand(*this, Loc, PExp)) 7432 return QualType(); 7433 7434 if (isObjCPointer && checkArithmeticOnObjCPointer(*this, Loc, PExp)) 7435 return QualType(); 7436 7437 // Check array bounds for pointer arithemtic 7438 CheckArrayAccess(PExp, IExp); 7439 7440 if (CompLHSTy) { 7441 QualType LHSTy = Context.isPromotableBitField(LHS.get()); 7442 if (LHSTy.isNull()) { 7443 LHSTy = LHS.get()->getType(); 7444 if (LHSTy->isPromotableIntegerType()) 7445 LHSTy = Context.getPromotedIntegerType(LHSTy); 7446 } 7447 *CompLHSTy = LHSTy; 7448 } 7449 7450 return PExp->getType(); 7451} 7452 7453// C99 6.5.6 7454QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS, 7455 SourceLocation Loc, 7456 QualType* CompLHSTy) { 7457 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7458 7459 if (LHS.get()->getType()->isVectorType() || 7460 RHS.get()->getType()->isVectorType()) { 7461 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy); 7462 if (CompLHSTy) *CompLHSTy = compType; 7463 return compType; 7464 } 7465 7466 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy); 7467 if (LHS.isInvalid() || RHS.isInvalid()) 7468 return QualType(); 7469 7470 // Enforce type constraints: C99 6.5.6p3. 7471 7472 // Handle the common case first (both operands are arithmetic). 7473 if (!compType.isNull() && compType->isArithmeticType()) { 7474 if (CompLHSTy) *CompLHSTy = compType; 7475 return compType; 7476 } 7477 7478 // Either ptr - int or ptr - ptr. 7479 if (LHS.get()->getType()->isAnyPointerType()) { 7480 QualType lpointee = LHS.get()->getType()->getPointeeType(); 7481 7482 // Diagnose bad cases where we step over interface counts. 7483 if (LHS.get()->getType()->isObjCObjectPointerType() && 7484 checkArithmeticOnObjCPointer(*this, Loc, LHS.get())) 7485 return QualType(); 7486 7487 // The result type of a pointer-int computation is the pointer type. 7488 if (RHS.get()->getType()->isIntegerType()) { 7489 if (!checkArithmeticOpPointerOperand(*this, Loc, LHS.get())) 7490 return QualType(); 7491 7492 // Check array bounds for pointer arithemtic 7493 CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/nullptr, 7494 /*AllowOnePastEnd*/true, /*IndexNegated*/true); 7495 7496 if (CompLHSTy) *CompLHSTy = LHS.get()->getType(); 7497 return LHS.get()->getType(); 7498 } 7499 7500 // Handle pointer-pointer subtractions. 7501 if (const PointerType *RHSPTy 7502 = RHS.get()->getType()->getAs<PointerType>()) { 7503 QualType rpointee = RHSPTy->getPointeeType(); 7504 7505 if (getLangOpts().CPlusPlus) { 7506 // Pointee types must be the same: C++ [expr.add] 7507 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) { 7508 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get()); 7509 } 7510 } else { 7511 // Pointee types must be compatible C99 6.5.6p3 7512 if (!Context.typesAreCompatible( 7513 Context.getCanonicalType(lpointee).getUnqualifiedType(), 7514 Context.getCanonicalType(rpointee).getUnqualifiedType())) { 7515 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get()); 7516 return QualType(); 7517 } 7518 } 7519 7520 if (!checkArithmeticBinOpPointerOperands(*this, Loc, 7521 LHS.get(), RHS.get())) 7522 return QualType(); 7523 7524 // The pointee type may have zero size. As an extension, a structure or 7525 // union may have zero size or an array may have zero length. In this 7526 // case subtraction does not make sense. 7527 if (!rpointee->isVoidType() && !rpointee->isFunctionType()) { 7528 CharUnits ElementSize = Context.getTypeSizeInChars(rpointee); 7529 if (ElementSize.isZero()) { 7530 Diag(Loc,diag::warn_sub_ptr_zero_size_types) 7531 << rpointee.getUnqualifiedType() 7532 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7533 } 7534 } 7535 7536 if (CompLHSTy) *CompLHSTy = LHS.get()->getType(); 7537 return Context.getPointerDiffType(); 7538 } 7539 } 7540 7541 return InvalidOperands(Loc, LHS, RHS); 7542} 7543 7544static bool isScopedEnumerationType(QualType T) { 7545 if (const EnumType *ET = T->getAs<EnumType>()) 7546 return ET->getDecl()->isScoped(); 7547 return false; 7548} 7549 7550static void DiagnoseBadShiftValues(Sema& S, ExprResult &LHS, ExprResult &RHS, 7551 SourceLocation Loc, unsigned Opc, 7552 QualType LHSType) { 7553 // OpenCL 6.3j: shift values are effectively % word size of LHS (more defined), 7554 // so skip remaining warnings as we don't want to modify values within Sema. 7555 if (S.getLangOpts().OpenCL) 7556 return; 7557 7558 llvm::APSInt Right; 7559 // Check right/shifter operand 7560 if (RHS.get()->isValueDependent() || 7561 !RHS.get()->isIntegerConstantExpr(Right, S.Context)) 7562 return; 7563 7564 if (Right.isNegative()) { 7565 S.DiagRuntimeBehavior(Loc, RHS.get(), 7566 S.PDiag(diag::warn_shift_negative) 7567 << RHS.get()->getSourceRange()); 7568 return; 7569 } 7570 llvm::APInt LeftBits(Right.getBitWidth(), 7571 S.Context.getTypeSize(LHS.get()->getType())); 7572 if (Right.uge(LeftBits)) { 7573 S.DiagRuntimeBehavior(Loc, RHS.get(), 7574 S.PDiag(diag::warn_shift_gt_typewidth) 7575 << RHS.get()->getSourceRange()); 7576 return; 7577 } 7578 if (Opc != BO_Shl) 7579 return; 7580 7581 // When left shifting an ICE which is signed, we can check for overflow which 7582 // according to C++ has undefined behavior ([expr.shift] 5.8/2). Unsigned 7583 // integers have defined behavior modulo one more than the maximum value 7584 // representable in the result type, so never warn for those. 7585 llvm::APSInt Left; 7586 if (LHS.get()->isValueDependent() || 7587 !LHS.get()->isIntegerConstantExpr(Left, S.Context) || 7588 LHSType->hasUnsignedIntegerRepresentation()) 7589 return; 7590 llvm::APInt ResultBits = 7591 static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits(); 7592 if (LeftBits.uge(ResultBits)) 7593 return; 7594 llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue()); 7595 Result = Result.shl(Right); 7596 7597 // Print the bit representation of the signed integer as an unsigned 7598 // hexadecimal number. 7599 SmallString<40> HexResult; 7600 Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true); 7601 7602 // If we are only missing a sign bit, this is less likely to result in actual 7603 // bugs -- if the result is cast back to an unsigned type, it will have the 7604 // expected value. Thus we place this behind a different warning that can be 7605 // turned off separately if needed. 7606 if (LeftBits == ResultBits - 1) { 7607 S.Diag(Loc, diag::warn_shift_result_sets_sign_bit) 7608 << HexResult.str() << LHSType 7609 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7610 return; 7611 } 7612 7613 S.Diag(Loc, diag::warn_shift_result_gt_typewidth) 7614 << HexResult.str() << Result.getMinSignedBits() << LHSType 7615 << Left.getBitWidth() << LHS.get()->getSourceRange() 7616 << RHS.get()->getSourceRange(); 7617} 7618 7619// C99 6.5.7 7620QualType Sema::CheckShiftOperands(ExprResult &LHS, ExprResult &RHS, 7621 SourceLocation Loc, unsigned Opc, 7622 bool IsCompAssign) { 7623 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7624 7625 // Vector shifts promote their scalar inputs to vector type. 7626 if (LHS.get()->getType()->isVectorType() || 7627 RHS.get()->getType()->isVectorType()) 7628 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 7629 7630 // Shifts don't perform usual arithmetic conversions, they just do integer 7631 // promotions on each operand. C99 6.5.7p3 7632 7633 // For the LHS, do usual unary conversions, but then reset them away 7634 // if this is a compound assignment. 7635 ExprResult OldLHS = LHS; 7636 LHS = UsualUnaryConversions(LHS.get()); 7637 if (LHS.isInvalid()) 7638 return QualType(); 7639 QualType LHSType = LHS.get()->getType(); 7640 if (IsCompAssign) LHS = OldLHS; 7641 7642 // The RHS is simpler. 7643 RHS = UsualUnaryConversions(RHS.get()); 7644 if (RHS.isInvalid()) 7645 return QualType(); 7646 QualType RHSType = RHS.get()->getType(); 7647 7648 // C99 6.5.7p2: Each of the operands shall have integer type. 7649 if (!LHSType->hasIntegerRepresentation() || 7650 !RHSType->hasIntegerRepresentation()) 7651 return InvalidOperands(Loc, LHS, RHS); 7652 7653 // C++0x: Don't allow scoped enums. FIXME: Use something better than 7654 // hasIntegerRepresentation() above instead of this. 7655 if (isScopedEnumerationType(LHSType) || 7656 isScopedEnumerationType(RHSType)) { 7657 return InvalidOperands(Loc, LHS, RHS); 7658 } 7659 // Sanity-check shift operands 7660 DiagnoseBadShiftValues(*this, LHS, RHS, Loc, Opc, LHSType); 7661 7662 // "The type of the result is that of the promoted left operand." 7663 return LHSType; 7664} 7665 7666static bool IsWithinTemplateSpecialization(Decl *D) { 7667 if (DeclContext *DC = D->getDeclContext()) { 7668 if (isa<ClassTemplateSpecializationDecl>(DC)) 7669 return true; 7670 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) 7671 return FD->isFunctionTemplateSpecialization(); 7672 } 7673 return false; 7674} 7675 7676/// If two different enums are compared, raise a warning. 7677static void checkEnumComparison(Sema &S, SourceLocation Loc, Expr *LHS, 7678 Expr *RHS) { 7679 QualType LHSStrippedType = LHS->IgnoreParenImpCasts()->getType(); 7680 QualType RHSStrippedType = RHS->IgnoreParenImpCasts()->getType(); 7681 7682 const EnumType *LHSEnumType = LHSStrippedType->getAs<EnumType>(); 7683 if (!LHSEnumType) 7684 return; 7685 const EnumType *RHSEnumType = RHSStrippedType->getAs<EnumType>(); 7686 if (!RHSEnumType) 7687 return; 7688 7689 // Ignore anonymous enums. 7690 if (!LHSEnumType->getDecl()->getIdentifier()) 7691 return; 7692 if (!RHSEnumType->getDecl()->getIdentifier()) 7693 return; 7694 7695 if (S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType)) 7696 return; 7697 7698 S.Diag(Loc, diag::warn_comparison_of_mixed_enum_types) 7699 << LHSStrippedType << RHSStrippedType 7700 << LHS->getSourceRange() << RHS->getSourceRange(); 7701} 7702 7703/// \brief Diagnose bad pointer comparisons. 7704static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, 7705 ExprResult &LHS, ExprResult &RHS, 7706 bool IsError) { 7707 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers 7708 : diag::ext_typecheck_comparison_of_distinct_pointers) 7709 << LHS.get()->getType() << RHS.get()->getType() 7710 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7711} 7712 7713/// \brief Returns false if the pointers are converted to a composite type, 7714/// true otherwise. 7715static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc, 7716 ExprResult &LHS, ExprResult &RHS) { 7717 // C++ [expr.rel]p2: 7718 // [...] Pointer conversions (4.10) and qualification 7719 // conversions (4.4) are performed on pointer operands (or on 7720 // a pointer operand and a null pointer constant) to bring 7721 // them to their composite pointer type. [...] 7722 // 7723 // C++ [expr.eq]p1 uses the same notion for (in)equality 7724 // comparisons of pointers. 7725 7726 // C++ [expr.eq]p2: 7727 // In addition, pointers to members can be compared, or a pointer to 7728 // member and a null pointer constant. Pointer to member conversions 7729 // (4.11) and qualification conversions (4.4) are performed to bring 7730 // them to a common type. If one operand is a null pointer constant, 7731 // the common type is the type of the other operand. Otherwise, the 7732 // common type is a pointer to member type similar (4.4) to the type 7733 // of one of the operands, with a cv-qualification signature (4.4) 7734 // that is the union of the cv-qualification signatures of the operand 7735 // types. 7736 7737 QualType LHSType = LHS.get()->getType(); 7738 QualType RHSType = RHS.get()->getType(); 7739 assert((LHSType->isPointerType() && RHSType->isPointerType()) || 7740 (LHSType->isMemberPointerType() && RHSType->isMemberPointerType())); 7741 7742 bool NonStandardCompositeType = false; 7743 bool *BoolPtr = S.isSFINAEContext() ? nullptr : &NonStandardCompositeType; 7744 QualType T = S.FindCompositePointerType(Loc, LHS, RHS, BoolPtr); 7745 if (T.isNull()) { 7746 diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true); 7747 return true; 7748 } 7749 7750 if (NonStandardCompositeType) 7751 S.Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard) 7752 << LHSType << RHSType << T << LHS.get()->getSourceRange() 7753 << RHS.get()->getSourceRange(); 7754 7755 LHS = S.ImpCastExprToType(LHS.get(), T, CK_BitCast); 7756 RHS = S.ImpCastExprToType(RHS.get(), T, CK_BitCast); 7757 return false; 7758} 7759 7760static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc, 7761 ExprResult &LHS, 7762 ExprResult &RHS, 7763 bool IsError) { 7764 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void 7765 : diag::ext_typecheck_comparison_of_fptr_to_void) 7766 << LHS.get()->getType() << RHS.get()->getType() 7767 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7768} 7769 7770static bool isObjCObjectLiteral(ExprResult &E) { 7771 switch (E.get()->IgnoreParenImpCasts()->getStmtClass()) { 7772 case Stmt::ObjCArrayLiteralClass: 7773 case Stmt::ObjCDictionaryLiteralClass: 7774 case Stmt::ObjCStringLiteralClass: 7775 case Stmt::ObjCBoxedExprClass: 7776 return true; 7777 default: 7778 // Note that ObjCBoolLiteral is NOT an object literal! 7779 return false; 7780 } 7781} 7782 7783static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) { 7784 const ObjCObjectPointerType *Type = 7785 LHS->getType()->getAs<ObjCObjectPointerType>(); 7786 7787 // If this is not actually an Objective-C object, bail out. 7788 if (!Type) 7789 return false; 7790 7791 // Get the LHS object's interface type. 7792 QualType InterfaceType = Type->getPointeeType(); 7793 if (const ObjCObjectType *iQFaceTy = 7794 InterfaceType->getAsObjCQualifiedInterfaceType()) 7795 InterfaceType = iQFaceTy->getBaseType(); 7796 7797 // If the RHS isn't an Objective-C object, bail out. 7798 if (!RHS->getType()->isObjCObjectPointerType()) 7799 return false; 7800 7801 // Try to find the -isEqual: method. 7802 Selector IsEqualSel = S.NSAPIObj->getIsEqualSelector(); 7803 ObjCMethodDecl *Method = S.LookupMethodInObjectType(IsEqualSel, 7804 InterfaceType, 7805 /*instance=*/true); 7806 if (!Method) { 7807 if (Type->isObjCIdType()) { 7808 // For 'id', just check the global pool. 7809 Method = S.LookupInstanceMethodInGlobalPool(IsEqualSel, SourceRange(), 7810 /*receiverId=*/true, 7811 /*warn=*/false); 7812 } else { 7813 // Check protocols. 7814 Method = S.LookupMethodInQualifiedType(IsEqualSel, Type, 7815 /*instance=*/true); 7816 } 7817 } 7818 7819 if (!Method) 7820 return false; 7821 7822 QualType T = Method->parameters()[0]->getType(); 7823 if (!T->isObjCObjectPointerType()) 7824 return false; 7825 7826 QualType R = Method->getReturnType(); 7827 if (!R->isScalarType()) 7828 return false; 7829 7830 return true; 7831} 7832 7833Sema::ObjCLiteralKind Sema::CheckLiteralKind(Expr *FromE) { 7834 FromE = FromE->IgnoreParenImpCasts(); 7835 switch (FromE->getStmtClass()) { 7836 default: 7837 break; 7838 case Stmt::ObjCStringLiteralClass: 7839 // "string literal" 7840 return LK_String; 7841 case Stmt::ObjCArrayLiteralClass: 7842 // "array literal" 7843 return LK_Array; 7844 case Stmt::ObjCDictionaryLiteralClass: 7845 // "dictionary literal" 7846 return LK_Dictionary; 7847 case Stmt::BlockExprClass: 7848 return LK_Block; 7849 case Stmt::ObjCBoxedExprClass: { 7850 Expr *Inner = cast<ObjCBoxedExpr>(FromE)->getSubExpr()->IgnoreParens(); 7851 switch (Inner->getStmtClass()) { 7852 case Stmt::IntegerLiteralClass: 7853 case Stmt::FloatingLiteralClass: 7854 case Stmt::CharacterLiteralClass: 7855 case Stmt::ObjCBoolLiteralExprClass: 7856 case Stmt::CXXBoolLiteralExprClass: 7857 // "numeric literal" 7858 return LK_Numeric; 7859 case Stmt::ImplicitCastExprClass: { 7860 CastKind CK = cast<CastExpr>(Inner)->getCastKind(); 7861 // Boolean literals can be represented by implicit casts. 7862 if (CK == CK_IntegralToBoolean || CK == CK_IntegralCast) 7863 return LK_Numeric; 7864 break; 7865 } 7866 default: 7867 break; 7868 } 7869 return LK_Boxed; 7870 } 7871 } 7872 return LK_None; 7873} 7874 7875static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc, 7876 ExprResult &LHS, ExprResult &RHS, 7877 BinaryOperator::Opcode Opc){ 7878 Expr *Literal; 7879 Expr *Other; 7880 if (isObjCObjectLiteral(LHS)) { 7881 Literal = LHS.get(); 7882 Other = RHS.get(); 7883 } else { 7884 Literal = RHS.get(); 7885 Other = LHS.get(); 7886 } 7887 7888 // Don't warn on comparisons against nil. 7889 Other = Other->IgnoreParenCasts(); 7890 if (Other->isNullPointerConstant(S.getASTContext(), 7891 Expr::NPC_ValueDependentIsNotNull)) 7892 return; 7893 7894 // This should be kept in sync with warn_objc_literal_comparison. 7895 // LK_String should always be after the other literals, since it has its own 7896 // warning flag. 7897 Sema::ObjCLiteralKind LiteralKind = S.CheckLiteralKind(Literal); 7898 assert(LiteralKind != Sema::LK_Block); 7899 if (LiteralKind == Sema::LK_None) { 7900 llvm_unreachable("Unknown Objective-C object literal kind"); 7901 } 7902 7903 if (LiteralKind == Sema::LK_String) 7904 S.Diag(Loc, diag::warn_objc_string_literal_comparison) 7905 << Literal->getSourceRange(); 7906 else 7907 S.Diag(Loc, diag::warn_objc_literal_comparison) 7908 << LiteralKind << Literal->getSourceRange(); 7909 7910 if (BinaryOperator::isEqualityOp(Opc) && 7911 hasIsEqualMethod(S, LHS.get(), RHS.get())) { 7912 SourceLocation Start = LHS.get()->getLocStart(); 7913 SourceLocation End = S.PP.getLocForEndOfToken(RHS.get()->getLocEnd()); 7914 CharSourceRange OpRange = 7915 CharSourceRange::getCharRange(Loc, S.PP.getLocForEndOfToken(Loc)); 7916 7917 S.Diag(Loc, diag::note_objc_literal_comparison_isequal) 7918 << FixItHint::CreateInsertion(Start, Opc == BO_EQ ? "[" : "![") 7919 << FixItHint::CreateReplacement(OpRange, " isEqual:") 7920 << FixItHint::CreateInsertion(End, "]"); 7921 } 7922} 7923 7924static void diagnoseLogicalNotOnLHSofComparison(Sema &S, ExprResult &LHS, 7925 ExprResult &RHS, 7926 SourceLocation Loc, 7927 unsigned OpaqueOpc) { 7928 // This checking requires bools. 7929 if (!S.getLangOpts().Bool) return; 7930 7931 // Check that left hand side is !something. 7932 UnaryOperator *UO = dyn_cast<UnaryOperator>(LHS.get()->IgnoreImpCasts()); 7933 if (!UO || UO->getOpcode() != UO_LNot) return; 7934 7935 // Only check if the right hand side is non-bool arithmetic type. 7936 if (RHS.get()->getType()->isBooleanType()) return; 7937 7938 // Make sure that the something in !something is not bool. 7939 Expr *SubExpr = UO->getSubExpr()->IgnoreImpCasts(); 7940 if (SubExpr->getType()->isBooleanType()) return; 7941 7942 // Emit warning. 7943 S.Diag(UO->getOperatorLoc(), diag::warn_logical_not_on_lhs_of_comparison) 7944 << Loc; 7945 7946 // First note suggest !(x < y) 7947 SourceLocation FirstOpen = SubExpr->getLocStart(); 7948 SourceLocation FirstClose = RHS.get()->getLocEnd(); 7949 FirstClose = S.getPreprocessor().getLocForEndOfToken(FirstClose); 7950 if (FirstClose.isInvalid()) 7951 FirstOpen = SourceLocation(); 7952 S.Diag(UO->getOperatorLoc(), diag::note_logical_not_fix) 7953 << FixItHint::CreateInsertion(FirstOpen, "(") 7954 << FixItHint::CreateInsertion(FirstClose, ")"); 7955 7956 // Second note suggests (!x) < y 7957 SourceLocation SecondOpen = LHS.get()->getLocStart(); 7958 SourceLocation SecondClose = LHS.get()->getLocEnd(); 7959 SecondClose = S.getPreprocessor().getLocForEndOfToken(SecondClose); 7960 if (SecondClose.isInvalid()) 7961 SecondOpen = SourceLocation(); 7962 S.Diag(UO->getOperatorLoc(), diag::note_logical_not_silence_with_parens) 7963 << FixItHint::CreateInsertion(SecondOpen, "(") 7964 << FixItHint::CreateInsertion(SecondClose, ")"); 7965} 7966 7967// Get the decl for a simple expression: a reference to a variable, 7968// an implicit C++ field reference, or an implicit ObjC ivar reference. 7969static ValueDecl *getCompareDecl(Expr *E) { 7970 if (DeclRefExpr* DR = dyn_cast<DeclRefExpr>(E)) 7971 return DR->getDecl(); 7972 if (ObjCIvarRefExpr* Ivar = dyn_cast<ObjCIvarRefExpr>(E)) { 7973 if (Ivar->isFreeIvar()) 7974 return Ivar->getDecl(); 7975 } 7976 if (MemberExpr* Mem = dyn_cast<MemberExpr>(E)) { 7977 if (Mem->isImplicitAccess()) 7978 return Mem->getMemberDecl(); 7979 } 7980 return nullptr; 7981} 7982 7983// C99 6.5.8, C++ [expr.rel] 7984QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS, 7985 SourceLocation Loc, unsigned OpaqueOpc, 7986 bool IsRelational) { 7987 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/true); 7988 7989 BinaryOperatorKind Opc = (BinaryOperatorKind) OpaqueOpc; 7990 7991 // Handle vector comparisons separately. 7992 if (LHS.get()->getType()->isVectorType() || 7993 RHS.get()->getType()->isVectorType()) 7994 return CheckVectorCompareOperands(LHS, RHS, Loc, IsRelational); 7995 7996 QualType LHSType = LHS.get()->getType(); 7997 QualType RHSType = RHS.get()->getType(); 7998 7999 Expr *LHSStripped = LHS.get()->IgnoreParenImpCasts(); 8000 Expr *RHSStripped = RHS.get()->IgnoreParenImpCasts(); 8001 8002 checkEnumComparison(*this, Loc, LHS.get(), RHS.get()); 8003 diagnoseLogicalNotOnLHSofComparison(*this, LHS, RHS, Loc, OpaqueOpc); 8004 8005 if (!LHSType->hasFloatingRepresentation() && 8006 !(LHSType->isBlockPointerType() && IsRelational) && 8007 !LHS.get()->getLocStart().isMacroID() && 8008 !RHS.get()->getLocStart().isMacroID() && 8009 ActiveTemplateInstantiations.empty()) { 8010 // For non-floating point types, check for self-comparisons of the form 8011 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 8012 // often indicate logic errors in the program. 8013 // 8014 // NOTE: Don't warn about comparison expressions resulting from macro 8015 // expansion. Also don't warn about comparisons which are only self 8016 // comparisons within a template specialization. The warnings should catch 8017 // obvious cases in the definition of the template anyways. The idea is to 8018 // warn when the typed comparison operator will always evaluate to the same 8019 // result. 8020 ValueDecl *DL = getCompareDecl(LHSStripped); 8021 ValueDecl *DR = getCompareDecl(RHSStripped); 8022 if (DL && DR && DL == DR && !IsWithinTemplateSpecialization(DL)) { 8023 DiagRuntimeBehavior(Loc, nullptr, PDiag(diag::warn_comparison_always) 8024 << 0 // self- 8025 << (Opc == BO_EQ 8026 || Opc == BO_LE 8027 || Opc == BO_GE)); 8028 } else if (DL && DR && LHSType->isArrayType() && RHSType->isArrayType() && 8029 !DL->getType()->isReferenceType() && 8030 !DR->getType()->isReferenceType()) { 8031 // what is it always going to eval to? 8032 char always_evals_to; 8033 switch(Opc) { 8034 case BO_EQ: // e.g. array1 == array2 8035 always_evals_to = 0; // false 8036 break; 8037 case BO_NE: // e.g. array1 != array2 8038 always_evals_to = 1; // true 8039 break; 8040 default: 8041 // best we can say is 'a constant' 8042 always_evals_to = 2; // e.g. array1 <= array2 8043 break; 8044 } 8045 DiagRuntimeBehavior(Loc, nullptr, PDiag(diag::warn_comparison_always) 8046 << 1 // array 8047 << always_evals_to); 8048 } 8049 8050 if (isa<CastExpr>(LHSStripped)) 8051 LHSStripped = LHSStripped->IgnoreParenCasts(); 8052 if (isa<CastExpr>(RHSStripped)) 8053 RHSStripped = RHSStripped->IgnoreParenCasts(); 8054 8055 // Warn about comparisons against a string constant (unless the other 8056 // operand is null), the user probably wants strcmp. 8057 Expr *literalString = nullptr; 8058 Expr *literalStringStripped = nullptr; 8059 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) && 8060 !RHSStripped->isNullPointerConstant(Context, 8061 Expr::NPC_ValueDependentIsNull)) { 8062 literalString = LHS.get(); 8063 literalStringStripped = LHSStripped; 8064 } else if ((isa<StringLiteral>(RHSStripped) || 8065 isa<ObjCEncodeExpr>(RHSStripped)) && 8066 !LHSStripped->isNullPointerConstant(Context, 8067 Expr::NPC_ValueDependentIsNull)) { 8068 literalString = RHS.get(); 8069 literalStringStripped = RHSStripped; 8070 } 8071 8072 if (literalString) { 8073 DiagRuntimeBehavior(Loc, nullptr, 8074 PDiag(diag::warn_stringcompare) 8075 << isa<ObjCEncodeExpr>(literalStringStripped) 8076 << literalString->getSourceRange()); 8077 } 8078 } 8079 8080 // C99 6.5.8p3 / C99 6.5.9p4 8081 UsualArithmeticConversions(LHS, RHS); 8082 if (LHS.isInvalid() || RHS.isInvalid()) 8083 return QualType(); 8084 8085 LHSType = LHS.get()->getType(); 8086 RHSType = RHS.get()->getType(); 8087 8088 // The result of comparisons is 'bool' in C++, 'int' in C. 8089 QualType ResultTy = Context.getLogicalOperationType(); 8090 8091 if (IsRelational) { 8092 if (LHSType->isRealType() && RHSType->isRealType()) 8093 return ResultTy; 8094 } else { 8095 // Check for comparisons of floating point operands using != and ==. 8096 if (LHSType->hasFloatingRepresentation()) 8097 CheckFloatComparison(Loc, LHS.get(), RHS.get()); 8098 8099 if (LHSType->isArithmeticType() && RHSType->isArithmeticType()) 8100 return ResultTy; 8101 } 8102 8103 const Expr::NullPointerConstantKind LHSNullKind = 8104 LHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull); 8105 const Expr::NullPointerConstantKind RHSNullKind = 8106 RHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull); 8107 bool LHSIsNull = LHSNullKind != Expr::NPCK_NotNull; 8108 bool RHSIsNull = RHSNullKind != Expr::NPCK_NotNull; 8109 8110 if (!IsRelational && LHSIsNull != RHSIsNull) { 8111 bool IsEquality = Opc == BO_EQ; 8112 if (RHSIsNull) 8113 DiagnoseAlwaysNonNullPointer(LHS.get(), RHSNullKind, IsEquality, 8114 RHS.get()->getSourceRange()); 8115 else 8116 DiagnoseAlwaysNonNullPointer(RHS.get(), LHSNullKind, IsEquality, 8117 LHS.get()->getSourceRange()); 8118 } 8119 8120 // All of the following pointer-related warnings are GCC extensions, except 8121 // when handling null pointer constants. 8122 if (LHSType->isPointerType() && RHSType->isPointerType()) { // C99 6.5.8p2 8123 QualType LCanPointeeTy = 8124 LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType(); 8125 QualType RCanPointeeTy = 8126 RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType(); 8127 8128 if (getLangOpts().CPlusPlus) { 8129 if (LCanPointeeTy == RCanPointeeTy) 8130 return ResultTy; 8131 if (!IsRelational && 8132 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 8133 // Valid unless comparison between non-null pointer and function pointer 8134 // This is a gcc extension compatibility comparison. 8135 // In a SFINAE context, we treat this as a hard error to maintain 8136 // conformance with the C++ standard. 8137 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 8138 && !LHSIsNull && !RHSIsNull) { 8139 diagnoseFunctionPointerToVoidComparison( 8140 *this, Loc, LHS, RHS, /*isError*/ (bool)isSFINAEContext()); 8141 8142 if (isSFINAEContext()) 8143 return QualType(); 8144 8145 RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); 8146 return ResultTy; 8147 } 8148 } 8149 8150 if (convertPointersToCompositeType(*this, Loc, LHS, RHS)) 8151 return QualType(); 8152 else 8153 return ResultTy; 8154 } 8155 // C99 6.5.9p2 and C99 6.5.8p2 8156 if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(), 8157 RCanPointeeTy.getUnqualifiedType())) { 8158 // Valid unless a relational comparison of function pointers 8159 if (IsRelational && LCanPointeeTy->isFunctionType()) { 8160 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers) 8161 << LHSType << RHSType << LHS.get()->getSourceRange() 8162 << RHS.get()->getSourceRange(); 8163 } 8164 } else if (!IsRelational && 8165 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 8166 // Valid unless comparison between non-null pointer and function pointer 8167 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 8168 && !LHSIsNull && !RHSIsNull) 8169 diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS, 8170 /*isError*/false); 8171 } else { 8172 // Invalid 8173 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false); 8174 } 8175 if (LCanPointeeTy != RCanPointeeTy) { 8176 const PointerType *lhsPtr = LHSType->getAs<PointerType>(); 8177 if (!lhsPtr->isAddressSpaceOverlapping(*RHSType->getAs<PointerType>())) { 8178 Diag(Loc, 8179 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers) 8180 << LHSType << RHSType << 0 /* comparison */ 8181 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 8182 } 8183 unsigned AddrSpaceL = LCanPointeeTy.getAddressSpace(); 8184 unsigned AddrSpaceR = RCanPointeeTy.getAddressSpace(); 8185 CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion 8186 : CK_BitCast; 8187 if (LHSIsNull && !RHSIsNull) 8188 LHS = ImpCastExprToType(LHS.get(), RHSType, Kind); 8189 else 8190 RHS = ImpCastExprToType(RHS.get(), LHSType, Kind); 8191 } 8192 return ResultTy; 8193 } 8194 8195 if (getLangOpts().CPlusPlus) { 8196 // Comparison of nullptr_t with itself. 8197 if (LHSType->isNullPtrType() && RHSType->isNullPtrType()) 8198 return ResultTy; 8199 8200 // Comparison of pointers with null pointer constants and equality 8201 // comparisons of member pointers to null pointer constants. 8202 if (RHSIsNull && 8203 ((LHSType->isAnyPointerType() || LHSType->isNullPtrType()) || 8204 (!IsRelational && 8205 (LHSType->isMemberPointerType() || LHSType->isBlockPointerType())))) { 8206 RHS = ImpCastExprToType(RHS.get(), LHSType, 8207 LHSType->isMemberPointerType() 8208 ? CK_NullToMemberPointer 8209 : CK_NullToPointer); 8210 return ResultTy; 8211 } 8212 if (LHSIsNull && 8213 ((RHSType->isAnyPointerType() || RHSType->isNullPtrType()) || 8214 (!IsRelational && 8215 (RHSType->isMemberPointerType() || RHSType->isBlockPointerType())))) { 8216 LHS = ImpCastExprToType(LHS.get(), RHSType, 8217 RHSType->isMemberPointerType() 8218 ? CK_NullToMemberPointer 8219 : CK_NullToPointer); 8220 return ResultTy; 8221 } 8222 8223 // Comparison of member pointers. 8224 if (!IsRelational && 8225 LHSType->isMemberPointerType() && RHSType->isMemberPointerType()) { 8226 if (convertPointersToCompositeType(*this, Loc, LHS, RHS)) 8227 return QualType(); 8228 else 8229 return ResultTy; 8230 } 8231 8232 // Handle scoped enumeration types specifically, since they don't promote 8233 // to integers. 8234 if (LHS.get()->getType()->isEnumeralType() && 8235 Context.hasSameUnqualifiedType(LHS.get()->getType(), 8236 RHS.get()->getType())) 8237 return ResultTy; 8238 } 8239 8240 // Handle block pointer types. 8241 if (!IsRelational && LHSType->isBlockPointerType() && 8242 RHSType->isBlockPointerType()) { 8243 QualType lpointee = LHSType->castAs<BlockPointerType>()->getPointeeType(); 8244 QualType rpointee = RHSType->castAs<BlockPointerType>()->getPointeeType(); 8245 8246 if (!LHSIsNull && !RHSIsNull && 8247 !Context.typesAreCompatible(lpointee, rpointee)) { 8248 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 8249 << LHSType << RHSType << LHS.get()->getSourceRange() 8250 << RHS.get()->getSourceRange(); 8251 } 8252 RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); 8253 return ResultTy; 8254 } 8255 8256 // Allow block pointers to be compared with null pointer constants. 8257 if (!IsRelational 8258 && ((LHSType->isBlockPointerType() && RHSType->isPointerType()) 8259 || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) { 8260 if (!LHSIsNull && !RHSIsNull) { 8261 if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>() 8262 ->getPointeeType()->isVoidType()) 8263 || (LHSType->isPointerType() && LHSType->castAs<PointerType>() 8264 ->getPointeeType()->isVoidType()))) 8265 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 8266 << LHSType << RHSType << LHS.get()->getSourceRange() 8267 << RHS.get()->getSourceRange(); 8268 } 8269 if (LHSIsNull && !RHSIsNull) 8270 LHS = ImpCastExprToType(LHS.get(), RHSType, 8271 RHSType->isPointerType() ? CK_BitCast 8272 : CK_AnyPointerToBlockPointerCast); 8273 else 8274 RHS = ImpCastExprToType(RHS.get(), LHSType, 8275 LHSType->isPointerType() ? CK_BitCast 8276 : CK_AnyPointerToBlockPointerCast); 8277 return ResultTy; 8278 } 8279 8280 if (LHSType->isObjCObjectPointerType() || 8281 RHSType->isObjCObjectPointerType()) { 8282 const PointerType *LPT = LHSType->getAs<PointerType>(); 8283 const PointerType *RPT = RHSType->getAs<PointerType>(); 8284 if (LPT || RPT) { 8285 bool LPtrToVoid = LPT ? LPT->getPointeeType()->isVoidType() : false; 8286 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() : false; 8287 8288 if (!LPtrToVoid && !RPtrToVoid && 8289 !Context.typesAreCompatible(LHSType, RHSType)) { 8290 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, 8291 /*isError*/false); 8292 } 8293 if (LHSIsNull && !RHSIsNull) { 8294 Expr *E = LHS.get(); 8295 if (getLangOpts().ObjCAutoRefCount) 8296 CheckObjCARCConversion(SourceRange(), RHSType, E, CCK_ImplicitConversion); 8297 LHS = ImpCastExprToType(E, RHSType, 8298 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast); 8299 } 8300 else { 8301 Expr *E = RHS.get(); 8302 if (getLangOpts().ObjCAutoRefCount) 8303 CheckObjCARCConversion(SourceRange(), LHSType, E, CCK_ImplicitConversion, false, 8304 Opc); 8305 RHS = ImpCastExprToType(E, LHSType, 8306 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast); 8307 } 8308 return ResultTy; 8309 } 8310 if (LHSType->isObjCObjectPointerType() && 8311 RHSType->isObjCObjectPointerType()) { 8312 if (!Context.areComparableObjCPointerTypes(LHSType, RHSType)) 8313 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, 8314 /*isError*/false); 8315 if (isObjCObjectLiteral(LHS) || isObjCObjectLiteral(RHS)) 8316 diagnoseObjCLiteralComparison(*this, Loc, LHS, RHS, Opc); 8317 8318 if (LHSIsNull && !RHSIsNull) 8319 LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast); 8320 else 8321 RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); 8322 return ResultTy; 8323 } 8324 } 8325 if ((LHSType->isAnyPointerType() && RHSType->isIntegerType()) || 8326 (LHSType->isIntegerType() && RHSType->isAnyPointerType())) { 8327 unsigned DiagID = 0; 8328 bool isError = false; 8329 if (LangOpts.DebuggerSupport) { 8330 // Under a debugger, allow the comparison of pointers to integers, 8331 // since users tend to want to compare addresses. 8332 } else if ((LHSIsNull && LHSType->isIntegerType()) || 8333 (RHSIsNull && RHSType->isIntegerType())) { 8334 if (IsRelational && !getLangOpts().CPlusPlus) 8335 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero; 8336 } else if (IsRelational && !getLangOpts().CPlusPlus) 8337 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer; 8338 else if (getLangOpts().CPlusPlus) { 8339 DiagID = diag::err_typecheck_comparison_of_pointer_integer; 8340 isError = true; 8341 } else 8342 DiagID = diag::ext_typecheck_comparison_of_pointer_integer; 8343 8344 if (DiagID) { 8345 Diag(Loc, DiagID) 8346 << LHSType << RHSType << LHS.get()->getSourceRange() 8347 << RHS.get()->getSourceRange(); 8348 if (isError) 8349 return QualType(); 8350 } 8351 8352 if (LHSType->isIntegerType()) 8353 LHS = ImpCastExprToType(LHS.get(), RHSType, 8354 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 8355 else 8356 RHS = ImpCastExprToType(RHS.get(), LHSType, 8357 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 8358 return ResultTy; 8359 } 8360 8361 // Handle block pointers. 8362 if (!IsRelational && RHSIsNull 8363 && LHSType->isBlockPointerType() && RHSType->isIntegerType()) { 8364 RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer); 8365 return ResultTy; 8366 } 8367 if (!IsRelational && LHSIsNull 8368 && LHSType->isIntegerType() && RHSType->isBlockPointerType()) { 8369 LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer); 8370 return ResultTy; 8371 } 8372 8373 return InvalidOperands(Loc, LHS, RHS); 8374} 8375 8376 8377// Return a signed type that is of identical size and number of elements. 8378// For floating point vectors, return an integer type of identical size 8379// and number of elements. 8380QualType Sema::GetSignedVectorType(QualType V) { 8381 const VectorType *VTy = V->getAs<VectorType>(); 8382 unsigned TypeSize = Context.getTypeSize(VTy->getElementType()); 8383 if (TypeSize == Context.getTypeSize(Context.CharTy)) 8384 return Context.getExtVectorType(Context.CharTy, VTy->getNumElements()); 8385 else if (TypeSize == Context.getTypeSize(Context.ShortTy)) 8386 return Context.getExtVectorType(Context.ShortTy, VTy->getNumElements()); 8387 else if (TypeSize == Context.getTypeSize(Context.IntTy)) 8388 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements()); 8389 else if (TypeSize == Context.getTypeSize(Context.LongTy)) 8390 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements()); 8391 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) && 8392 "Unhandled vector element size in vector compare"); 8393 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements()); 8394} 8395 8396/// CheckVectorCompareOperands - vector comparisons are a clang extension that 8397/// operates on extended vector types. Instead of producing an IntTy result, 8398/// like a scalar comparison, a vector comparison produces a vector of integer 8399/// types. 8400QualType Sema::CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, 8401 SourceLocation Loc, 8402 bool IsRelational) { 8403 // Check to make sure we're operating on vectors of the same type and width, 8404 // Allowing one side to be a scalar of element type. 8405 QualType vType = CheckVectorOperands(LHS, RHS, Loc, /*isCompAssign*/false); 8406 if (vType.isNull()) 8407 return vType; 8408 8409 QualType LHSType = LHS.get()->getType(); 8410 8411 // If AltiVec, the comparison results in a numeric type, i.e. 8412 // bool for C++, int for C 8413 if (vType->getAs<VectorType>()->getVectorKind() == VectorType::AltiVecVector) 8414 return Context.getLogicalOperationType(); 8415 8416 // For non-floating point types, check for self-comparisons of the form 8417 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 8418 // often indicate logic errors in the program. 8419 if (!LHSType->hasFloatingRepresentation() && 8420 ActiveTemplateInstantiations.empty()) { 8421 if (DeclRefExpr* DRL 8422 = dyn_cast<DeclRefExpr>(LHS.get()->IgnoreParenImpCasts())) 8423 if (DeclRefExpr* DRR 8424 = dyn_cast<DeclRefExpr>(RHS.get()->IgnoreParenImpCasts())) 8425 if (DRL->getDecl() == DRR->getDecl()) 8426 DiagRuntimeBehavior(Loc, nullptr, 8427 PDiag(diag::warn_comparison_always) 8428 << 0 // self- 8429 << 2 // "a constant" 8430 ); 8431 } 8432 8433 // Check for comparisons of floating point operands using != and ==. 8434 if (!IsRelational && LHSType->hasFloatingRepresentation()) { 8435 assert (RHS.get()->getType()->hasFloatingRepresentation()); 8436 CheckFloatComparison(Loc, LHS.get(), RHS.get()); 8437 } 8438 8439 // Return a signed type for the vector. 8440 return GetSignedVectorType(LHSType); 8441} 8442 8443QualType Sema::CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, 8444 SourceLocation Loc) { 8445 // Ensure that either both operands are of the same vector type, or 8446 // one operand is of a vector type and the other is of its element type. 8447 QualType vType = CheckVectorOperands(LHS, RHS, Loc, false); 8448 if (vType.isNull()) 8449 return InvalidOperands(Loc, LHS, RHS); 8450 if (getLangOpts().OpenCL && getLangOpts().OpenCLVersion < 120 && 8451 vType->hasFloatingRepresentation()) 8452 return InvalidOperands(Loc, LHS, RHS); 8453 8454 return GetSignedVectorType(LHS.get()->getType()); 8455} 8456 8457inline QualType Sema::CheckBitwiseOperands( 8458 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { 8459 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 8460 8461 if (LHS.get()->getType()->isVectorType() || 8462 RHS.get()->getType()->isVectorType()) { 8463 if (LHS.get()->getType()->hasIntegerRepresentation() && 8464 RHS.get()->getType()->hasIntegerRepresentation()) 8465 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 8466 8467 return InvalidOperands(Loc, LHS, RHS); 8468 } 8469 8470 ExprResult LHSResult = LHS, RHSResult = RHS; 8471 QualType compType = UsualArithmeticConversions(LHSResult, RHSResult, 8472 IsCompAssign); 8473 if (LHSResult.isInvalid() || RHSResult.isInvalid()) 8474 return QualType(); 8475 LHS = LHSResult.get(); 8476 RHS = RHSResult.get(); 8477 8478 if (!compType.isNull() && compType->isIntegralOrUnscopedEnumerationType()) 8479 return compType; 8480 return InvalidOperands(Loc, LHS, RHS); 8481} 8482 8483inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14] 8484 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc) { 8485 8486 // Check vector operands differently. 8487 if (LHS.get()->getType()->isVectorType() || RHS.get()->getType()->isVectorType()) 8488 return CheckVectorLogicalOperands(LHS, RHS, Loc); 8489 8490 // Diagnose cases where the user write a logical and/or but probably meant a 8491 // bitwise one. We do this when the LHS is a non-bool integer and the RHS 8492 // is a constant. 8493 if (LHS.get()->getType()->isIntegerType() && 8494 !LHS.get()->getType()->isBooleanType() && 8495 RHS.get()->getType()->isIntegerType() && !RHS.get()->isValueDependent() && 8496 // Don't warn in macros or template instantiations. 8497 !Loc.isMacroID() && ActiveTemplateInstantiations.empty()) { 8498 // If the RHS can be constant folded, and if it constant folds to something 8499 // that isn't 0 or 1 (which indicate a potential logical operation that 8500 // happened to fold to true/false) then warn. 8501 // Parens on the RHS are ignored. 8502 llvm::APSInt Result; 8503 if (RHS.get()->EvaluateAsInt(Result, Context)) 8504 if ((getLangOpts().Bool && !RHS.get()->getType()->isBooleanType() && 8505 !RHS.get()->getExprLoc().isMacroID()) || 8506 (Result != 0 && Result != 1)) { 8507 Diag(Loc, diag::warn_logical_instead_of_bitwise) 8508 << RHS.get()->getSourceRange() 8509 << (Opc == BO_LAnd ? "&&" : "||"); 8510 // Suggest replacing the logical operator with the bitwise version 8511 Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator) 8512 << (Opc == BO_LAnd ? "&" : "|") 8513 << FixItHint::CreateReplacement(SourceRange( 8514 Loc, Lexer::getLocForEndOfToken(Loc, 0, getSourceManager(), 8515 getLangOpts())), 8516 Opc == BO_LAnd ? "&" : "|"); 8517 if (Opc == BO_LAnd) 8518 // Suggest replacing "Foo() && kNonZero" with "Foo()" 8519 Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant) 8520 << FixItHint::CreateRemoval( 8521 SourceRange( 8522 Lexer::getLocForEndOfToken(LHS.get()->getLocEnd(), 8523 0, getSourceManager(), 8524 getLangOpts()), 8525 RHS.get()->getLocEnd())); 8526 } 8527 } 8528 8529 if (!Context.getLangOpts().CPlusPlus) { 8530 // OpenCL v1.1 s6.3.g: The logical operators and (&&), or (||) do 8531 // not operate on the built-in scalar and vector float types. 8532 if (Context.getLangOpts().OpenCL && 8533 Context.getLangOpts().OpenCLVersion < 120) { 8534 if (LHS.get()->getType()->isFloatingType() || 8535 RHS.get()->getType()->isFloatingType()) 8536 return InvalidOperands(Loc, LHS, RHS); 8537 } 8538 8539 LHS = UsualUnaryConversions(LHS.get()); 8540 if (LHS.isInvalid()) 8541 return QualType(); 8542 8543 RHS = UsualUnaryConversions(RHS.get()); 8544 if (RHS.isInvalid()) 8545 return QualType(); 8546 8547 if (!LHS.get()->getType()->isScalarType() || 8548 !RHS.get()->getType()->isScalarType()) 8549 return InvalidOperands(Loc, LHS, RHS); 8550 8551 return Context.IntTy; 8552 } 8553 8554 // The following is safe because we only use this method for 8555 // non-overloadable operands. 8556 8557 // C++ [expr.log.and]p1 8558 // C++ [expr.log.or]p1 8559 // The operands are both contextually converted to type bool. 8560 ExprResult LHSRes = PerformContextuallyConvertToBool(LHS.get()); 8561 if (LHSRes.isInvalid()) 8562 return InvalidOperands(Loc, LHS, RHS); 8563 LHS = LHSRes; 8564 8565 ExprResult RHSRes = PerformContextuallyConvertToBool(RHS.get()); 8566 if (RHSRes.isInvalid()) 8567 return InvalidOperands(Loc, LHS, RHS); 8568 RHS = RHSRes; 8569 8570 // C++ [expr.log.and]p2 8571 // C++ [expr.log.or]p2 8572 // The result is a bool. 8573 return Context.BoolTy; 8574} 8575 8576static bool IsReadonlyMessage(Expr *E, Sema &S) { 8577 const MemberExpr *ME = dyn_cast<MemberExpr>(E); 8578 if (!ME) return false; 8579 if (!isa<FieldDecl>(ME->getMemberDecl())) return false; 8580 ObjCMessageExpr *Base = 8581 dyn_cast<ObjCMessageExpr>(ME->getBase()->IgnoreParenImpCasts()); 8582 if (!Base) return false; 8583 return Base->getMethodDecl() != nullptr; 8584} 8585 8586/// Is the given expression (which must be 'const') a reference to a 8587/// variable which was originally non-const, but which has become 8588/// 'const' due to being captured within a block? 8589enum NonConstCaptureKind { NCCK_None, NCCK_Block, NCCK_Lambda }; 8590static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) { 8591 assert(E->isLValue() && E->getType().isConstQualified()); 8592 E = E->IgnoreParens(); 8593 8594 // Must be a reference to a declaration from an enclosing scope. 8595 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 8596 if (!DRE) return NCCK_None; 8597 if (!DRE->refersToEnclosingVariableOrCapture()) return NCCK_None; 8598 8599 // The declaration must be a variable which is not declared 'const'. 8600 VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl()); 8601 if (!var) return NCCK_None; 8602 if (var->getType().isConstQualified()) return NCCK_None; 8603 assert(var->hasLocalStorage() && "capture added 'const' to non-local?"); 8604 8605 // Decide whether the first capture was for a block or a lambda. 8606 DeclContext *DC = S.CurContext, *Prev = nullptr; 8607 while (DC != var->getDeclContext()) { 8608 Prev = DC; 8609 DC = DC->getParent(); 8610 } 8611 // Unless we have an init-capture, we've gone one step too far. 8612 if (!var->isInitCapture()) 8613 DC = Prev; 8614 return (isa<BlockDecl>(DC) ? NCCK_Block : NCCK_Lambda); 8615} 8616 8617/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not, 8618/// emit an error and return true. If so, return false. 8619static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) { 8620 assert(!E->hasPlaceholderType(BuiltinType::PseudoObject)); 8621 SourceLocation OrigLoc = Loc; 8622 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context, 8623 &Loc); 8624 if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S)) 8625 IsLV = Expr::MLV_InvalidMessageExpression; 8626 if (IsLV == Expr::MLV_Valid) 8627 return false; 8628 8629 unsigned DiagID = 0; 8630 bool NeedType = false; 8631 switch (IsLV) { // C99 6.5.16p2 8632 case Expr::MLV_ConstQualified: 8633 DiagID = diag::err_typecheck_assign_const; 8634 8635 // Use a specialized diagnostic when we're assigning to an object 8636 // from an enclosing function or block. 8637 if (NonConstCaptureKind NCCK = isReferenceToNonConstCapture(S, E)) { 8638 if (NCCK == NCCK_Block) 8639 DiagID = diag::err_block_decl_ref_not_modifiable_lvalue; 8640 else 8641 DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue; 8642 break; 8643 } 8644 8645 // In ARC, use some specialized diagnostics for occasions where we 8646 // infer 'const'. These are always pseudo-strong variables. 8647 if (S.getLangOpts().ObjCAutoRefCount) { 8648 DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()); 8649 if (declRef && isa<VarDecl>(declRef->getDecl())) { 8650 VarDecl *var = cast<VarDecl>(declRef->getDecl()); 8651 8652 // Use the normal diagnostic if it's pseudo-__strong but the 8653 // user actually wrote 'const'. 8654 if (var->isARCPseudoStrong() && 8655 (!var->getTypeSourceInfo() || 8656 !var->getTypeSourceInfo()->getType().isConstQualified())) { 8657 // There are two pseudo-strong cases: 8658 // - self 8659 ObjCMethodDecl *method = S.getCurMethodDecl(); 8660 if (method && var == method->getSelfDecl()) 8661 DiagID = method->isClassMethod() 8662 ? diag::err_typecheck_arc_assign_self_class_method 8663 : diag::err_typecheck_arc_assign_self; 8664 8665 // - fast enumeration variables 8666 else 8667 DiagID = diag::err_typecheck_arr_assign_enumeration; 8668 8669 SourceRange Assign; 8670 if (Loc != OrigLoc) 8671 Assign = SourceRange(OrigLoc, OrigLoc); 8672 S.Diag(Loc, DiagID) << E->getSourceRange() << Assign; 8673 // We need to preserve the AST regardless, so migration tool 8674 // can do its job. 8675 return false; 8676 } 8677 } 8678 } 8679 8680 break; 8681 case Expr::MLV_ArrayType: 8682 case Expr::MLV_ArrayTemporary: 8683 DiagID = diag::err_typecheck_array_not_modifiable_lvalue; 8684 NeedType = true; 8685 break; 8686 case Expr::MLV_NotObjectType: 8687 DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue; 8688 NeedType = true; 8689 break; 8690 case Expr::MLV_LValueCast: 8691 DiagID = diag::err_typecheck_lvalue_casts_not_supported; 8692 break; 8693 case Expr::MLV_Valid: 8694 llvm_unreachable("did not take early return for MLV_Valid"); 8695 case Expr::MLV_InvalidExpression: 8696 case Expr::MLV_MemberFunction: 8697 case Expr::MLV_ClassTemporary: 8698 DiagID = diag::err_typecheck_expression_not_modifiable_lvalue; 8699 break; 8700 case Expr::MLV_IncompleteType: 8701 case Expr::MLV_IncompleteVoidType: 8702 return S.RequireCompleteType(Loc, E->getType(), 8703 diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E); 8704 case Expr::MLV_DuplicateVectorComponents: 8705 DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue; 8706 break; 8707 case Expr::MLV_NoSetterProperty: 8708 llvm_unreachable("readonly properties should be processed differently"); 8709 case Expr::MLV_InvalidMessageExpression: 8710 DiagID = diag::error_readonly_message_assignment; 8711 break; 8712 case Expr::MLV_SubObjCPropertySetting: 8713 DiagID = diag::error_no_subobject_property_setting; 8714 break; 8715 } 8716 8717 SourceRange Assign; 8718 if (Loc != OrigLoc) 8719 Assign = SourceRange(OrigLoc, OrigLoc); 8720 if (NeedType) 8721 S.Diag(Loc, DiagID) << E->getType() << E->getSourceRange() << Assign; 8722 else 8723 S.Diag(Loc, DiagID) << E->getSourceRange() << Assign; 8724 return true; 8725} 8726 8727static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr, 8728 SourceLocation Loc, 8729 Sema &Sema) { 8730 // C / C++ fields 8731 MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr); 8732 MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr); 8733 if (ML && MR && ML->getMemberDecl() == MR->getMemberDecl()) { 8734 if (isa<CXXThisExpr>(ML->getBase()) && isa<CXXThisExpr>(MR->getBase())) 8735 Sema.Diag(Loc, diag::warn_identity_field_assign) << 0; 8736 } 8737 8738 // Objective-C instance variables 8739 ObjCIvarRefExpr *OL = dyn_cast<ObjCIvarRefExpr>(LHSExpr); 8740 ObjCIvarRefExpr *OR = dyn_cast<ObjCIvarRefExpr>(RHSExpr); 8741 if (OL && OR && OL->getDecl() == OR->getDecl()) { 8742 DeclRefExpr *RL = dyn_cast<DeclRefExpr>(OL->getBase()->IgnoreImpCasts()); 8743 DeclRefExpr *RR = dyn_cast<DeclRefExpr>(OR->getBase()->IgnoreImpCasts()); 8744 if (RL && RR && RL->getDecl() == RR->getDecl()) 8745 Sema.Diag(Loc, diag::warn_identity_field_assign) << 1; 8746 } 8747} 8748 8749// C99 6.5.16.1 8750QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, 8751 SourceLocation Loc, 8752 QualType CompoundType) { 8753 assert(!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject)); 8754 8755 // Verify that LHS is a modifiable lvalue, and emit error if not. 8756 if (CheckForModifiableLvalue(LHSExpr, Loc, *this)) 8757 return QualType(); 8758 8759 QualType LHSType = LHSExpr->getType(); 8760 QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() : 8761 CompoundType; 8762 AssignConvertType ConvTy; 8763 if (CompoundType.isNull()) { 8764 Expr *RHSCheck = RHS.get(); 8765 8766 CheckIdentityFieldAssignment(LHSExpr, RHSCheck, Loc, *this); 8767 8768 QualType LHSTy(LHSType); 8769 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS); 8770 if (RHS.isInvalid()) 8771 return QualType(); 8772 // Special case of NSObject attributes on c-style pointer types. 8773 if (ConvTy == IncompatiblePointer && 8774 ((Context.isObjCNSObjectType(LHSType) && 8775 RHSType->isObjCObjectPointerType()) || 8776 (Context.isObjCNSObjectType(RHSType) && 8777 LHSType->isObjCObjectPointerType()))) 8778 ConvTy = Compatible; 8779 8780 if (ConvTy == Compatible && 8781 LHSType->isObjCObjectType()) 8782 Diag(Loc, diag::err_objc_object_assignment) 8783 << LHSType; 8784 8785 // If the RHS is a unary plus or minus, check to see if they = and + are 8786 // right next to each other. If so, the user may have typo'd "x =+ 4" 8787 // instead of "x += 4". 8788 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck)) 8789 RHSCheck = ICE->getSubExpr(); 8790 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) { 8791 if ((UO->getOpcode() == UO_Plus || 8792 UO->getOpcode() == UO_Minus) && 8793 Loc.isFileID() && UO->getOperatorLoc().isFileID() && 8794 // Only if the two operators are exactly adjacent. 8795 Loc.getLocWithOffset(1) == UO->getOperatorLoc() && 8796 // And there is a space or other character before the subexpr of the 8797 // unary +/-. We don't want to warn on "x=-1". 8798 Loc.getLocWithOffset(2) != UO->getSubExpr()->getLocStart() && 8799 UO->getSubExpr()->getLocStart().isFileID()) { 8800 Diag(Loc, diag::warn_not_compound_assign) 8801 << (UO->getOpcode() == UO_Plus ? "+" : "-") 8802 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc()); 8803 } 8804 } 8805 8806 if (ConvTy == Compatible) { 8807 if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong) { 8808 // Warn about retain cycles where a block captures the LHS, but 8809 // not if the LHS is a simple variable into which the block is 8810 // being stored...unless that variable can be captured by reference! 8811 const Expr *InnerLHS = LHSExpr->IgnoreParenCasts(); 8812 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS); 8813 if (!DRE || DRE->getDecl()->hasAttr<BlocksAttr>()) 8814 checkRetainCycles(LHSExpr, RHS.get()); 8815 8816 // It is safe to assign a weak reference into a strong variable. 8817 // Although this code can still have problems: 8818 // id x = self.weakProp; 8819 // id y = self.weakProp; 8820 // we do not warn to warn spuriously when 'x' and 'y' are on separate 8821 // paths through the function. This should be revisited if 8822 // -Wrepeated-use-of-weak is made flow-sensitive. 8823 if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, 8824 RHS.get()->getLocStart())) 8825 getCurFunction()->markSafeWeakUse(RHS.get()); 8826 8827 } else if (getLangOpts().ObjCAutoRefCount) { 8828 checkUnsafeExprAssigns(Loc, LHSExpr, RHS.get()); 8829 } 8830 } 8831 } else { 8832 // Compound assignment "x += y" 8833 ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType); 8834 } 8835 8836 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType, 8837 RHS.get(), AA_Assigning)) 8838 return QualType(); 8839 8840 CheckForNullPointerDereference(*this, LHSExpr); 8841 8842 // C99 6.5.16p3: The type of an assignment expression is the type of the 8843 // left operand unless the left operand has qualified type, in which case 8844 // it is the unqualified version of the type of the left operand. 8845 // C99 6.5.16.1p2: In simple assignment, the value of the right operand 8846 // is converted to the type of the assignment expression (above). 8847 // C++ 5.17p1: the type of the assignment expression is that of its left 8848 // operand. 8849 return (getLangOpts().CPlusPlus 8850 ? LHSType : LHSType.getUnqualifiedType()); 8851} 8852 8853// C99 6.5.17 8854static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, 8855 SourceLocation Loc) { 8856 LHS = S.CheckPlaceholderExpr(LHS.get()); 8857 RHS = S.CheckPlaceholderExpr(RHS.get()); 8858 if (LHS.isInvalid() || RHS.isInvalid()) 8859 return QualType(); 8860 8861 // C's comma performs lvalue conversion (C99 6.3.2.1) on both its 8862 // operands, but not unary promotions. 8863 // C++'s comma does not do any conversions at all (C++ [expr.comma]p1). 8864 8865 // So we treat the LHS as a ignored value, and in C++ we allow the 8866 // containing site to determine what should be done with the RHS. 8867 LHS = S.IgnoredValueConversions(LHS.get()); 8868 if (LHS.isInvalid()) 8869 return QualType(); 8870 8871 S.DiagnoseUnusedExprResult(LHS.get()); 8872 8873 if (!S.getLangOpts().CPlusPlus) { 8874 RHS = S.DefaultFunctionArrayLvalueConversion(RHS.get()); 8875 if (RHS.isInvalid()) 8876 return QualType(); 8877 if (!RHS.get()->getType()->isVoidType()) 8878 S.RequireCompleteType(Loc, RHS.get()->getType(), 8879 diag::err_incomplete_type); 8880 } 8881 8882 return RHS.get()->getType(); 8883} 8884 8885/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine 8886/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions. 8887static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, 8888 ExprValueKind &VK, 8889 ExprObjectKind &OK, 8890 SourceLocation OpLoc, 8891 bool IsInc, bool IsPrefix) { 8892 if (Op->isTypeDependent()) 8893 return S.Context.DependentTy; 8894 8895 QualType ResType = Op->getType(); 8896 // Atomic types can be used for increment / decrement where the non-atomic 8897 // versions can, so ignore the _Atomic() specifier for the purpose of 8898 // checking. 8899 if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>()) 8900 ResType = ResAtomicType->getValueType(); 8901 8902 assert(!ResType.isNull() && "no type for increment/decrement expression"); 8903 8904 if (S.getLangOpts().CPlusPlus && ResType->isBooleanType()) { 8905 // Decrement of bool is not allowed. 8906 if (!IsInc) { 8907 S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange(); 8908 return QualType(); 8909 } 8910 // Increment of bool sets it to true, but is deprecated. 8911 S.Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange(); 8912 } else if (S.getLangOpts().CPlusPlus && ResType->isEnumeralType()) { 8913 // Error on enum increments and decrements in C++ mode 8914 S.Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType; 8915 return QualType(); 8916 } else if (ResType->isRealType()) { 8917 // OK! 8918 } else if (ResType->isPointerType()) { 8919 // C99 6.5.2.4p2, 6.5.6p2 8920 if (!checkArithmeticOpPointerOperand(S, OpLoc, Op)) 8921 return QualType(); 8922 } else if (ResType->isObjCObjectPointerType()) { 8923 // On modern runtimes, ObjC pointer arithmetic is forbidden. 8924 // Otherwise, we just need a complete type. 8925 if (checkArithmeticIncompletePointerType(S, OpLoc, Op) || 8926 checkArithmeticOnObjCPointer(S, OpLoc, Op)) 8927 return QualType(); 8928 } else if (ResType->isAnyComplexType()) { 8929 // C99 does not support ++/-- on complex types, we allow as an extension. 8930 S.Diag(OpLoc, diag::ext_integer_increment_complex) 8931 << ResType << Op->getSourceRange(); 8932 } else if (ResType->isPlaceholderType()) { 8933 ExprResult PR = S.CheckPlaceholderExpr(Op); 8934 if (PR.isInvalid()) return QualType(); 8935 return CheckIncrementDecrementOperand(S, PR.get(), VK, OK, OpLoc, 8936 IsInc, IsPrefix); 8937 } else if (S.getLangOpts().AltiVec && ResType->isVectorType()) { 8938 // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 ) 8939 } else if(S.getLangOpts().OpenCL && ResType->isVectorType() && 8940 ResType->getAs<VectorType>()->getElementType()->isIntegerType()) { 8941 // OpenCL V1.2 6.3 says dec/inc ops operate on integer vector types. 8942 } else { 8943 S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement) 8944 << ResType << int(IsInc) << Op->getSourceRange(); 8945 return QualType(); 8946 } 8947 // At this point, we know we have a real, complex or pointer type. 8948 // Now make sure the operand is a modifiable lvalue. 8949 if (CheckForModifiableLvalue(Op, OpLoc, S)) 8950 return QualType(); 8951 // In C++, a prefix increment is the same type as the operand. Otherwise 8952 // (in C or with postfix), the increment is the unqualified type of the 8953 // operand. 8954 if (IsPrefix && S.getLangOpts().CPlusPlus) { 8955 VK = VK_LValue; 8956 OK = Op->getObjectKind(); 8957 return ResType; 8958 } else { 8959 VK = VK_RValue; 8960 return ResType.getUnqualifiedType(); 8961 } 8962} 8963 8964 8965/// getPrimaryDecl - Helper function for CheckAddressOfOperand(). 8966/// This routine allows us to typecheck complex/recursive expressions 8967/// where the declaration is needed for type checking. We only need to 8968/// handle cases when the expression references a function designator 8969/// or is an lvalue. Here are some examples: 8970/// - &(x) => x 8971/// - &*****f => f for f a function designator. 8972/// - &s.xx => s 8973/// - &s.zz[1].yy -> s, if zz is an array 8974/// - *(x + 1) -> x, if x is an array 8975/// - &"123"[2] -> 0 8976/// - & __real__ x -> x 8977static ValueDecl *getPrimaryDecl(Expr *E) { 8978 switch (E->getStmtClass()) { 8979 case Stmt::DeclRefExprClass: 8980 return cast<DeclRefExpr>(E)->getDecl(); 8981 case Stmt::MemberExprClass: 8982 // If this is an arrow operator, the address is an offset from 8983 // the base's value, so the object the base refers to is 8984 // irrelevant. 8985 if (cast<MemberExpr>(E)->isArrow()) 8986 return nullptr; 8987 // Otherwise, the expression refers to a part of the base 8988 return getPrimaryDecl(cast<MemberExpr>(E)->getBase()); 8989 case Stmt::ArraySubscriptExprClass: { 8990 // FIXME: This code shouldn't be necessary! We should catch the implicit 8991 // promotion of register arrays earlier. 8992 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase(); 8993 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) { 8994 if (ICE->getSubExpr()->getType()->isArrayType()) 8995 return getPrimaryDecl(ICE->getSubExpr()); 8996 } 8997 return nullptr; 8998 } 8999 case Stmt::UnaryOperatorClass: { 9000 UnaryOperator *UO = cast<UnaryOperator>(E); 9001 9002 switch(UO->getOpcode()) { 9003 case UO_Real: 9004 case UO_Imag: 9005 case UO_Extension: 9006 return getPrimaryDecl(UO->getSubExpr()); 9007 default: 9008 return nullptr; 9009 } 9010 } 9011 case Stmt::ParenExprClass: 9012 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr()); 9013 case Stmt::ImplicitCastExprClass: 9014 // If the result of an implicit cast is an l-value, we care about 9015 // the sub-expression; otherwise, the result here doesn't matter. 9016 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr()); 9017 default: 9018 return nullptr; 9019 } 9020} 9021 9022namespace { 9023 enum { 9024 AO_Bit_Field = 0, 9025 AO_Vector_Element = 1, 9026 AO_Property_Expansion = 2, 9027 AO_Register_Variable = 3, 9028 AO_No_Error = 4 9029 }; 9030} 9031/// \brief Diagnose invalid operand for address of operations. 9032/// 9033/// \param Type The type of operand which cannot have its address taken. 9034static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, 9035 Expr *E, unsigned Type) { 9036 S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange(); 9037} 9038 9039/// CheckAddressOfOperand - The operand of & must be either a function 9040/// designator or an lvalue designating an object. If it is an lvalue, the 9041/// object cannot be declared with storage class register or be a bit field. 9042/// Note: The usual conversions are *not* applied to the operand of the & 9043/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue. 9044/// In C++, the operand might be an overloaded function name, in which case 9045/// we allow the '&' but retain the overloaded-function type. 9046QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) { 9047 if (const BuiltinType *PTy = OrigOp.get()->getType()->getAsPlaceholderType()){ 9048 if (PTy->getKind() == BuiltinType::Overload) { 9049 Expr *E = OrigOp.get()->IgnoreParens(); 9050 if (!isa<OverloadExpr>(E)) { 9051 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf); 9052 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function) 9053 << OrigOp.get()->getSourceRange(); 9054 return QualType(); 9055 } 9056 9057 OverloadExpr *Ovl = cast<OverloadExpr>(E); 9058 if (isa<UnresolvedMemberExpr>(Ovl)) 9059 if (!ResolveSingleFunctionTemplateSpecialization(Ovl)) { 9060 Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 9061 << OrigOp.get()->getSourceRange(); 9062 return QualType(); 9063 } 9064 9065 return Context.OverloadTy; 9066 } 9067 9068 if (PTy->getKind() == BuiltinType::UnknownAny) 9069 return Context.UnknownAnyTy; 9070 9071 if (PTy->getKind() == BuiltinType::BoundMember) { 9072 Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 9073 << OrigOp.get()->getSourceRange(); 9074 return QualType(); 9075 } 9076 9077 OrigOp = CheckPlaceholderExpr(OrigOp.get()); 9078 if (OrigOp.isInvalid()) return QualType(); 9079 } 9080 9081 if (OrigOp.get()->isTypeDependent()) 9082 return Context.DependentTy; 9083 9084 assert(!OrigOp.get()->getType()->isPlaceholderType()); 9085 9086 // Make sure to ignore parentheses in subsequent checks 9087 Expr *op = OrigOp.get()->IgnoreParens(); 9088 9089 // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed. 9090 if (LangOpts.OpenCL && op->getType()->isFunctionType()) { 9091 Diag(op->getExprLoc(), diag::err_opencl_taking_function_address); 9092 return QualType(); 9093 } 9094 9095 if (getLangOpts().C99) { 9096 // Implement C99-only parts of addressof rules. 9097 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) { 9098 if (uOp->getOpcode() == UO_Deref) 9099 // Per C99 6.5.3.2, the address of a deref always returns a valid result 9100 // (assuming the deref expression is valid). 9101 return uOp->getSubExpr()->getType(); 9102 } 9103 // Technically, there should be a check for array subscript 9104 // expressions here, but the result of one is always an lvalue anyway. 9105 } 9106 ValueDecl *dcl = getPrimaryDecl(op); 9107 Expr::LValueClassification lval = op->ClassifyLValue(Context); 9108 unsigned AddressOfError = AO_No_Error; 9109 9110 if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) { 9111 bool sfinae = (bool)isSFINAEContext(); 9112 Diag(OpLoc, isSFINAEContext() ? diag::err_typecheck_addrof_temporary 9113 : diag::ext_typecheck_addrof_temporary) 9114 << op->getType() << op->getSourceRange(); 9115 if (sfinae) 9116 return QualType(); 9117 // Materialize the temporary as an lvalue so that we can take its address. 9118 OrigOp = op = new (Context) 9119 MaterializeTemporaryExpr(op->getType(), OrigOp.get(), true); 9120 } else if (isa<ObjCSelectorExpr>(op)) { 9121 return Context.getPointerType(op->getType()); 9122 } else if (lval == Expr::LV_MemberFunction) { 9123 // If it's an instance method, make a member pointer. 9124 // The expression must have exactly the form &A::foo. 9125 9126 // If the underlying expression isn't a decl ref, give up. 9127 if (!isa<DeclRefExpr>(op)) { 9128 Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 9129 << OrigOp.get()->getSourceRange(); 9130 return QualType(); 9131 } 9132 DeclRefExpr *DRE = cast<DeclRefExpr>(op); 9133 CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl()); 9134 9135 // The id-expression was parenthesized. 9136 if (OrigOp.get() != DRE) { 9137 Diag(OpLoc, diag::err_parens_pointer_member_function) 9138 << OrigOp.get()->getSourceRange(); 9139 9140 // The method was named without a qualifier. 9141 } else if (!DRE->getQualifier()) { 9142 if (MD->getParent()->getName().empty()) 9143 Diag(OpLoc, diag::err_unqualified_pointer_member_function) 9144 << op->getSourceRange(); 9145 else { 9146 SmallString<32> Str; 9147 StringRef Qual = (MD->getParent()->getName() + "::").toStringRef(Str); 9148 Diag(OpLoc, diag::err_unqualified_pointer_member_function) 9149 << op->getSourceRange() 9150 << FixItHint::CreateInsertion(op->getSourceRange().getBegin(), Qual); 9151 } 9152 } 9153 9154 // Taking the address of a dtor is illegal per C++ [class.dtor]p2. 9155 if (isa<CXXDestructorDecl>(MD)) 9156 Diag(OpLoc, diag::err_typecheck_addrof_dtor) << op->getSourceRange(); 9157 9158 QualType MPTy = Context.getMemberPointerType( 9159 op->getType(), Context.getTypeDeclType(MD->getParent()).getTypePtr()); 9160 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) 9161 RequireCompleteType(OpLoc, MPTy, 0); 9162 return MPTy; 9163 } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) { 9164 // C99 6.5.3.2p1 9165 // The operand must be either an l-value or a function designator 9166 if (!op->getType()->isFunctionType()) { 9167 // Use a special diagnostic for loads from property references. 9168 if (isa<PseudoObjectExpr>(op)) { 9169 AddressOfError = AO_Property_Expansion; 9170 } else { 9171 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof) 9172 << op->getType() << op->getSourceRange(); 9173 return QualType(); 9174 } 9175 } 9176 } else if (op->getObjectKind() == OK_BitField) { // C99 6.5.3.2p1 9177 // The operand cannot be a bit-field 9178 AddressOfError = AO_Bit_Field; 9179 } else if (op->getObjectKind() == OK_VectorComponent) { 9180 // The operand cannot be an element of a vector 9181 AddressOfError = AO_Vector_Element; 9182 } else if (dcl) { // C99 6.5.3.2p1 9183 // We have an lvalue with a decl. Make sure the decl is not declared 9184 // with the register storage-class specifier. 9185 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) { 9186 // in C++ it is not error to take address of a register 9187 // variable (c++03 7.1.1P3) 9188 if (vd->getStorageClass() == SC_Register && 9189 !getLangOpts().CPlusPlus) { 9190 AddressOfError = AO_Register_Variable; 9191 } 9192 } else if (isa<FunctionTemplateDecl>(dcl)) { 9193 return Context.OverloadTy; 9194 } else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) { 9195 // Okay: we can take the address of a field. 9196 // Could be a pointer to member, though, if there is an explicit 9197 // scope qualifier for the class. 9198 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) { 9199 DeclContext *Ctx = dcl->getDeclContext(); 9200 if (Ctx && Ctx->isRecord()) { 9201 if (dcl->getType()->isReferenceType()) { 9202 Diag(OpLoc, 9203 diag::err_cannot_form_pointer_to_member_of_reference_type) 9204 << dcl->getDeclName() << dcl->getType(); 9205 return QualType(); 9206 } 9207 9208 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion()) 9209 Ctx = Ctx->getParent(); 9210 9211 QualType MPTy = Context.getMemberPointerType( 9212 op->getType(), 9213 Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr()); 9214 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) 9215 RequireCompleteType(OpLoc, MPTy, 0); 9216 return MPTy; 9217 } 9218 } 9219 } else if (!isa<FunctionDecl>(dcl) && !isa<NonTypeTemplateParmDecl>(dcl)) 9220 llvm_unreachable("Unknown/unexpected decl type"); 9221 } 9222 9223 if (AddressOfError != AO_No_Error) { 9224 diagnoseAddressOfInvalidType(*this, OpLoc, op, AddressOfError); 9225 return QualType(); 9226 } 9227 9228 if (lval == Expr::LV_IncompleteVoidType) { 9229 // Taking the address of a void variable is technically illegal, but we 9230 // allow it in cases which are otherwise valid. 9231 // Example: "extern void x; void* y = &x;". 9232 Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange(); 9233 } 9234 9235 // If the operand has type "type", the result has type "pointer to type". 9236 if (op->getType()->isObjCObjectType()) 9237 return Context.getObjCObjectPointerType(op->getType()); 9238 return Context.getPointerType(op->getType()); 9239} 9240 9241static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp) { 9242 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp); 9243 if (!DRE) 9244 return; 9245 const Decl *D = DRE->getDecl(); 9246 if (!D) 9247 return; 9248 const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D); 9249 if (!Param) 9250 return; 9251 if (const FunctionDecl* FD = dyn_cast<FunctionDecl>(Param->getDeclContext())) 9252 if (!FD->hasAttr<NonNullAttr>() && !Param->hasAttr<NonNullAttr>()) 9253 return; 9254 if (FunctionScopeInfo *FD = S.getCurFunction()) 9255 if (!FD->ModifiedNonNullParams.count(Param)) 9256 FD->ModifiedNonNullParams.insert(Param); 9257} 9258 9259/// CheckIndirectionOperand - Type check unary indirection (prefix '*'). 9260static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK, 9261 SourceLocation OpLoc) { 9262 if (Op->isTypeDependent()) 9263 return S.Context.DependentTy; 9264 9265 ExprResult ConvResult = S.UsualUnaryConversions(Op); 9266 if (ConvResult.isInvalid()) 9267 return QualType(); 9268 Op = ConvResult.get(); 9269 QualType OpTy = Op->getType(); 9270 QualType Result; 9271 9272 if (isa<CXXReinterpretCastExpr>(Op)) { 9273 QualType OpOrigType = Op->IgnoreParenCasts()->getType(); 9274 S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true, 9275 Op->getSourceRange()); 9276 } 9277 9278 if (const PointerType *PT = OpTy->getAs<PointerType>()) 9279 Result = PT->getPointeeType(); 9280 else if (const ObjCObjectPointerType *OPT = 9281 OpTy->getAs<ObjCObjectPointerType>()) 9282 Result = OPT->getPointeeType(); 9283 else { 9284 ExprResult PR = S.CheckPlaceholderExpr(Op); 9285 if (PR.isInvalid()) return QualType(); 9286 if (PR.get() != Op) 9287 return CheckIndirectionOperand(S, PR.get(), VK, OpLoc); 9288 } 9289 9290 if (Result.isNull()) { 9291 S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer) 9292 << OpTy << Op->getSourceRange(); 9293 return QualType(); 9294 } 9295 9296 // Note that per both C89 and C99, indirection is always legal, even if Result 9297 // is an incomplete type or void. It would be possible to warn about 9298 // dereferencing a void pointer, but it's completely well-defined, and such a 9299 // warning is unlikely to catch any mistakes. In C++, indirection is not valid 9300 // for pointers to 'void' but is fine for any other pointer type: 9301 // 9302 // C++ [expr.unary.op]p1: 9303 // [...] the expression to which [the unary * operator] is applied shall 9304 // be a pointer to an object type, or a pointer to a function type 9305 if (S.getLangOpts().CPlusPlus && Result->isVoidType()) 9306 S.Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer) 9307 << OpTy << Op->getSourceRange(); 9308 9309 // Dereferences are usually l-values... 9310 VK = VK_LValue; 9311 9312 // ...except that certain expressions are never l-values in C. 9313 if (!S.getLangOpts().CPlusPlus && Result.isCForbiddenLValueType()) 9314 VK = VK_RValue; 9315 9316 return Result; 9317} 9318 9319BinaryOperatorKind Sema::ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind) { 9320 BinaryOperatorKind Opc; 9321 switch (Kind) { 9322 default: llvm_unreachable("Unknown binop!"); 9323 case tok::periodstar: Opc = BO_PtrMemD; break; 9324 case tok::arrowstar: Opc = BO_PtrMemI; break; 9325 case tok::star: Opc = BO_Mul; break; 9326 case tok::slash: Opc = BO_Div; break; 9327 case tok::percent: Opc = BO_Rem; break; 9328 case tok::plus: Opc = BO_Add; break; 9329 case tok::minus: Opc = BO_Sub; break; 9330 case tok::lessless: Opc = BO_Shl; break; 9331 case tok::greatergreater: Opc = BO_Shr; break; 9332 case tok::lessequal: Opc = BO_LE; break; 9333 case tok::less: Opc = BO_LT; break; 9334 case tok::greaterequal: Opc = BO_GE; break; 9335 case tok::greater: Opc = BO_GT; break; 9336 case tok::exclaimequal: Opc = BO_NE; break; 9337 case tok::equalequal: Opc = BO_EQ; break; 9338 case tok::amp: Opc = BO_And; break; 9339 case tok::caret: Opc = BO_Xor; break; 9340 case tok::pipe: Opc = BO_Or; break; 9341 case tok::ampamp: Opc = BO_LAnd; break; 9342 case tok::pipepipe: Opc = BO_LOr; break; 9343 case tok::equal: Opc = BO_Assign; break; 9344 case tok::starequal: Opc = BO_MulAssign; break; 9345 case tok::slashequal: Opc = BO_DivAssign; break; 9346 case tok::percentequal: Opc = BO_RemAssign; break; 9347 case tok::plusequal: Opc = BO_AddAssign; break; 9348 case tok::minusequal: Opc = BO_SubAssign; break; 9349 case tok::lesslessequal: Opc = BO_ShlAssign; break; 9350 case tok::greatergreaterequal: Opc = BO_ShrAssign; break; 9351 case tok::ampequal: Opc = BO_AndAssign; break; 9352 case tok::caretequal: Opc = BO_XorAssign; break; 9353 case tok::pipeequal: Opc = BO_OrAssign; break; 9354 case tok::comma: Opc = BO_Comma; break; 9355 } 9356 return Opc; 9357} 9358 9359static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode( 9360 tok::TokenKind Kind) { 9361 UnaryOperatorKind Opc; 9362 switch (Kind) { 9363 default: llvm_unreachable("Unknown unary op!"); 9364 case tok::plusplus: Opc = UO_PreInc; break; 9365 case tok::minusminus: Opc = UO_PreDec; break; 9366 case tok::amp: Opc = UO_AddrOf; break; 9367 case tok::star: Opc = UO_Deref; break; 9368 case tok::plus: Opc = UO_Plus; break; 9369 case tok::minus: Opc = UO_Minus; break; 9370 case tok::tilde: Opc = UO_Not; break; 9371 case tok::exclaim: Opc = UO_LNot; break; 9372 case tok::kw___real: Opc = UO_Real; break; 9373 case tok::kw___imag: Opc = UO_Imag; break; 9374 case tok::kw___extension__: Opc = UO_Extension; break; 9375 } 9376 return Opc; 9377} 9378 9379/// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself. 9380/// This warning is only emitted for builtin assignment operations. It is also 9381/// suppressed in the event of macro expansions. 9382static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr, 9383 SourceLocation OpLoc) { 9384 if (!S.ActiveTemplateInstantiations.empty()) 9385 return; 9386 if (OpLoc.isInvalid() || OpLoc.isMacroID()) 9387 return; 9388 LHSExpr = LHSExpr->IgnoreParenImpCasts(); 9389 RHSExpr = RHSExpr->IgnoreParenImpCasts(); 9390 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr); 9391 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr); 9392 if (!LHSDeclRef || !RHSDeclRef || 9393 LHSDeclRef->getLocation().isMacroID() || 9394 RHSDeclRef->getLocation().isMacroID()) 9395 return; 9396 const ValueDecl *LHSDecl = 9397 cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl()); 9398 const ValueDecl *RHSDecl = 9399 cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl()); 9400 if (LHSDecl != RHSDecl) 9401 return; 9402 if (LHSDecl->getType().isVolatileQualified()) 9403 return; 9404 if (const ReferenceType *RefTy = LHSDecl->getType()->getAs<ReferenceType>()) 9405 if (RefTy->getPointeeType().isVolatileQualified()) 9406 return; 9407 9408 S.Diag(OpLoc, diag::warn_self_assignment) 9409 << LHSDeclRef->getType() 9410 << LHSExpr->getSourceRange() << RHSExpr->getSourceRange(); 9411} 9412 9413/// Check if a bitwise-& is performed on an Objective-C pointer. This 9414/// is usually indicative of introspection within the Objective-C pointer. 9415static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R, 9416 SourceLocation OpLoc) { 9417 if (!S.getLangOpts().ObjC1) 9418 return; 9419 9420 const Expr *ObjCPointerExpr = nullptr, *OtherExpr = nullptr; 9421 const Expr *LHS = L.get(); 9422 const Expr *RHS = R.get(); 9423 9424 if (LHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) { 9425 ObjCPointerExpr = LHS; 9426 OtherExpr = RHS; 9427 } 9428 else if (RHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) { 9429 ObjCPointerExpr = RHS; 9430 OtherExpr = LHS; 9431 } 9432 9433 // This warning is deliberately made very specific to reduce false 9434 // positives with logic that uses '&' for hashing. This logic mainly 9435 // looks for code trying to introspect into tagged pointers, which 9436 // code should generally never do. 9437 if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) { 9438 unsigned Diag = diag::warn_objc_pointer_masking; 9439 // Determine if we are introspecting the result of performSelectorXXX. 9440 const Expr *Ex = ObjCPointerExpr->IgnoreParenCasts(); 9441 // Special case messages to -performSelector and friends, which 9442 // can return non-pointer values boxed in a pointer value. 9443 // Some clients may wish to silence warnings in this subcase. 9444 if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(Ex)) { 9445 Selector S = ME->getSelector(); 9446 StringRef SelArg0 = S.getNameForSlot(0); 9447 if (SelArg0.startswith("performSelector")) 9448 Diag = diag::warn_objc_pointer_masking_performSelector; 9449 } 9450 9451 S.Diag(OpLoc, Diag) 9452 << ObjCPointerExpr->getSourceRange(); 9453 } 9454} 9455 9456static NamedDecl *getDeclFromExpr(Expr *E) { 9457 if (!E) 9458 return nullptr; 9459 if (auto *DRE = dyn_cast<DeclRefExpr>(E)) 9460 return DRE->getDecl(); 9461 if (auto *ME = dyn_cast<MemberExpr>(E)) 9462 return ME->getMemberDecl(); 9463 if (auto *IRE = dyn_cast<ObjCIvarRefExpr>(E)) 9464 return IRE->getDecl(); 9465 return nullptr; 9466} 9467 9468/// CreateBuiltinBinOp - Creates a new built-in binary operation with 9469/// operator @p Opc at location @c TokLoc. This routine only supports 9470/// built-in operations; ActOnBinOp handles overloaded operators. 9471ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc, 9472 BinaryOperatorKind Opc, 9473 Expr *LHSExpr, Expr *RHSExpr) { 9474 if (getLangOpts().CPlusPlus11 && isa<InitListExpr>(RHSExpr)) { 9475 // The syntax only allows initializer lists on the RHS of assignment, 9476 // so we don't need to worry about accepting invalid code for 9477 // non-assignment operators. 9478 // C++11 5.17p9: 9479 // The meaning of x = {v} [...] is that of x = T(v) [...]. The meaning 9480 // of x = {} is x = T(). 9481 InitializationKind Kind = 9482 InitializationKind::CreateDirectList(RHSExpr->getLocStart()); 9483 InitializedEntity Entity = 9484 InitializedEntity::InitializeTemporary(LHSExpr->getType()); 9485 InitializationSequence InitSeq(*this, Entity, Kind, RHSExpr); 9486 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, RHSExpr); 9487 if (Init.isInvalid()) 9488 return Init; 9489 RHSExpr = Init.get(); 9490 } 9491 9492 ExprResult LHS = LHSExpr, RHS = RHSExpr; 9493 QualType ResultTy; // Result type of the binary operator. 9494 // The following two variables are used for compound assignment operators 9495 QualType CompLHSTy; // Type of LHS after promotions for computation 9496 QualType CompResultTy; // Type of computation result 9497 ExprValueKind VK = VK_RValue; 9498 ExprObjectKind OK = OK_Ordinary; 9499 9500 if (!getLangOpts().CPlusPlus) { 9501 // C cannot handle TypoExpr nodes on either side of a binop because it 9502 // doesn't handle dependent types properly, so make sure any TypoExprs have 9503 // been dealt with before checking the operands. 9504 LHS = CorrectDelayedTyposInExpr(LHSExpr); 9505 RHS = CorrectDelayedTyposInExpr(RHSExpr, [Opc, LHS](Expr *E) { 9506 if (Opc != BO_Assign) 9507 return ExprResult(E); 9508 // Avoid correcting the RHS to the same Expr as the LHS. 9509 Decl *D = getDeclFromExpr(E); 9510 return (D && D == getDeclFromExpr(LHS.get())) ? ExprError() : E; 9511 }); 9512 if (!LHS.isUsable() || !RHS.isUsable()) 9513 return ExprError(); 9514 } 9515 9516 switch (Opc) { 9517 case BO_Assign: 9518 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, QualType()); 9519 if (getLangOpts().CPlusPlus && 9520 LHS.get()->getObjectKind() != OK_ObjCProperty) { 9521 VK = LHS.get()->getValueKind(); 9522 OK = LHS.get()->getObjectKind(); 9523 } 9524 if (!ResultTy.isNull()) { 9525 DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc); 9526 DiagnoseSelfMove(LHS.get(), RHS.get(), OpLoc); 9527 } 9528 RecordModifiableNonNullParam(*this, LHS.get()); 9529 break; 9530 case BO_PtrMemD: 9531 case BO_PtrMemI: 9532 ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc, 9533 Opc == BO_PtrMemI); 9534 break; 9535 case BO_Mul: 9536 case BO_Div: 9537 ResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, false, 9538 Opc == BO_Div); 9539 break; 9540 case BO_Rem: 9541 ResultTy = CheckRemainderOperands(LHS, RHS, OpLoc); 9542 break; 9543 case BO_Add: 9544 ResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc); 9545 break; 9546 case BO_Sub: 9547 ResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc); 9548 break; 9549 case BO_Shl: 9550 case BO_Shr: 9551 ResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc); 9552 break; 9553 case BO_LE: 9554 case BO_LT: 9555 case BO_GE: 9556 case BO_GT: 9557 ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, true); 9558 break; 9559 case BO_EQ: 9560 case BO_NE: 9561 ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, false); 9562 break; 9563 case BO_And: 9564 checkObjCPointerIntrospection(*this, LHS, RHS, OpLoc); 9565 case BO_Xor: 9566 case BO_Or: 9567 ResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc); 9568 break; 9569 case BO_LAnd: 9570 case BO_LOr: 9571 ResultTy = CheckLogicalOperands(LHS, RHS, OpLoc, Opc); 9572 break; 9573 case BO_MulAssign: 9574 case BO_DivAssign: 9575 CompResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, true, 9576 Opc == BO_DivAssign); 9577 CompLHSTy = CompResultTy; 9578 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9579 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9580 break; 9581 case BO_RemAssign: 9582 CompResultTy = CheckRemainderOperands(LHS, RHS, OpLoc, true); 9583 CompLHSTy = CompResultTy; 9584 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9585 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9586 break; 9587 case BO_AddAssign: 9588 CompResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc, &CompLHSTy); 9589 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9590 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9591 break; 9592 case BO_SubAssign: 9593 CompResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc, &CompLHSTy); 9594 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9595 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9596 break; 9597 case BO_ShlAssign: 9598 case BO_ShrAssign: 9599 CompResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc, true); 9600 CompLHSTy = CompResultTy; 9601 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9602 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9603 break; 9604 case BO_AndAssign: 9605 case BO_OrAssign: // fallthrough 9606 DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc); 9607 case BO_XorAssign: 9608 CompResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, true); 9609 CompLHSTy = CompResultTy; 9610 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9611 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9612 break; 9613 case BO_Comma: 9614 ResultTy = CheckCommaOperands(*this, LHS, RHS, OpLoc); 9615 if (getLangOpts().CPlusPlus && !RHS.isInvalid()) { 9616 VK = RHS.get()->getValueKind(); 9617 OK = RHS.get()->getObjectKind(); 9618 } 9619 break; 9620 } 9621 if (ResultTy.isNull() || LHS.isInvalid() || RHS.isInvalid()) 9622 return ExprError(); 9623 9624 // Check for array bounds violations for both sides of the BinaryOperator 9625 CheckArrayAccess(LHS.get()); 9626 CheckArrayAccess(RHS.get()); 9627 9628 if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) { 9629 NamedDecl *ObjectSetClass = LookupSingleName(TUScope, 9630 &Context.Idents.get("object_setClass"), 9631 SourceLocation(), LookupOrdinaryName); 9632 if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.get())) { 9633 SourceLocation RHSLocEnd = PP.getLocForEndOfToken(RHS.get()->getLocEnd()); 9634 Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign) << 9635 FixItHint::CreateInsertion(LHS.get()->getLocStart(), "object_setClass(") << 9636 FixItHint::CreateReplacement(SourceRange(OISA->getOpLoc(), OpLoc), ",") << 9637 FixItHint::CreateInsertion(RHSLocEnd, ")"); 9638 } 9639 else 9640 Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign); 9641 } 9642 else if (const ObjCIvarRefExpr *OIRE = 9643 dyn_cast<ObjCIvarRefExpr>(LHS.get()->IgnoreParenCasts())) 9644 DiagnoseDirectIsaAccess(*this, OIRE, OpLoc, RHS.get()); 9645 9646 if (CompResultTy.isNull()) 9647 return new (Context) BinaryOperator(LHS.get(), RHS.get(), Opc, ResultTy, VK, 9648 OK, OpLoc, FPFeatures.fp_contract); 9649 if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() != 9650 OK_ObjCProperty) { 9651 VK = VK_LValue; 9652 OK = LHS.get()->getObjectKind(); 9653 } 9654 return new (Context) CompoundAssignOperator( 9655 LHS.get(), RHS.get(), Opc, ResultTy, VK, OK, CompLHSTy, CompResultTy, 9656 OpLoc, FPFeatures.fp_contract); 9657} 9658 9659/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison 9660/// operators are mixed in a way that suggests that the programmer forgot that 9661/// comparison operators have higher precedence. The most typical example of 9662/// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1". 9663static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, 9664 SourceLocation OpLoc, Expr *LHSExpr, 9665 Expr *RHSExpr) { 9666 BinaryOperator *LHSBO = dyn_cast<BinaryOperator>(LHSExpr); 9667 BinaryOperator *RHSBO = dyn_cast<BinaryOperator>(RHSExpr); 9668 9669 // Check that one of the sides is a comparison operator. 9670 bool isLeftComp = LHSBO && LHSBO->isComparisonOp(); 9671 bool isRightComp = RHSBO && RHSBO->isComparisonOp(); 9672 if (!isLeftComp && !isRightComp) 9673 return; 9674 9675 // Bitwise operations are sometimes used as eager logical ops. 9676 // Don't diagnose this. 9677 bool isLeftBitwise = LHSBO && LHSBO->isBitwiseOp(); 9678 bool isRightBitwise = RHSBO && RHSBO->isBitwiseOp(); 9679 if ((isLeftComp || isLeftBitwise) && (isRightComp || isRightBitwise)) 9680 return; 9681 9682 SourceRange DiagRange = isLeftComp ? SourceRange(LHSExpr->getLocStart(), 9683 OpLoc) 9684 : SourceRange(OpLoc, RHSExpr->getLocEnd()); 9685 StringRef OpStr = isLeftComp ? LHSBO->getOpcodeStr() : RHSBO->getOpcodeStr(); 9686 SourceRange ParensRange = isLeftComp ? 9687 SourceRange(LHSBO->getRHS()->getLocStart(), RHSExpr->getLocEnd()) 9688 : SourceRange(LHSExpr->getLocStart(), RHSBO->getLHS()->getLocEnd()); 9689 9690 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel) 9691 << DiagRange << BinaryOperator::getOpcodeStr(Opc) << OpStr; 9692 SuggestParentheses(Self, OpLoc, 9693 Self.PDiag(diag::note_precedence_silence) << OpStr, 9694 (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange()); 9695 SuggestParentheses(Self, OpLoc, 9696 Self.PDiag(diag::note_precedence_bitwise_first) 9697 << BinaryOperator::getOpcodeStr(Opc), 9698 ParensRange); 9699} 9700 9701/// \brief It accepts a '&' expr that is inside a '|' one. 9702/// Emit a diagnostic together with a fixit hint that wraps the '&' expression 9703/// in parentheses. 9704static void 9705EmitDiagnosticForBitwiseAndInBitwiseOr(Sema &Self, SourceLocation OpLoc, 9706 BinaryOperator *Bop) { 9707 assert(Bop->getOpcode() == BO_And); 9708 Self.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_and_in_bitwise_or) 9709 << Bop->getSourceRange() << OpLoc; 9710 SuggestParentheses(Self, Bop->getOperatorLoc(), 9711 Self.PDiag(diag::note_precedence_silence) 9712 << Bop->getOpcodeStr(), 9713 Bop->getSourceRange()); 9714} 9715 9716/// \brief It accepts a '&&' expr that is inside a '||' one. 9717/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression 9718/// in parentheses. 9719static void 9720EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, 9721 BinaryOperator *Bop) { 9722 assert(Bop->getOpcode() == BO_LAnd); 9723 Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or) 9724 << Bop->getSourceRange() << OpLoc; 9725 SuggestParentheses(Self, Bop->getOperatorLoc(), 9726 Self.PDiag(diag::note_precedence_silence) 9727 << Bop->getOpcodeStr(), 9728 Bop->getSourceRange()); 9729} 9730 9731/// \brief Returns true if the given expression can be evaluated as a constant 9732/// 'true'. 9733static bool EvaluatesAsTrue(Sema &S, Expr *E) { 9734 bool Res; 9735 return !E->isValueDependent() && 9736 E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res; 9737} 9738 9739/// \brief Returns true if the given expression can be evaluated as a constant 9740/// 'false'. 9741static bool EvaluatesAsFalse(Sema &S, Expr *E) { 9742 bool Res; 9743 return !E->isValueDependent() && 9744 E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res; 9745} 9746 9747/// \brief Look for '&&' in the left hand of a '||' expr. 9748static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, 9749 Expr *LHSExpr, Expr *RHSExpr) { 9750 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(LHSExpr)) { 9751 if (Bop->getOpcode() == BO_LAnd) { 9752 // If it's "a && b || 0" don't warn since the precedence doesn't matter. 9753 if (EvaluatesAsFalse(S, RHSExpr)) 9754 return; 9755 // If it's "1 && a || b" don't warn since the precedence doesn't matter. 9756 if (!EvaluatesAsTrue(S, Bop->getLHS())) 9757 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 9758 } else if (Bop->getOpcode() == BO_LOr) { 9759 if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) { 9760 // If it's "a || b && 1 || c" we didn't warn earlier for 9761 // "a || b && 1", but warn now. 9762 if (RBop->getOpcode() == BO_LAnd && EvaluatesAsTrue(S, RBop->getRHS())) 9763 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop); 9764 } 9765 } 9766 } 9767} 9768 9769/// \brief Look for '&&' in the right hand of a '||' expr. 9770static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, 9771 Expr *LHSExpr, Expr *RHSExpr) { 9772 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(RHSExpr)) { 9773 if (Bop->getOpcode() == BO_LAnd) { 9774 // If it's "0 || a && b" don't warn since the precedence doesn't matter. 9775 if (EvaluatesAsFalse(S, LHSExpr)) 9776 return; 9777 // If it's "a || b && 1" don't warn since the precedence doesn't matter. 9778 if (!EvaluatesAsTrue(S, Bop->getRHS())) 9779 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 9780 } 9781 } 9782} 9783 9784/// \brief Look for '&' in the left or right hand of a '|' expr. 9785static void DiagnoseBitwiseAndInBitwiseOr(Sema &S, SourceLocation OpLoc, 9786 Expr *OrArg) { 9787 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrArg)) { 9788 if (Bop->getOpcode() == BO_And) 9789 return EmitDiagnosticForBitwiseAndInBitwiseOr(S, OpLoc, Bop); 9790 } 9791} 9792 9793static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc, 9794 Expr *SubExpr, StringRef Shift) { 9795 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) { 9796 if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) { 9797 StringRef Op = Bop->getOpcodeStr(); 9798 S.Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift) 9799 << Bop->getSourceRange() << OpLoc << Shift << Op; 9800 SuggestParentheses(S, Bop->getOperatorLoc(), 9801 S.PDiag(diag::note_precedence_silence) << Op, 9802 Bop->getSourceRange()); 9803 } 9804 } 9805} 9806 9807static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, 9808 Expr *LHSExpr, Expr *RHSExpr) { 9809 CXXOperatorCallExpr *OCE = dyn_cast<CXXOperatorCallExpr>(LHSExpr); 9810 if (!OCE) 9811 return; 9812 9813 FunctionDecl *FD = OCE->getDirectCallee(); 9814 if (!FD || !FD->isOverloadedOperator()) 9815 return; 9816 9817 OverloadedOperatorKind Kind = FD->getOverloadedOperator(); 9818 if (Kind != OO_LessLess && Kind != OO_GreaterGreater) 9819 return; 9820 9821 S.Diag(OpLoc, diag::warn_overloaded_shift_in_comparison) 9822 << LHSExpr->getSourceRange() << RHSExpr->getSourceRange() 9823 << (Kind == OO_LessLess); 9824 SuggestParentheses(S, OCE->getOperatorLoc(), 9825 S.PDiag(diag::note_precedence_silence) 9826 << (Kind == OO_LessLess ? "<<" : ">>"), 9827 OCE->getSourceRange()); 9828 SuggestParentheses(S, OpLoc, 9829 S.PDiag(diag::note_evaluate_comparison_first), 9830 SourceRange(OCE->getArg(1)->getLocStart(), 9831 RHSExpr->getLocEnd())); 9832} 9833 9834/// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky 9835/// precedence. 9836static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc, 9837 SourceLocation OpLoc, Expr *LHSExpr, 9838 Expr *RHSExpr){ 9839 // Diagnose "arg1 'bitwise' arg2 'eq' arg3". 9840 if (BinaryOperator::isBitwiseOp(Opc)) 9841 DiagnoseBitwisePrecedence(Self, Opc, OpLoc, LHSExpr, RHSExpr); 9842 9843 // Diagnose "arg1 & arg2 | arg3" 9844 if (Opc == BO_Or && !OpLoc.isMacroID()/* Don't warn in macros. */) { 9845 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, LHSExpr); 9846 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, RHSExpr); 9847 } 9848 9849 // Warn about arg1 || arg2 && arg3, as GCC 4.3+ does. 9850 // We don't warn for 'assert(a || b && "bad")' since this is safe. 9851 if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) { 9852 DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, LHSExpr, RHSExpr); 9853 DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, LHSExpr, RHSExpr); 9854 } 9855 9856 if ((Opc == BO_Shl && LHSExpr->getType()->isIntegralType(Self.getASTContext())) 9857 || Opc == BO_Shr) { 9858 StringRef Shift = BinaryOperator::getOpcodeStr(Opc); 9859 DiagnoseAdditionInShift(Self, OpLoc, LHSExpr, Shift); 9860 DiagnoseAdditionInShift(Self, OpLoc, RHSExpr, Shift); 9861 } 9862 9863 // Warn on overloaded shift operators and comparisons, such as: 9864 // cout << 5 == 4; 9865 if (BinaryOperator::isComparisonOp(Opc)) 9866 DiagnoseShiftCompare(Self, OpLoc, LHSExpr, RHSExpr); 9867} 9868 9869// Binary Operators. 'Tok' is the token for the operator. 9870ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc, 9871 tok::TokenKind Kind, 9872 Expr *LHSExpr, Expr *RHSExpr) { 9873 BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind); 9874 assert(LHSExpr && "ActOnBinOp(): missing left expression"); 9875 assert(RHSExpr && "ActOnBinOp(): missing right expression"); 9876 9877 // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0" 9878 DiagnoseBinOpPrecedence(*this, Opc, TokLoc, LHSExpr, RHSExpr); 9879 9880 return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr); 9881} 9882 9883/// Build an overloaded binary operator expression in the given scope. 9884static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc, 9885 BinaryOperatorKind Opc, 9886 Expr *LHS, Expr *RHS) { 9887 // Find all of the overloaded operators visible from this 9888 // point. We perform both an operator-name lookup from the local 9889 // scope and an argument-dependent lookup based on the types of 9890 // the arguments. 9891 UnresolvedSet<16> Functions; 9892 OverloadedOperatorKind OverOp 9893 = BinaryOperator::getOverloadedOperator(Opc); 9894 if (Sc && OverOp != OO_None && OverOp != OO_Equal) 9895 S.LookupOverloadedOperatorName(OverOp, Sc, LHS->getType(), 9896 RHS->getType(), Functions); 9897 9898 // Build the (potentially-overloaded, potentially-dependent) 9899 // binary operation. 9900 return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS); 9901} 9902 9903ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc, 9904 BinaryOperatorKind Opc, 9905 Expr *LHSExpr, Expr *RHSExpr) { 9906 // We want to end up calling one of checkPseudoObjectAssignment 9907 // (if the LHS is a pseudo-object), BuildOverloadedBinOp (if 9908 // both expressions are overloadable or either is type-dependent), 9909 // or CreateBuiltinBinOp (in any other case). We also want to get 9910 // any placeholder types out of the way. 9911 9912 // Handle pseudo-objects in the LHS. 9913 if (const BuiltinType *pty = LHSExpr->getType()->getAsPlaceholderType()) { 9914 // Assignments with a pseudo-object l-value need special analysis. 9915 if (pty->getKind() == BuiltinType::PseudoObject && 9916 BinaryOperator::isAssignmentOp(Opc)) 9917 return checkPseudoObjectAssignment(S, OpLoc, Opc, LHSExpr, RHSExpr); 9918 9919 // Don't resolve overloads if the other type is overloadable. 9920 if (pty->getKind() == BuiltinType::Overload) { 9921 // We can't actually test that if we still have a placeholder, 9922 // though. Fortunately, none of the exceptions we see in that 9923 // code below are valid when the LHS is an overload set. Note 9924 // that an overload set can be dependently-typed, but it never 9925 // instantiates to having an overloadable type. 9926 ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr); 9927 if (resolvedRHS.isInvalid()) return ExprError(); 9928 RHSExpr = resolvedRHS.get(); 9929 9930 if (RHSExpr->isTypeDependent() || 9931 RHSExpr->getType()->isOverloadableType()) 9932 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9933 } 9934 9935 ExprResult LHS = CheckPlaceholderExpr(LHSExpr); 9936 if (LHS.isInvalid()) return ExprError(); 9937 LHSExpr = LHS.get(); 9938 } 9939 9940 // Handle pseudo-objects in the RHS. 9941 if (const BuiltinType *pty = RHSExpr->getType()->getAsPlaceholderType()) { 9942 // An overload in the RHS can potentially be resolved by the type 9943 // being assigned to. 9944 if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) { 9945 if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent()) 9946 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9947 9948 if (LHSExpr->getType()->isOverloadableType()) 9949 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9950 9951 return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr); 9952 } 9953 9954 // Don't resolve overloads if the other type is overloadable. 9955 if (pty->getKind() == BuiltinType::Overload && 9956 LHSExpr->getType()->isOverloadableType()) 9957 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9958 9959 ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr); 9960 if (!resolvedRHS.isUsable()) return ExprError(); 9961 RHSExpr = resolvedRHS.get(); 9962 } 9963 9964 if (getLangOpts().CPlusPlus) { 9965 // If either expression is type-dependent, always build an 9966 // overloaded op. 9967 if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent()) 9968 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9969 9970 // Otherwise, build an overloaded op if either expression has an 9971 // overloadable type. 9972 if (LHSExpr->getType()->isOverloadableType() || 9973 RHSExpr->getType()->isOverloadableType()) 9974 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9975 } 9976 9977 // Build a built-in binary operation. 9978 return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr); 9979} 9980 9981ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc, 9982 UnaryOperatorKind Opc, 9983 Expr *InputExpr) { 9984 ExprResult Input = InputExpr; 9985 ExprValueKind VK = VK_RValue; 9986 ExprObjectKind OK = OK_Ordinary; 9987 QualType resultType; 9988 switch (Opc) { 9989 case UO_PreInc: 9990 case UO_PreDec: 9991 case UO_PostInc: 9992 case UO_PostDec: 9993 resultType = CheckIncrementDecrementOperand(*this, Input.get(), VK, OK, 9994 OpLoc, 9995 Opc == UO_PreInc || 9996 Opc == UO_PostInc, 9997 Opc == UO_PreInc || 9998 Opc == UO_PreDec); 9999 break; 10000 case UO_AddrOf: 10001 resultType = CheckAddressOfOperand(Input, OpLoc); 10002 RecordModifiableNonNullParam(*this, InputExpr); 10003 break; 10004 case UO_Deref: { 10005 Input = DefaultFunctionArrayLvalueConversion(Input.get()); 10006 if (Input.isInvalid()) return ExprError(); 10007 resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc); 10008 break; 10009 } 10010 case UO_Plus: 10011 case UO_Minus: 10012 Input = UsualUnaryConversions(Input.get()); 10013 if (Input.isInvalid()) return ExprError(); 10014 resultType = Input.get()->getType(); 10015 if (resultType->isDependentType()) 10016 break; 10017 if (resultType->isArithmeticType() || // C99 6.5.3.3p1 10018 resultType->isVectorType()) 10019 break; 10020 else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6 10021 Opc == UO_Plus && 10022 resultType->isPointerType()) 10023 break; 10024 10025 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10026 << resultType << Input.get()->getSourceRange()); 10027 10028 case UO_Not: // bitwise complement 10029 Input = UsualUnaryConversions(Input.get()); 10030 if (Input.isInvalid()) 10031 return ExprError(); 10032 resultType = Input.get()->getType(); 10033 if (resultType->isDependentType()) 10034 break; 10035 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension. 10036 if (resultType->isComplexType() || resultType->isComplexIntegerType()) 10037 // C99 does not support '~' for complex conjugation. 10038 Diag(OpLoc, diag::ext_integer_complement_complex) 10039 << resultType << Input.get()->getSourceRange(); 10040 else if (resultType->hasIntegerRepresentation()) 10041 break; 10042 else if (resultType->isExtVectorType()) { 10043 if (Context.getLangOpts().OpenCL) { 10044 // OpenCL v1.1 s6.3.f: The bitwise operator not (~) does not operate 10045 // on vector float types. 10046 QualType T = resultType->getAs<ExtVectorType>()->getElementType(); 10047 if (!T->isIntegerType()) 10048 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10049 << resultType << Input.get()->getSourceRange()); 10050 } 10051 break; 10052 } else { 10053 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10054 << resultType << Input.get()->getSourceRange()); 10055 } 10056 break; 10057 10058 case UO_LNot: // logical negation 10059 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5). 10060 Input = DefaultFunctionArrayLvalueConversion(Input.get()); 10061 if (Input.isInvalid()) return ExprError(); 10062 resultType = Input.get()->getType(); 10063 10064 // Though we still have to promote half FP to float... 10065 if (resultType->isHalfType() && !Context.getLangOpts().NativeHalfType) { 10066 Input = ImpCastExprToType(Input.get(), Context.FloatTy, CK_FloatingCast).get(); 10067 resultType = Context.FloatTy; 10068 } 10069 10070 if (resultType->isDependentType()) 10071 break; 10072 if (resultType->isScalarType() && !isScopedEnumerationType(resultType)) { 10073 // C99 6.5.3.3p1: ok, fallthrough; 10074 if (Context.getLangOpts().CPlusPlus) { 10075 // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9: 10076 // operand contextually converted to bool. 10077 Input = ImpCastExprToType(Input.get(), Context.BoolTy, 10078 ScalarTypeToBooleanCastKind(resultType)); 10079 } else if (Context.getLangOpts().OpenCL && 10080 Context.getLangOpts().OpenCLVersion < 120) { 10081 // OpenCL v1.1 6.3.h: The logical operator not (!) does not 10082 // operate on scalar float types. 10083 if (!resultType->isIntegerType()) 10084 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10085 << resultType << Input.get()->getSourceRange()); 10086 } 10087 } else if (resultType->isExtVectorType()) { 10088 if (Context.getLangOpts().OpenCL && 10089 Context.getLangOpts().OpenCLVersion < 120) { 10090 // OpenCL v1.1 6.3.h: The logical operator not (!) does not 10091 // operate on vector float types. 10092 QualType T = resultType->getAs<ExtVectorType>()->getElementType(); 10093 if (!T->isIntegerType()) 10094 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10095 << resultType << Input.get()->getSourceRange()); 10096 } 10097 // Vector logical not returns the signed variant of the operand type. 10098 resultType = GetSignedVectorType(resultType); 10099 break; 10100 } else { 10101 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10102 << resultType << Input.get()->getSourceRange()); 10103 } 10104 10105 // LNot always has type int. C99 6.5.3.3p5. 10106 // In C++, it's bool. C++ 5.3.1p8 10107 resultType = Context.getLogicalOperationType(); 10108 break; 10109 case UO_Real: 10110 case UO_Imag: 10111 resultType = CheckRealImagOperand(*this, Input, OpLoc, Opc == UO_Real); 10112 // _Real maps ordinary l-values into ordinary l-values. _Imag maps ordinary 10113 // complex l-values to ordinary l-values and all other values to r-values. 10114 if (Input.isInvalid()) return ExprError(); 10115 if (Opc == UO_Real || Input.get()->getType()->isAnyComplexType()) { 10116 if (Input.get()->getValueKind() != VK_RValue && 10117 Input.get()->getObjectKind() == OK_Ordinary) 10118 VK = Input.get()->getValueKind(); 10119 } else if (!getLangOpts().CPlusPlus) { 10120 // In C, a volatile scalar is read by __imag. In C++, it is not. 10121 Input = DefaultLvalueConversion(Input.get()); 10122 } 10123 break; 10124 case UO_Extension: 10125 resultType = Input.get()->getType(); 10126 VK = Input.get()->getValueKind(); 10127 OK = Input.get()->getObjectKind(); 10128 break; 10129 } 10130 if (resultType.isNull() || Input.isInvalid()) 10131 return ExprError(); 10132 10133 // Check for array bounds violations in the operand of the UnaryOperator, 10134 // except for the '*' and '&' operators that have to be handled specially 10135 // by CheckArrayAccess (as there are special cases like &array[arraysize] 10136 // that are explicitly defined as valid by the standard). 10137 if (Opc != UO_AddrOf && Opc != UO_Deref) 10138 CheckArrayAccess(Input.get()); 10139 10140 return new (Context) 10141 UnaryOperator(Input.get(), Opc, resultType, VK, OK, OpLoc); 10142} 10143 10144/// \brief Determine whether the given expression is a qualified member 10145/// access expression, of a form that could be turned into a pointer to member 10146/// with the address-of operator. 10147static bool isQualifiedMemberAccess(Expr *E) { 10148 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 10149 if (!DRE->getQualifier()) 10150 return false; 10151 10152 ValueDecl *VD = DRE->getDecl(); 10153 if (!VD->isCXXClassMember()) 10154 return false; 10155 10156 if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD)) 10157 return true; 10158 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(VD)) 10159 return Method->isInstance(); 10160 10161 return false; 10162 } 10163 10164 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) { 10165 if (!ULE->getQualifier()) 10166 return false; 10167 10168 for (UnresolvedLookupExpr::decls_iterator D = ULE->decls_begin(), 10169 DEnd = ULE->decls_end(); 10170 D != DEnd; ++D) { 10171 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(*D)) { 10172 if (Method->isInstance()) 10173 return true; 10174 } else { 10175 // Overload set does not contain methods. 10176 break; 10177 } 10178 } 10179 10180 return false; 10181 } 10182 10183 return false; 10184} 10185 10186ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc, 10187 UnaryOperatorKind Opc, Expr *Input) { 10188 // First things first: handle placeholders so that the 10189 // overloaded-operator check considers the right type. 10190 if (const BuiltinType *pty = Input->getType()->getAsPlaceholderType()) { 10191 // Increment and decrement of pseudo-object references. 10192 if (pty->getKind() == BuiltinType::PseudoObject && 10193 UnaryOperator::isIncrementDecrementOp(Opc)) 10194 return checkPseudoObjectIncDec(S, OpLoc, Opc, Input); 10195 10196 // extension is always a builtin operator. 10197 if (Opc == UO_Extension) 10198 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 10199 10200 // & gets special logic for several kinds of placeholder. 10201 // The builtin code knows what to do. 10202 if (Opc == UO_AddrOf && 10203 (pty->getKind() == BuiltinType::Overload || 10204 pty->getKind() == BuiltinType::UnknownAny || 10205 pty->getKind() == BuiltinType::BoundMember)) 10206 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 10207 10208 // Anything else needs to be handled now. 10209 ExprResult Result = CheckPlaceholderExpr(Input); 10210 if (Result.isInvalid()) return ExprError(); 10211 Input = Result.get(); 10212 } 10213 10214 if (getLangOpts().CPlusPlus && Input->getType()->isOverloadableType() && 10215 UnaryOperator::getOverloadedOperator(Opc) != OO_None && 10216 !(Opc == UO_AddrOf && isQualifiedMemberAccess(Input))) { 10217 // Find all of the overloaded operators visible from this 10218 // point. We perform both an operator-name lookup from the local 10219 // scope and an argument-dependent lookup based on the types of 10220 // the arguments. 10221 UnresolvedSet<16> Functions; 10222 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc); 10223 if (S && OverOp != OO_None) 10224 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(), 10225 Functions); 10226 10227 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input); 10228 } 10229 10230 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 10231} 10232 10233// Unary Operators. 'Tok' is the token for the operator. 10234ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc, 10235 tok::TokenKind Op, Expr *Input) { 10236 return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input); 10237} 10238 10239/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo". 10240ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, 10241 LabelDecl *TheDecl) { 10242 TheDecl->markUsed(Context); 10243 // Create the AST node. The address of a label always has type 'void*'. 10244 return new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl, 10245 Context.getPointerType(Context.VoidTy)); 10246} 10247 10248/// Given the last statement in a statement-expression, check whether 10249/// the result is a producing expression (like a call to an 10250/// ns_returns_retained function) and, if so, rebuild it to hoist the 10251/// release out of the full-expression. Otherwise, return null. 10252/// Cannot fail. 10253static Expr *maybeRebuildARCConsumingStmt(Stmt *Statement) { 10254 // Should always be wrapped with one of these. 10255 ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(Statement); 10256 if (!cleanups) return nullptr; 10257 10258 ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(cleanups->getSubExpr()); 10259 if (!cast || cast->getCastKind() != CK_ARCConsumeObject) 10260 return nullptr; 10261 10262 // Splice out the cast. This shouldn't modify any interesting 10263 // features of the statement. 10264 Expr *producer = cast->getSubExpr(); 10265 assert(producer->getType() == cast->getType()); 10266 assert(producer->getValueKind() == cast->getValueKind()); 10267 cleanups->setSubExpr(producer); 10268 return cleanups; 10269} 10270 10271void Sema::ActOnStartStmtExpr() { 10272 PushExpressionEvaluationContext(ExprEvalContexts.back().Context); 10273} 10274 10275void Sema::ActOnStmtExprError() { 10276 // Note that function is also called by TreeTransform when leaving a 10277 // StmtExpr scope without rebuilding anything. 10278 10279 DiscardCleanupsInEvaluationContext(); 10280 PopExpressionEvaluationContext(); 10281} 10282 10283ExprResult 10284Sema::ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, 10285 SourceLocation RPLoc) { // "({..})" 10286 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!"); 10287 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt); 10288 10289 if (hasAnyUnrecoverableErrorsInThisFunction()) 10290 DiscardCleanupsInEvaluationContext(); 10291 assert(!ExprNeedsCleanups && "cleanups within StmtExpr not correctly bound!"); 10292 PopExpressionEvaluationContext(); 10293 10294 // FIXME: there are a variety of strange constraints to enforce here, for 10295 // example, it is not possible to goto into a stmt expression apparently. 10296 // More semantic analysis is needed. 10297 10298 // If there are sub-stmts in the compound stmt, take the type of the last one 10299 // as the type of the stmtexpr. 10300 QualType Ty = Context.VoidTy; 10301 bool StmtExprMayBindToTemp = false; 10302 if (!Compound->body_empty()) { 10303 Stmt *LastStmt = Compound->body_back(); 10304 LabelStmt *LastLabelStmt = nullptr; 10305 // If LastStmt is a label, skip down through into the body. 10306 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt)) { 10307 LastLabelStmt = Label; 10308 LastStmt = Label->getSubStmt(); 10309 } 10310 10311 if (Expr *LastE = dyn_cast<Expr>(LastStmt)) { 10312 // Do function/array conversion on the last expression, but not 10313 // lvalue-to-rvalue. However, initialize an unqualified type. 10314 ExprResult LastExpr = DefaultFunctionArrayConversion(LastE); 10315 if (LastExpr.isInvalid()) 10316 return ExprError(); 10317 Ty = LastExpr.get()->getType().getUnqualifiedType(); 10318 10319 if (!Ty->isDependentType() && !LastExpr.get()->isTypeDependent()) { 10320 // In ARC, if the final expression ends in a consume, splice 10321 // the consume out and bind it later. In the alternate case 10322 // (when dealing with a retainable type), the result 10323 // initialization will create a produce. In both cases the 10324 // result will be +1, and we'll need to balance that out with 10325 // a bind. 10326 if (Expr *rebuiltLastStmt 10327 = maybeRebuildARCConsumingStmt(LastExpr.get())) { 10328 LastExpr = rebuiltLastStmt; 10329 } else { 10330 LastExpr = PerformCopyInitialization( 10331 InitializedEntity::InitializeResult(LPLoc, 10332 Ty, 10333 false), 10334 SourceLocation(), 10335 LastExpr); 10336 } 10337 10338 if (LastExpr.isInvalid()) 10339 return ExprError(); 10340 if (LastExpr.get() != nullptr) { 10341 if (!LastLabelStmt) 10342 Compound->setLastStmt(LastExpr.get()); 10343 else 10344 LastLabelStmt->setSubStmt(LastExpr.get()); 10345 StmtExprMayBindToTemp = true; 10346 } 10347 } 10348 } 10349 } 10350 10351 // FIXME: Check that expression type is complete/non-abstract; statement 10352 // expressions are not lvalues. 10353 Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc); 10354 if (StmtExprMayBindToTemp) 10355 return MaybeBindToTemporary(ResStmtExpr); 10356 return ResStmtExpr; 10357} 10358 10359ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, 10360 TypeSourceInfo *TInfo, 10361 OffsetOfComponent *CompPtr, 10362 unsigned NumComponents, 10363 SourceLocation RParenLoc) { 10364 QualType ArgTy = TInfo->getType(); 10365 bool Dependent = ArgTy->isDependentType(); 10366 SourceRange TypeRange = TInfo->getTypeLoc().getLocalSourceRange(); 10367 10368 // We must have at least one component that refers to the type, and the first 10369 // one is known to be a field designator. Verify that the ArgTy represents 10370 // a struct/union/class. 10371 if (!Dependent && !ArgTy->isRecordType()) 10372 return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type) 10373 << ArgTy << TypeRange); 10374 10375 // Type must be complete per C99 7.17p3 because a declaring a variable 10376 // with an incomplete type would be ill-formed. 10377 if (!Dependent 10378 && RequireCompleteType(BuiltinLoc, ArgTy, 10379 diag::err_offsetof_incomplete_type, TypeRange)) 10380 return ExprError(); 10381 10382 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a 10383 // GCC extension, diagnose them. 10384 // FIXME: This diagnostic isn't actually visible because the location is in 10385 // a system header! 10386 if (NumComponents != 1) 10387 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator) 10388 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd); 10389 10390 bool DidWarnAboutNonPOD = false; 10391 QualType CurrentType = ArgTy; 10392 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode; 10393 SmallVector<OffsetOfNode, 4> Comps; 10394 SmallVector<Expr*, 4> Exprs; 10395 for (unsigned i = 0; i != NumComponents; ++i) { 10396 const OffsetOfComponent &OC = CompPtr[i]; 10397 if (OC.isBrackets) { 10398 // Offset of an array sub-field. TODO: Should we allow vector elements? 10399 if (!CurrentType->isDependentType()) { 10400 const ArrayType *AT = Context.getAsArrayType(CurrentType); 10401 if(!AT) 10402 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type) 10403 << CurrentType); 10404 CurrentType = AT->getElementType(); 10405 } else 10406 CurrentType = Context.DependentTy; 10407 10408 ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr*>(OC.U.E)); 10409 if (IdxRval.isInvalid()) 10410 return ExprError(); 10411 Expr *Idx = IdxRval.get(); 10412 10413 // The expression must be an integral expression. 10414 // FIXME: An integral constant expression? 10415 if (!Idx->isTypeDependent() && !Idx->isValueDependent() && 10416 !Idx->getType()->isIntegerType()) 10417 return ExprError(Diag(Idx->getLocStart(), 10418 diag::err_typecheck_subscript_not_integer) 10419 << Idx->getSourceRange()); 10420 10421 // Record this array index. 10422 Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd)); 10423 Exprs.push_back(Idx); 10424 continue; 10425 } 10426 10427 // Offset of a field. 10428 if (CurrentType->isDependentType()) { 10429 // We have the offset of a field, but we can't look into the dependent 10430 // type. Just record the identifier of the field. 10431 Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd)); 10432 CurrentType = Context.DependentTy; 10433 continue; 10434 } 10435 10436 // We need to have a complete type to look into. 10437 if (RequireCompleteType(OC.LocStart, CurrentType, 10438 diag::err_offsetof_incomplete_type)) 10439 return ExprError(); 10440 10441 // Look for the designated field. 10442 const RecordType *RC = CurrentType->getAs<RecordType>(); 10443 if (!RC) 10444 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type) 10445 << CurrentType); 10446 RecordDecl *RD = RC->getDecl(); 10447 10448 // C++ [lib.support.types]p5: 10449 // The macro offsetof accepts a restricted set of type arguments in this 10450 // International Standard. type shall be a POD structure or a POD union 10451 // (clause 9). 10452 // C++11 [support.types]p4: 10453 // If type is not a standard-layout class (Clause 9), the results are 10454 // undefined. 10455 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) { 10456 bool IsSafe = LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD(); 10457 unsigned DiagID = 10458 LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type 10459 : diag::ext_offsetof_non_pod_type; 10460 10461 if (!IsSafe && !DidWarnAboutNonPOD && 10462 DiagRuntimeBehavior(BuiltinLoc, nullptr, 10463 PDiag(DiagID) 10464 << SourceRange(CompPtr[0].LocStart, OC.LocEnd) 10465 << CurrentType)) 10466 DidWarnAboutNonPOD = true; 10467 } 10468 10469 // Look for the field. 10470 LookupResult R(*this, OC.U.IdentInfo, OC.LocStart, LookupMemberName); 10471 LookupQualifiedName(R, RD); 10472 FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>(); 10473 IndirectFieldDecl *IndirectMemberDecl = nullptr; 10474 if (!MemberDecl) { 10475 if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>())) 10476 MemberDecl = IndirectMemberDecl->getAnonField(); 10477 } 10478 10479 if (!MemberDecl) 10480 return ExprError(Diag(BuiltinLoc, diag::err_no_member) 10481 << OC.U.IdentInfo << RD << SourceRange(OC.LocStart, 10482 OC.LocEnd)); 10483 10484 // C99 7.17p3: 10485 // (If the specified member is a bit-field, the behavior is undefined.) 10486 // 10487 // We diagnose this as an error. 10488 if (MemberDecl->isBitField()) { 10489 Diag(OC.LocEnd, diag::err_offsetof_bitfield) 10490 << MemberDecl->getDeclName() 10491 << SourceRange(BuiltinLoc, RParenLoc); 10492 Diag(MemberDecl->getLocation(), diag::note_bitfield_decl); 10493 return ExprError(); 10494 } 10495 10496 RecordDecl *Parent = MemberDecl->getParent(); 10497 if (IndirectMemberDecl) 10498 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext()); 10499 10500 // If the member was found in a base class, introduce OffsetOfNodes for 10501 // the base class indirections. 10502 CXXBasePaths Paths; 10503 if (IsDerivedFrom(CurrentType, Context.getTypeDeclType(Parent), Paths)) { 10504 if (Paths.getDetectedVirtual()) { 10505 Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base) 10506 << MemberDecl->getDeclName() 10507 << SourceRange(BuiltinLoc, RParenLoc); 10508 return ExprError(); 10509 } 10510 10511 CXXBasePath &Path = Paths.front(); 10512 for (CXXBasePath::iterator B = Path.begin(), BEnd = Path.end(); 10513 B != BEnd; ++B) 10514 Comps.push_back(OffsetOfNode(B->Base)); 10515 } 10516 10517 if (IndirectMemberDecl) { 10518 for (auto *FI : IndirectMemberDecl->chain()) { 10519 assert(isa<FieldDecl>(FI)); 10520 Comps.push_back(OffsetOfNode(OC.LocStart, 10521 cast<FieldDecl>(FI), OC.LocEnd)); 10522 } 10523 } else 10524 Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd)); 10525 10526 CurrentType = MemberDecl->getType().getNonReferenceType(); 10527 } 10528 10529 return OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc, TInfo, 10530 Comps, Exprs, RParenLoc); 10531} 10532 10533ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S, 10534 SourceLocation BuiltinLoc, 10535 SourceLocation TypeLoc, 10536 ParsedType ParsedArgTy, 10537 OffsetOfComponent *CompPtr, 10538 unsigned NumComponents, 10539 SourceLocation RParenLoc) { 10540 10541 TypeSourceInfo *ArgTInfo; 10542 QualType ArgTy = GetTypeFromParser(ParsedArgTy, &ArgTInfo); 10543 if (ArgTy.isNull()) 10544 return ExprError(); 10545 10546 if (!ArgTInfo) 10547 ArgTInfo = Context.getTrivialTypeSourceInfo(ArgTy, TypeLoc); 10548 10549 return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, CompPtr, NumComponents, 10550 RParenLoc); 10551} 10552 10553 10554ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, 10555 Expr *CondExpr, 10556 Expr *LHSExpr, Expr *RHSExpr, 10557 SourceLocation RPLoc) { 10558 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)"); 10559 10560 ExprValueKind VK = VK_RValue; 10561 ExprObjectKind OK = OK_Ordinary; 10562 QualType resType; 10563 bool ValueDependent = false; 10564 bool CondIsTrue = false; 10565 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) { 10566 resType = Context.DependentTy; 10567 ValueDependent = true; 10568 } else { 10569 // The conditional expression is required to be a constant expression. 10570 llvm::APSInt condEval(32); 10571 ExprResult CondICE 10572 = VerifyIntegerConstantExpression(CondExpr, &condEval, 10573 diag::err_typecheck_choose_expr_requires_constant, false); 10574 if (CondICE.isInvalid()) 10575 return ExprError(); 10576 CondExpr = CondICE.get(); 10577 CondIsTrue = condEval.getZExtValue(); 10578 10579 // If the condition is > zero, then the AST type is the same as the LSHExpr. 10580 Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr; 10581 10582 resType = ActiveExpr->getType(); 10583 ValueDependent = ActiveExpr->isValueDependent(); 10584 VK = ActiveExpr->getValueKind(); 10585 OK = ActiveExpr->getObjectKind(); 10586 } 10587 10588 return new (Context) 10589 ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, resType, VK, OK, RPLoc, 10590 CondIsTrue, resType->isDependentType(), ValueDependent); 10591} 10592 10593//===----------------------------------------------------------------------===// 10594// Clang Extensions. 10595//===----------------------------------------------------------------------===// 10596 10597/// ActOnBlockStart - This callback is invoked when a block literal is started. 10598void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope) { 10599 BlockDecl *Block = BlockDecl::Create(Context, CurContext, CaretLoc); 10600 10601 if (LangOpts.CPlusPlus) { 10602 Decl *ManglingContextDecl; 10603 if (MangleNumberingContext *MCtx = 10604 getCurrentMangleNumberContext(Block->getDeclContext(), 10605 ManglingContextDecl)) { 10606 unsigned ManglingNumber = MCtx->getManglingNumber(Block); 10607 Block->setBlockMangling(ManglingNumber, ManglingContextDecl); 10608 } 10609 } 10610 10611 PushBlockScope(CurScope, Block); 10612 CurContext->addDecl(Block); 10613 if (CurScope) 10614 PushDeclContext(CurScope, Block); 10615 else 10616 CurContext = Block; 10617 10618 getCurBlock()->HasImplicitReturnType = true; 10619 10620 // Enter a new evaluation context to insulate the block from any 10621 // cleanups from the enclosing full-expression. 10622 PushExpressionEvaluationContext(PotentiallyEvaluated); 10623} 10624 10625void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo, 10626 Scope *CurScope) { 10627 assert(ParamInfo.getIdentifier() == nullptr && 10628 "block-id should have no identifier!"); 10629 assert(ParamInfo.getContext() == Declarator::BlockLiteralContext); 10630 BlockScopeInfo *CurBlock = getCurBlock(); 10631 10632 TypeSourceInfo *Sig = GetTypeForDeclarator(ParamInfo, CurScope); 10633 QualType T = Sig->getType(); 10634 10635 // FIXME: We should allow unexpanded parameter packs here, but that would, 10636 // in turn, make the block expression contain unexpanded parameter packs. 10637 if (DiagnoseUnexpandedParameterPack(CaretLoc, Sig, UPPC_Block)) { 10638 // Drop the parameters. 10639 FunctionProtoType::ExtProtoInfo EPI; 10640 EPI.HasTrailingReturn = false; 10641 EPI.TypeQuals |= DeclSpec::TQ_const; 10642 T = Context.getFunctionType(Context.DependentTy, None, EPI); 10643 Sig = Context.getTrivialTypeSourceInfo(T); 10644 } 10645 10646 // GetTypeForDeclarator always produces a function type for a block 10647 // literal signature. Furthermore, it is always a FunctionProtoType 10648 // unless the function was written with a typedef. 10649 assert(T->isFunctionType() && 10650 "GetTypeForDeclarator made a non-function block signature"); 10651 10652 // Look for an explicit signature in that function type. 10653 FunctionProtoTypeLoc ExplicitSignature; 10654 10655 TypeLoc tmp = Sig->getTypeLoc().IgnoreParens(); 10656 if ((ExplicitSignature = tmp.getAs<FunctionProtoTypeLoc>())) { 10657 10658 // Check whether that explicit signature was synthesized by 10659 // GetTypeForDeclarator. If so, don't save that as part of the 10660 // written signature. 10661 if (ExplicitSignature.getLocalRangeBegin() == 10662 ExplicitSignature.getLocalRangeEnd()) { 10663 // This would be much cheaper if we stored TypeLocs instead of 10664 // TypeSourceInfos. 10665 TypeLoc Result = ExplicitSignature.getReturnLoc(); 10666 unsigned Size = Result.getFullDataSize(); 10667 Sig = Context.CreateTypeSourceInfo(Result.getType(), Size); 10668 Sig->getTypeLoc().initializeFullCopy(Result, Size); 10669 10670 ExplicitSignature = FunctionProtoTypeLoc(); 10671 } 10672 } 10673 10674 CurBlock->TheDecl->setSignatureAsWritten(Sig); 10675 CurBlock->FunctionType = T; 10676 10677 const FunctionType *Fn = T->getAs<FunctionType>(); 10678 QualType RetTy = Fn->getReturnType(); 10679 bool isVariadic = 10680 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic()); 10681 10682 CurBlock->TheDecl->setIsVariadic(isVariadic); 10683 10684 // Context.DependentTy is used as a placeholder for a missing block 10685 // return type. TODO: what should we do with declarators like: 10686 // ^ * { ... } 10687 // If the answer is "apply template argument deduction".... 10688 if (RetTy != Context.DependentTy) { 10689 CurBlock->ReturnType = RetTy; 10690 CurBlock->TheDecl->setBlockMissingReturnType(false); 10691 CurBlock->HasImplicitReturnType = false; 10692 } 10693 10694 // Push block parameters from the declarator if we had them. 10695 SmallVector<ParmVarDecl*, 8> Params; 10696 if (ExplicitSignature) { 10697 for (unsigned I = 0, E = ExplicitSignature.getNumParams(); I != E; ++I) { 10698 ParmVarDecl *Param = ExplicitSignature.getParam(I); 10699 if (Param->getIdentifier() == nullptr && 10700 !Param->isImplicit() && 10701 !Param->isInvalidDecl() && 10702 !getLangOpts().CPlusPlus) 10703 Diag(Param->getLocation(), diag::err_parameter_name_omitted); 10704 Params.push_back(Param); 10705 } 10706 10707 // Fake up parameter variables if we have a typedef, like 10708 // ^ fntype { ... } 10709 } else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) { 10710 for (const auto &I : Fn->param_types()) { 10711 ParmVarDecl *Param = BuildParmVarDeclForTypedef( 10712 CurBlock->TheDecl, ParamInfo.getLocStart(), I); 10713 Params.push_back(Param); 10714 } 10715 } 10716 10717 // Set the parameters on the block decl. 10718 if (!Params.empty()) { 10719 CurBlock->TheDecl->setParams(Params); 10720 CheckParmsForFunctionDef(CurBlock->TheDecl->param_begin(), 10721 CurBlock->TheDecl->param_end(), 10722 /*CheckParameterNames=*/false); 10723 } 10724 10725 // Finally we can process decl attributes. 10726 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo); 10727 10728 // Put the parameter variables in scope. 10729 for (auto AI : CurBlock->TheDecl->params()) { 10730 AI->setOwningFunction(CurBlock->TheDecl); 10731 10732 // If this has an identifier, add it to the scope stack. 10733 if (AI->getIdentifier()) { 10734 CheckShadow(CurBlock->TheScope, AI); 10735 10736 PushOnScopeChains(AI, CurBlock->TheScope); 10737 } 10738 } 10739} 10740 10741/// ActOnBlockError - If there is an error parsing a block, this callback 10742/// is invoked to pop the information about the block from the action impl. 10743void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) { 10744 // Leave the expression-evaluation context. 10745 DiscardCleanupsInEvaluationContext(); 10746 PopExpressionEvaluationContext(); 10747 10748 // Pop off CurBlock, handle nested blocks. 10749 PopDeclContext(); 10750 PopFunctionScopeInfo(); 10751} 10752 10753/// ActOnBlockStmtExpr - This is called when the body of a block statement 10754/// literal was successfully completed. ^(int x){...} 10755ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, 10756 Stmt *Body, Scope *CurScope) { 10757 // If blocks are disabled, emit an error. 10758 if (!LangOpts.Blocks) 10759 Diag(CaretLoc, diag::err_blocks_disable); 10760 10761 // Leave the expression-evaluation context. 10762 if (hasAnyUnrecoverableErrorsInThisFunction()) 10763 DiscardCleanupsInEvaluationContext(); 10764 assert(!ExprNeedsCleanups && "cleanups within block not correctly bound!"); 10765 PopExpressionEvaluationContext(); 10766 10767 BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back()); 10768 10769 if (BSI->HasImplicitReturnType) 10770 deduceClosureReturnType(*BSI); 10771 10772 PopDeclContext(); 10773 10774 QualType RetTy = Context.VoidTy; 10775 if (!BSI->ReturnType.isNull()) 10776 RetTy = BSI->ReturnType; 10777 10778 bool NoReturn = BSI->TheDecl->hasAttr<NoReturnAttr>(); 10779 QualType BlockTy; 10780 10781 // Set the captured variables on the block. 10782 // FIXME: Share capture structure between BlockDecl and CapturingScopeInfo! 10783 SmallVector<BlockDecl::Capture, 4> Captures; 10784 for (unsigned i = 0, e = BSI->Captures.size(); i != e; i++) { 10785 CapturingScopeInfo::Capture &Cap = BSI->Captures[i]; 10786 if (Cap.isThisCapture()) 10787 continue; 10788 BlockDecl::Capture NewCap(Cap.getVariable(), Cap.isBlockCapture(), 10789 Cap.isNested(), Cap.getInitExpr()); 10790 Captures.push_back(NewCap); 10791 } 10792 BSI->TheDecl->setCaptures(Context, Captures.begin(), Captures.end(), 10793 BSI->CXXThisCaptureIndex != 0); 10794 10795 // If the user wrote a function type in some form, try to use that. 10796 if (!BSI->FunctionType.isNull()) { 10797 const FunctionType *FTy = BSI->FunctionType->getAs<FunctionType>(); 10798 10799 FunctionType::ExtInfo Ext = FTy->getExtInfo(); 10800 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true); 10801 10802 // Turn protoless block types into nullary block types. 10803 if (isa<FunctionNoProtoType>(FTy)) { 10804 FunctionProtoType::ExtProtoInfo EPI; 10805 EPI.ExtInfo = Ext; 10806 BlockTy = Context.getFunctionType(RetTy, None, EPI); 10807 10808 // Otherwise, if we don't need to change anything about the function type, 10809 // preserve its sugar structure. 10810 } else if (FTy->getReturnType() == RetTy && 10811 (!NoReturn || FTy->getNoReturnAttr())) { 10812 BlockTy = BSI->FunctionType; 10813 10814 // Otherwise, make the minimal modifications to the function type. 10815 } else { 10816 const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy); 10817 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 10818 EPI.TypeQuals = 0; // FIXME: silently? 10819 EPI.ExtInfo = Ext; 10820 BlockTy = Context.getFunctionType(RetTy, FPT->getParamTypes(), EPI); 10821 } 10822 10823 // If we don't have a function type, just build one from nothing. 10824 } else { 10825 FunctionProtoType::ExtProtoInfo EPI; 10826 EPI.ExtInfo = FunctionType::ExtInfo().withNoReturn(NoReturn); 10827 BlockTy = Context.getFunctionType(RetTy, None, EPI); 10828 } 10829 10830 DiagnoseUnusedParameters(BSI->TheDecl->param_begin(), 10831 BSI->TheDecl->param_end()); 10832 BlockTy = Context.getBlockPointerType(BlockTy); 10833 10834 // If needed, diagnose invalid gotos and switches in the block. 10835 if (getCurFunction()->NeedsScopeChecking() && 10836 !PP.isCodeCompletionEnabled()) 10837 DiagnoseInvalidJumps(cast<CompoundStmt>(Body)); 10838 10839 BSI->TheDecl->setBody(cast<CompoundStmt>(Body)); 10840 10841 // Try to apply the named return value optimization. We have to check again 10842 // if we can do this, though, because blocks keep return statements around 10843 // to deduce an implicit return type. 10844 if (getLangOpts().CPlusPlus && RetTy->isRecordType() && 10845 !BSI->TheDecl->isDependentContext()) 10846 computeNRVO(Body, BSI); 10847 10848 BlockExpr *Result = new (Context) BlockExpr(BSI->TheDecl, BlockTy); 10849 AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy(); 10850 PopFunctionScopeInfo(&WP, Result->getBlockDecl(), Result); 10851 10852 // If the block isn't obviously global, i.e. it captures anything at 10853 // all, then we need to do a few things in the surrounding context: 10854 if (Result->getBlockDecl()->hasCaptures()) { 10855 // First, this expression has a new cleanup object. 10856 ExprCleanupObjects.push_back(Result->getBlockDecl()); 10857 ExprNeedsCleanups = true; 10858 10859 // It also gets a branch-protected scope if any of the captured 10860 // variables needs destruction. 10861 for (const auto &CI : Result->getBlockDecl()->captures()) { 10862 const VarDecl *var = CI.getVariable(); 10863 if (var->getType().isDestructedType() != QualType::DK_none) { 10864 getCurFunction()->setHasBranchProtectedScope(); 10865 break; 10866 } 10867 } 10868 } 10869 10870 return Result; 10871} 10872 10873ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc, 10874 Expr *E, ParsedType Ty, 10875 SourceLocation RPLoc) { 10876 TypeSourceInfo *TInfo; 10877 GetTypeFromParser(Ty, &TInfo); 10878 return BuildVAArgExpr(BuiltinLoc, E, TInfo, RPLoc); 10879} 10880 10881ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, 10882 Expr *E, TypeSourceInfo *TInfo, 10883 SourceLocation RPLoc) { 10884 Expr *OrigExpr = E; 10885 10886 // Get the va_list type 10887 QualType VaListType = Context.getBuiltinVaListType(); 10888 if (VaListType->isArrayType()) { 10889 // Deal with implicit array decay; for example, on x86-64, 10890 // va_list is an array, but it's supposed to decay to 10891 // a pointer for va_arg. 10892 VaListType = Context.getArrayDecayedType(VaListType); 10893 // Make sure the input expression also decays appropriately. 10894 ExprResult Result = UsualUnaryConversions(E); 10895 if (Result.isInvalid()) 10896 return ExprError(); 10897 E = Result.get(); 10898 } else if (VaListType->isRecordType() && getLangOpts().CPlusPlus) { 10899 // If va_list is a record type and we are compiling in C++ mode, 10900 // check the argument using reference binding. 10901 InitializedEntity Entity 10902 = InitializedEntity::InitializeParameter(Context, 10903 Context.getLValueReferenceType(VaListType), false); 10904 ExprResult Init = PerformCopyInitialization(Entity, SourceLocation(), E); 10905 if (Init.isInvalid()) 10906 return ExprError(); 10907 E = Init.getAs<Expr>(); 10908 } else { 10909 // Otherwise, the va_list argument must be an l-value because 10910 // it is modified by va_arg. 10911 if (!E->isTypeDependent() && 10912 CheckForModifiableLvalue(E, BuiltinLoc, *this)) 10913 return ExprError(); 10914 } 10915 10916 if (!E->isTypeDependent() && 10917 !Context.hasSameType(VaListType, E->getType())) { 10918 return ExprError(Diag(E->getLocStart(), 10919 diag::err_first_argument_to_va_arg_not_of_type_va_list) 10920 << OrigExpr->getType() << E->getSourceRange()); 10921 } 10922 10923 if (!TInfo->getType()->isDependentType()) { 10924 if (RequireCompleteType(TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(), 10925 diag::err_second_parameter_to_va_arg_incomplete, 10926 TInfo->getTypeLoc())) 10927 return ExprError(); 10928 10929 if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(), 10930 TInfo->getType(), 10931 diag::err_second_parameter_to_va_arg_abstract, 10932 TInfo->getTypeLoc())) 10933 return ExprError(); 10934 10935 if (!TInfo->getType().isPODType(Context)) { 10936 Diag(TInfo->getTypeLoc().getBeginLoc(), 10937 TInfo->getType()->isObjCLifetimeType() 10938 ? diag::warn_second_parameter_to_va_arg_ownership_qualified 10939 : diag::warn_second_parameter_to_va_arg_not_pod) 10940 << TInfo->getType() 10941 << TInfo->getTypeLoc().getSourceRange(); 10942 } 10943 10944 // Check for va_arg where arguments of the given type will be promoted 10945 // (i.e. this va_arg is guaranteed to have undefined behavior). 10946 QualType PromoteType; 10947 if (TInfo->getType()->isPromotableIntegerType()) { 10948 PromoteType = Context.getPromotedIntegerType(TInfo->getType()); 10949 if (Context.typesAreCompatible(PromoteType, TInfo->getType())) 10950 PromoteType = QualType(); 10951 } 10952 if (TInfo->getType()->isSpecificBuiltinType(BuiltinType::Float)) 10953 PromoteType = Context.DoubleTy; 10954 if (!PromoteType.isNull()) 10955 DiagRuntimeBehavior(TInfo->getTypeLoc().getBeginLoc(), E, 10956 PDiag(diag::warn_second_parameter_to_va_arg_never_compatible) 10957 << TInfo->getType() 10958 << PromoteType 10959 << TInfo->getTypeLoc().getSourceRange()); 10960 } 10961 10962 QualType T = TInfo->getType().getNonLValueExprType(Context); 10963 return new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T); 10964} 10965 10966ExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) { 10967 // The type of __null will be int or long, depending on the size of 10968 // pointers on the target. 10969 QualType Ty; 10970 unsigned pw = Context.getTargetInfo().getPointerWidth(0); 10971 if (pw == Context.getTargetInfo().getIntWidth()) 10972 Ty = Context.IntTy; 10973 else if (pw == Context.getTargetInfo().getLongWidth()) 10974 Ty = Context.LongTy; 10975 else if (pw == Context.getTargetInfo().getLongLongWidth()) 10976 Ty = Context.LongLongTy; 10977 else { 10978 llvm_unreachable("I don't know size of pointer!"); 10979 } 10980 10981 return new (Context) GNUNullExpr(Ty, TokenLoc); 10982} 10983 10984bool 10985Sema::ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&Exp) { 10986 if (!getLangOpts().ObjC1) 10987 return false; 10988 10989 const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>(); 10990 if (!PT) 10991 return false; 10992 10993 if (!PT->isObjCIdType()) { 10994 // Check if the destination is the 'NSString' interface. 10995 const ObjCInterfaceDecl *ID = PT->getInterfaceDecl(); 10996 if (!ID || !ID->getIdentifier()->isStr("NSString")) 10997 return false; 10998 } 10999 11000 // Ignore any parens, implicit casts (should only be 11001 // array-to-pointer decays), and not-so-opaque values. The last is 11002 // important for making this trigger for property assignments. 11003 Expr *SrcExpr = Exp->IgnoreParenImpCasts(); 11004 if (OpaqueValueExpr *OV = dyn_cast<OpaqueValueExpr>(SrcExpr)) 11005 if (OV->getSourceExpr()) 11006 SrcExpr = OV->getSourceExpr()->IgnoreParenImpCasts(); 11007 11008 StringLiteral *SL = dyn_cast<StringLiteral>(SrcExpr); 11009 if (!SL || !SL->isAscii()) 11010 return false; 11011 Diag(SL->getLocStart(), diag::err_missing_atsign_prefix) 11012 << FixItHint::CreateInsertion(SL->getLocStart(), "@"); 11013 Exp = BuildObjCStringLiteral(SL->getLocStart(), SL).get(); 11014 return true; 11015} 11016 11017bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy, 11018 SourceLocation Loc, 11019 QualType DstType, QualType SrcType, 11020 Expr *SrcExpr, AssignmentAction Action, 11021 bool *Complained) { 11022 if (Complained) 11023 *Complained = false; 11024 11025 // Decode the result (notice that AST's are still created for extensions). 11026 bool CheckInferredResultType = false; 11027 bool isInvalid = false; 11028 unsigned DiagKind = 0; 11029 FixItHint Hint; 11030 ConversionFixItGenerator ConvHints; 11031 bool MayHaveConvFixit = false; 11032 bool MayHaveFunctionDiff = false; 11033 const ObjCInterfaceDecl *IFace = nullptr; 11034 const ObjCProtocolDecl *PDecl = nullptr; 11035 11036 switch (ConvTy) { 11037 case Compatible: 11038 DiagnoseAssignmentEnum(DstType, SrcType, SrcExpr); 11039 return false; 11040 11041 case PointerToInt: 11042 DiagKind = diag::ext_typecheck_convert_pointer_int; 11043 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 11044 MayHaveConvFixit = true; 11045 break; 11046 case IntToPointer: 11047 DiagKind = diag::ext_typecheck_convert_int_pointer; 11048 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 11049 MayHaveConvFixit = true; 11050 break; 11051 case IncompatiblePointer: 11052 DiagKind = 11053 (Action == AA_Passing_CFAudited ? 11054 diag::err_arc_typecheck_convert_incompatible_pointer : 11055 diag::ext_typecheck_convert_incompatible_pointer); 11056 CheckInferredResultType = DstType->isObjCObjectPointerType() && 11057 SrcType->isObjCObjectPointerType(); 11058 if (Hint.isNull() && !CheckInferredResultType) { 11059 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 11060 } 11061 else if (CheckInferredResultType) { 11062 SrcType = SrcType.getUnqualifiedType(); 11063 DstType = DstType.getUnqualifiedType(); 11064 } 11065 MayHaveConvFixit = true; 11066 break; 11067 case IncompatiblePointerSign: 11068 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign; 11069 break; 11070 case FunctionVoidPointer: 11071 DiagKind = diag::ext_typecheck_convert_pointer_void_func; 11072 break; 11073 case IncompatiblePointerDiscardsQualifiers: { 11074 // Perform array-to-pointer decay if necessary. 11075 if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType); 11076 11077 Qualifiers lhq = SrcType->getPointeeType().getQualifiers(); 11078 Qualifiers rhq = DstType->getPointeeType().getQualifiers(); 11079 if (lhq.getAddressSpace() != rhq.getAddressSpace()) { 11080 DiagKind = diag::err_typecheck_incompatible_address_space; 11081 break; 11082 11083 11084 } else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) { 11085 DiagKind = diag::err_typecheck_incompatible_ownership; 11086 break; 11087 } 11088 11089 llvm_unreachable("unknown error case for discarding qualifiers!"); 11090 // fallthrough 11091 } 11092 case CompatiblePointerDiscardsQualifiers: 11093 // If the qualifiers lost were because we were applying the 11094 // (deprecated) C++ conversion from a string literal to a char* 11095 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME: 11096 // Ideally, this check would be performed in 11097 // checkPointerTypesForAssignment. However, that would require a 11098 // bit of refactoring (so that the second argument is an 11099 // expression, rather than a type), which should be done as part 11100 // of a larger effort to fix checkPointerTypesForAssignment for 11101 // C++ semantics. 11102 if (getLangOpts().CPlusPlus && 11103 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType)) 11104 return false; 11105 DiagKind = diag::ext_typecheck_convert_discards_qualifiers; 11106 break; 11107 case IncompatibleNestedPointerQualifiers: 11108 DiagKind = diag::ext_nested_pointer_qualifier_mismatch; 11109 break; 11110 case IntToBlockPointer: 11111 DiagKind = diag::err_int_to_block_pointer; 11112 break; 11113 case IncompatibleBlockPointer: 11114 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer; 11115 break; 11116 case IncompatibleObjCQualifiedId: { 11117 if (SrcType->isObjCQualifiedIdType()) { 11118 const ObjCObjectPointerType *srcOPT = 11119 SrcType->getAs<ObjCObjectPointerType>(); 11120 for (auto *srcProto : srcOPT->quals()) { 11121 PDecl = srcProto; 11122 break; 11123 } 11124 if (const ObjCInterfaceType *IFaceT = 11125 DstType->getAs<ObjCObjectPointerType>()->getInterfaceType()) 11126 IFace = IFaceT->getDecl(); 11127 } 11128 else if (DstType->isObjCQualifiedIdType()) { 11129 const ObjCObjectPointerType *dstOPT = 11130 DstType->getAs<ObjCObjectPointerType>(); 11131 for (auto *dstProto : dstOPT->quals()) { 11132 PDecl = dstProto; 11133 break; 11134 } 11135 if (const ObjCInterfaceType *IFaceT = 11136 SrcType->getAs<ObjCObjectPointerType>()->getInterfaceType()) 11137 IFace = IFaceT->getDecl(); 11138 } 11139 DiagKind = diag::warn_incompatible_qualified_id; 11140 break; 11141 } 11142 case IncompatibleVectors: 11143 DiagKind = diag::warn_incompatible_vectors; 11144 break; 11145 case IncompatibleObjCWeakRef: 11146 DiagKind = diag::err_arc_weak_unavailable_assign; 11147 break; 11148 case Incompatible: 11149 DiagKind = diag::err_typecheck_convert_incompatible; 11150 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 11151 MayHaveConvFixit = true; 11152 isInvalid = true; 11153 MayHaveFunctionDiff = true; 11154 break; 11155 } 11156 11157 QualType FirstType, SecondType; 11158 switch (Action) { 11159 case AA_Assigning: 11160 case AA_Initializing: 11161 // The destination type comes first. 11162 FirstType = DstType; 11163 SecondType = SrcType; 11164 break; 11165 11166 case AA_Returning: 11167 case AA_Passing: 11168 case AA_Passing_CFAudited: 11169 case AA_Converting: 11170 case AA_Sending: 11171 case AA_Casting: 11172 // The source type comes first. 11173 FirstType = SrcType; 11174 SecondType = DstType; 11175 break; 11176 } 11177 11178 PartialDiagnostic FDiag = PDiag(DiagKind); 11179 if (Action == AA_Passing_CFAudited) 11180 FDiag << FirstType << SecondType << AA_Passing << SrcExpr->getSourceRange(); 11181 else 11182 FDiag << FirstType << SecondType << Action << SrcExpr->getSourceRange(); 11183 11184 // If we can fix the conversion, suggest the FixIts. 11185 assert(ConvHints.isNull() || Hint.isNull()); 11186 if (!ConvHints.isNull()) { 11187 for (std::vector<FixItHint>::iterator HI = ConvHints.Hints.begin(), 11188 HE = ConvHints.Hints.end(); HI != HE; ++HI) 11189 FDiag << *HI; 11190 } else { 11191 FDiag << Hint; 11192 } 11193 if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); } 11194 11195 if (MayHaveFunctionDiff) 11196 HandleFunctionTypeMismatch(FDiag, SecondType, FirstType); 11197 11198 Diag(Loc, FDiag); 11199 if (DiagKind == diag::warn_incompatible_qualified_id && 11200 PDecl && IFace && !IFace->hasDefinition()) 11201 Diag(IFace->getLocation(), diag::not_incomplete_class_and_qualified_id) 11202 << IFace->getName() << PDecl->getName(); 11203 11204 if (SecondType == Context.OverloadTy) 11205 NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression, 11206 FirstType); 11207 11208 if (CheckInferredResultType) 11209 EmitRelatedResultTypeNote(SrcExpr); 11210 11211 if (Action == AA_Returning && ConvTy == IncompatiblePointer) 11212 EmitRelatedResultTypeNoteForReturn(DstType); 11213 11214 if (Complained) 11215 *Complained = true; 11216 return isInvalid; 11217} 11218 11219ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, 11220 llvm::APSInt *Result) { 11221 class SimpleICEDiagnoser : public VerifyICEDiagnoser { 11222 public: 11223 void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override { 11224 S.Diag(Loc, diag::err_expr_not_ice) << S.LangOpts.CPlusPlus << SR; 11225 } 11226 } Diagnoser; 11227 11228 return VerifyIntegerConstantExpression(E, Result, Diagnoser); 11229} 11230 11231ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, 11232 llvm::APSInt *Result, 11233 unsigned DiagID, 11234 bool AllowFold) { 11235 class IDDiagnoser : public VerifyICEDiagnoser { 11236 unsigned DiagID; 11237 11238 public: 11239 IDDiagnoser(unsigned DiagID) 11240 : VerifyICEDiagnoser(DiagID == 0), DiagID(DiagID) { } 11241 11242 void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override { 11243 S.Diag(Loc, DiagID) << SR; 11244 } 11245 } Diagnoser(DiagID); 11246 11247 return VerifyIntegerConstantExpression(E, Result, Diagnoser, AllowFold); 11248} 11249 11250void Sema::VerifyICEDiagnoser::diagnoseFold(Sema &S, SourceLocation Loc, 11251 SourceRange SR) { 11252 S.Diag(Loc, diag::ext_expr_not_ice) << SR << S.LangOpts.CPlusPlus; 11253} 11254 11255ExprResult 11256Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, 11257 VerifyICEDiagnoser &Diagnoser, 11258 bool AllowFold) { 11259 SourceLocation DiagLoc = E->getLocStart(); 11260 11261 if (getLangOpts().CPlusPlus11) { 11262 // C++11 [expr.const]p5: 11263 // If an expression of literal class type is used in a context where an 11264 // integral constant expression is required, then that class type shall 11265 // have a single non-explicit conversion function to an integral or 11266 // unscoped enumeration type 11267 ExprResult Converted; 11268 class CXX11ConvertDiagnoser : public ICEConvertDiagnoser { 11269 public: 11270 CXX11ConvertDiagnoser(bool Silent) 11271 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/false, 11272 Silent, true) {} 11273 11274 SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc, 11275 QualType T) override { 11276 return S.Diag(Loc, diag::err_ice_not_integral) << T; 11277 } 11278 11279 SemaDiagnosticBuilder diagnoseIncomplete( 11280 Sema &S, SourceLocation Loc, QualType T) override { 11281 return S.Diag(Loc, diag::err_ice_incomplete_type) << T; 11282 } 11283 11284 SemaDiagnosticBuilder diagnoseExplicitConv( 11285 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override { 11286 return S.Diag(Loc, diag::err_ice_explicit_conversion) << T << ConvTy; 11287 } 11288 11289 SemaDiagnosticBuilder noteExplicitConv( 11290 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override { 11291 return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here) 11292 << ConvTy->isEnumeralType() << ConvTy; 11293 } 11294 11295 SemaDiagnosticBuilder diagnoseAmbiguous( 11296 Sema &S, SourceLocation Loc, QualType T) override { 11297 return S.Diag(Loc, diag::err_ice_ambiguous_conversion) << T; 11298 } 11299 11300 SemaDiagnosticBuilder noteAmbiguous( 11301 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override { 11302 return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here) 11303 << ConvTy->isEnumeralType() << ConvTy; 11304 } 11305 11306 SemaDiagnosticBuilder diagnoseConversion( 11307 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override { 11308 llvm_unreachable("conversion functions are permitted"); 11309 } 11310 } ConvertDiagnoser(Diagnoser.Suppress); 11311 11312 Converted = PerformContextualImplicitConversion(DiagLoc, E, 11313 ConvertDiagnoser); 11314 if (Converted.isInvalid()) 11315 return Converted; 11316 E = Converted.get(); 11317 if (!E->getType()->isIntegralOrUnscopedEnumerationType()) 11318 return ExprError(); 11319 } else if (!E->getType()->isIntegralOrUnscopedEnumerationType()) { 11320 // An ICE must be of integral or unscoped enumeration type. 11321 if (!Diagnoser.Suppress) 11322 Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange()); 11323 return ExprError(); 11324 } 11325 11326 // Circumvent ICE checking in C++11 to avoid evaluating the expression twice 11327 // in the non-ICE case. 11328 if (!getLangOpts().CPlusPlus11 && E->isIntegerConstantExpr(Context)) { 11329 if (Result) 11330 *Result = E->EvaluateKnownConstInt(Context); 11331 return E; 11332 } 11333 11334 Expr::EvalResult EvalResult; 11335 SmallVector<PartialDiagnosticAt, 8> Notes; 11336 EvalResult.Diag = &Notes; 11337 11338 // Try to evaluate the expression, and produce diagnostics explaining why it's 11339 // not a constant expression as a side-effect. 11340 bool Folded = E->EvaluateAsRValue(EvalResult, Context) && 11341 EvalResult.Val.isInt() && !EvalResult.HasSideEffects; 11342 11343 // In C++11, we can rely on diagnostics being produced for any expression 11344 // which is not a constant expression. If no diagnostics were produced, then 11345 // this is a constant expression. 11346 if (Folded && getLangOpts().CPlusPlus11 && Notes.empty()) { 11347 if (Result) 11348 *Result = EvalResult.Val.getInt(); 11349 return E; 11350 } 11351 11352 // If our only note is the usual "invalid subexpression" note, just point 11353 // the caret at its location rather than producing an essentially 11354 // redundant note. 11355 if (Notes.size() == 1 && Notes[0].second.getDiagID() == 11356 diag::note_invalid_subexpr_in_const_expr) { 11357 DiagLoc = Notes[0].first; 11358 Notes.clear(); 11359 } 11360 11361 if (!Folded || !AllowFold) { 11362 if (!Diagnoser.Suppress) { 11363 Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange()); 11364 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 11365 Diag(Notes[I].first, Notes[I].second); 11366 } 11367 11368 return ExprError(); 11369 } 11370 11371 Diagnoser.diagnoseFold(*this, DiagLoc, E->getSourceRange()); 11372 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 11373 Diag(Notes[I].first, Notes[I].second); 11374 11375 if (Result) 11376 *Result = EvalResult.Val.getInt(); 11377 return E; 11378} 11379 11380namespace { 11381 // Handle the case where we conclude a expression which we speculatively 11382 // considered to be unevaluated is actually evaluated. 11383 class TransformToPE : public TreeTransform<TransformToPE> { 11384 typedef TreeTransform<TransformToPE> BaseTransform; 11385 11386 public: 11387 TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) { } 11388 11389 // Make sure we redo semantic analysis 11390 bool AlwaysRebuild() { return true; } 11391 11392 // Make sure we handle LabelStmts correctly. 11393 // FIXME: This does the right thing, but maybe we need a more general 11394 // fix to TreeTransform? 11395 StmtResult TransformLabelStmt(LabelStmt *S) { 11396 S->getDecl()->setStmt(nullptr); 11397 return BaseTransform::TransformLabelStmt(S); 11398 } 11399 11400 // We need to special-case DeclRefExprs referring to FieldDecls which 11401 // are not part of a member pointer formation; normal TreeTransforming 11402 // doesn't catch this case because of the way we represent them in the AST. 11403 // FIXME: This is a bit ugly; is it really the best way to handle this 11404 // case? 11405 // 11406 // Error on DeclRefExprs referring to FieldDecls. 11407 ExprResult TransformDeclRefExpr(DeclRefExpr *E) { 11408 if (isa<FieldDecl>(E->getDecl()) && 11409 !SemaRef.isUnevaluatedContext()) 11410 return SemaRef.Diag(E->getLocation(), 11411 diag::err_invalid_non_static_member_use) 11412 << E->getDecl() << E->getSourceRange(); 11413 11414 return BaseTransform::TransformDeclRefExpr(E); 11415 } 11416 11417 // Exception: filter out member pointer formation 11418 ExprResult TransformUnaryOperator(UnaryOperator *E) { 11419 if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType()) 11420 return E; 11421 11422 return BaseTransform::TransformUnaryOperator(E); 11423 } 11424 11425 ExprResult TransformLambdaExpr(LambdaExpr *E) { 11426 // Lambdas never need to be transformed. 11427 return E; 11428 } 11429 }; 11430} 11431 11432ExprResult Sema::TransformToPotentiallyEvaluated(Expr *E) { 11433 assert(isUnevaluatedContext() && 11434 "Should only transform unevaluated expressions"); 11435 ExprEvalContexts.back().Context = 11436 ExprEvalContexts[ExprEvalContexts.size()-2].Context; 11437 if (isUnevaluatedContext()) 11438 return E; 11439 return TransformToPE(*this).TransformExpr(E); 11440} 11441 11442void 11443Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, 11444 Decl *LambdaContextDecl, 11445 bool IsDecltype) { 11446 ExprEvalContexts.push_back( 11447 ExpressionEvaluationContextRecord(NewContext, 11448 ExprCleanupObjects.size(), 11449 ExprNeedsCleanups, 11450 LambdaContextDecl, 11451 IsDecltype)); 11452 ExprNeedsCleanups = false; 11453 if (!MaybeODRUseExprs.empty()) 11454 std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs); 11455} 11456 11457void 11458Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, 11459 ReuseLambdaContextDecl_t, 11460 bool IsDecltype) { 11461 Decl *ClosureContextDecl = ExprEvalContexts.back().ManglingContextDecl; 11462 PushExpressionEvaluationContext(NewContext, ClosureContextDecl, IsDecltype); 11463} 11464 11465void Sema::PopExpressionEvaluationContext() { 11466 ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back(); 11467 unsigned NumTypos = Rec.NumTypos; 11468 11469 if (!Rec.Lambdas.empty()) { 11470 if (Rec.isUnevaluated() || Rec.Context == ConstantEvaluated) { 11471 unsigned D; 11472 if (Rec.isUnevaluated()) { 11473 // C++11 [expr.prim.lambda]p2: 11474 // A lambda-expression shall not appear in an unevaluated operand 11475 // (Clause 5). 11476 D = diag::err_lambda_unevaluated_operand; 11477 } else { 11478 // C++1y [expr.const]p2: 11479 // A conditional-expression e is a core constant expression unless the 11480 // evaluation of e, following the rules of the abstract machine, would 11481 // evaluate [...] a lambda-expression. 11482 D = diag::err_lambda_in_constant_expression; 11483 } 11484 for (const auto *L : Rec.Lambdas) 11485 Diag(L->getLocStart(), D); 11486 } else { 11487 // Mark the capture expressions odr-used. This was deferred 11488 // during lambda expression creation. 11489 for (auto *Lambda : Rec.Lambdas) { 11490 for (auto *C : Lambda->capture_inits()) 11491 MarkDeclarationsReferencedInExpr(C); 11492 } 11493 } 11494 } 11495 11496 // When are coming out of an unevaluated context, clear out any 11497 // temporaries that we may have created as part of the evaluation of 11498 // the expression in that context: they aren't relevant because they 11499 // will never be constructed. 11500 if (Rec.isUnevaluated() || Rec.Context == ConstantEvaluated) { 11501 ExprCleanupObjects.erase(ExprCleanupObjects.begin() + Rec.NumCleanupObjects, 11502 ExprCleanupObjects.end()); 11503 ExprNeedsCleanups = Rec.ParentNeedsCleanups; 11504 CleanupVarDeclMarking(); 11505 std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs); 11506 // Otherwise, merge the contexts together. 11507 } else { 11508 ExprNeedsCleanups |= Rec.ParentNeedsCleanups; 11509 MaybeODRUseExprs.insert(Rec.SavedMaybeODRUseExprs.begin(), 11510 Rec.SavedMaybeODRUseExprs.end()); 11511 } 11512 11513 // Pop the current expression evaluation context off the stack. 11514 ExprEvalContexts.pop_back(); 11515 11516 if (!ExprEvalContexts.empty()) 11517 ExprEvalContexts.back().NumTypos += NumTypos; 11518 else 11519 assert(NumTypos == 0 && "There are outstanding typos after popping the " 11520 "last ExpressionEvaluationContextRecord"); 11521} 11522 11523void Sema::DiscardCleanupsInEvaluationContext() { 11524 ExprCleanupObjects.erase( 11525 ExprCleanupObjects.begin() + ExprEvalContexts.back().NumCleanupObjects, 11526 ExprCleanupObjects.end()); 11527 ExprNeedsCleanups = false; 11528 MaybeODRUseExprs.clear(); 11529} 11530 11531ExprResult Sema::HandleExprEvaluationContextForTypeof(Expr *E) { 11532 if (!E->getType()->isVariablyModifiedType()) 11533 return E; 11534 return TransformToPotentiallyEvaluated(E); 11535} 11536 11537static bool IsPotentiallyEvaluatedContext(Sema &SemaRef) { 11538 // Do not mark anything as "used" within a dependent context; wait for 11539 // an instantiation. 11540 if (SemaRef.CurContext->isDependentContext()) 11541 return false; 11542 11543 switch (SemaRef.ExprEvalContexts.back().Context) { 11544 case Sema::Unevaluated: 11545 case Sema::UnevaluatedAbstract: 11546 // We are in an expression that is not potentially evaluated; do nothing. 11547 // (Depending on how you read the standard, we actually do need to do 11548 // something here for null pointer constants, but the standard's 11549 // definition of a null pointer constant is completely crazy.) 11550 return false; 11551 11552 case Sema::ConstantEvaluated: 11553 case Sema::PotentiallyEvaluated: 11554 // We are in a potentially evaluated expression (or a constant-expression 11555 // in C++03); we need to do implicit template instantiation, implicitly 11556 // define class members, and mark most declarations as used. 11557 return true; 11558 11559 case Sema::PotentiallyEvaluatedIfUsed: 11560 // Referenced declarations will only be used if the construct in the 11561 // containing expression is used. 11562 return false; 11563 } 11564 llvm_unreachable("Invalid context"); 11565} 11566 11567/// \brief Mark a function referenced, and check whether it is odr-used 11568/// (C++ [basic.def.odr]p2, C99 6.9p3) 11569void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, 11570 bool OdrUse) { 11571 assert(Func && "No function?"); 11572 11573 Func->setReferenced(); 11574 11575 // C++11 [basic.def.odr]p3: 11576 // A function whose name appears as a potentially-evaluated expression is 11577 // odr-used if it is the unique lookup result or the selected member of a 11578 // set of overloaded functions [...]. 11579 // 11580 // We (incorrectly) mark overload resolution as an unevaluated context, so we 11581 // can just check that here. Skip the rest of this function if we've already 11582 // marked the function as used. 11583 if (Func->isUsed(false) || !IsPotentiallyEvaluatedContext(*this)) { 11584 // C++11 [temp.inst]p3: 11585 // Unless a function template specialization has been explicitly 11586 // instantiated or explicitly specialized, the function template 11587 // specialization is implicitly instantiated when the specialization is 11588 // referenced in a context that requires a function definition to exist. 11589 // 11590 // We consider constexpr function templates to be referenced in a context 11591 // that requires a definition to exist whenever they are referenced. 11592 // 11593 // FIXME: This instantiates constexpr functions too frequently. If this is 11594 // really an unevaluated context (and we're not just in the definition of a 11595 // function template or overload resolution or other cases which we 11596 // incorrectly consider to be unevaluated contexts), and we're not in a 11597 // subexpression which we actually need to evaluate (for instance, a 11598 // template argument, array bound or an expression in a braced-init-list), 11599 // we are not permitted to instantiate this constexpr function definition. 11600 // 11601 // FIXME: This also implicitly defines special members too frequently. They 11602 // are only supposed to be implicitly defined if they are odr-used, but they 11603 // are not odr-used from constant expressions in unevaluated contexts. 11604 // However, they cannot be referenced if they are deleted, and they are 11605 // deleted whenever the implicit definition of the special member would 11606 // fail. 11607 if (!Func->isConstexpr() || Func->getBody()) 11608 return; 11609 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Func); 11610 if (!Func->isImplicitlyInstantiable() && (!MD || MD->isUserProvided())) 11611 return; 11612 } 11613 11614 // Note that this declaration has been used. 11615 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Func)) { 11616 Constructor = cast<CXXConstructorDecl>(Constructor->getFirstDecl()); 11617 if (Constructor->isDefaulted() && !Constructor->isDeleted()) { 11618 if (Constructor->isDefaultConstructor()) { 11619 if (Constructor->isTrivial() && !Constructor->hasAttr<DLLExportAttr>()) 11620 return; 11621 DefineImplicitDefaultConstructor(Loc, Constructor); 11622 } else if (Constructor->isCopyConstructor()) { 11623 DefineImplicitCopyConstructor(Loc, Constructor); 11624 } else if (Constructor->isMoveConstructor()) { 11625 DefineImplicitMoveConstructor(Loc, Constructor); 11626 } 11627 } else if (Constructor->getInheritedConstructor()) { 11628 DefineInheritingConstructor(Loc, Constructor); 11629 } 11630 } else if (CXXDestructorDecl *Destructor = 11631 dyn_cast<CXXDestructorDecl>(Func)) { 11632 Destructor = cast<CXXDestructorDecl>(Destructor->getFirstDecl());
| 121 case AR_Deprecated: 122 if (S.getCurContextAvailability() != AR_Deprecated) 123 S.EmitAvailabilityWarning(Sema::AD_Deprecation, 124 D, Message, Loc, UnknownObjCClass, ObjCPDecl, 125 ObjCPropertyAccess); 126 break; 127 128 case AR_Unavailable: 129 if (S.getCurContextAvailability() != AR_Unavailable) 130 S.EmitAvailabilityWarning(Sema::AD_Unavailable, 131 D, Message, Loc, UnknownObjCClass, ObjCPDecl, 132 ObjCPropertyAccess); 133 break; 134 135 } 136 return Result; 137} 138 139/// \brief Emit a note explaining that this function is deleted. 140void Sema::NoteDeletedFunction(FunctionDecl *Decl) { 141 assert(Decl->isDeleted()); 142 143 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Decl); 144 145 if (Method && Method->isDeleted() && Method->isDefaulted()) { 146 // If the method was explicitly defaulted, point at that declaration. 147 if (!Method->isImplicit()) 148 Diag(Decl->getLocation(), diag::note_implicitly_deleted); 149 150 // Try to diagnose why this special member function was implicitly 151 // deleted. This might fail, if that reason no longer applies. 152 CXXSpecialMember CSM = getSpecialMember(Method); 153 if (CSM != CXXInvalid) 154 ShouldDeleteSpecialMember(Method, CSM, /*Diagnose=*/true); 155 156 return; 157 } 158 159 if (CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Decl)) { 160 if (CXXConstructorDecl *BaseCD = 161 const_cast<CXXConstructorDecl*>(CD->getInheritedConstructor())) { 162 Diag(Decl->getLocation(), diag::note_inherited_deleted_here); 163 if (BaseCD->isDeleted()) { 164 NoteDeletedFunction(BaseCD); 165 } else { 166 // FIXME: An explanation of why exactly it can't be inherited 167 // would be nice. 168 Diag(BaseCD->getLocation(), diag::note_cannot_inherit); 169 } 170 return; 171 } 172 } 173 174 Diag(Decl->getLocation(), diag::note_availability_specified_here) 175 << Decl << true; 176} 177 178/// \brief Determine whether a FunctionDecl was ever declared with an 179/// explicit storage class. 180static bool hasAnyExplicitStorageClass(const FunctionDecl *D) { 181 for (auto I : D->redecls()) { 182 if (I->getStorageClass() != SC_None) 183 return true; 184 } 185 return false; 186} 187 188/// \brief Check whether we're in an extern inline function and referring to a 189/// variable or function with internal linkage (C11 6.7.4p3). 190/// 191/// This is only a warning because we used to silently accept this code, but 192/// in many cases it will not behave correctly. This is not enabled in C++ mode 193/// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6) 194/// and so while there may still be user mistakes, most of the time we can't 195/// prove that there are errors. 196static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S, 197 const NamedDecl *D, 198 SourceLocation Loc) { 199 // This is disabled under C++; there are too many ways for this to fire in 200 // contexts where the warning is a false positive, or where it is technically 201 // correct but benign. 202 if (S.getLangOpts().CPlusPlus) 203 return; 204 205 // Check if this is an inlined function or method. 206 FunctionDecl *Current = S.getCurFunctionDecl(); 207 if (!Current) 208 return; 209 if (!Current->isInlined()) 210 return; 211 if (!Current->isExternallyVisible()) 212 return; 213 214 // Check if the decl has internal linkage. 215 if (D->getFormalLinkage() != InternalLinkage) 216 return; 217 218 // Downgrade from ExtWarn to Extension if 219 // (1) the supposedly external inline function is in the main file, 220 // and probably won't be included anywhere else. 221 // (2) the thing we're referencing is a pure function. 222 // (3) the thing we're referencing is another inline function. 223 // This last can give us false negatives, but it's better than warning on 224 // wrappers for simple C library functions. 225 const FunctionDecl *UsedFn = dyn_cast<FunctionDecl>(D); 226 bool DowngradeWarning = S.getSourceManager().isInMainFile(Loc); 227 if (!DowngradeWarning && UsedFn) 228 DowngradeWarning = UsedFn->isInlined() || UsedFn->hasAttr<ConstAttr>(); 229 230 S.Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet 231 : diag::ext_internal_in_extern_inline) 232 << /*IsVar=*/!UsedFn << D; 233 234 S.MaybeSuggestAddingStaticToDecl(Current); 235 236 S.Diag(D->getCanonicalDecl()->getLocation(), diag::note_entity_declared_at) 237 << D; 238} 239 240void Sema::MaybeSuggestAddingStaticToDecl(const FunctionDecl *Cur) { 241 const FunctionDecl *First = Cur->getFirstDecl(); 242 243 // Suggest "static" on the function, if possible. 244 if (!hasAnyExplicitStorageClass(First)) { 245 SourceLocation DeclBegin = First->getSourceRange().getBegin(); 246 Diag(DeclBegin, diag::note_convert_inline_to_static) 247 << Cur << FixItHint::CreateInsertion(DeclBegin, "static "); 248 } 249} 250 251/// \brief Determine whether the use of this declaration is valid, and 252/// emit any corresponding diagnostics. 253/// 254/// This routine diagnoses various problems with referencing 255/// declarations that can occur when using a declaration. For example, 256/// it might warn if a deprecated or unavailable declaration is being 257/// used, or produce an error (and return true) if a C++0x deleted 258/// function is being used. 259/// 260/// \returns true if there was an error (this declaration cannot be 261/// referenced), false otherwise. 262/// 263bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, 264 const ObjCInterfaceDecl *UnknownObjCClass, 265 bool ObjCPropertyAccess) { 266 if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) { 267 // If there were any diagnostics suppressed by template argument deduction, 268 // emit them now. 269 SuppressedDiagnosticsMap::iterator 270 Pos = SuppressedDiagnostics.find(D->getCanonicalDecl()); 271 if (Pos != SuppressedDiagnostics.end()) { 272 SmallVectorImpl<PartialDiagnosticAt> &Suppressed = Pos->second; 273 for (unsigned I = 0, N = Suppressed.size(); I != N; ++I) 274 Diag(Suppressed[I].first, Suppressed[I].second); 275 276 // Clear out the list of suppressed diagnostics, so that we don't emit 277 // them again for this specialization. However, we don't obsolete this 278 // entry from the table, because we want to avoid ever emitting these 279 // diagnostics again. 280 Suppressed.clear(); 281 } 282 283 // C++ [basic.start.main]p3: 284 // The function 'main' shall not be used within a program. 285 if (cast<FunctionDecl>(D)->isMain()) 286 Diag(Loc, diag::ext_main_used); 287 } 288 289 // See if this is an auto-typed variable whose initializer we are parsing. 290 if (ParsingInitForAutoVars.count(D)) { 291 Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer) 292 << D->getDeclName(); 293 return true; 294 } 295 296 // See if this is a deleted function. 297 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 298 if (FD->isDeleted()) { 299 Diag(Loc, diag::err_deleted_function_use); 300 NoteDeletedFunction(FD); 301 return true; 302 } 303 304 // If the function has a deduced return type, and we can't deduce it, 305 // then we can't use it either. 306 if (getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() && 307 DeduceReturnType(FD, Loc)) 308 return true; 309 } 310 DiagnoseAvailabilityOfDecl(*this, D, Loc, UnknownObjCClass, ObjCPropertyAccess); 311 312 DiagnoseUnusedOfDecl(*this, D, Loc); 313 314 diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc); 315 316 return false; 317} 318 319/// \brief Retrieve the message suffix that should be added to a 320/// diagnostic complaining about the given function being deleted or 321/// unavailable. 322std::string Sema::getDeletedOrUnavailableSuffix(const FunctionDecl *FD) { 323 std::string Message; 324 if (FD->getAvailability(&Message)) 325 return ": " + Message; 326 327 return std::string(); 328} 329 330/// DiagnoseSentinelCalls - This routine checks whether a call or 331/// message-send is to a declaration with the sentinel attribute, and 332/// if so, it checks that the requirements of the sentinel are 333/// satisfied. 334void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, 335 ArrayRef<Expr *> Args) { 336 const SentinelAttr *attr = D->getAttr<SentinelAttr>(); 337 if (!attr) 338 return; 339 340 // The number of formal parameters of the declaration. 341 unsigned numFormalParams; 342 343 // The kind of declaration. This is also an index into a %select in 344 // the diagnostic. 345 enum CalleeType { CT_Function, CT_Method, CT_Block } calleeType; 346 347 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 348 numFormalParams = MD->param_size(); 349 calleeType = CT_Method; 350 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 351 numFormalParams = FD->param_size(); 352 calleeType = CT_Function; 353 } else if (isa<VarDecl>(D)) { 354 QualType type = cast<ValueDecl>(D)->getType(); 355 const FunctionType *fn = nullptr; 356 if (const PointerType *ptr = type->getAs<PointerType>()) { 357 fn = ptr->getPointeeType()->getAs<FunctionType>(); 358 if (!fn) return; 359 calleeType = CT_Function; 360 } else if (const BlockPointerType *ptr = type->getAs<BlockPointerType>()) { 361 fn = ptr->getPointeeType()->castAs<FunctionType>(); 362 calleeType = CT_Block; 363 } else { 364 return; 365 } 366 367 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fn)) { 368 numFormalParams = proto->getNumParams(); 369 } else { 370 numFormalParams = 0; 371 } 372 } else { 373 return; 374 } 375 376 // "nullPos" is the number of formal parameters at the end which 377 // effectively count as part of the variadic arguments. This is 378 // useful if you would prefer to not have *any* formal parameters, 379 // but the language forces you to have at least one. 380 unsigned nullPos = attr->getNullPos(); 381 assert((nullPos == 0 || nullPos == 1) && "invalid null position on sentinel"); 382 numFormalParams = (nullPos > numFormalParams ? 0 : numFormalParams - nullPos); 383 384 // The number of arguments which should follow the sentinel. 385 unsigned numArgsAfterSentinel = attr->getSentinel(); 386 387 // If there aren't enough arguments for all the formal parameters, 388 // the sentinel, and the args after the sentinel, complain. 389 if (Args.size() < numFormalParams + numArgsAfterSentinel + 1) { 390 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName(); 391 Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType); 392 return; 393 } 394 395 // Otherwise, find the sentinel expression. 396 Expr *sentinelExpr = Args[Args.size() - numArgsAfterSentinel - 1]; 397 if (!sentinelExpr) return; 398 if (sentinelExpr->isValueDependent()) return; 399 if (Context.isSentinelNullExpr(sentinelExpr)) return; 400 401 // Pick a reasonable string to insert. Optimistically use 'nil', 'nullptr', 402 // or 'NULL' if those are actually defined in the context. Only use 403 // 'nil' for ObjC methods, where it's much more likely that the 404 // variadic arguments form a list of object pointers. 405 SourceLocation MissingNilLoc 406 = PP.getLocForEndOfToken(sentinelExpr->getLocEnd()); 407 std::string NullValue; 408 if (calleeType == CT_Method && 409 PP.getIdentifierInfo("nil")->hasMacroDefinition()) 410 NullValue = "nil"; 411 else if (getLangOpts().CPlusPlus11) 412 NullValue = "nullptr"; 413 else if (PP.getIdentifierInfo("NULL")->hasMacroDefinition()) 414 NullValue = "NULL"; 415 else 416 NullValue = "(void*) 0"; 417 418 if (MissingNilLoc.isInvalid()) 419 Diag(Loc, diag::warn_missing_sentinel) << int(calleeType); 420 else 421 Diag(MissingNilLoc, diag::warn_missing_sentinel) 422 << int(calleeType) 423 << FixItHint::CreateInsertion(MissingNilLoc, ", " + NullValue); 424 Diag(D->getLocation(), diag::note_sentinel_here) << int(calleeType); 425} 426 427SourceRange Sema::getExprRange(Expr *E) const { 428 return E ? E->getSourceRange() : SourceRange(); 429} 430 431//===----------------------------------------------------------------------===// 432// Standard Promotions and Conversions 433//===----------------------------------------------------------------------===// 434 435/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4). 436ExprResult Sema::DefaultFunctionArrayConversion(Expr *E) { 437 // Handle any placeholder expressions which made it here. 438 if (E->getType()->isPlaceholderType()) { 439 ExprResult result = CheckPlaceholderExpr(E); 440 if (result.isInvalid()) return ExprError(); 441 E = result.get(); 442 } 443 444 QualType Ty = E->getType(); 445 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type"); 446 447 if (Ty->isFunctionType()) { 448 // If we are here, we are not calling a function but taking 449 // its address (which is not allowed in OpenCL v1.0 s6.8.a.3). 450 if (getLangOpts().OpenCL) { 451 Diag(E->getExprLoc(), diag::err_opencl_taking_function_address); 452 return ExprError(); 453 } 454 E = ImpCastExprToType(E, Context.getPointerType(Ty), 455 CK_FunctionToPointerDecay).get(); 456 } else if (Ty->isArrayType()) { 457 // In C90 mode, arrays only promote to pointers if the array expression is 458 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has 459 // type 'array of type' is converted to an expression that has type 'pointer 460 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression 461 // that has type 'array of type' ...". The relevant change is "an lvalue" 462 // (C90) to "an expression" (C99). 463 // 464 // C++ 4.2p1: 465 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of 466 // T" can be converted to an rvalue of type "pointer to T". 467 // 468 if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue()) 469 E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty), 470 CK_ArrayToPointerDecay).get(); 471 } 472 return E; 473} 474 475static void CheckForNullPointerDereference(Sema &S, Expr *E) { 476 // Check to see if we are dereferencing a null pointer. If so, 477 // and if not volatile-qualified, this is undefined behavior that the 478 // optimizer will delete, so warn about it. People sometimes try to use this 479 // to get a deterministic trap and are surprised by clang's behavior. This 480 // only handles the pattern "*null", which is a very syntactic check. 481 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts())) 482 if (UO->getOpcode() == UO_Deref && 483 UO->getSubExpr()->IgnoreParenCasts()-> 484 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) && 485 !UO->getType().isVolatileQualified()) { 486 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 487 S.PDiag(diag::warn_indirection_through_null) 488 << UO->getSubExpr()->getSourceRange()); 489 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 490 S.PDiag(diag::note_indirection_through_null)); 491 } 492} 493 494static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE, 495 SourceLocation AssignLoc, 496 const Expr* RHS) { 497 const ObjCIvarDecl *IV = OIRE->getDecl(); 498 if (!IV) 499 return; 500 501 DeclarationName MemberName = IV->getDeclName(); 502 IdentifierInfo *Member = MemberName.getAsIdentifierInfo(); 503 if (!Member || !Member->isStr("isa")) 504 return; 505 506 const Expr *Base = OIRE->getBase(); 507 QualType BaseType = Base->getType(); 508 if (OIRE->isArrow()) 509 BaseType = BaseType->getPointeeType(); 510 if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) 511 if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) { 512 ObjCInterfaceDecl *ClassDeclared = nullptr; 513 ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared); 514 if (!ClassDeclared->getSuperClass() 515 && (*ClassDeclared->ivar_begin()) == IV) { 516 if (RHS) { 517 NamedDecl *ObjectSetClass = 518 S.LookupSingleName(S.TUScope, 519 &S.Context.Idents.get("object_setClass"), 520 SourceLocation(), S.LookupOrdinaryName); 521 if (ObjectSetClass) { 522 SourceLocation RHSLocEnd = S.PP.getLocForEndOfToken(RHS->getLocEnd()); 523 S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_assign) << 524 FixItHint::CreateInsertion(OIRE->getLocStart(), "object_setClass(") << 525 FixItHint::CreateReplacement(SourceRange(OIRE->getOpLoc(), 526 AssignLoc), ",") << 527 FixItHint::CreateInsertion(RHSLocEnd, ")"); 528 } 529 else 530 S.Diag(OIRE->getLocation(), diag::warn_objc_isa_assign); 531 } else { 532 NamedDecl *ObjectGetClass = 533 S.LookupSingleName(S.TUScope, 534 &S.Context.Idents.get("object_getClass"), 535 SourceLocation(), S.LookupOrdinaryName); 536 if (ObjectGetClass) 537 S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_use) << 538 FixItHint::CreateInsertion(OIRE->getLocStart(), "object_getClass(") << 539 FixItHint::CreateReplacement( 540 SourceRange(OIRE->getOpLoc(), 541 OIRE->getLocEnd()), ")"); 542 else 543 S.Diag(OIRE->getLocation(), diag::warn_objc_isa_use); 544 } 545 S.Diag(IV->getLocation(), diag::note_ivar_decl); 546 } 547 } 548} 549 550ExprResult Sema::DefaultLvalueConversion(Expr *E) { 551 // Handle any placeholder expressions which made it here. 552 if (E->getType()->isPlaceholderType()) { 553 ExprResult result = CheckPlaceholderExpr(E); 554 if (result.isInvalid()) return ExprError(); 555 E = result.get(); 556 } 557 558 // C++ [conv.lval]p1: 559 // A glvalue of a non-function, non-array type T can be 560 // converted to a prvalue. 561 if (!E->isGLValue()) return E; 562 563 QualType T = E->getType(); 564 assert(!T.isNull() && "r-value conversion on typeless expression?"); 565 566 // We don't want to throw lvalue-to-rvalue casts on top of 567 // expressions of certain types in C++. 568 if (getLangOpts().CPlusPlus && 569 (E->getType() == Context.OverloadTy || 570 T->isDependentType() || 571 T->isRecordType())) 572 return E; 573 574 // The C standard is actually really unclear on this point, and 575 // DR106 tells us what the result should be but not why. It's 576 // generally best to say that void types just doesn't undergo 577 // lvalue-to-rvalue at all. Note that expressions of unqualified 578 // 'void' type are never l-values, but qualified void can be. 579 if (T->isVoidType()) 580 return E; 581 582 // OpenCL usually rejects direct accesses to values of 'half' type. 583 if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp16 && 584 T->isHalfType()) { 585 Diag(E->getExprLoc(), diag::err_opencl_half_load_store) 586 << 0 << T; 587 return ExprError(); 588 } 589 590 CheckForNullPointerDereference(*this, E); 591 if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(E->IgnoreParenCasts())) { 592 NamedDecl *ObjectGetClass = LookupSingleName(TUScope, 593 &Context.Idents.get("object_getClass"), 594 SourceLocation(), LookupOrdinaryName); 595 if (ObjectGetClass) 596 Diag(E->getExprLoc(), diag::warn_objc_isa_use) << 597 FixItHint::CreateInsertion(OISA->getLocStart(), "object_getClass(") << 598 FixItHint::CreateReplacement( 599 SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()), ")"); 600 else 601 Diag(E->getExprLoc(), diag::warn_objc_isa_use); 602 } 603 else if (const ObjCIvarRefExpr *OIRE = 604 dyn_cast<ObjCIvarRefExpr>(E->IgnoreParenCasts())) 605 DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/nullptr); 606 607 // C++ [conv.lval]p1: 608 // [...] If T is a non-class type, the type of the prvalue is the 609 // cv-unqualified version of T. Otherwise, the type of the 610 // rvalue is T. 611 // 612 // C99 6.3.2.1p2: 613 // If the lvalue has qualified type, the value has the unqualified 614 // version of the type of the lvalue; otherwise, the value has the 615 // type of the lvalue. 616 if (T.hasQualifiers()) 617 T = T.getUnqualifiedType(); 618 619 UpdateMarkingForLValueToRValue(E); 620 621 // Loading a __weak object implicitly retains the value, so we need a cleanup to 622 // balance that. 623 if (getLangOpts().ObjCAutoRefCount && 624 E->getType().getObjCLifetime() == Qualifiers::OCL_Weak) 625 ExprNeedsCleanups = true; 626 627 ExprResult Res = ImplicitCastExpr::Create(Context, T, CK_LValueToRValue, E, 628 nullptr, VK_RValue); 629 630 // C11 6.3.2.1p2: 631 // ... if the lvalue has atomic type, the value has the non-atomic version 632 // of the type of the lvalue ... 633 if (const AtomicType *Atomic = T->getAs<AtomicType>()) { 634 T = Atomic->getValueType().getUnqualifiedType(); 635 Res = ImplicitCastExpr::Create(Context, T, CK_AtomicToNonAtomic, Res.get(), 636 nullptr, VK_RValue); 637 } 638 639 return Res; 640} 641 642ExprResult Sema::DefaultFunctionArrayLvalueConversion(Expr *E) { 643 ExprResult Res = DefaultFunctionArrayConversion(E); 644 if (Res.isInvalid()) 645 return ExprError(); 646 Res = DefaultLvalueConversion(Res.get()); 647 if (Res.isInvalid()) 648 return ExprError(); 649 return Res; 650} 651 652/// CallExprUnaryConversions - a special case of an unary conversion 653/// performed on a function designator of a call expression. 654ExprResult Sema::CallExprUnaryConversions(Expr *E) { 655 QualType Ty = E->getType(); 656 ExprResult Res = E; 657 // Only do implicit cast for a function type, but not for a pointer 658 // to function type. 659 if (Ty->isFunctionType()) { 660 Res = ImpCastExprToType(E, Context.getPointerType(Ty), 661 CK_FunctionToPointerDecay).get(); 662 if (Res.isInvalid()) 663 return ExprError(); 664 } 665 Res = DefaultLvalueConversion(Res.get()); 666 if (Res.isInvalid()) 667 return ExprError(); 668 return Res.get(); 669} 670 671/// UsualUnaryConversions - Performs various conversions that are common to most 672/// operators (C99 6.3). The conversions of array and function types are 673/// sometimes suppressed. For example, the array->pointer conversion doesn't 674/// apply if the array is an argument to the sizeof or address (&) operators. 675/// In these instances, this routine should *not* be called. 676ExprResult Sema::UsualUnaryConversions(Expr *E) { 677 // First, convert to an r-value. 678 ExprResult Res = DefaultFunctionArrayLvalueConversion(E); 679 if (Res.isInvalid()) 680 return ExprError(); 681 E = Res.get(); 682 683 QualType Ty = E->getType(); 684 assert(!Ty.isNull() && "UsualUnaryConversions - missing type"); 685 686 // Half FP have to be promoted to float unless it is natively supported 687 if (Ty->isHalfType() && !getLangOpts().NativeHalfType) 688 return ImpCastExprToType(Res.get(), Context.FloatTy, CK_FloatingCast); 689 690 // Try to perform integral promotions if the object has a theoretically 691 // promotable type. 692 if (Ty->isIntegralOrUnscopedEnumerationType()) { 693 // C99 6.3.1.1p2: 694 // 695 // The following may be used in an expression wherever an int or 696 // unsigned int may be used: 697 // - an object or expression with an integer type whose integer 698 // conversion rank is less than or equal to the rank of int 699 // and unsigned int. 700 // - A bit-field of type _Bool, int, signed int, or unsigned int. 701 // 702 // If an int can represent all values of the original type, the 703 // value is converted to an int; otherwise, it is converted to an 704 // unsigned int. These are called the integer promotions. All 705 // other types are unchanged by the integer promotions. 706 707 QualType PTy = Context.isPromotableBitField(E); 708 if (!PTy.isNull()) { 709 E = ImpCastExprToType(E, PTy, CK_IntegralCast).get(); 710 return E; 711 } 712 if (Ty->isPromotableIntegerType()) { 713 QualType PT = Context.getPromotedIntegerType(Ty); 714 E = ImpCastExprToType(E, PT, CK_IntegralCast).get(); 715 return E; 716 } 717 } 718 return E; 719} 720 721/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that 722/// do not have a prototype. Arguments that have type float or __fp16 723/// are promoted to double. All other argument types are converted by 724/// UsualUnaryConversions(). 725ExprResult Sema::DefaultArgumentPromotion(Expr *E) { 726 QualType Ty = E->getType(); 727 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type"); 728 729 ExprResult Res = UsualUnaryConversions(E); 730 if (Res.isInvalid()) 731 return ExprError(); 732 E = Res.get(); 733 734 // If this is a 'float' or '__fp16' (CVR qualified or typedef) promote to 735 // double. 736 const BuiltinType *BTy = Ty->getAs<BuiltinType>(); 737 if (BTy && (BTy->getKind() == BuiltinType::Half || 738 BTy->getKind() == BuiltinType::Float)) 739 E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).get(); 740 741 // C++ performs lvalue-to-rvalue conversion as a default argument 742 // promotion, even on class types, but note: 743 // C++11 [conv.lval]p2: 744 // When an lvalue-to-rvalue conversion occurs in an unevaluated 745 // operand or a subexpression thereof the value contained in the 746 // referenced object is not accessed. Otherwise, if the glvalue 747 // has a class type, the conversion copy-initializes a temporary 748 // of type T from the glvalue and the result of the conversion 749 // is a prvalue for the temporary. 750 // FIXME: add some way to gate this entire thing for correctness in 751 // potentially potentially evaluated contexts. 752 if (getLangOpts().CPlusPlus && E->isGLValue() && !isUnevaluatedContext()) { 753 ExprResult Temp = PerformCopyInitialization( 754 InitializedEntity::InitializeTemporary(E->getType()), 755 E->getExprLoc(), E); 756 if (Temp.isInvalid()) 757 return ExprError(); 758 E = Temp.get(); 759 } 760 761 return E; 762} 763 764/// Determine the degree of POD-ness for an expression. 765/// Incomplete types are considered POD, since this check can be performed 766/// when we're in an unevaluated context. 767Sema::VarArgKind Sema::isValidVarArgType(const QualType &Ty) { 768 if (Ty->isIncompleteType()) { 769 // C++11 [expr.call]p7: 770 // After these conversions, if the argument does not have arithmetic, 771 // enumeration, pointer, pointer to member, or class type, the program 772 // is ill-formed. 773 // 774 // Since we've already performed array-to-pointer and function-to-pointer 775 // decay, the only such type in C++ is cv void. This also handles 776 // initializer lists as variadic arguments. 777 if (Ty->isVoidType()) 778 return VAK_Invalid; 779 780 if (Ty->isObjCObjectType()) 781 return VAK_Invalid; 782 return VAK_Valid; 783 } 784 785 if (Ty.isCXX98PODType(Context)) 786 return VAK_Valid; 787 788 // C++11 [expr.call]p7: 789 // Passing a potentially-evaluated argument of class type (Clause 9) 790 // having a non-trivial copy constructor, a non-trivial move constructor, 791 // or a non-trivial destructor, with no corresponding parameter, 792 // is conditionally-supported with implementation-defined semantics. 793 if (getLangOpts().CPlusPlus11 && !Ty->isDependentType()) 794 if (CXXRecordDecl *Record = Ty->getAsCXXRecordDecl()) 795 if (!Record->hasNonTrivialCopyConstructor() && 796 !Record->hasNonTrivialMoveConstructor() && 797 !Record->hasNonTrivialDestructor()) 798 return VAK_ValidInCXX11; 799 800 if (getLangOpts().ObjCAutoRefCount && Ty->isObjCLifetimeType()) 801 return VAK_Valid; 802 803 if (Ty->isObjCObjectType()) 804 return VAK_Invalid; 805 806 if (getLangOpts().MSVCCompat) 807 return VAK_MSVCUndefined; 808 809 // FIXME: In C++11, these cases are conditionally-supported, meaning we're 810 // permitted to reject them. We should consider doing so. 811 return VAK_Undefined; 812} 813 814void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) { 815 // Don't allow one to pass an Objective-C interface to a vararg. 816 const QualType &Ty = E->getType(); 817 VarArgKind VAK = isValidVarArgType(Ty); 818 819 // Complain about passing non-POD types through varargs. 820 switch (VAK) { 821 case VAK_ValidInCXX11: 822 DiagRuntimeBehavior( 823 E->getLocStart(), nullptr, 824 PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) 825 << Ty << CT); 826 // Fall through. 827 case VAK_Valid: 828 if (Ty->isRecordType()) { 829 // This is unlikely to be what the user intended. If the class has a 830 // 'c_str' member function, the user probably meant to call that. 831 DiagRuntimeBehavior(E->getLocStart(), nullptr, 832 PDiag(diag::warn_pass_class_arg_to_vararg) 833 << Ty << CT << hasCStrMethod(E) << ".c_str()"); 834 } 835 break; 836 837 case VAK_Undefined: 838 case VAK_MSVCUndefined: 839 DiagRuntimeBehavior( 840 E->getLocStart(), nullptr, 841 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg) 842 << getLangOpts().CPlusPlus11 << Ty << CT); 843 break; 844 845 case VAK_Invalid: 846 if (Ty->isObjCObjectType()) 847 DiagRuntimeBehavior( 848 E->getLocStart(), nullptr, 849 PDiag(diag::err_cannot_pass_objc_interface_to_vararg) 850 << Ty << CT); 851 else 852 Diag(E->getLocStart(), diag::err_cannot_pass_to_vararg) 853 << isa<InitListExpr>(E) << Ty << CT; 854 break; 855 } 856} 857 858/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but 859/// will create a trap if the resulting type is not a POD type. 860ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, 861 FunctionDecl *FDecl) { 862 if (const BuiltinType *PlaceholderTy = E->getType()->getAsPlaceholderType()) { 863 // Strip the unbridged-cast placeholder expression off, if applicable. 864 if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast && 865 (CT == VariadicMethod || 866 (FDecl && FDecl->hasAttr<CFAuditedTransferAttr>()))) { 867 E = stripARCUnbridgedCast(E); 868 869 // Otherwise, do normal placeholder checking. 870 } else { 871 ExprResult ExprRes = CheckPlaceholderExpr(E); 872 if (ExprRes.isInvalid()) 873 return ExprError(); 874 E = ExprRes.get(); 875 } 876 } 877 878 ExprResult ExprRes = DefaultArgumentPromotion(E); 879 if (ExprRes.isInvalid()) 880 return ExprError(); 881 E = ExprRes.get(); 882 883 // Diagnostics regarding non-POD argument types are 884 // emitted along with format string checking in Sema::CheckFunctionCall(). 885 if (isValidVarArgType(E->getType()) == VAK_Undefined) { 886 // Turn this into a trap. 887 CXXScopeSpec SS; 888 SourceLocation TemplateKWLoc; 889 UnqualifiedId Name; 890 Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"), 891 E->getLocStart()); 892 ExprResult TrapFn = ActOnIdExpression(TUScope, SS, TemplateKWLoc, 893 Name, true, false); 894 if (TrapFn.isInvalid()) 895 return ExprError(); 896 897 ExprResult Call = ActOnCallExpr(TUScope, TrapFn.get(), 898 E->getLocStart(), None, 899 E->getLocEnd()); 900 if (Call.isInvalid()) 901 return ExprError(); 902 903 ExprResult Comma = ActOnBinOp(TUScope, E->getLocStart(), tok::comma, 904 Call.get(), E); 905 if (Comma.isInvalid()) 906 return ExprError(); 907 return Comma.get(); 908 } 909 910 if (!getLangOpts().CPlusPlus && 911 RequireCompleteType(E->getExprLoc(), E->getType(), 912 diag::err_call_incomplete_argument)) 913 return ExprError(); 914 915 return E; 916} 917 918/// \brief Converts an integer to complex float type. Helper function of 919/// UsualArithmeticConversions() 920/// 921/// \return false if the integer expression is an integer type and is 922/// successfully converted to the complex type. 923static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &IntExpr, 924 ExprResult &ComplexExpr, 925 QualType IntTy, 926 QualType ComplexTy, 927 bool SkipCast) { 928 if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true; 929 if (SkipCast) return false; 930 if (IntTy->isIntegerType()) { 931 QualType fpTy = cast<ComplexType>(ComplexTy)->getElementType(); 932 IntExpr = S.ImpCastExprToType(IntExpr.get(), fpTy, CK_IntegralToFloating); 933 IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy, 934 CK_FloatingRealToComplex); 935 } else { 936 assert(IntTy->isComplexIntegerType()); 937 IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy, 938 CK_IntegralComplexToFloatingComplex); 939 } 940 return false; 941} 942 943/// \brief Handle arithmetic conversion with complex types. Helper function of 944/// UsualArithmeticConversions() 945static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS, 946 ExprResult &RHS, QualType LHSType, 947 QualType RHSType, 948 bool IsCompAssign) { 949 // if we have an integer operand, the result is the complex type. 950 if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType, 951 /*skipCast*/false)) 952 return LHSType; 953 if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType, 954 /*skipCast*/IsCompAssign)) 955 return RHSType; 956 957 // This handles complex/complex, complex/float, or float/complex. 958 // When both operands are complex, the shorter operand is converted to the 959 // type of the longer, and that is the type of the result. This corresponds 960 // to what is done when combining two real floating-point operands. 961 // The fun begins when size promotion occur across type domains. 962 // From H&S 6.3.4: When one operand is complex and the other is a real 963 // floating-point type, the less precise type is converted, within it's 964 // real or complex domain, to the precision of the other type. For example, 965 // when combining a "long double" with a "double _Complex", the 966 // "double _Complex" is promoted to "long double _Complex". 967 968 // Compute the rank of the two types, regardless of whether they are complex. 969 int Order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 970 971 auto *LHSComplexType = dyn_cast<ComplexType>(LHSType); 972 auto *RHSComplexType = dyn_cast<ComplexType>(RHSType); 973 QualType LHSElementType = 974 LHSComplexType ? LHSComplexType->getElementType() : LHSType; 975 QualType RHSElementType = 976 RHSComplexType ? RHSComplexType->getElementType() : RHSType; 977 978 QualType ResultType = S.Context.getComplexType(LHSElementType); 979 if (Order < 0) { 980 // Promote the precision of the LHS if not an assignment. 981 ResultType = S.Context.getComplexType(RHSElementType); 982 if (!IsCompAssign) { 983 if (LHSComplexType) 984 LHS = 985 S.ImpCastExprToType(LHS.get(), ResultType, CK_FloatingComplexCast); 986 else 987 LHS = S.ImpCastExprToType(LHS.get(), RHSElementType, CK_FloatingCast); 988 } 989 } else if (Order > 0) { 990 // Promote the precision of the RHS. 991 if (RHSComplexType) 992 RHS = S.ImpCastExprToType(RHS.get(), ResultType, CK_FloatingComplexCast); 993 else 994 RHS = S.ImpCastExprToType(RHS.get(), LHSElementType, CK_FloatingCast); 995 } 996 return ResultType; 997} 998 999/// \brief Hande arithmetic conversion from integer to float. Helper function 1000/// of UsualArithmeticConversions() 1001static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, 1002 ExprResult &IntExpr, 1003 QualType FloatTy, QualType IntTy, 1004 bool ConvertFloat, bool ConvertInt) { 1005 if (IntTy->isIntegerType()) { 1006 if (ConvertInt) 1007 // Convert intExpr to the lhs floating point type. 1008 IntExpr = S.ImpCastExprToType(IntExpr.get(), FloatTy, 1009 CK_IntegralToFloating); 1010 return FloatTy; 1011 } 1012 1013 // Convert both sides to the appropriate complex float. 1014 assert(IntTy->isComplexIntegerType()); 1015 QualType result = S.Context.getComplexType(FloatTy); 1016 1017 // _Complex int -> _Complex float 1018 if (ConvertInt) 1019 IntExpr = S.ImpCastExprToType(IntExpr.get(), result, 1020 CK_IntegralComplexToFloatingComplex); 1021 1022 // float -> _Complex float 1023 if (ConvertFloat) 1024 FloatExpr = S.ImpCastExprToType(FloatExpr.get(), result, 1025 CK_FloatingRealToComplex); 1026 1027 return result; 1028} 1029 1030/// \brief Handle arithmethic conversion with floating point types. Helper 1031/// function of UsualArithmeticConversions() 1032static QualType handleFloatConversion(Sema &S, ExprResult &LHS, 1033 ExprResult &RHS, QualType LHSType, 1034 QualType RHSType, bool IsCompAssign) { 1035 bool LHSFloat = LHSType->isRealFloatingType(); 1036 bool RHSFloat = RHSType->isRealFloatingType(); 1037 1038 // If we have two real floating types, convert the smaller operand 1039 // to the bigger result. 1040 if (LHSFloat && RHSFloat) { 1041 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 1042 if (order > 0) { 1043 RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FloatingCast); 1044 return LHSType; 1045 } 1046 1047 assert(order < 0 && "illegal float comparison"); 1048 if (!IsCompAssign) 1049 LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FloatingCast); 1050 return RHSType; 1051 } 1052 1053 if (LHSFloat) 1054 return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType, 1055 /*convertFloat=*/!IsCompAssign, 1056 /*convertInt=*/ true); 1057 assert(RHSFloat); 1058 return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType, 1059 /*convertInt=*/ true, 1060 /*convertFloat=*/!IsCompAssign); 1061} 1062 1063typedef ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType); 1064 1065namespace { 1066/// These helper callbacks are placed in an anonymous namespace to 1067/// permit their use as function template parameters. 1068ExprResult doIntegralCast(Sema &S, Expr *op, QualType toType) { 1069 return S.ImpCastExprToType(op, toType, CK_IntegralCast); 1070} 1071 1072ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) { 1073 return S.ImpCastExprToType(op, S.Context.getComplexType(toType), 1074 CK_IntegralComplexCast); 1075} 1076} 1077 1078/// \brief Handle integer arithmetic conversions. Helper function of 1079/// UsualArithmeticConversions() 1080template <PerformCastFn doLHSCast, PerformCastFn doRHSCast> 1081static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, 1082 ExprResult &RHS, QualType LHSType, 1083 QualType RHSType, bool IsCompAssign) { 1084 // The rules for this case are in C99 6.3.1.8 1085 int order = S.Context.getIntegerTypeOrder(LHSType, RHSType); 1086 bool LHSSigned = LHSType->hasSignedIntegerRepresentation(); 1087 bool RHSSigned = RHSType->hasSignedIntegerRepresentation(); 1088 if (LHSSigned == RHSSigned) { 1089 // Same signedness; use the higher-ranked type 1090 if (order >= 0) { 1091 RHS = (*doRHSCast)(S, RHS.get(), LHSType); 1092 return LHSType; 1093 } else if (!IsCompAssign) 1094 LHS = (*doLHSCast)(S, LHS.get(), RHSType); 1095 return RHSType; 1096 } else if (order != (LHSSigned ? 1 : -1)) { 1097 // The unsigned type has greater than or equal rank to the 1098 // signed type, so use the unsigned type 1099 if (RHSSigned) { 1100 RHS = (*doRHSCast)(S, RHS.get(), LHSType); 1101 return LHSType; 1102 } else if (!IsCompAssign) 1103 LHS = (*doLHSCast)(S, LHS.get(), RHSType); 1104 return RHSType; 1105 } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) { 1106 // The two types are different widths; if we are here, that 1107 // means the signed type is larger than the unsigned type, so 1108 // use the signed type. 1109 if (LHSSigned) { 1110 RHS = (*doRHSCast)(S, RHS.get(), LHSType); 1111 return LHSType; 1112 } else if (!IsCompAssign) 1113 LHS = (*doLHSCast)(S, LHS.get(), RHSType); 1114 return RHSType; 1115 } else { 1116 // The signed type is higher-ranked than the unsigned type, 1117 // but isn't actually any bigger (like unsigned int and long 1118 // on most 32-bit systems). Use the unsigned type corresponding 1119 // to the signed type. 1120 QualType result = 1121 S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType); 1122 RHS = (*doRHSCast)(S, RHS.get(), result); 1123 if (!IsCompAssign) 1124 LHS = (*doLHSCast)(S, LHS.get(), result); 1125 return result; 1126 } 1127} 1128 1129/// \brief Handle conversions with GCC complex int extension. Helper function 1130/// of UsualArithmeticConversions() 1131static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS, 1132 ExprResult &RHS, QualType LHSType, 1133 QualType RHSType, 1134 bool IsCompAssign) { 1135 const ComplexType *LHSComplexInt = LHSType->getAsComplexIntegerType(); 1136 const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType(); 1137 1138 if (LHSComplexInt && RHSComplexInt) { 1139 QualType LHSEltType = LHSComplexInt->getElementType(); 1140 QualType RHSEltType = RHSComplexInt->getElementType(); 1141 QualType ScalarType = 1142 handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast> 1143 (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign); 1144 1145 return S.Context.getComplexType(ScalarType); 1146 } 1147 1148 if (LHSComplexInt) { 1149 QualType LHSEltType = LHSComplexInt->getElementType(); 1150 QualType ScalarType = 1151 handleIntegerConversion<doComplexIntegralCast, doIntegralCast> 1152 (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign); 1153 QualType ComplexType = S.Context.getComplexType(ScalarType); 1154 RHS = S.ImpCastExprToType(RHS.get(), ComplexType, 1155 CK_IntegralRealToComplex); 1156 1157 return ComplexType; 1158 } 1159 1160 assert(RHSComplexInt); 1161 1162 QualType RHSEltType = RHSComplexInt->getElementType(); 1163 QualType ScalarType = 1164 handleIntegerConversion<doIntegralCast, doComplexIntegralCast> 1165 (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign); 1166 QualType ComplexType = S.Context.getComplexType(ScalarType); 1167 1168 if (!IsCompAssign) 1169 LHS = S.ImpCastExprToType(LHS.get(), ComplexType, 1170 CK_IntegralRealToComplex); 1171 return ComplexType; 1172} 1173 1174/// UsualArithmeticConversions - Performs various conversions that are common to 1175/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this 1176/// routine returns the first non-arithmetic type found. The client is 1177/// responsible for emitting appropriate error diagnostics. 1178QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, 1179 bool IsCompAssign) { 1180 if (!IsCompAssign) { 1181 LHS = UsualUnaryConversions(LHS.get()); 1182 if (LHS.isInvalid()) 1183 return QualType(); 1184 } 1185 1186 RHS = UsualUnaryConversions(RHS.get()); 1187 if (RHS.isInvalid()) 1188 return QualType(); 1189 1190 // For conversion purposes, we ignore any qualifiers. 1191 // For example, "const float" and "float" are equivalent. 1192 QualType LHSType = 1193 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType(); 1194 QualType RHSType = 1195 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType(); 1196 1197 // For conversion purposes, we ignore any atomic qualifier on the LHS. 1198 if (const AtomicType *AtomicLHS = LHSType->getAs<AtomicType>()) 1199 LHSType = AtomicLHS->getValueType(); 1200 1201 // If both types are identical, no conversion is needed. 1202 if (LHSType == RHSType) 1203 return LHSType; 1204 1205 // If either side is a non-arithmetic type (e.g. a pointer), we are done. 1206 // The caller can deal with this (e.g. pointer + int). 1207 if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType()) 1208 return QualType(); 1209 1210 // Apply unary and bitfield promotions to the LHS's type. 1211 QualType LHSUnpromotedType = LHSType; 1212 if (LHSType->isPromotableIntegerType()) 1213 LHSType = Context.getPromotedIntegerType(LHSType); 1214 QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get()); 1215 if (!LHSBitfieldPromoteTy.isNull()) 1216 LHSType = LHSBitfieldPromoteTy; 1217 if (LHSType != LHSUnpromotedType && !IsCompAssign) 1218 LHS = ImpCastExprToType(LHS.get(), LHSType, CK_IntegralCast); 1219 1220 // If both types are identical, no conversion is needed. 1221 if (LHSType == RHSType) 1222 return LHSType; 1223 1224 // At this point, we have two different arithmetic types. 1225 1226 // Handle complex types first (C99 6.3.1.8p1). 1227 if (LHSType->isComplexType() || RHSType->isComplexType()) 1228 return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType, 1229 IsCompAssign); 1230 1231 // Now handle "real" floating types (i.e. float, double, long double). 1232 if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType()) 1233 return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType, 1234 IsCompAssign); 1235 1236 // Handle GCC complex int extension. 1237 if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType()) 1238 return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType, 1239 IsCompAssign); 1240 1241 // Finally, we have two differing integer types. 1242 return handleIntegerConversion<doIntegralCast, doIntegralCast> 1243 (*this, LHS, RHS, LHSType, RHSType, IsCompAssign); 1244} 1245 1246 1247//===----------------------------------------------------------------------===// 1248// Semantic Analysis for various Expression Types 1249//===----------------------------------------------------------------------===// 1250 1251 1252ExprResult 1253Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc, 1254 SourceLocation DefaultLoc, 1255 SourceLocation RParenLoc, 1256 Expr *ControllingExpr, 1257 ArrayRef<ParsedType> ArgTypes, 1258 ArrayRef<Expr *> ArgExprs) { 1259 unsigned NumAssocs = ArgTypes.size(); 1260 assert(NumAssocs == ArgExprs.size()); 1261 1262 TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs]; 1263 for (unsigned i = 0; i < NumAssocs; ++i) { 1264 if (ArgTypes[i]) 1265 (void) GetTypeFromParser(ArgTypes[i], &Types[i]); 1266 else 1267 Types[i] = nullptr; 1268 } 1269 1270 ExprResult ER = CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, 1271 ControllingExpr, 1272 llvm::makeArrayRef(Types, NumAssocs), 1273 ArgExprs); 1274 delete [] Types; 1275 return ER; 1276} 1277 1278ExprResult 1279Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc, 1280 SourceLocation DefaultLoc, 1281 SourceLocation RParenLoc, 1282 Expr *ControllingExpr, 1283 ArrayRef<TypeSourceInfo *> Types, 1284 ArrayRef<Expr *> Exprs) { 1285 unsigned NumAssocs = Types.size(); 1286 assert(NumAssocs == Exprs.size()); 1287 if (ControllingExpr->getType()->isPlaceholderType()) { 1288 ExprResult result = CheckPlaceholderExpr(ControllingExpr); 1289 if (result.isInvalid()) return ExprError(); 1290 ControllingExpr = result.get(); 1291 } 1292 1293 // The controlling expression is an unevaluated operand, so side effects are 1294 // likely unintended. 1295 if (ActiveTemplateInstantiations.empty() && 1296 ControllingExpr->HasSideEffects(Context, false)) 1297 Diag(ControllingExpr->getExprLoc(), 1298 diag::warn_side_effects_unevaluated_context); 1299 1300 bool TypeErrorFound = false, 1301 IsResultDependent = ControllingExpr->isTypeDependent(), 1302 ContainsUnexpandedParameterPack 1303 = ControllingExpr->containsUnexpandedParameterPack(); 1304 1305 for (unsigned i = 0; i < NumAssocs; ++i) { 1306 if (Exprs[i]->containsUnexpandedParameterPack()) 1307 ContainsUnexpandedParameterPack = true; 1308 1309 if (Types[i]) { 1310 if (Types[i]->getType()->containsUnexpandedParameterPack()) 1311 ContainsUnexpandedParameterPack = true; 1312 1313 if (Types[i]->getType()->isDependentType()) { 1314 IsResultDependent = true; 1315 } else { 1316 // C11 6.5.1.1p2 "The type name in a generic association shall specify a 1317 // complete object type other than a variably modified type." 1318 unsigned D = 0; 1319 if (Types[i]->getType()->isIncompleteType()) 1320 D = diag::err_assoc_type_incomplete; 1321 else if (!Types[i]->getType()->isObjectType()) 1322 D = diag::err_assoc_type_nonobject; 1323 else if (Types[i]->getType()->isVariablyModifiedType()) 1324 D = diag::err_assoc_type_variably_modified; 1325 1326 if (D != 0) { 1327 Diag(Types[i]->getTypeLoc().getBeginLoc(), D) 1328 << Types[i]->getTypeLoc().getSourceRange() 1329 << Types[i]->getType(); 1330 TypeErrorFound = true; 1331 } 1332 1333 // C11 6.5.1.1p2 "No two generic associations in the same generic 1334 // selection shall specify compatible types." 1335 for (unsigned j = i+1; j < NumAssocs; ++j) 1336 if (Types[j] && !Types[j]->getType()->isDependentType() && 1337 Context.typesAreCompatible(Types[i]->getType(), 1338 Types[j]->getType())) { 1339 Diag(Types[j]->getTypeLoc().getBeginLoc(), 1340 diag::err_assoc_compatible_types) 1341 << Types[j]->getTypeLoc().getSourceRange() 1342 << Types[j]->getType() 1343 << Types[i]->getType(); 1344 Diag(Types[i]->getTypeLoc().getBeginLoc(), 1345 diag::note_compat_assoc) 1346 << Types[i]->getTypeLoc().getSourceRange() 1347 << Types[i]->getType(); 1348 TypeErrorFound = true; 1349 } 1350 } 1351 } 1352 } 1353 if (TypeErrorFound) 1354 return ExprError(); 1355 1356 // If we determined that the generic selection is result-dependent, don't 1357 // try to compute the result expression. 1358 if (IsResultDependent) 1359 return new (Context) GenericSelectionExpr( 1360 Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc, 1361 ContainsUnexpandedParameterPack); 1362 1363 SmallVector<unsigned, 1> CompatIndices; 1364 unsigned DefaultIndex = -1U; 1365 for (unsigned i = 0; i < NumAssocs; ++i) { 1366 if (!Types[i]) 1367 DefaultIndex = i; 1368 else if (Context.typesAreCompatible(ControllingExpr->getType(), 1369 Types[i]->getType())) 1370 CompatIndices.push_back(i); 1371 } 1372 1373 // C11 6.5.1.1p2 "The controlling expression of a generic selection shall have 1374 // type compatible with at most one of the types named in its generic 1375 // association list." 1376 if (CompatIndices.size() > 1) { 1377 // We strip parens here because the controlling expression is typically 1378 // parenthesized in macro definitions. 1379 ControllingExpr = ControllingExpr->IgnoreParens(); 1380 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_multi_match) 1381 << ControllingExpr->getSourceRange() << ControllingExpr->getType() 1382 << (unsigned) CompatIndices.size(); 1383 for (SmallVectorImpl<unsigned>::iterator I = CompatIndices.begin(), 1384 E = CompatIndices.end(); I != E; ++I) { 1385 Diag(Types[*I]->getTypeLoc().getBeginLoc(), 1386 diag::note_compat_assoc) 1387 << Types[*I]->getTypeLoc().getSourceRange() 1388 << Types[*I]->getType(); 1389 } 1390 return ExprError(); 1391 } 1392 1393 // C11 6.5.1.1p2 "If a generic selection has no default generic association, 1394 // its controlling expression shall have type compatible with exactly one of 1395 // the types named in its generic association list." 1396 if (DefaultIndex == -1U && CompatIndices.size() == 0) { 1397 // We strip parens here because the controlling expression is typically 1398 // parenthesized in macro definitions. 1399 ControllingExpr = ControllingExpr->IgnoreParens(); 1400 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_no_match) 1401 << ControllingExpr->getSourceRange() << ControllingExpr->getType(); 1402 return ExprError(); 1403 } 1404 1405 // C11 6.5.1.1p3 "If a generic selection has a generic association with a 1406 // type name that is compatible with the type of the controlling expression, 1407 // then the result expression of the generic selection is the expression 1408 // in that generic association. Otherwise, the result expression of the 1409 // generic selection is the expression in the default generic association." 1410 unsigned ResultIndex = 1411 CompatIndices.size() ? CompatIndices[0] : DefaultIndex; 1412 1413 return new (Context) GenericSelectionExpr( 1414 Context, KeyLoc, ControllingExpr, Types, Exprs, DefaultLoc, RParenLoc, 1415 ContainsUnexpandedParameterPack, ResultIndex); 1416} 1417 1418/// getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the 1419/// location of the token and the offset of the ud-suffix within it. 1420static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc, 1421 unsigned Offset) { 1422 return Lexer::AdvanceToTokenCharacter(TokLoc, Offset, S.getSourceManager(), 1423 S.getLangOpts()); 1424} 1425 1426/// BuildCookedLiteralOperatorCall - A user-defined literal was found. Look up 1427/// the corresponding cooked (non-raw) literal operator, and build a call to it. 1428static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope, 1429 IdentifierInfo *UDSuffix, 1430 SourceLocation UDSuffixLoc, 1431 ArrayRef<Expr*> Args, 1432 SourceLocation LitEndLoc) { 1433 assert(Args.size() <= 2 && "too many arguments for literal operator"); 1434 1435 QualType ArgTy[2]; 1436 for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) { 1437 ArgTy[ArgIdx] = Args[ArgIdx]->getType(); 1438 if (ArgTy[ArgIdx]->isArrayType()) 1439 ArgTy[ArgIdx] = S.Context.getArrayDecayedType(ArgTy[ArgIdx]); 1440 } 1441 1442 DeclarationName OpName = 1443 S.Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 1444 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 1445 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 1446 1447 LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName); 1448 if (S.LookupLiteralOperator(Scope, R, llvm::makeArrayRef(ArgTy, Args.size()), 1449 /*AllowRaw*/false, /*AllowTemplate*/false, 1450 /*AllowStringTemplate*/false) == Sema::LOLR_Error) 1451 return ExprError(); 1452 1453 return S.BuildLiteralOperatorCall(R, OpNameInfo, Args, LitEndLoc); 1454} 1455 1456/// ActOnStringLiteral - The specified tokens were lexed as pasted string 1457/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string 1458/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from 1459/// multiple tokens. However, the common case is that StringToks points to one 1460/// string. 1461/// 1462ExprResult 1463Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) { 1464 assert(!StringToks.empty() && "Must have at least one string!"); 1465 1466 StringLiteralParser Literal(StringToks, PP); 1467 if (Literal.hadError) 1468 return ExprError(); 1469 1470 SmallVector<SourceLocation, 4> StringTokLocs; 1471 for (unsigned i = 0; i != StringToks.size(); ++i) 1472 StringTokLocs.push_back(StringToks[i].getLocation()); 1473 1474 QualType CharTy = Context.CharTy; 1475 StringLiteral::StringKind Kind = StringLiteral::Ascii; 1476 if (Literal.isWide()) { 1477 CharTy = Context.getWideCharType(); 1478 Kind = StringLiteral::Wide; 1479 } else if (Literal.isUTF8()) { 1480 Kind = StringLiteral::UTF8; 1481 } else if (Literal.isUTF16()) { 1482 CharTy = Context.Char16Ty; 1483 Kind = StringLiteral::UTF16; 1484 } else if (Literal.isUTF32()) { 1485 CharTy = Context.Char32Ty; 1486 Kind = StringLiteral::UTF32; 1487 } else if (Literal.isPascal()) { 1488 CharTy = Context.UnsignedCharTy; 1489 } 1490 1491 QualType CharTyConst = CharTy; 1492 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1). 1493 if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings) 1494 CharTyConst.addConst(); 1495 1496 // Get an array type for the string, according to C99 6.4.5. This includes 1497 // the nul terminator character as well as the string length for pascal 1498 // strings. 1499 QualType StrTy = Context.getConstantArrayType(CharTyConst, 1500 llvm::APInt(32, Literal.GetNumStringChars()+1), 1501 ArrayType::Normal, 0); 1502 1503 // OpenCL v1.1 s6.5.3: a string literal is in the constant address space. 1504 if (getLangOpts().OpenCL) { 1505 StrTy = Context.getAddrSpaceQualType(StrTy, LangAS::opencl_constant); 1506 } 1507 1508 // Pass &StringTokLocs[0], StringTokLocs.size() to factory! 1509 StringLiteral *Lit = StringLiteral::Create(Context, Literal.GetString(), 1510 Kind, Literal.Pascal, StrTy, 1511 &StringTokLocs[0], 1512 StringTokLocs.size()); 1513 if (Literal.getUDSuffix().empty()) 1514 return Lit; 1515 1516 // We're building a user-defined literal. 1517 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 1518 SourceLocation UDSuffixLoc = 1519 getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()], 1520 Literal.getUDSuffixOffset()); 1521 1522 // Make sure we're allowed user-defined literals here. 1523 if (!UDLScope) 1524 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_string_udl)); 1525 1526 // C++11 [lex.ext]p5: The literal L is treated as a call of the form 1527 // operator "" X (str, len) 1528 QualType SizeType = Context.getSizeType(); 1529 1530 DeclarationName OpName = 1531 Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 1532 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 1533 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 1534 1535 QualType ArgTy[] = { 1536 Context.getArrayDecayedType(StrTy), SizeType 1537 }; 1538 1539 LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName); 1540 switch (LookupLiteralOperator(UDLScope, R, ArgTy, 1541 /*AllowRaw*/false, /*AllowTemplate*/false, 1542 /*AllowStringTemplate*/true)) { 1543 1544 case LOLR_Cooked: { 1545 llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars()); 1546 IntegerLiteral *LenArg = IntegerLiteral::Create(Context, Len, SizeType, 1547 StringTokLocs[0]); 1548 Expr *Args[] = { Lit, LenArg }; 1549 1550 return BuildLiteralOperatorCall(R, OpNameInfo, Args, StringTokLocs.back()); 1551 } 1552 1553 case LOLR_StringTemplate: { 1554 TemplateArgumentListInfo ExplicitArgs; 1555 1556 unsigned CharBits = Context.getIntWidth(CharTy); 1557 bool CharIsUnsigned = CharTy->isUnsignedIntegerType(); 1558 llvm::APSInt Value(CharBits, CharIsUnsigned); 1559 1560 TemplateArgument TypeArg(CharTy); 1561 TemplateArgumentLocInfo TypeArgInfo(Context.getTrivialTypeSourceInfo(CharTy)); 1562 ExplicitArgs.addArgument(TemplateArgumentLoc(TypeArg, TypeArgInfo)); 1563 1564 for (unsigned I = 0, N = Lit->getLength(); I != N; ++I) { 1565 Value = Lit->getCodeUnit(I); 1566 TemplateArgument Arg(Context, Value, CharTy); 1567 TemplateArgumentLocInfo ArgInfo; 1568 ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo)); 1569 } 1570 return BuildLiteralOperatorCall(R, OpNameInfo, None, StringTokLocs.back(), 1571 &ExplicitArgs); 1572 } 1573 case LOLR_Raw: 1574 case LOLR_Template: 1575 llvm_unreachable("unexpected literal operator lookup result"); 1576 case LOLR_Error: 1577 return ExprError(); 1578 } 1579 llvm_unreachable("unexpected literal operator lookup result"); 1580} 1581 1582ExprResult 1583Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1584 SourceLocation Loc, 1585 const CXXScopeSpec *SS) { 1586 DeclarationNameInfo NameInfo(D->getDeclName(), Loc); 1587 return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS); 1588} 1589 1590/// BuildDeclRefExpr - Build an expression that references a 1591/// declaration that does not require a closure capture. 1592ExprResult 1593Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1594 const DeclarationNameInfo &NameInfo, 1595 const CXXScopeSpec *SS, NamedDecl *FoundD, 1596 const TemplateArgumentListInfo *TemplateArgs) { 1597 if (getLangOpts().CUDA) 1598 if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext)) 1599 if (const FunctionDecl *Callee = dyn_cast<FunctionDecl>(D)) { 1600 if (CheckCUDATarget(Caller, Callee)) { 1601 Diag(NameInfo.getLoc(), diag::err_ref_bad_target) 1602 << IdentifyCUDATarget(Callee) << D->getIdentifier() 1603 << IdentifyCUDATarget(Caller); 1604 Diag(D->getLocation(), diag::note_previous_decl) 1605 << D->getIdentifier(); 1606 return ExprError(); 1607 } 1608 } 1609 1610 bool RefersToCapturedVariable = 1611 isa<VarDecl>(D) && 1612 NeedToCaptureVariable(cast<VarDecl>(D), NameInfo.getLoc()); 1613 1614 DeclRefExpr *E; 1615 if (isa<VarTemplateSpecializationDecl>(D)) { 1616 VarTemplateSpecializationDecl *VarSpec = 1617 cast<VarTemplateSpecializationDecl>(D); 1618 1619 E = DeclRefExpr::Create(Context, SS ? SS->getWithLocInContext(Context) 1620 : NestedNameSpecifierLoc(), 1621 VarSpec->getTemplateKeywordLoc(), D, 1622 RefersToCapturedVariable, NameInfo.getLoc(), Ty, VK, 1623 FoundD, TemplateArgs); 1624 } else { 1625 assert(!TemplateArgs && "No template arguments for non-variable" 1626 " template specialization references"); 1627 E = DeclRefExpr::Create(Context, SS ? SS->getWithLocInContext(Context) 1628 : NestedNameSpecifierLoc(), 1629 SourceLocation(), D, RefersToCapturedVariable, 1630 NameInfo, Ty, VK, FoundD); 1631 } 1632 1633 MarkDeclRefReferenced(E); 1634 1635 if (getLangOpts().ObjCARCWeak && isa<VarDecl>(D) && 1636 Ty.getObjCLifetime() == Qualifiers::OCL_Weak && 1637 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, E->getLocStart())) 1638 recordUseOfEvaluatedWeak(E); 1639 1640 // Just in case we're building an illegal pointer-to-member. 1641 FieldDecl *FD = dyn_cast<FieldDecl>(D); 1642 if (FD && FD->isBitField()) 1643 E->setObjectKind(OK_BitField); 1644 1645 return E; 1646} 1647 1648/// Decomposes the given name into a DeclarationNameInfo, its location, and 1649/// possibly a list of template arguments. 1650/// 1651/// If this produces template arguments, it is permitted to call 1652/// DecomposeTemplateName. 1653/// 1654/// This actually loses a lot of source location information for 1655/// non-standard name kinds; we should consider preserving that in 1656/// some way. 1657void 1658Sema::DecomposeUnqualifiedId(const UnqualifiedId &Id, 1659 TemplateArgumentListInfo &Buffer, 1660 DeclarationNameInfo &NameInfo, 1661 const TemplateArgumentListInfo *&TemplateArgs) { 1662 if (Id.getKind() == UnqualifiedId::IK_TemplateId) { 1663 Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc); 1664 Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc); 1665 1666 ASTTemplateArgsPtr TemplateArgsPtr(Id.TemplateId->getTemplateArgs(), 1667 Id.TemplateId->NumArgs); 1668 translateTemplateArguments(TemplateArgsPtr, Buffer); 1669 1670 TemplateName TName = Id.TemplateId->Template.get(); 1671 SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc; 1672 NameInfo = Context.getNameForTemplate(TName, TNameLoc); 1673 TemplateArgs = &Buffer; 1674 } else { 1675 NameInfo = GetNameFromUnqualifiedId(Id); 1676 TemplateArgs = nullptr; 1677 } 1678} 1679 1680static void emitEmptyLookupTypoDiagnostic( 1681 const TypoCorrection &TC, Sema &SemaRef, const CXXScopeSpec &SS, 1682 DeclarationName Typo, SourceLocation TypoLoc, ArrayRef<Expr *> Args, 1683 unsigned DiagnosticID, unsigned DiagnosticSuggestID) { 1684 DeclContext *Ctx = 1685 SS.isEmpty() ? nullptr : SemaRef.computeDeclContext(SS, false); 1686 if (!TC) { 1687 // Emit a special diagnostic for failed member lookups. 1688 // FIXME: computing the declaration context might fail here (?) 1689 if (Ctx) 1690 SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << Ctx 1691 << SS.getRange(); 1692 else 1693 SemaRef.Diag(TypoLoc, DiagnosticID) << Typo; 1694 return; 1695 } 1696 1697 std::string CorrectedStr = TC.getAsString(SemaRef.getLangOpts()); 1698 bool DroppedSpecifier = 1699 TC.WillReplaceSpecifier() && Typo.getAsString() == CorrectedStr; 1700 unsigned NoteID = 1701 (TC.getCorrectionDecl() && isa<ImplicitParamDecl>(TC.getCorrectionDecl())) 1702 ? diag::note_implicit_param_decl 1703 : diag::note_previous_decl; 1704 if (!Ctx) 1705 SemaRef.diagnoseTypo(TC, SemaRef.PDiag(DiagnosticSuggestID) << Typo, 1706 SemaRef.PDiag(NoteID)); 1707 else 1708 SemaRef.diagnoseTypo(TC, SemaRef.PDiag(diag::err_no_member_suggest) 1709 << Typo << Ctx << DroppedSpecifier 1710 << SS.getRange(), 1711 SemaRef.PDiag(NoteID)); 1712} 1713 1714/// Diagnose an empty lookup. 1715/// 1716/// \return false if new lookup candidates were found 1717bool 1718Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, 1719 std::unique_ptr<CorrectionCandidateCallback> CCC, 1720 TemplateArgumentListInfo *ExplicitTemplateArgs, 1721 ArrayRef<Expr *> Args, TypoExpr **Out) { 1722 DeclarationName Name = R.getLookupName(); 1723 1724 unsigned diagnostic = diag::err_undeclared_var_use; 1725 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest; 1726 if (Name.getNameKind() == DeclarationName::CXXOperatorName || 1727 Name.getNameKind() == DeclarationName::CXXLiteralOperatorName || 1728 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 1729 diagnostic = diag::err_undeclared_use; 1730 diagnostic_suggest = diag::err_undeclared_use_suggest; 1731 } 1732 1733 // If the original lookup was an unqualified lookup, fake an 1734 // unqualified lookup. This is useful when (for example) the 1735 // original lookup would not have found something because it was a 1736 // dependent name. 1737 DeclContext *DC = (SS.isEmpty() && !CallsUndergoingInstantiation.empty()) 1738 ? CurContext : nullptr; 1739 while (DC) { 1740 if (isa<CXXRecordDecl>(DC)) { 1741 LookupQualifiedName(R, DC); 1742 1743 if (!R.empty()) { 1744 // Don't give errors about ambiguities in this lookup. 1745 R.suppressDiagnostics(); 1746 1747 // During a default argument instantiation the CurContext points 1748 // to a CXXMethodDecl; but we can't apply a this-> fixit inside a 1749 // function parameter list, hence add an explicit check. 1750 bool isDefaultArgument = !ActiveTemplateInstantiations.empty() && 1751 ActiveTemplateInstantiations.back().Kind == 1752 ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation; 1753 CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext); 1754 bool isInstance = CurMethod && 1755 CurMethod->isInstance() && 1756 DC == CurMethod->getParent() && !isDefaultArgument; 1757 1758 1759 // Give a code modification hint to insert 'this->'. 1760 // TODO: fixit for inserting 'Base<T>::' in the other cases. 1761 // Actually quite difficult! 1762 if (getLangOpts().MSVCCompat) 1763 diagnostic = diag::ext_found_via_dependent_bases_lookup; 1764 if (isInstance) { 1765 Diag(R.getNameLoc(), diagnostic) << Name 1766 << FixItHint::CreateInsertion(R.getNameLoc(), "this->"); 1767 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>( 1768 CallsUndergoingInstantiation.back()->getCallee()); 1769 1770 CXXMethodDecl *DepMethod; 1771 if (CurMethod->isDependentContext()) 1772 DepMethod = CurMethod; 1773 else if (CurMethod->getTemplatedKind() == 1774 FunctionDecl::TK_FunctionTemplateSpecialization) 1775 DepMethod = cast<CXXMethodDecl>(CurMethod->getPrimaryTemplate()-> 1776 getInstantiatedFromMemberTemplate()->getTemplatedDecl()); 1777 else 1778 DepMethod = cast<CXXMethodDecl>( 1779 CurMethod->getInstantiatedFromMemberFunction()); 1780 assert(DepMethod && "No template pattern found"); 1781 1782 QualType DepThisType = DepMethod->getThisType(Context); 1783 CheckCXXThisCapture(R.getNameLoc()); 1784 CXXThisExpr *DepThis = new (Context) CXXThisExpr( 1785 R.getNameLoc(), DepThisType, false); 1786 TemplateArgumentListInfo TList; 1787 if (ULE->hasExplicitTemplateArgs()) 1788 ULE->copyTemplateArgumentsInto(TList); 1789 1790 CXXScopeSpec SS; 1791 SS.Adopt(ULE->getQualifierLoc()); 1792 CXXDependentScopeMemberExpr *DepExpr = 1793 CXXDependentScopeMemberExpr::Create( 1794 Context, DepThis, DepThisType, true, SourceLocation(), 1795 SS.getWithLocInContext(Context), 1796 ULE->getTemplateKeywordLoc(), nullptr, 1797 R.getLookupNameInfo(), 1798 ULE->hasExplicitTemplateArgs() ? &TList : nullptr); 1799 CallsUndergoingInstantiation.back()->setCallee(DepExpr); 1800 } else { 1801 Diag(R.getNameLoc(), diagnostic) << Name; 1802 } 1803 1804 // Do we really want to note all of these? 1805 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) 1806 Diag((*I)->getLocation(), diag::note_dependent_var_use); 1807 1808 // Return true if we are inside a default argument instantiation 1809 // and the found name refers to an instance member function, otherwise 1810 // the function calling DiagnoseEmptyLookup will try to create an 1811 // implicit member call and this is wrong for default argument. 1812 if (isDefaultArgument && ((*R.begin())->isCXXInstanceMember())) { 1813 Diag(R.getNameLoc(), diag::err_member_call_without_object); 1814 return true; 1815 } 1816 1817 // Tell the callee to try to recover. 1818 return false; 1819 } 1820 1821 R.clear(); 1822 } 1823 1824 // In Microsoft mode, if we are performing lookup from within a friend 1825 // function definition declared at class scope then we must set 1826 // DC to the lexical parent to be able to search into the parent 1827 // class. 1828 if (getLangOpts().MSVCCompat && isa<FunctionDecl>(DC) && 1829 cast<FunctionDecl>(DC)->getFriendObjectKind() && 1830 DC->getLexicalParent()->isRecord()) 1831 DC = DC->getLexicalParent(); 1832 else 1833 DC = DC->getParent(); 1834 } 1835 1836 // We didn't find anything, so try to correct for a typo. 1837 TypoCorrection Corrected; 1838 if (S && Out) { 1839 SourceLocation TypoLoc = R.getNameLoc(); 1840 assert(!ExplicitTemplateArgs && 1841 "Diagnosing an empty lookup with explicit template args!"); 1842 *Out = CorrectTypoDelayed( 1843 R.getLookupNameInfo(), R.getLookupKind(), S, &SS, std::move(CCC), 1844 [=](const TypoCorrection &TC) { 1845 emitEmptyLookupTypoDiagnostic(TC, *this, SS, Name, TypoLoc, Args, 1846 diagnostic, diagnostic_suggest); 1847 }, 1848 nullptr, CTK_ErrorRecovery); 1849 if (*Out) 1850 return true; 1851 } else if (S && (Corrected = 1852 CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, 1853 &SS, std::move(CCC), CTK_ErrorRecovery))) { 1854 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 1855 bool DroppedSpecifier = 1856 Corrected.WillReplaceSpecifier() && Name.getAsString() == CorrectedStr; 1857 R.setLookupName(Corrected.getCorrection()); 1858 1859 bool AcceptableWithRecovery = false; 1860 bool AcceptableWithoutRecovery = false; 1861 NamedDecl *ND = Corrected.getCorrectionDecl(); 1862 if (ND) { 1863 if (Corrected.isOverloaded()) { 1864 OverloadCandidateSet OCS(R.getNameLoc(), 1865 OverloadCandidateSet::CSK_Normal); 1866 OverloadCandidateSet::iterator Best; 1867 for (TypoCorrection::decl_iterator CD = Corrected.begin(), 1868 CDEnd = Corrected.end(); 1869 CD != CDEnd; ++CD) { 1870 if (FunctionTemplateDecl *FTD = 1871 dyn_cast<FunctionTemplateDecl>(*CD)) 1872 AddTemplateOverloadCandidate( 1873 FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs, 1874 Args, OCS); 1875 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD)) 1876 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0) 1877 AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), 1878 Args, OCS); 1879 } 1880 switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) { 1881 case OR_Success: 1882 ND = Best->Function; 1883 Corrected.setCorrectionDecl(ND); 1884 break; 1885 default: 1886 // FIXME: Arbitrarily pick the first declaration for the note. 1887 Corrected.setCorrectionDecl(ND); 1888 break; 1889 } 1890 } 1891 R.addDecl(ND); 1892 if (getLangOpts().CPlusPlus && ND->isCXXClassMember()) { 1893 CXXRecordDecl *Record = nullptr; 1894 if (Corrected.getCorrectionSpecifier()) { 1895 const Type *Ty = Corrected.getCorrectionSpecifier()->getAsType(); 1896 Record = Ty->getAsCXXRecordDecl(); 1897 } 1898 if (!Record) 1899 Record = cast<CXXRecordDecl>( 1900 ND->getDeclContext()->getRedeclContext()); 1901 R.setNamingClass(Record); 1902 } 1903 1904 AcceptableWithRecovery = 1905 isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND); 1906 // FIXME: If we ended up with a typo for a type name or 1907 // Objective-C class name, we're in trouble because the parser 1908 // is in the wrong place to recover. Suggest the typo 1909 // correction, but don't make it a fix-it since we're not going 1910 // to recover well anyway. 1911 AcceptableWithoutRecovery = 1912 isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND); 1913 } else { 1914 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it 1915 // because we aren't able to recover. 1916 AcceptableWithoutRecovery = true; 1917 } 1918 1919 if (AcceptableWithRecovery || AcceptableWithoutRecovery) { 1920 unsigned NoteID = (Corrected.getCorrectionDecl() && 1921 isa<ImplicitParamDecl>(Corrected.getCorrectionDecl())) 1922 ? diag::note_implicit_param_decl 1923 : diag::note_previous_decl; 1924 if (SS.isEmpty()) 1925 diagnoseTypo(Corrected, PDiag(diagnostic_suggest) << Name, 1926 PDiag(NoteID), AcceptableWithRecovery); 1927 else 1928 diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest) 1929 << Name << computeDeclContext(SS, false) 1930 << DroppedSpecifier << SS.getRange(), 1931 PDiag(NoteID), AcceptableWithRecovery); 1932 1933 // Tell the callee whether to try to recover. 1934 return !AcceptableWithRecovery; 1935 } 1936 } 1937 R.clear(); 1938 1939 // Emit a special diagnostic for failed member lookups. 1940 // FIXME: computing the declaration context might fail here (?) 1941 if (!SS.isEmpty()) { 1942 Diag(R.getNameLoc(), diag::err_no_member) 1943 << Name << computeDeclContext(SS, false) 1944 << SS.getRange(); 1945 return true; 1946 } 1947 1948 // Give up, we can't recover. 1949 Diag(R.getNameLoc(), diagnostic) << Name; 1950 return true; 1951} 1952 1953/// In Microsoft mode, if we are inside a template class whose parent class has 1954/// dependent base classes, and we can't resolve an unqualified identifier, then 1955/// assume the identifier is a member of a dependent base class. We can only 1956/// recover successfully in static methods, instance methods, and other contexts 1957/// where 'this' is available. This doesn't precisely match MSVC's 1958/// instantiation model, but it's close enough. 1959static Expr * 1960recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context, 1961 DeclarationNameInfo &NameInfo, 1962 SourceLocation TemplateKWLoc, 1963 const TemplateArgumentListInfo *TemplateArgs) { 1964 // Only try to recover from lookup into dependent bases in static methods or 1965 // contexts where 'this' is available. 1966 QualType ThisType = S.getCurrentThisType(); 1967 const CXXRecordDecl *RD = nullptr; 1968 if (!ThisType.isNull()) 1969 RD = ThisType->getPointeeType()->getAsCXXRecordDecl(); 1970 else if (auto *MD = dyn_cast<CXXMethodDecl>(S.CurContext)) 1971 RD = MD->getParent(); 1972 if (!RD || !RD->hasAnyDependentBases()) 1973 return nullptr; 1974 1975 // Diagnose this as unqualified lookup into a dependent base class. If 'this' 1976 // is available, suggest inserting 'this->' as a fixit. 1977 SourceLocation Loc = NameInfo.getLoc(); 1978 auto DB = S.Diag(Loc, diag::ext_undeclared_unqual_id_with_dependent_base); 1979 DB << NameInfo.getName() << RD; 1980 1981 if (!ThisType.isNull()) { 1982 DB << FixItHint::CreateInsertion(Loc, "this->"); 1983 return CXXDependentScopeMemberExpr::Create( 1984 Context, /*This=*/nullptr, ThisType, /*IsArrow=*/true, 1985 /*Op=*/SourceLocation(), NestedNameSpecifierLoc(), TemplateKWLoc, 1986 /*FirstQualifierInScope=*/nullptr, NameInfo, TemplateArgs); 1987 } 1988 1989 // Synthesize a fake NNS that points to the derived class. This will 1990 // perform name lookup during template instantiation. 1991 CXXScopeSpec SS; 1992 auto *NNS = 1993 NestedNameSpecifier::Create(Context, nullptr, true, RD->getTypeForDecl()); 1994 SS.MakeTrivial(Context, NNS, SourceRange(Loc, Loc)); 1995 return DependentScopeDeclRefExpr::Create( 1996 Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo, 1997 TemplateArgs); 1998} 1999 2000ExprResult 2001Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS, 2002 SourceLocation TemplateKWLoc, UnqualifiedId &Id, 2003 bool HasTrailingLParen, bool IsAddressOfOperand, 2004 std::unique_ptr<CorrectionCandidateCallback> CCC, 2005 bool IsInlineAsmIdentifier, Token *KeywordReplacement) { 2006 assert(!(IsAddressOfOperand && HasTrailingLParen) && 2007 "cannot be direct & operand and have a trailing lparen"); 2008 if (SS.isInvalid()) 2009 return ExprError(); 2010 2011 TemplateArgumentListInfo TemplateArgsBuffer; 2012 2013 // Decompose the UnqualifiedId into the following data. 2014 DeclarationNameInfo NameInfo; 2015 const TemplateArgumentListInfo *TemplateArgs; 2016 DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs); 2017 2018 DeclarationName Name = NameInfo.getName(); 2019 IdentifierInfo *II = Name.getAsIdentifierInfo(); 2020 SourceLocation NameLoc = NameInfo.getLoc(); 2021 2022 // C++ [temp.dep.expr]p3: 2023 // An id-expression is type-dependent if it contains: 2024 // -- an identifier that was declared with a dependent type, 2025 // (note: handled after lookup) 2026 // -- a template-id that is dependent, 2027 // (note: handled in BuildTemplateIdExpr) 2028 // -- a conversion-function-id that specifies a dependent type, 2029 // -- a nested-name-specifier that contains a class-name that 2030 // names a dependent type. 2031 // Determine whether this is a member of an unknown specialization; 2032 // we need to handle these differently. 2033 bool DependentID = false; 2034 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName && 2035 Name.getCXXNameType()->isDependentType()) { 2036 DependentID = true; 2037 } else if (SS.isSet()) { 2038 if (DeclContext *DC = computeDeclContext(SS, false)) { 2039 if (RequireCompleteDeclContext(SS, DC)) 2040 return ExprError(); 2041 } else { 2042 DependentID = true; 2043 } 2044 } 2045 2046 if (DependentID) 2047 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 2048 IsAddressOfOperand, TemplateArgs); 2049 2050 // Perform the required lookup. 2051 LookupResult R(*this, NameInfo, 2052 (Id.getKind() == UnqualifiedId::IK_ImplicitSelfParam) 2053 ? LookupObjCImplicitSelfParam : LookupOrdinaryName); 2054 if (TemplateArgs) { 2055 // Lookup the template name again to correctly establish the context in 2056 // which it was found. This is really unfortunate as we already did the 2057 // lookup to determine that it was a template name in the first place. If 2058 // this becomes a performance hit, we can work harder to preserve those 2059 // results until we get here but it's likely not worth it. 2060 bool MemberOfUnknownSpecialization; 2061 LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false, 2062 MemberOfUnknownSpecialization); 2063 2064 if (MemberOfUnknownSpecialization || 2065 (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)) 2066 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 2067 IsAddressOfOperand, TemplateArgs); 2068 } else { 2069 bool IvarLookupFollowUp = II && !SS.isSet() && getCurMethodDecl(); 2070 LookupParsedName(R, S, &SS, !IvarLookupFollowUp); 2071 2072 // If the result might be in a dependent base class, this is a dependent 2073 // id-expression. 2074 if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation) 2075 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 2076 IsAddressOfOperand, TemplateArgs); 2077 2078 // If this reference is in an Objective-C method, then we need to do 2079 // some special Objective-C lookup, too. 2080 if (IvarLookupFollowUp) { 2081 ExprResult E(LookupInObjCMethod(R, S, II, true)); 2082 if (E.isInvalid()) 2083 return ExprError(); 2084 2085 if (Expr *Ex = E.getAs<Expr>()) 2086 return Ex; 2087 } 2088 } 2089 2090 if (R.isAmbiguous()) 2091 return ExprError(); 2092 2093 // This could be an implicitly declared function reference (legal in C90, 2094 // extension in C99, forbidden in C++). 2095 if (R.empty() && HasTrailingLParen && II && !getLangOpts().CPlusPlus) { 2096 NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S); 2097 if (D) R.addDecl(D); 2098 } 2099 2100 // Determine whether this name might be a candidate for 2101 // argument-dependent lookup. 2102 bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen); 2103 2104 if (R.empty() && !ADL) { 2105 if (SS.isEmpty() && getLangOpts().MSVCCompat) { 2106 if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo, 2107 TemplateKWLoc, TemplateArgs)) 2108 return E; 2109 } 2110 2111 // Don't diagnose an empty lookup for inline assembly. 2112 if (IsInlineAsmIdentifier) 2113 return ExprError(); 2114 2115 // If this name wasn't predeclared and if this is not a function 2116 // call, diagnose the problem. 2117 TypoExpr *TE = nullptr; 2118 auto DefaultValidator = llvm::make_unique<CorrectionCandidateCallback>( 2119 II, SS.isValid() ? SS.getScopeRep() : nullptr); 2120 DefaultValidator->IsAddressOfOperand = IsAddressOfOperand; 2121 assert((!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) && 2122 "Typo correction callback misconfigured"); 2123 if (CCC) { 2124 // Make sure the callback knows what the typo being diagnosed is. 2125 CCC->setTypoName(II); 2126 if (SS.isValid()) 2127 CCC->setTypoNNS(SS.getScopeRep()); 2128 } 2129 if (DiagnoseEmptyLookup(S, SS, R, 2130 CCC ? std::move(CCC) : std::move(DefaultValidator), 2131 nullptr, None, &TE)) { 2132 if (TE && KeywordReplacement) { 2133 auto &State = getTypoExprState(TE); 2134 auto BestTC = State.Consumer->getNextCorrection(); 2135 if (BestTC.isKeyword()) { 2136 auto *II = BestTC.getCorrectionAsIdentifierInfo(); 2137 if (State.DiagHandler) 2138 State.DiagHandler(BestTC); 2139 KeywordReplacement->startToken(); 2140 KeywordReplacement->setKind(II->getTokenID()); 2141 KeywordReplacement->setIdentifierInfo(II); 2142 KeywordReplacement->setLocation(BestTC.getCorrectionRange().getBegin()); 2143 // Clean up the state associated with the TypoExpr, since it has 2144 // now been diagnosed (without a call to CorrectDelayedTyposInExpr). 2145 clearDelayedTypo(TE); 2146 // Signal that a correction to a keyword was performed by returning a 2147 // valid-but-null ExprResult. 2148 return (Expr*)nullptr; 2149 } 2150 State.Consumer->resetCorrectionStream(); 2151 } 2152 return TE ? TE : ExprError(); 2153 } 2154 2155 assert(!R.empty() && 2156 "DiagnoseEmptyLookup returned false but added no results"); 2157 2158 // If we found an Objective-C instance variable, let 2159 // LookupInObjCMethod build the appropriate expression to 2160 // reference the ivar. 2161 if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) { 2162 R.clear(); 2163 ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier())); 2164 // In a hopelessly buggy code, Objective-C instance variable 2165 // lookup fails and no expression will be built to reference it. 2166 if (!E.isInvalid() && !E.get()) 2167 return ExprError(); 2168 return E; 2169 } 2170 } 2171 2172 // This is guaranteed from this point on. 2173 assert(!R.empty() || ADL); 2174 2175 // Check whether this might be a C++ implicit instance member access. 2176 // C++ [class.mfct.non-static]p3: 2177 // When an id-expression that is not part of a class member access 2178 // syntax and not used to form a pointer to member is used in the 2179 // body of a non-static member function of class X, if name lookup 2180 // resolves the name in the id-expression to a non-static non-type 2181 // member of some class C, the id-expression is transformed into a 2182 // class member access expression using (*this) as the 2183 // postfix-expression to the left of the . operator. 2184 // 2185 // But we don't actually need to do this for '&' operands if R 2186 // resolved to a function or overloaded function set, because the 2187 // expression is ill-formed if it actually works out to be a 2188 // non-static member function: 2189 // 2190 // C++ [expr.ref]p4: 2191 // Otherwise, if E1.E2 refers to a non-static member function. . . 2192 // [t]he expression can be used only as the left-hand operand of a 2193 // member function call. 2194 // 2195 // There are other safeguards against such uses, but it's important 2196 // to get this right here so that we don't end up making a 2197 // spuriously dependent expression if we're inside a dependent 2198 // instance method. 2199 if (!R.empty() && (*R.begin())->isCXXClassMember()) { 2200 bool MightBeImplicitMember; 2201 if (!IsAddressOfOperand) 2202 MightBeImplicitMember = true; 2203 else if (!SS.isEmpty()) 2204 MightBeImplicitMember = false; 2205 else if (R.isOverloadedResult()) 2206 MightBeImplicitMember = false; 2207 else if (R.isUnresolvableResult()) 2208 MightBeImplicitMember = true; 2209 else 2210 MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) || 2211 isa<IndirectFieldDecl>(R.getFoundDecl()) || 2212 isa<MSPropertyDecl>(R.getFoundDecl()); 2213 2214 if (MightBeImplicitMember) 2215 return BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, 2216 R, TemplateArgs); 2217 } 2218 2219 if (TemplateArgs || TemplateKWLoc.isValid()) { 2220 2221 // In C++1y, if this is a variable template id, then check it 2222 // in BuildTemplateIdExpr(). 2223 // The single lookup result must be a variable template declaration. 2224 if (Id.getKind() == UnqualifiedId::IK_TemplateId && Id.TemplateId && 2225 Id.TemplateId->Kind == TNK_Var_template) { 2226 assert(R.getAsSingle<VarTemplateDecl>() && 2227 "There should only be one declaration found."); 2228 } 2229 2230 return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs); 2231 } 2232 2233 return BuildDeclarationNameExpr(SS, R, ADL); 2234} 2235 2236/// BuildQualifiedDeclarationNameExpr - Build a C++ qualified 2237/// declaration name, generally during template instantiation. 2238/// There's a large number of things which don't need to be done along 2239/// this path. 2240ExprResult 2241Sema::BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, 2242 const DeclarationNameInfo &NameInfo, 2243 bool IsAddressOfOperand, 2244 TypeSourceInfo **RecoveryTSI) { 2245 DeclContext *DC = computeDeclContext(SS, false); 2246 if (!DC) 2247 return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(), 2248 NameInfo, /*TemplateArgs=*/nullptr); 2249 2250 if (RequireCompleteDeclContext(SS, DC)) 2251 return ExprError(); 2252 2253 LookupResult R(*this, NameInfo, LookupOrdinaryName); 2254 LookupQualifiedName(R, DC); 2255 2256 if (R.isAmbiguous()) 2257 return ExprError(); 2258 2259 if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation) 2260 return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(), 2261 NameInfo, /*TemplateArgs=*/nullptr); 2262 2263 if (R.empty()) { 2264 Diag(NameInfo.getLoc(), diag::err_no_member) 2265 << NameInfo.getName() << DC << SS.getRange(); 2266 return ExprError(); 2267 } 2268 2269 if (const TypeDecl *TD = R.getAsSingle<TypeDecl>()) { 2270 // Diagnose a missing typename if this resolved unambiguously to a type in 2271 // a dependent context. If we can recover with a type, downgrade this to 2272 // a warning in Microsoft compatibility mode. 2273 unsigned DiagID = diag::err_typename_missing; 2274 if (RecoveryTSI && getLangOpts().MSVCCompat) 2275 DiagID = diag::ext_typename_missing; 2276 SourceLocation Loc = SS.getBeginLoc(); 2277 auto D = Diag(Loc, DiagID); 2278 D << SS.getScopeRep() << NameInfo.getName().getAsString() 2279 << SourceRange(Loc, NameInfo.getEndLoc()); 2280 2281 // Don't recover if the caller isn't expecting us to or if we're in a SFINAE 2282 // context. 2283 if (!RecoveryTSI) 2284 return ExprError(); 2285 2286 // Only issue the fixit if we're prepared to recover. 2287 D << FixItHint::CreateInsertion(Loc, "typename "); 2288 2289 // Recover by pretending this was an elaborated type. 2290 QualType Ty = Context.getTypeDeclType(TD); 2291 TypeLocBuilder TLB; 2292 TLB.pushTypeSpec(Ty).setNameLoc(NameInfo.getLoc()); 2293 2294 QualType ET = getElaboratedType(ETK_None, SS, Ty); 2295 ElaboratedTypeLoc QTL = TLB.push<ElaboratedTypeLoc>(ET); 2296 QTL.setElaboratedKeywordLoc(SourceLocation()); 2297 QTL.setQualifierLoc(SS.getWithLocInContext(Context)); 2298 2299 *RecoveryTSI = TLB.getTypeSourceInfo(Context, ET); 2300 2301 return ExprEmpty(); 2302 } 2303 2304 // Defend against this resolving to an implicit member access. We usually 2305 // won't get here if this might be a legitimate a class member (we end up in 2306 // BuildMemberReferenceExpr instead), but this can be valid if we're forming 2307 // a pointer-to-member or in an unevaluated context in C++11. 2308 if (!R.empty() && (*R.begin())->isCXXClassMember() && !IsAddressOfOperand) 2309 return BuildPossibleImplicitMemberExpr(SS, 2310 /*TemplateKWLoc=*/SourceLocation(), 2311 R, /*TemplateArgs=*/nullptr); 2312 2313 return BuildDeclarationNameExpr(SS, R, /* ADL */ false); 2314} 2315 2316/// LookupInObjCMethod - The parser has read a name in, and Sema has 2317/// detected that we're currently inside an ObjC method. Perform some 2318/// additional lookup. 2319/// 2320/// Ideally, most of this would be done by lookup, but there's 2321/// actually quite a lot of extra work involved. 2322/// 2323/// Returns a null sentinel to indicate trivial success. 2324ExprResult 2325Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S, 2326 IdentifierInfo *II, bool AllowBuiltinCreation) { 2327 SourceLocation Loc = Lookup.getNameLoc(); 2328 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 2329 2330 // Check for error condition which is already reported. 2331 if (!CurMethod) 2332 return ExprError(); 2333 2334 // There are two cases to handle here. 1) scoped lookup could have failed, 2335 // in which case we should look for an ivar. 2) scoped lookup could have 2336 // found a decl, but that decl is outside the current instance method (i.e. 2337 // a global variable). In these two cases, we do a lookup for an ivar with 2338 // this name, if the lookup sucedes, we replace it our current decl. 2339 2340 // If we're in a class method, we don't normally want to look for 2341 // ivars. But if we don't find anything else, and there's an 2342 // ivar, that's an error. 2343 bool IsClassMethod = CurMethod->isClassMethod(); 2344 2345 bool LookForIvars; 2346 if (Lookup.empty()) 2347 LookForIvars = true; 2348 else if (IsClassMethod) 2349 LookForIvars = false; 2350 else 2351 LookForIvars = (Lookup.isSingleResult() && 2352 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()); 2353 ObjCInterfaceDecl *IFace = nullptr; 2354 if (LookForIvars) { 2355 IFace = CurMethod->getClassInterface(); 2356 ObjCInterfaceDecl *ClassDeclared; 2357 ObjCIvarDecl *IV = nullptr; 2358 if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) { 2359 // Diagnose using an ivar in a class method. 2360 if (IsClassMethod) 2361 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 2362 << IV->getDeclName()); 2363 2364 // If we're referencing an invalid decl, just return this as a silent 2365 // error node. The error diagnostic was already emitted on the decl. 2366 if (IV->isInvalidDecl()) 2367 return ExprError(); 2368 2369 // Check if referencing a field with __attribute__((deprecated)). 2370 if (DiagnoseUseOfDecl(IV, Loc)) 2371 return ExprError(); 2372 2373 // Diagnose the use of an ivar outside of the declaring class. 2374 if (IV->getAccessControl() == ObjCIvarDecl::Private && 2375 !declaresSameEntity(ClassDeclared, IFace) && 2376 !getLangOpts().DebuggerSupport) 2377 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName(); 2378 2379 // FIXME: This should use a new expr for a direct reference, don't 2380 // turn this into Self->ivar, just return a BareIVarExpr or something. 2381 IdentifierInfo &II = Context.Idents.get("self"); 2382 UnqualifiedId SelfName; 2383 SelfName.setIdentifier(&II, SourceLocation()); 2384 SelfName.setKind(UnqualifiedId::IK_ImplicitSelfParam); 2385 CXXScopeSpec SelfScopeSpec; 2386 SourceLocation TemplateKWLoc; 2387 ExprResult SelfExpr = ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc, 2388 SelfName, false, false); 2389 if (SelfExpr.isInvalid()) 2390 return ExprError(); 2391 2392 SelfExpr = DefaultLvalueConversion(SelfExpr.get()); 2393 if (SelfExpr.isInvalid()) 2394 return ExprError(); 2395 2396 MarkAnyDeclReferenced(Loc, IV, true); 2397 2398 ObjCMethodFamily MF = CurMethod->getMethodFamily(); 2399 if (MF != OMF_init && MF != OMF_dealloc && MF != OMF_finalize && 2400 !IvarBacksCurrentMethodAccessor(IFace, CurMethod, IV)) 2401 Diag(Loc, diag::warn_direct_ivar_access) << IV->getDeclName(); 2402 2403 ObjCIvarRefExpr *Result = new (Context) 2404 ObjCIvarRefExpr(IV, IV->getType(), Loc, IV->getLocation(), 2405 SelfExpr.get(), true, true); 2406 2407 if (getLangOpts().ObjCAutoRefCount) { 2408 if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) { 2409 if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, Loc)) 2410 recordUseOfEvaluatedWeak(Result); 2411 } 2412 if (CurContext->isClosure()) 2413 Diag(Loc, diag::warn_implicitly_retains_self) 2414 << FixItHint::CreateInsertion(Loc, "self->"); 2415 } 2416 2417 return Result; 2418 } 2419 } else if (CurMethod->isInstanceMethod()) { 2420 // We should warn if a local variable hides an ivar. 2421 if (ObjCInterfaceDecl *IFace = CurMethod->getClassInterface()) { 2422 ObjCInterfaceDecl *ClassDeclared; 2423 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) { 2424 if (IV->getAccessControl() != ObjCIvarDecl::Private || 2425 declaresSameEntity(IFace, ClassDeclared)) 2426 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName(); 2427 } 2428 } 2429 } else if (Lookup.isSingleResult() && 2430 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()) { 2431 // If accessing a stand-alone ivar in a class method, this is an error. 2432 if (const ObjCIvarDecl *IV = dyn_cast<ObjCIvarDecl>(Lookup.getFoundDecl())) 2433 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 2434 << IV->getDeclName()); 2435 } 2436 2437 if (Lookup.empty() && II && AllowBuiltinCreation) { 2438 // FIXME. Consolidate this with similar code in LookupName. 2439 if (unsigned BuiltinID = II->getBuiltinID()) { 2440 if (!(getLangOpts().CPlusPlus && 2441 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) { 2442 NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID, 2443 S, Lookup.isForRedeclaration(), 2444 Lookup.getNameLoc()); 2445 if (D) Lookup.addDecl(D); 2446 } 2447 } 2448 } 2449 // Sentinel value saying that we didn't do anything special. 2450 return ExprResult((Expr *)nullptr); 2451} 2452 2453/// \brief Cast a base object to a member's actual type. 2454/// 2455/// Logically this happens in three phases: 2456/// 2457/// * First we cast from the base type to the naming class. 2458/// The naming class is the class into which we were looking 2459/// when we found the member; it's the qualifier type if a 2460/// qualifier was provided, and otherwise it's the base type. 2461/// 2462/// * Next we cast from the naming class to the declaring class. 2463/// If the member we found was brought into a class's scope by 2464/// a using declaration, this is that class; otherwise it's 2465/// the class declaring the member. 2466/// 2467/// * Finally we cast from the declaring class to the "true" 2468/// declaring class of the member. This conversion does not 2469/// obey access control. 2470ExprResult 2471Sema::PerformObjectMemberConversion(Expr *From, 2472 NestedNameSpecifier *Qualifier, 2473 NamedDecl *FoundDecl, 2474 NamedDecl *Member) { 2475 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext()); 2476 if (!RD) 2477 return From; 2478 2479 QualType DestRecordType; 2480 QualType DestType; 2481 QualType FromRecordType; 2482 QualType FromType = From->getType(); 2483 bool PointerConversions = false; 2484 if (isa<FieldDecl>(Member)) { 2485 DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD)); 2486 2487 if (FromType->getAs<PointerType>()) { 2488 DestType = Context.getPointerType(DestRecordType); 2489 FromRecordType = FromType->getPointeeType(); 2490 PointerConversions = true; 2491 } else { 2492 DestType = DestRecordType; 2493 FromRecordType = FromType; 2494 } 2495 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) { 2496 if (Method->isStatic()) 2497 return From; 2498 2499 DestType = Method->getThisType(Context); 2500 DestRecordType = DestType->getPointeeType(); 2501 2502 if (FromType->getAs<PointerType>()) { 2503 FromRecordType = FromType->getPointeeType(); 2504 PointerConversions = true; 2505 } else { 2506 FromRecordType = FromType; 2507 DestType = DestRecordType; 2508 } 2509 } else { 2510 // No conversion necessary. 2511 return From; 2512 } 2513 2514 if (DestType->isDependentType() || FromType->isDependentType()) 2515 return From; 2516 2517 // If the unqualified types are the same, no conversion is necessary. 2518 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 2519 return From; 2520 2521 SourceRange FromRange = From->getSourceRange(); 2522 SourceLocation FromLoc = FromRange.getBegin(); 2523 2524 ExprValueKind VK = From->getValueKind(); 2525 2526 // C++ [class.member.lookup]p8: 2527 // [...] Ambiguities can often be resolved by qualifying a name with its 2528 // class name. 2529 // 2530 // If the member was a qualified name and the qualified referred to a 2531 // specific base subobject type, we'll cast to that intermediate type 2532 // first and then to the object in which the member is declared. That allows 2533 // one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as: 2534 // 2535 // class Base { public: int x; }; 2536 // class Derived1 : public Base { }; 2537 // class Derived2 : public Base { }; 2538 // class VeryDerived : public Derived1, public Derived2 { void f(); }; 2539 // 2540 // void VeryDerived::f() { 2541 // x = 17; // error: ambiguous base subobjects 2542 // Derived1::x = 17; // okay, pick the Base subobject of Derived1 2543 // } 2544 if (Qualifier && Qualifier->getAsType()) { 2545 QualType QType = QualType(Qualifier->getAsType(), 0); 2546 assert(QType->isRecordType() && "lookup done with non-record type"); 2547 2548 QualType QRecordType = QualType(QType->getAs<RecordType>(), 0); 2549 2550 // In C++98, the qualifier type doesn't actually have to be a base 2551 // type of the object type, in which case we just ignore it. 2552 // Otherwise build the appropriate casts. 2553 if (IsDerivedFrom(FromRecordType, QRecordType)) { 2554 CXXCastPath BasePath; 2555 if (CheckDerivedToBaseConversion(FromRecordType, QRecordType, 2556 FromLoc, FromRange, &BasePath)) 2557 return ExprError(); 2558 2559 if (PointerConversions) 2560 QType = Context.getPointerType(QType); 2561 From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase, 2562 VK, &BasePath).get(); 2563 2564 FromType = QType; 2565 FromRecordType = QRecordType; 2566 2567 // If the qualifier type was the same as the destination type, 2568 // we're done. 2569 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 2570 return From; 2571 } 2572 } 2573 2574 bool IgnoreAccess = false; 2575 2576 // If we actually found the member through a using declaration, cast 2577 // down to the using declaration's type. 2578 // 2579 // Pointer equality is fine here because only one declaration of a 2580 // class ever has member declarations. 2581 if (FoundDecl->getDeclContext() != Member->getDeclContext()) { 2582 assert(isa<UsingShadowDecl>(FoundDecl)); 2583 QualType URecordType = Context.getTypeDeclType( 2584 cast<CXXRecordDecl>(FoundDecl->getDeclContext())); 2585 2586 // We only need to do this if the naming-class to declaring-class 2587 // conversion is non-trivial. 2588 if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) { 2589 assert(IsDerivedFrom(FromRecordType, URecordType)); 2590 CXXCastPath BasePath; 2591 if (CheckDerivedToBaseConversion(FromRecordType, URecordType, 2592 FromLoc, FromRange, &BasePath)) 2593 return ExprError(); 2594 2595 QualType UType = URecordType; 2596 if (PointerConversions) 2597 UType = Context.getPointerType(UType); 2598 From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase, 2599 VK, &BasePath).get(); 2600 FromType = UType; 2601 FromRecordType = URecordType; 2602 } 2603 2604 // We don't do access control for the conversion from the 2605 // declaring class to the true declaring class. 2606 IgnoreAccess = true; 2607 } 2608 2609 CXXCastPath BasePath; 2610 if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType, 2611 FromLoc, FromRange, &BasePath, 2612 IgnoreAccess)) 2613 return ExprError(); 2614 2615 return ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase, 2616 VK, &BasePath); 2617} 2618 2619bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS, 2620 const LookupResult &R, 2621 bool HasTrailingLParen) { 2622 // Only when used directly as the postfix-expression of a call. 2623 if (!HasTrailingLParen) 2624 return false; 2625 2626 // Never if a scope specifier was provided. 2627 if (SS.isSet()) 2628 return false; 2629 2630 // Only in C++ or ObjC++. 2631 if (!getLangOpts().CPlusPlus) 2632 return false; 2633 2634 // Turn off ADL when we find certain kinds of declarations during 2635 // normal lookup: 2636 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { 2637 NamedDecl *D = *I; 2638 2639 // C++0x [basic.lookup.argdep]p3: 2640 // -- a declaration of a class member 2641 // Since using decls preserve this property, we check this on the 2642 // original decl. 2643 if (D->isCXXClassMember()) 2644 return false; 2645 2646 // C++0x [basic.lookup.argdep]p3: 2647 // -- a block-scope function declaration that is not a 2648 // using-declaration 2649 // NOTE: we also trigger this for function templates (in fact, we 2650 // don't check the decl type at all, since all other decl types 2651 // turn off ADL anyway). 2652 if (isa<UsingShadowDecl>(D)) 2653 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 2654 else if (D->getLexicalDeclContext()->isFunctionOrMethod()) 2655 return false; 2656 2657 // C++0x [basic.lookup.argdep]p3: 2658 // -- a declaration that is neither a function or a function 2659 // template 2660 // And also for builtin functions. 2661 if (isa<FunctionDecl>(D)) { 2662 FunctionDecl *FDecl = cast<FunctionDecl>(D); 2663 2664 // But also builtin functions. 2665 if (FDecl->getBuiltinID() && FDecl->isImplicit()) 2666 return false; 2667 } else if (!isa<FunctionTemplateDecl>(D)) 2668 return false; 2669 } 2670 2671 return true; 2672} 2673 2674 2675/// Diagnoses obvious problems with the use of the given declaration 2676/// as an expression. This is only actually called for lookups that 2677/// were not overloaded, and it doesn't promise that the declaration 2678/// will in fact be used. 2679static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) { 2680 if (isa<TypedefNameDecl>(D)) { 2681 S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName(); 2682 return true; 2683 } 2684 2685 if (isa<ObjCInterfaceDecl>(D)) { 2686 S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName(); 2687 return true; 2688 } 2689 2690 if (isa<NamespaceDecl>(D)) { 2691 S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName(); 2692 return true; 2693 } 2694 2695 return false; 2696} 2697 2698ExprResult Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2699 LookupResult &R, bool NeedsADL, 2700 bool AcceptInvalidDecl) { 2701 // If this is a single, fully-resolved result and we don't need ADL, 2702 // just build an ordinary singleton decl ref. 2703 if (!NeedsADL && R.isSingleResult() && !R.getAsSingle<FunctionTemplateDecl>()) 2704 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), R.getFoundDecl(), 2705 R.getRepresentativeDecl(), nullptr, 2706 AcceptInvalidDecl); 2707 2708 // We only need to check the declaration if there's exactly one 2709 // result, because in the overloaded case the results can only be 2710 // functions and function templates. 2711 if (R.isSingleResult() && 2712 CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl())) 2713 return ExprError(); 2714 2715 // Otherwise, just build an unresolved lookup expression. Suppress 2716 // any lookup-related diagnostics; we'll hash these out later, when 2717 // we've picked a target. 2718 R.suppressDiagnostics(); 2719 2720 UnresolvedLookupExpr *ULE 2721 = UnresolvedLookupExpr::Create(Context, R.getNamingClass(), 2722 SS.getWithLocInContext(Context), 2723 R.getLookupNameInfo(), 2724 NeedsADL, R.isOverloadedResult(), 2725 R.begin(), R.end()); 2726 2727 return ULE; 2728} 2729 2730/// \brief Complete semantic analysis for a reference to the given declaration. 2731ExprResult Sema::BuildDeclarationNameExpr( 2732 const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D, 2733 NamedDecl *FoundD, const TemplateArgumentListInfo *TemplateArgs, 2734 bool AcceptInvalidDecl) { 2735 assert(D && "Cannot refer to a NULL declaration"); 2736 assert(!isa<FunctionTemplateDecl>(D) && 2737 "Cannot refer unambiguously to a function template"); 2738 2739 SourceLocation Loc = NameInfo.getLoc(); 2740 if (CheckDeclInExpr(*this, Loc, D)) 2741 return ExprError(); 2742 2743 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) { 2744 // Specifically diagnose references to class templates that are missing 2745 // a template argument list. 2746 Diag(Loc, diag::err_template_decl_ref) << (isa<VarTemplateDecl>(D) ? 1 : 0) 2747 << Template << SS.getRange(); 2748 Diag(Template->getLocation(), diag::note_template_decl_here); 2749 return ExprError(); 2750 } 2751 2752 // Make sure that we're referring to a value. 2753 ValueDecl *VD = dyn_cast<ValueDecl>(D); 2754 if (!VD) { 2755 Diag(Loc, diag::err_ref_non_value) 2756 << D << SS.getRange(); 2757 Diag(D->getLocation(), diag::note_declared_at); 2758 return ExprError(); 2759 } 2760 2761 // Check whether this declaration can be used. Note that we suppress 2762 // this check when we're going to perform argument-dependent lookup 2763 // on this function name, because this might not be the function 2764 // that overload resolution actually selects. 2765 if (DiagnoseUseOfDecl(VD, Loc)) 2766 return ExprError(); 2767 2768 // Only create DeclRefExpr's for valid Decl's. 2769 if (VD->isInvalidDecl() && !AcceptInvalidDecl) 2770 return ExprError(); 2771 2772 // Handle members of anonymous structs and unions. If we got here, 2773 // and the reference is to a class member indirect field, then this 2774 // must be the subject of a pointer-to-member expression. 2775 if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD)) 2776 if (!indirectField->isCXXClassMember()) 2777 return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(), 2778 indirectField); 2779 2780 { 2781 QualType type = VD->getType(); 2782 ExprValueKind valueKind = VK_RValue; 2783 2784 switch (D->getKind()) { 2785 // Ignore all the non-ValueDecl kinds. 2786#define ABSTRACT_DECL(kind) 2787#define VALUE(type, base) 2788#define DECL(type, base) \ 2789 case Decl::type: 2790#include "clang/AST/DeclNodes.inc" 2791 llvm_unreachable("invalid value decl kind"); 2792 2793 // These shouldn't make it here. 2794 case Decl::ObjCAtDefsField: 2795 case Decl::ObjCIvar: 2796 llvm_unreachable("forming non-member reference to ivar?"); 2797 2798 // Enum constants are always r-values and never references. 2799 // Unresolved using declarations are dependent. 2800 case Decl::EnumConstant: 2801 case Decl::UnresolvedUsingValue: 2802 valueKind = VK_RValue; 2803 break; 2804 2805 // Fields and indirect fields that got here must be for 2806 // pointer-to-member expressions; we just call them l-values for 2807 // internal consistency, because this subexpression doesn't really 2808 // exist in the high-level semantics. 2809 case Decl::Field: 2810 case Decl::IndirectField: 2811 assert(getLangOpts().CPlusPlus && 2812 "building reference to field in C?"); 2813 2814 // These can't have reference type in well-formed programs, but 2815 // for internal consistency we do this anyway. 2816 type = type.getNonReferenceType(); 2817 valueKind = VK_LValue; 2818 break; 2819 2820 // Non-type template parameters are either l-values or r-values 2821 // depending on the type. 2822 case Decl::NonTypeTemplateParm: { 2823 if (const ReferenceType *reftype = type->getAs<ReferenceType>()) { 2824 type = reftype->getPointeeType(); 2825 valueKind = VK_LValue; // even if the parameter is an r-value reference 2826 break; 2827 } 2828 2829 // For non-references, we need to strip qualifiers just in case 2830 // the template parameter was declared as 'const int' or whatever. 2831 valueKind = VK_RValue; 2832 type = type.getUnqualifiedType(); 2833 break; 2834 } 2835 2836 case Decl::Var: 2837 case Decl::VarTemplateSpecialization: 2838 case Decl::VarTemplatePartialSpecialization: 2839 // In C, "extern void blah;" is valid and is an r-value. 2840 if (!getLangOpts().CPlusPlus && 2841 !type.hasQualifiers() && 2842 type->isVoidType()) { 2843 valueKind = VK_RValue; 2844 break; 2845 } 2846 // fallthrough 2847 2848 case Decl::ImplicitParam: 2849 case Decl::ParmVar: { 2850 // These are always l-values. 2851 valueKind = VK_LValue; 2852 type = type.getNonReferenceType(); 2853 2854 // FIXME: Does the addition of const really only apply in 2855 // potentially-evaluated contexts? Since the variable isn't actually 2856 // captured in an unevaluated context, it seems that the answer is no. 2857 if (!isUnevaluatedContext()) { 2858 QualType CapturedType = getCapturedDeclRefType(cast<VarDecl>(VD), Loc); 2859 if (!CapturedType.isNull()) 2860 type = CapturedType; 2861 } 2862 2863 break; 2864 } 2865 2866 case Decl::Function: { 2867 if (unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) { 2868 if (!Context.BuiltinInfo.isPredefinedLibFunction(BID)) { 2869 type = Context.BuiltinFnTy; 2870 valueKind = VK_RValue; 2871 break; 2872 } 2873 } 2874 2875 const FunctionType *fty = type->castAs<FunctionType>(); 2876 2877 // If we're referring to a function with an __unknown_anytype 2878 // result type, make the entire expression __unknown_anytype. 2879 if (fty->getReturnType() == Context.UnknownAnyTy) { 2880 type = Context.UnknownAnyTy; 2881 valueKind = VK_RValue; 2882 break; 2883 } 2884 2885 // Functions are l-values in C++. 2886 if (getLangOpts().CPlusPlus) { 2887 valueKind = VK_LValue; 2888 break; 2889 } 2890 2891 // C99 DR 316 says that, if a function type comes from a 2892 // function definition (without a prototype), that type is only 2893 // used for checking compatibility. Therefore, when referencing 2894 // the function, we pretend that we don't have the full function 2895 // type. 2896 if (!cast<FunctionDecl>(VD)->hasPrototype() && 2897 isa<FunctionProtoType>(fty)) 2898 type = Context.getFunctionNoProtoType(fty->getReturnType(), 2899 fty->getExtInfo()); 2900 2901 // Functions are r-values in C. 2902 valueKind = VK_RValue; 2903 break; 2904 } 2905 2906 case Decl::MSProperty: 2907 valueKind = VK_LValue; 2908 break; 2909 2910 case Decl::CXXMethod: 2911 // If we're referring to a method with an __unknown_anytype 2912 // result type, make the entire expression __unknown_anytype. 2913 // This should only be possible with a type written directly. 2914 if (const FunctionProtoType *proto 2915 = dyn_cast<FunctionProtoType>(VD->getType())) 2916 if (proto->getReturnType() == Context.UnknownAnyTy) { 2917 type = Context.UnknownAnyTy; 2918 valueKind = VK_RValue; 2919 break; 2920 } 2921 2922 // C++ methods are l-values if static, r-values if non-static. 2923 if (cast<CXXMethodDecl>(VD)->isStatic()) { 2924 valueKind = VK_LValue; 2925 break; 2926 } 2927 // fallthrough 2928 2929 case Decl::CXXConversion: 2930 case Decl::CXXDestructor: 2931 case Decl::CXXConstructor: 2932 valueKind = VK_RValue; 2933 break; 2934 } 2935 2936 return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD, 2937 TemplateArgs); 2938 } 2939} 2940 2941static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source, 2942 SmallString<32> &Target) { 2943 Target.resize(CharByteWidth * (Source.size() + 1)); 2944 char *ResultPtr = &Target[0]; 2945 const UTF8 *ErrorPtr; 2946 bool success = ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr); 2947 (void)success; 2948 assert(success); 2949 Target.resize(ResultPtr - &Target[0]); 2950} 2951 2952ExprResult Sema::BuildPredefinedExpr(SourceLocation Loc, 2953 PredefinedExpr::IdentType IT) { 2954 // Pick the current block, lambda, captured statement or function. 2955 Decl *currentDecl = nullptr; 2956 if (const BlockScopeInfo *BSI = getCurBlock()) 2957 currentDecl = BSI->TheDecl; 2958 else if (const LambdaScopeInfo *LSI = getCurLambda()) 2959 currentDecl = LSI->CallOperator; 2960 else if (const CapturedRegionScopeInfo *CSI = getCurCapturedRegion()) 2961 currentDecl = CSI->TheCapturedDecl; 2962 else 2963 currentDecl = getCurFunctionOrMethodDecl(); 2964 2965 if (!currentDecl) { 2966 Diag(Loc, diag::ext_predef_outside_function); 2967 currentDecl = Context.getTranslationUnitDecl(); 2968 } 2969 2970 QualType ResTy; 2971 StringLiteral *SL = nullptr; 2972 if (cast<DeclContext>(currentDecl)->isDependentContext()) 2973 ResTy = Context.DependentTy; 2974 else { 2975 // Pre-defined identifiers are of type char[x], where x is the length of 2976 // the string. 2977 auto Str = PredefinedExpr::ComputeName(IT, currentDecl); 2978 unsigned Length = Str.length(); 2979 2980 llvm::APInt LengthI(32, Length + 1); 2981 if (IT == PredefinedExpr::LFunction) { 2982 ResTy = Context.WideCharTy.withConst(); 2983 SmallString<32> RawChars; 2984 ConvertUTF8ToWideString(Context.getTypeSizeInChars(ResTy).getQuantity(), 2985 Str, RawChars); 2986 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 2987 /*IndexTypeQuals*/ 0); 2988 SL = StringLiteral::Create(Context, RawChars, StringLiteral::Wide, 2989 /*Pascal*/ false, ResTy, Loc); 2990 } else { 2991 ResTy = Context.CharTy.withConst(); 2992 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 2993 /*IndexTypeQuals*/ 0); 2994 SL = StringLiteral::Create(Context, Str, StringLiteral::Ascii, 2995 /*Pascal*/ false, ResTy, Loc); 2996 } 2997 } 2998 2999 return new (Context) PredefinedExpr(Loc, ResTy, IT, SL); 3000} 3001 3002ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) { 3003 PredefinedExpr::IdentType IT; 3004 3005 switch (Kind) { 3006 default: llvm_unreachable("Unknown simple primary expr!"); 3007 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2] 3008 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break; 3009 case tok::kw___FUNCDNAME__: IT = PredefinedExpr::FuncDName; break; // [MS] 3010 case tok::kw___FUNCSIG__: IT = PredefinedExpr::FuncSig; break; // [MS] 3011 case tok::kw_L__FUNCTION__: IT = PredefinedExpr::LFunction; break; 3012 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break; 3013 } 3014 3015 return BuildPredefinedExpr(Loc, IT); 3016} 3017 3018ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) { 3019 SmallString<16> CharBuffer; 3020 bool Invalid = false; 3021 StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid); 3022 if (Invalid) 3023 return ExprError(); 3024 3025 CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(), 3026 PP, Tok.getKind()); 3027 if (Literal.hadError()) 3028 return ExprError(); 3029 3030 QualType Ty; 3031 if (Literal.isWide()) 3032 Ty = Context.WideCharTy; // L'x' -> wchar_t in C and C++. 3033 else if (Literal.isUTF16()) 3034 Ty = Context.Char16Ty; // u'x' -> char16_t in C11 and C++11. 3035 else if (Literal.isUTF32()) 3036 Ty = Context.Char32Ty; // U'x' -> char32_t in C11 and C++11. 3037 else if (!getLangOpts().CPlusPlus || Literal.isMultiChar()) 3038 Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++. 3039 else 3040 Ty = Context.CharTy; // 'x' -> char in C++ 3041 3042 CharacterLiteral::CharacterKind Kind = CharacterLiteral::Ascii; 3043 if (Literal.isWide()) 3044 Kind = CharacterLiteral::Wide; 3045 else if (Literal.isUTF16()) 3046 Kind = CharacterLiteral::UTF16; 3047 else if (Literal.isUTF32()) 3048 Kind = CharacterLiteral::UTF32; 3049 3050 Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty, 3051 Tok.getLocation()); 3052 3053 if (Literal.getUDSuffix().empty()) 3054 return Lit; 3055 3056 // We're building a user-defined literal. 3057 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 3058 SourceLocation UDSuffixLoc = 3059 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset()); 3060 3061 // Make sure we're allowed user-defined literals here. 3062 if (!UDLScope) 3063 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_character_udl)); 3064 3065 // C++11 [lex.ext]p6: The literal L is treated as a call of the form 3066 // operator "" X (ch) 3067 return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc, 3068 Lit, Tok.getLocation()); 3069} 3070 3071ExprResult Sema::ActOnIntegerConstant(SourceLocation Loc, uint64_t Val) { 3072 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 3073 return IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val), 3074 Context.IntTy, Loc); 3075} 3076 3077static Expr *BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal, 3078 QualType Ty, SourceLocation Loc) { 3079 const llvm::fltSemantics &Format = S.Context.getFloatTypeSemantics(Ty); 3080 3081 using llvm::APFloat; 3082 APFloat Val(Format); 3083 3084 APFloat::opStatus result = Literal.GetFloatValue(Val); 3085 3086 // Overflow is always an error, but underflow is only an error if 3087 // we underflowed to zero (APFloat reports denormals as underflow). 3088 if ((result & APFloat::opOverflow) || 3089 ((result & APFloat::opUnderflow) && Val.isZero())) { 3090 unsigned diagnostic; 3091 SmallString<20> buffer; 3092 if (result & APFloat::opOverflow) { 3093 diagnostic = diag::warn_float_overflow; 3094 APFloat::getLargest(Format).toString(buffer); 3095 } else { 3096 diagnostic = diag::warn_float_underflow; 3097 APFloat::getSmallest(Format).toString(buffer); 3098 } 3099 3100 S.Diag(Loc, diagnostic) 3101 << Ty 3102 << StringRef(buffer.data(), buffer.size()); 3103 } 3104 3105 bool isExact = (result == APFloat::opOK); 3106 return FloatingLiteral::Create(S.Context, Val, isExact, Ty, Loc); 3107} 3108 3109bool Sema::CheckLoopHintExpr(Expr *E, SourceLocation Loc) { 3110 assert(E && "Invalid expression"); 3111 3112 if (E->isValueDependent()) 3113 return false; 3114 3115 QualType QT = E->getType(); 3116 if (!QT->isIntegerType() || QT->isBooleanType() || QT->isCharType()) { 3117 Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_type) << QT; 3118 return true; 3119 } 3120 3121 llvm::APSInt ValueAPS; 3122 ExprResult R = VerifyIntegerConstantExpression(E, &ValueAPS); 3123 3124 if (R.isInvalid()) 3125 return true; 3126 3127 bool ValueIsPositive = ValueAPS.isStrictlyPositive(); 3128 if (!ValueIsPositive || ValueAPS.getActiveBits() > 31) { 3129 Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_value) 3130 << ValueAPS.toString(10) << ValueIsPositive; 3131 return true; 3132 } 3133 3134 return false; 3135} 3136 3137ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) { 3138 // Fast path for a single digit (which is quite common). A single digit 3139 // cannot have a trigraph, escaped newline, radix prefix, or suffix. 3140 if (Tok.getLength() == 1) { 3141 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok); 3142 return ActOnIntegerConstant(Tok.getLocation(), Val-'0'); 3143 } 3144 3145 SmallString<128> SpellingBuffer; 3146 // NumericLiteralParser wants to overread by one character. Add padding to 3147 // the buffer in case the token is copied to the buffer. If getSpelling() 3148 // returns a StringRef to the memory buffer, it should have a null char at 3149 // the EOF, so it is also safe. 3150 SpellingBuffer.resize(Tok.getLength() + 1); 3151 3152 // Get the spelling of the token, which eliminates trigraphs, etc. 3153 bool Invalid = false; 3154 StringRef TokSpelling = PP.getSpelling(Tok, SpellingBuffer, &Invalid); 3155 if (Invalid) 3156 return ExprError(); 3157 3158 NumericLiteralParser Literal(TokSpelling, Tok.getLocation(), PP); 3159 if (Literal.hadError) 3160 return ExprError(); 3161 3162 if (Literal.hasUDSuffix()) { 3163 // We're building a user-defined literal. 3164 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 3165 SourceLocation UDSuffixLoc = 3166 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset()); 3167 3168 // Make sure we're allowed user-defined literals here. 3169 if (!UDLScope) 3170 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_numeric_udl)); 3171 3172 QualType CookedTy; 3173 if (Literal.isFloatingLiteral()) { 3174 // C++11 [lex.ext]p4: If S contains a literal operator with parameter type 3175 // long double, the literal is treated as a call of the form 3176 // operator "" X (f L) 3177 CookedTy = Context.LongDoubleTy; 3178 } else { 3179 // C++11 [lex.ext]p3: If S contains a literal operator with parameter type 3180 // unsigned long long, the literal is treated as a call of the form 3181 // operator "" X (n ULL) 3182 CookedTy = Context.UnsignedLongLongTy; 3183 } 3184 3185 DeclarationName OpName = 3186 Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 3187 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 3188 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 3189 3190 SourceLocation TokLoc = Tok.getLocation(); 3191 3192 // Perform literal operator lookup to determine if we're building a raw 3193 // literal or a cooked one. 3194 LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName); 3195 switch (LookupLiteralOperator(UDLScope, R, CookedTy, 3196 /*AllowRaw*/true, /*AllowTemplate*/true, 3197 /*AllowStringTemplate*/false)) { 3198 case LOLR_Error: 3199 return ExprError(); 3200 3201 case LOLR_Cooked: { 3202 Expr *Lit; 3203 if (Literal.isFloatingLiteral()) { 3204 Lit = BuildFloatingLiteral(*this, Literal, CookedTy, Tok.getLocation()); 3205 } else { 3206 llvm::APInt ResultVal(Context.getTargetInfo().getLongLongWidth(), 0); 3207 if (Literal.GetIntegerValue(ResultVal)) 3208 Diag(Tok.getLocation(), diag::err_integer_literal_too_large) 3209 << /* Unsigned */ 1; 3210 Lit = IntegerLiteral::Create(Context, ResultVal, CookedTy, 3211 Tok.getLocation()); 3212 } 3213 return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc); 3214 } 3215 3216 case LOLR_Raw: { 3217 // C++11 [lit.ext]p3, p4: If S contains a raw literal operator, the 3218 // literal is treated as a call of the form 3219 // operator "" X ("n") 3220 unsigned Length = Literal.getUDSuffixOffset(); 3221 QualType StrTy = Context.getConstantArrayType( 3222 Context.CharTy.withConst(), llvm::APInt(32, Length + 1), 3223 ArrayType::Normal, 0); 3224 Expr *Lit = StringLiteral::Create( 3225 Context, StringRef(TokSpelling.data(), Length), StringLiteral::Ascii, 3226 /*Pascal*/false, StrTy, &TokLoc, 1); 3227 return BuildLiteralOperatorCall(R, OpNameInfo, Lit, TokLoc); 3228 } 3229 3230 case LOLR_Template: { 3231 // C++11 [lit.ext]p3, p4: Otherwise (S contains a literal operator 3232 // template), L is treated as a call fo the form 3233 // operator "" X <'c1', 'c2', ... 'ck'>() 3234 // where n is the source character sequence c1 c2 ... ck. 3235 TemplateArgumentListInfo ExplicitArgs; 3236 unsigned CharBits = Context.getIntWidth(Context.CharTy); 3237 bool CharIsUnsigned = Context.CharTy->isUnsignedIntegerType(); 3238 llvm::APSInt Value(CharBits, CharIsUnsigned); 3239 for (unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) { 3240 Value = TokSpelling[I]; 3241 TemplateArgument Arg(Context, Value, Context.CharTy); 3242 TemplateArgumentLocInfo ArgInfo; 3243 ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo)); 3244 } 3245 return BuildLiteralOperatorCall(R, OpNameInfo, None, TokLoc, 3246 &ExplicitArgs); 3247 } 3248 case LOLR_StringTemplate: 3249 llvm_unreachable("unexpected literal operator lookup result"); 3250 } 3251 } 3252 3253 Expr *Res; 3254 3255 if (Literal.isFloatingLiteral()) { 3256 QualType Ty; 3257 if (Literal.isFloat) 3258 Ty = Context.FloatTy; 3259 else if (!Literal.isLong) 3260 Ty = Context.DoubleTy; 3261 else 3262 Ty = Context.LongDoubleTy; 3263 3264 Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation()); 3265 3266 if (Ty == Context.DoubleTy) { 3267 if (getLangOpts().SinglePrecisionConstants) { 3268 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get(); 3269 } else if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp64) { 3270 Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64); 3271 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get(); 3272 } 3273 } 3274 } else if (!Literal.isIntegerLiteral()) { 3275 return ExprError(); 3276 } else { 3277 QualType Ty; 3278 3279 // 'long long' is a C99 or C++11 feature. 3280 if (!getLangOpts().C99 && Literal.isLongLong) { 3281 if (getLangOpts().CPlusPlus) 3282 Diag(Tok.getLocation(), 3283 getLangOpts().CPlusPlus11 ? 3284 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong); 3285 else 3286 Diag(Tok.getLocation(), diag::ext_c99_longlong); 3287 } 3288 3289 // Get the value in the widest-possible width. 3290 unsigned MaxWidth = Context.getTargetInfo().getIntMaxTWidth(); 3291 // The microsoft literal suffix extensions support 128-bit literals, which 3292 // may be wider than [u]intmax_t. 3293 // FIXME: Actually, they don't. We seem to have accidentally invented the 3294 // i128 suffix. 3295 if (Literal.MicrosoftInteger == 128 && MaxWidth < 128 && 3296 Context.getTargetInfo().hasInt128Type()) 3297 MaxWidth = 128; 3298 llvm::APInt ResultVal(MaxWidth, 0); 3299 3300 if (Literal.GetIntegerValue(ResultVal)) { 3301 // If this value didn't fit into uintmax_t, error and force to ull. 3302 Diag(Tok.getLocation(), diag::err_integer_literal_too_large) 3303 << /* Unsigned */ 1; 3304 Ty = Context.UnsignedLongLongTy; 3305 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() && 3306 "long long is not intmax_t?"); 3307 } else { 3308 // If this value fits into a ULL, try to figure out what else it fits into 3309 // according to the rules of C99 6.4.4.1p5. 3310 3311 // Octal, Hexadecimal, and integers with a U suffix are allowed to 3312 // be an unsigned int. 3313 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10; 3314 3315 // Check from smallest to largest, picking the smallest type we can. 3316 unsigned Width = 0; 3317 3318 // Microsoft specific integer suffixes are explicitly sized. 3319 if (Literal.MicrosoftInteger) { 3320 if (Literal.MicrosoftInteger > MaxWidth) { 3321 // If this target doesn't support __int128, error and force to ull. 3322 Diag(Tok.getLocation(), diag::err_int128_unsupported); 3323 Width = MaxWidth; 3324 Ty = Context.getIntMaxType(); 3325 } else { 3326 Width = Literal.MicrosoftInteger; 3327 Ty = Context.getIntTypeForBitwidth(Width, 3328 /*Signed=*/!Literal.isUnsigned); 3329 } 3330 } 3331 3332 if (Ty.isNull() && !Literal.isLong && !Literal.isLongLong) { 3333 // Are int/unsigned possibilities? 3334 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 3335 3336 // Does it fit in a unsigned int? 3337 if (ResultVal.isIntN(IntSize)) { 3338 // Does it fit in a signed int? 3339 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0) 3340 Ty = Context.IntTy; 3341 else if (AllowUnsigned) 3342 Ty = Context.UnsignedIntTy; 3343 Width = IntSize; 3344 } 3345 } 3346 3347 // Are long/unsigned long possibilities? 3348 if (Ty.isNull() && !Literal.isLongLong) { 3349 unsigned LongSize = Context.getTargetInfo().getLongWidth(); 3350 3351 // Does it fit in a unsigned long? 3352 if (ResultVal.isIntN(LongSize)) { 3353 // Does it fit in a signed long? 3354 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0) 3355 Ty = Context.LongTy; 3356 else if (AllowUnsigned) 3357 Ty = Context.UnsignedLongTy; 3358 Width = LongSize; 3359 } 3360 } 3361 3362 // Check long long if needed. 3363 if (Ty.isNull()) { 3364 unsigned LongLongSize = Context.getTargetInfo().getLongLongWidth(); 3365 3366 // Does it fit in a unsigned long long? 3367 if (ResultVal.isIntN(LongLongSize)) { 3368 // Does it fit in a signed long long? 3369 // To be compatible with MSVC, hex integer literals ending with the 3370 // LL or i64 suffix are always signed in Microsoft mode. 3371 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 || 3372 (getLangOpts().MicrosoftExt && Literal.isLongLong))) 3373 Ty = Context.LongLongTy; 3374 else if (AllowUnsigned) 3375 Ty = Context.UnsignedLongLongTy; 3376 Width = LongLongSize; 3377 } 3378 } 3379 3380 // If we still couldn't decide a type, we probably have something that 3381 // does not fit in a signed long long, but has no U suffix. 3382 if (Ty.isNull()) { 3383 Diag(Tok.getLocation(), diag::ext_integer_literal_too_large_for_signed); 3384 Ty = Context.UnsignedLongLongTy; 3385 Width = Context.getTargetInfo().getLongLongWidth(); 3386 } 3387 3388 if (ResultVal.getBitWidth() != Width) 3389 ResultVal = ResultVal.trunc(Width); 3390 } 3391 Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation()); 3392 } 3393 3394 // If this is an imaginary literal, create the ImaginaryLiteral wrapper. 3395 if (Literal.isImaginary) 3396 Res = new (Context) ImaginaryLiteral(Res, 3397 Context.getComplexType(Res->getType())); 3398 3399 return Res; 3400} 3401 3402ExprResult Sema::ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E) { 3403 assert(E && "ActOnParenExpr() missing expr"); 3404 return new (Context) ParenExpr(L, R, E); 3405} 3406 3407static bool CheckVecStepTraitOperandType(Sema &S, QualType T, 3408 SourceLocation Loc, 3409 SourceRange ArgRange) { 3410 // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in 3411 // scalar or vector data type argument..." 3412 // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic 3413 // type (C99 6.2.5p18) or void. 3414 if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) { 3415 S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type) 3416 << T << ArgRange; 3417 return true; 3418 } 3419 3420 assert((T->isVoidType() || !T->isIncompleteType()) && 3421 "Scalar types should always be complete"); 3422 return false; 3423} 3424 3425static bool CheckExtensionTraitOperandType(Sema &S, QualType T, 3426 SourceLocation Loc, 3427 SourceRange ArgRange, 3428 UnaryExprOrTypeTrait TraitKind) { 3429 // Invalid types must be hard errors for SFINAE in C++. 3430 if (S.LangOpts.CPlusPlus) 3431 return true; 3432 3433 // C99 6.5.3.4p1: 3434 if (T->isFunctionType() && 3435 (TraitKind == UETT_SizeOf || TraitKind == UETT_AlignOf)) { 3436 // sizeof(function)/alignof(function) is allowed as an extension. 3437 S.Diag(Loc, diag::ext_sizeof_alignof_function_type) 3438 << TraitKind << ArgRange; 3439 return false; 3440 } 3441 3442 // Allow sizeof(void)/alignof(void) as an extension, unless in OpenCL where 3443 // this is an error (OpenCL v1.1 s6.3.k) 3444 if (T->isVoidType()) { 3445 unsigned DiagID = S.LangOpts.OpenCL ? diag::err_opencl_sizeof_alignof_type 3446 : diag::ext_sizeof_alignof_void_type; 3447 S.Diag(Loc, DiagID) << TraitKind << ArgRange; 3448 return false; 3449 } 3450 3451 return true; 3452} 3453 3454static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, 3455 SourceLocation Loc, 3456 SourceRange ArgRange, 3457 UnaryExprOrTypeTrait TraitKind) { 3458 // Reject sizeof(interface) and sizeof(interface<proto>) if the 3459 // runtime doesn't allow it. 3460 if (!S.LangOpts.ObjCRuntime.allowsSizeofAlignof() && T->isObjCObjectType()) { 3461 S.Diag(Loc, diag::err_sizeof_nonfragile_interface) 3462 << T << (TraitKind == UETT_SizeOf) 3463 << ArgRange; 3464 return true; 3465 } 3466 3467 return false; 3468} 3469 3470/// \brief Check whether E is a pointer from a decayed array type (the decayed 3471/// pointer type is equal to T) and emit a warning if it is. 3472static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T, 3473 Expr *E) { 3474 // Don't warn if the operation changed the type. 3475 if (T != E->getType()) 3476 return; 3477 3478 // Now look for array decays. 3479 ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E); 3480 if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay) 3481 return; 3482 3483 S.Diag(Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange() 3484 << ICE->getType() 3485 << ICE->getSubExpr()->getType(); 3486} 3487 3488/// \brief Check the constraints on expression operands to unary type expression 3489/// and type traits. 3490/// 3491/// Completes any types necessary and validates the constraints on the operand 3492/// expression. The logic mostly mirrors the type-based overload, but may modify 3493/// the expression as it completes the type for that expression through template 3494/// instantiation, etc. 3495bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E, 3496 UnaryExprOrTypeTrait ExprKind) { 3497 QualType ExprTy = E->getType(); 3498 assert(!ExprTy->isReferenceType()); 3499 3500 if (ExprKind == UETT_VecStep) 3501 return CheckVecStepTraitOperandType(*this, ExprTy, E->getExprLoc(), 3502 E->getSourceRange()); 3503 3504 // Whitelist some types as extensions 3505 if (!CheckExtensionTraitOperandType(*this, ExprTy, E->getExprLoc(), 3506 E->getSourceRange(), ExprKind)) 3507 return false; 3508 3509 // 'alignof' applied to an expression only requires the base element type of 3510 // the expression to be complete. 'sizeof' requires the expression's type to 3511 // be complete (and will attempt to complete it if it's an array of unknown 3512 // bound). 3513 if (ExprKind == UETT_AlignOf) { 3514 if (RequireCompleteType(E->getExprLoc(), 3515 Context.getBaseElementType(E->getType()), 3516 diag::err_sizeof_alignof_incomplete_type, ExprKind, 3517 E->getSourceRange())) 3518 return true; 3519 } else { 3520 if (RequireCompleteExprType(E, diag::err_sizeof_alignof_incomplete_type, 3521 ExprKind, E->getSourceRange())) 3522 return true; 3523 } 3524 3525 // Completing the expression's type may have changed it. 3526 ExprTy = E->getType(); 3527 assert(!ExprTy->isReferenceType()); 3528 3529 if (ExprTy->isFunctionType()) { 3530 Diag(E->getExprLoc(), diag::err_sizeof_alignof_function_type) 3531 << ExprKind << E->getSourceRange(); 3532 return true; 3533 } 3534 3535 // The operand for sizeof and alignof is in an unevaluated expression context, 3536 // so side effects could result in unintended consequences. 3537 if ((ExprKind == UETT_SizeOf || ExprKind == UETT_AlignOf) && 3538 ActiveTemplateInstantiations.empty() && E->HasSideEffects(Context, false)) 3539 Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context); 3540 3541 if (CheckObjCTraitOperandConstraints(*this, ExprTy, E->getExprLoc(), 3542 E->getSourceRange(), ExprKind)) 3543 return true; 3544 3545 if (ExprKind == UETT_SizeOf) { 3546 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E->IgnoreParens())) { 3547 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) { 3548 QualType OType = PVD->getOriginalType(); 3549 QualType Type = PVD->getType(); 3550 if (Type->isPointerType() && OType->isArrayType()) { 3551 Diag(E->getExprLoc(), diag::warn_sizeof_array_param) 3552 << Type << OType; 3553 Diag(PVD->getLocation(), diag::note_declared_at); 3554 } 3555 } 3556 } 3557 3558 // Warn on "sizeof(array op x)" and "sizeof(x op array)", where the array 3559 // decays into a pointer and returns an unintended result. This is most 3560 // likely a typo for "sizeof(array) op x". 3561 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E->IgnoreParens())) { 3562 warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(), 3563 BO->getLHS()); 3564 warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(), 3565 BO->getRHS()); 3566 } 3567 } 3568 3569 return false; 3570} 3571 3572/// \brief Check the constraints on operands to unary expression and type 3573/// traits. 3574/// 3575/// This will complete any types necessary, and validate the various constraints 3576/// on those operands. 3577/// 3578/// The UsualUnaryConversions() function is *not* called by this routine. 3579/// C99 6.3.2.1p[2-4] all state: 3580/// Except when it is the operand of the sizeof operator ... 3581/// 3582/// C++ [expr.sizeof]p4 3583/// The lvalue-to-rvalue, array-to-pointer, and function-to-pointer 3584/// standard conversions are not applied to the operand of sizeof. 3585/// 3586/// This policy is followed for all of the unary trait expressions. 3587bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType, 3588 SourceLocation OpLoc, 3589 SourceRange ExprRange, 3590 UnaryExprOrTypeTrait ExprKind) { 3591 if (ExprType->isDependentType()) 3592 return false; 3593 3594 // C++ [expr.sizeof]p2: 3595 // When applied to a reference or a reference type, the result 3596 // is the size of the referenced type. 3597 // C++11 [expr.alignof]p3: 3598 // When alignof is applied to a reference type, the result 3599 // shall be the alignment of the referenced type. 3600 if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>()) 3601 ExprType = Ref->getPointeeType(); 3602 3603 // C11 6.5.3.4/3, C++11 [expr.alignof]p3: 3604 // When alignof or _Alignof is applied to an array type, the result 3605 // is the alignment of the element type. 3606 if (ExprKind == UETT_AlignOf) 3607 ExprType = Context.getBaseElementType(ExprType); 3608 3609 if (ExprKind == UETT_VecStep) 3610 return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange); 3611 3612 // Whitelist some types as extensions 3613 if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange, 3614 ExprKind)) 3615 return false; 3616 3617 if (RequireCompleteType(OpLoc, ExprType, 3618 diag::err_sizeof_alignof_incomplete_type, 3619 ExprKind, ExprRange)) 3620 return true; 3621 3622 if (ExprType->isFunctionType()) { 3623 Diag(OpLoc, diag::err_sizeof_alignof_function_type) 3624 << ExprKind << ExprRange; 3625 return true; 3626 } 3627 3628 if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange, 3629 ExprKind)) 3630 return true; 3631 3632 return false; 3633} 3634 3635static bool CheckAlignOfExpr(Sema &S, Expr *E) { 3636 E = E->IgnoreParens(); 3637 3638 // Cannot know anything else if the expression is dependent. 3639 if (E->isTypeDependent()) 3640 return false; 3641 3642 if (E->getObjectKind() == OK_BitField) { 3643 S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) 3644 << 1 << E->getSourceRange(); 3645 return true; 3646 } 3647 3648 ValueDecl *D = nullptr; 3649 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 3650 D = DRE->getDecl(); 3651 } else if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 3652 D = ME->getMemberDecl(); 3653 } 3654 3655 // If it's a field, require the containing struct to have a 3656 // complete definition so that we can compute the layout. 3657 // 3658 // This can happen in C++11 onwards, either by naming the member 3659 // in a way that is not transformed into a member access expression 3660 // (in an unevaluated operand, for instance), or by naming the member 3661 // in a trailing-return-type. 3662 // 3663 // For the record, since __alignof__ on expressions is a GCC 3664 // extension, GCC seems to permit this but always gives the 3665 // nonsensical answer 0. 3666 // 3667 // We don't really need the layout here --- we could instead just 3668 // directly check for all the appropriate alignment-lowing 3669 // attributes --- but that would require duplicating a lot of 3670 // logic that just isn't worth duplicating for such a marginal 3671 // use-case. 3672 if (FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) { 3673 // Fast path this check, since we at least know the record has a 3674 // definition if we can find a member of it. 3675 if (!FD->getParent()->isCompleteDefinition()) { 3676 S.Diag(E->getExprLoc(), diag::err_alignof_member_of_incomplete_type) 3677 << E->getSourceRange(); 3678 return true; 3679 } 3680 3681 // Otherwise, if it's a field, and the field doesn't have 3682 // reference type, then it must have a complete type (or be a 3683 // flexible array member, which we explicitly want to 3684 // white-list anyway), which makes the following checks trivial. 3685 if (!FD->getType()->isReferenceType()) 3686 return false; 3687 } 3688 3689 return S.CheckUnaryExprOrTypeTraitOperand(E, UETT_AlignOf); 3690} 3691 3692bool Sema::CheckVecStepExpr(Expr *E) { 3693 E = E->IgnoreParens(); 3694 3695 // Cannot know anything else if the expression is dependent. 3696 if (E->isTypeDependent()) 3697 return false; 3698 3699 return CheckUnaryExprOrTypeTraitOperand(E, UETT_VecStep); 3700} 3701 3702/// \brief Build a sizeof or alignof expression given a type operand. 3703ExprResult 3704Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, 3705 SourceLocation OpLoc, 3706 UnaryExprOrTypeTrait ExprKind, 3707 SourceRange R) { 3708 if (!TInfo) 3709 return ExprError(); 3710 3711 QualType T = TInfo->getType(); 3712 3713 if (!T->isDependentType() && 3714 CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind)) 3715 return ExprError(); 3716 3717 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 3718 return new (Context) UnaryExprOrTypeTraitExpr( 3719 ExprKind, TInfo, Context.getSizeType(), OpLoc, R.getEnd()); 3720} 3721 3722/// \brief Build a sizeof or alignof expression given an expression 3723/// operand. 3724ExprResult 3725Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc, 3726 UnaryExprOrTypeTrait ExprKind) { 3727 ExprResult PE = CheckPlaceholderExpr(E); 3728 if (PE.isInvalid()) 3729 return ExprError(); 3730 3731 E = PE.get(); 3732 3733 // Verify that the operand is valid. 3734 bool isInvalid = false; 3735 if (E->isTypeDependent()) { 3736 // Delay type-checking for type-dependent expressions. 3737 } else if (ExprKind == UETT_AlignOf) { 3738 isInvalid = CheckAlignOfExpr(*this, E); 3739 } else if (ExprKind == UETT_VecStep) { 3740 isInvalid = CheckVecStepExpr(E); 3741 } else if (E->refersToBitField()) { // C99 6.5.3.4p1. 3742 Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) << 0; 3743 isInvalid = true; 3744 } else { 3745 isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf); 3746 } 3747 3748 if (isInvalid) 3749 return ExprError(); 3750 3751 if (ExprKind == UETT_SizeOf && E->getType()->isVariableArrayType()) { 3752 PE = TransformToPotentiallyEvaluated(E); 3753 if (PE.isInvalid()) return ExprError(); 3754 E = PE.get(); 3755 } 3756 3757 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 3758 return new (Context) UnaryExprOrTypeTraitExpr( 3759 ExprKind, E, Context.getSizeType(), OpLoc, E->getSourceRange().getEnd()); 3760} 3761 3762/// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c 3763/// expr and the same for @c alignof and @c __alignof 3764/// Note that the ArgRange is invalid if isType is false. 3765ExprResult 3766Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, 3767 UnaryExprOrTypeTrait ExprKind, bool IsType, 3768 void *TyOrEx, const SourceRange &ArgRange) { 3769 // If error parsing type, ignore. 3770 if (!TyOrEx) return ExprError(); 3771 3772 if (IsType) { 3773 TypeSourceInfo *TInfo; 3774 (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo); 3775 return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange); 3776 } 3777 3778 Expr *ArgEx = (Expr *)TyOrEx; 3779 ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind); 3780 return Result; 3781} 3782 3783static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, 3784 bool IsReal) { 3785 if (V.get()->isTypeDependent()) 3786 return S.Context.DependentTy; 3787 3788 // _Real and _Imag are only l-values for normal l-values. 3789 if (V.get()->getObjectKind() != OK_Ordinary) { 3790 V = S.DefaultLvalueConversion(V.get()); 3791 if (V.isInvalid()) 3792 return QualType(); 3793 } 3794 3795 // These operators return the element type of a complex type. 3796 if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>()) 3797 return CT->getElementType(); 3798 3799 // Otherwise they pass through real integer and floating point types here. 3800 if (V.get()->getType()->isArithmeticType()) 3801 return V.get()->getType(); 3802 3803 // Test for placeholders. 3804 ExprResult PR = S.CheckPlaceholderExpr(V.get()); 3805 if (PR.isInvalid()) return QualType(); 3806 if (PR.get() != V.get()) { 3807 V = PR; 3808 return CheckRealImagOperand(S, V, Loc, IsReal); 3809 } 3810 3811 // Reject anything else. 3812 S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType() 3813 << (IsReal ? "__real" : "__imag"); 3814 return QualType(); 3815} 3816 3817 3818 3819ExprResult 3820Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, 3821 tok::TokenKind Kind, Expr *Input) { 3822 UnaryOperatorKind Opc; 3823 switch (Kind) { 3824 default: llvm_unreachable("Unknown unary op!"); 3825 case tok::plusplus: Opc = UO_PostInc; break; 3826 case tok::minusminus: Opc = UO_PostDec; break; 3827 } 3828 3829 // Since this might is a postfix expression, get rid of ParenListExprs. 3830 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input); 3831 if (Result.isInvalid()) return ExprError(); 3832 Input = Result.get(); 3833 3834 return BuildUnaryOp(S, OpLoc, Opc, Input); 3835} 3836 3837/// \brief Diagnose if arithmetic on the given ObjC pointer is illegal. 3838/// 3839/// \return true on error 3840static bool checkArithmeticOnObjCPointer(Sema &S, 3841 SourceLocation opLoc, 3842 Expr *op) { 3843 assert(op->getType()->isObjCObjectPointerType()); 3844 if (S.LangOpts.ObjCRuntime.allowsPointerArithmetic() && 3845 !S.LangOpts.ObjCSubscriptingLegacyRuntime) 3846 return false; 3847 3848 S.Diag(opLoc, diag::err_arithmetic_nonfragile_interface) 3849 << op->getType()->castAs<ObjCObjectPointerType>()->getPointeeType() 3850 << op->getSourceRange(); 3851 return true; 3852} 3853 3854ExprResult 3855Sema::ActOnArraySubscriptExpr(Scope *S, Expr *base, SourceLocation lbLoc, 3856 Expr *idx, SourceLocation rbLoc) { 3857 // Since this might be a postfix expression, get rid of ParenListExprs. 3858 if (isa<ParenListExpr>(base)) { 3859 ExprResult result = MaybeConvertParenListExprToParenExpr(S, base); 3860 if (result.isInvalid()) return ExprError(); 3861 base = result.get(); 3862 } 3863 3864 // Handle any non-overload placeholder types in the base and index 3865 // expressions. We can't handle overloads here because the other 3866 // operand might be an overloadable type, in which case the overload 3867 // resolution for the operator overload should get the first crack 3868 // at the overload. 3869 if (base->getType()->isNonOverloadPlaceholderType()) { 3870 ExprResult result = CheckPlaceholderExpr(base); 3871 if (result.isInvalid()) return ExprError(); 3872 base = result.get(); 3873 } 3874 if (idx->getType()->isNonOverloadPlaceholderType()) { 3875 ExprResult result = CheckPlaceholderExpr(idx); 3876 if (result.isInvalid()) return ExprError(); 3877 idx = result.get(); 3878 } 3879 3880 // Build an unanalyzed expression if either operand is type-dependent. 3881 if (getLangOpts().CPlusPlus && 3882 (base->isTypeDependent() || idx->isTypeDependent())) { 3883 return new (Context) ArraySubscriptExpr(base, idx, Context.DependentTy, 3884 VK_LValue, OK_Ordinary, rbLoc); 3885 } 3886 3887 // Use C++ overloaded-operator rules if either operand has record 3888 // type. The spec says to do this if either type is *overloadable*, 3889 // but enum types can't declare subscript operators or conversion 3890 // operators, so there's nothing interesting for overload resolution 3891 // to do if there aren't any record types involved. 3892 // 3893 // ObjC pointers have their own subscripting logic that is not tied 3894 // to overload resolution and so should not take this path. 3895 if (getLangOpts().CPlusPlus && 3896 (base->getType()->isRecordType() || 3897 (!base->getType()->isObjCObjectPointerType() && 3898 idx->getType()->isRecordType()))) { 3899 return CreateOverloadedArraySubscriptExpr(lbLoc, rbLoc, base, idx); 3900 } 3901 3902 return CreateBuiltinArraySubscriptExpr(base, lbLoc, idx, rbLoc); 3903} 3904 3905ExprResult 3906Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, 3907 Expr *Idx, SourceLocation RLoc) { 3908 Expr *LHSExp = Base; 3909 Expr *RHSExp = Idx; 3910 3911 // Perform default conversions. 3912 if (!LHSExp->getType()->getAs<VectorType>()) { 3913 ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp); 3914 if (Result.isInvalid()) 3915 return ExprError(); 3916 LHSExp = Result.get(); 3917 } 3918 ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp); 3919 if (Result.isInvalid()) 3920 return ExprError(); 3921 RHSExp = Result.get(); 3922 3923 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType(); 3924 ExprValueKind VK = VK_LValue; 3925 ExprObjectKind OK = OK_Ordinary; 3926 3927 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent 3928 // to the expression *((e1)+(e2)). This means the array "Base" may actually be 3929 // in the subscript position. As a result, we need to derive the array base 3930 // and index from the expression types. 3931 Expr *BaseExpr, *IndexExpr; 3932 QualType ResultType; 3933 if (LHSTy->isDependentType() || RHSTy->isDependentType()) { 3934 BaseExpr = LHSExp; 3935 IndexExpr = RHSExp; 3936 ResultType = Context.DependentTy; 3937 } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) { 3938 BaseExpr = LHSExp; 3939 IndexExpr = RHSExp; 3940 ResultType = PTy->getPointeeType(); 3941 } else if (const ObjCObjectPointerType *PTy = 3942 LHSTy->getAs<ObjCObjectPointerType>()) { 3943 BaseExpr = LHSExp; 3944 IndexExpr = RHSExp; 3945 3946 // Use custom logic if this should be the pseudo-object subscript 3947 // expression. 3948 if (!LangOpts.isSubscriptPointerArithmetic()) 3949 return BuildObjCSubscriptExpression(RLoc, BaseExpr, IndexExpr, nullptr, 3950 nullptr); 3951 3952 ResultType = PTy->getPointeeType(); 3953 } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) { 3954 // Handle the uncommon case of "123[Ptr]". 3955 BaseExpr = RHSExp; 3956 IndexExpr = LHSExp; 3957 ResultType = PTy->getPointeeType(); 3958 } else if (const ObjCObjectPointerType *PTy = 3959 RHSTy->getAs<ObjCObjectPointerType>()) { 3960 // Handle the uncommon case of "123[Ptr]". 3961 BaseExpr = RHSExp; 3962 IndexExpr = LHSExp; 3963 ResultType = PTy->getPointeeType(); 3964 if (!LangOpts.isSubscriptPointerArithmetic()) { 3965 Diag(LLoc, diag::err_subscript_nonfragile_interface) 3966 << ResultType << BaseExpr->getSourceRange(); 3967 return ExprError(); 3968 } 3969 } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) { 3970 BaseExpr = LHSExp; // vectors: V[123] 3971 IndexExpr = RHSExp; 3972 VK = LHSExp->getValueKind(); 3973 if (VK != VK_RValue) 3974 OK = OK_VectorComponent; 3975 3976 // FIXME: need to deal with const... 3977 ResultType = VTy->getElementType(); 3978 } else if (LHSTy->isArrayType()) { 3979 // If we see an array that wasn't promoted by 3980 // DefaultFunctionArrayLvalueConversion, it must be an array that 3981 // wasn't promoted because of the C90 rule that doesn't 3982 // allow promoting non-lvalue arrays. Warn, then 3983 // force the promotion here. 3984 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3985 LHSExp->getSourceRange(); 3986 LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy), 3987 CK_ArrayToPointerDecay).get(); 3988 LHSTy = LHSExp->getType(); 3989 3990 BaseExpr = LHSExp; 3991 IndexExpr = RHSExp; 3992 ResultType = LHSTy->getAs<PointerType>()->getPointeeType(); 3993 } else if (RHSTy->isArrayType()) { 3994 // Same as previous, except for 123[f().a] case 3995 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3996 RHSExp->getSourceRange(); 3997 RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy), 3998 CK_ArrayToPointerDecay).get(); 3999 RHSTy = RHSExp->getType(); 4000 4001 BaseExpr = RHSExp; 4002 IndexExpr = LHSExp; 4003 ResultType = RHSTy->getAs<PointerType>()->getPointeeType(); 4004 } else { 4005 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value) 4006 << LHSExp->getSourceRange() << RHSExp->getSourceRange()); 4007 } 4008 // C99 6.5.2.1p1 4009 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent()) 4010 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer) 4011 << IndexExpr->getSourceRange()); 4012 4013 if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) || 4014 IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U)) 4015 && !IndexExpr->isTypeDependent()) 4016 Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange(); 4017 4018 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly, 4019 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object 4020 // type. Note that Functions are not objects, and that (in C99 parlance) 4021 // incomplete types are not object types. 4022 if (ResultType->isFunctionType()) { 4023 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type) 4024 << ResultType << BaseExpr->getSourceRange(); 4025 return ExprError(); 4026 } 4027 4028 if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) { 4029 // GNU extension: subscripting on pointer to void 4030 Diag(LLoc, diag::ext_gnu_subscript_void_type) 4031 << BaseExpr->getSourceRange(); 4032 4033 // C forbids expressions of unqualified void type from being l-values. 4034 // See IsCForbiddenLValueType. 4035 if (!ResultType.hasQualifiers()) VK = VK_RValue; 4036 } else if (!ResultType->isDependentType() && 4037 RequireCompleteType(LLoc, ResultType, 4038 diag::err_subscript_incomplete_type, BaseExpr)) 4039 return ExprError(); 4040 4041 assert(VK == VK_RValue || LangOpts.CPlusPlus || 4042 !ResultType.isCForbiddenLValueType()); 4043 4044 return new (Context) 4045 ArraySubscriptExpr(LHSExp, RHSExp, ResultType, VK, OK, RLoc); 4046} 4047 4048ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc, 4049 FunctionDecl *FD, 4050 ParmVarDecl *Param) { 4051 if (Param->hasUnparsedDefaultArg()) { 4052 Diag(CallLoc, 4053 diag::err_use_of_default_argument_to_function_declared_later) << 4054 FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName(); 4055 Diag(UnparsedDefaultArgLocs[Param], 4056 diag::note_default_argument_declared_here); 4057 return ExprError(); 4058 } 4059 4060 if (Param->hasUninstantiatedDefaultArg()) { 4061 Expr *UninstExpr = Param->getUninstantiatedDefaultArg(); 4062 4063 EnterExpressionEvaluationContext EvalContext(*this, PotentiallyEvaluated, 4064 Param); 4065 4066 // Instantiate the expression. 4067 MultiLevelTemplateArgumentList MutiLevelArgList 4068 = getTemplateInstantiationArgs(FD, nullptr, /*RelativeToPrimary=*/true); 4069 4070 InstantiatingTemplate Inst(*this, CallLoc, Param, 4071 MutiLevelArgList.getInnermost()); 4072 if (Inst.isInvalid()) 4073 return ExprError(); 4074 4075 ExprResult Result; 4076 { 4077 // C++ [dcl.fct.default]p5: 4078 // The names in the [default argument] expression are bound, and 4079 // the semantic constraints are checked, at the point where the 4080 // default argument expression appears. 4081 ContextRAII SavedContext(*this, FD); 4082 LocalInstantiationScope Local(*this); 4083 Result = SubstExpr(UninstExpr, MutiLevelArgList); 4084 } 4085 if (Result.isInvalid()) 4086 return ExprError(); 4087 4088 // Check the expression as an initializer for the parameter. 4089 InitializedEntity Entity 4090 = InitializedEntity::InitializeParameter(Context, Param); 4091 InitializationKind Kind 4092 = InitializationKind::CreateCopy(Param->getLocation(), 4093 /*FIXME:EqualLoc*/UninstExpr->getLocStart()); 4094 Expr *ResultE = Result.getAs<Expr>(); 4095 4096 InitializationSequence InitSeq(*this, Entity, Kind, ResultE); 4097 Result = InitSeq.Perform(*this, Entity, Kind, ResultE); 4098 if (Result.isInvalid()) 4099 return ExprError(); 4100 4101 Expr *Arg = Result.getAs<Expr>(); 4102 CheckCompletedExpr(Arg, Param->getOuterLocStart()); 4103 // Build the default argument expression. 4104 return CXXDefaultArgExpr::Create(Context, CallLoc, Param, Arg); 4105 } 4106 4107 // If the default expression creates temporaries, we need to 4108 // push them to the current stack of expression temporaries so they'll 4109 // be properly destroyed. 4110 // FIXME: We should really be rebuilding the default argument with new 4111 // bound temporaries; see the comment in PR5810. 4112 // We don't need to do that with block decls, though, because 4113 // blocks in default argument expression can never capture anything. 4114 if (isa<ExprWithCleanups>(Param->getInit())) { 4115 // Set the "needs cleanups" bit regardless of whether there are 4116 // any explicit objects. 4117 ExprNeedsCleanups = true; 4118 4119 // Append all the objects to the cleanup list. Right now, this 4120 // should always be a no-op, because blocks in default argument 4121 // expressions should never be able to capture anything. 4122 assert(!cast<ExprWithCleanups>(Param->getInit())->getNumObjects() && 4123 "default argument expression has capturing blocks?"); 4124 } 4125 4126 // We already type-checked the argument, so we know it works. 4127 // Just mark all of the declarations in this potentially-evaluated expression 4128 // as being "referenced". 4129 MarkDeclarationsReferencedInExpr(Param->getDefaultArg(), 4130 /*SkipLocalVariables=*/true); 4131 return CXXDefaultArgExpr::Create(Context, CallLoc, Param); 4132} 4133 4134 4135Sema::VariadicCallType 4136Sema::getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto, 4137 Expr *Fn) { 4138 if (Proto && Proto->isVariadic()) { 4139 if (dyn_cast_or_null<CXXConstructorDecl>(FDecl)) 4140 return VariadicConstructor; 4141 else if (Fn && Fn->getType()->isBlockPointerType()) 4142 return VariadicBlock; 4143 else if (FDecl) { 4144 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl)) 4145 if (Method->isInstance()) 4146 return VariadicMethod; 4147 } else if (Fn && Fn->getType() == Context.BoundMemberTy) 4148 return VariadicMethod; 4149 return VariadicFunction; 4150 } 4151 return VariadicDoesNotApply; 4152} 4153 4154namespace { 4155class FunctionCallCCC : public FunctionCallFilterCCC { 4156public: 4157 FunctionCallCCC(Sema &SemaRef, const IdentifierInfo *FuncName, 4158 unsigned NumArgs, MemberExpr *ME) 4159 : FunctionCallFilterCCC(SemaRef, NumArgs, false, ME), 4160 FunctionName(FuncName) {} 4161 4162 bool ValidateCandidate(const TypoCorrection &candidate) override { 4163 if (!candidate.getCorrectionSpecifier() || 4164 candidate.getCorrectionAsIdentifierInfo() != FunctionName) { 4165 return false; 4166 } 4167 4168 return FunctionCallFilterCCC::ValidateCandidate(candidate); 4169 } 4170 4171private: 4172 const IdentifierInfo *const FunctionName; 4173}; 4174} 4175 4176static TypoCorrection TryTypoCorrectionForCall(Sema &S, Expr *Fn, 4177 FunctionDecl *FDecl, 4178 ArrayRef<Expr *> Args) { 4179 MemberExpr *ME = dyn_cast<MemberExpr>(Fn); 4180 DeclarationName FuncName = FDecl->getDeclName(); 4181 SourceLocation NameLoc = ME ? ME->getMemberLoc() : Fn->getLocStart(); 4182 4183 if (TypoCorrection Corrected = S.CorrectTypo( 4184 DeclarationNameInfo(FuncName, NameLoc), Sema::LookupOrdinaryName, 4185 S.getScopeForContext(S.CurContext), nullptr, 4186 llvm::make_unique<FunctionCallCCC>(S, FuncName.getAsIdentifierInfo(), 4187 Args.size(), ME), 4188 Sema::CTK_ErrorRecovery)) { 4189 if (NamedDecl *ND = Corrected.getCorrectionDecl()) { 4190 if (Corrected.isOverloaded()) { 4191 OverloadCandidateSet OCS(NameLoc, OverloadCandidateSet::CSK_Normal); 4192 OverloadCandidateSet::iterator Best; 4193 for (TypoCorrection::decl_iterator CD = Corrected.begin(), 4194 CDEnd = Corrected.end(); 4195 CD != CDEnd; ++CD) { 4196 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD)) 4197 S.AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), Args, 4198 OCS); 4199 } 4200 switch (OCS.BestViableFunction(S, NameLoc, Best)) { 4201 case OR_Success: 4202 ND = Best->Function; 4203 Corrected.setCorrectionDecl(ND); 4204 break; 4205 default: 4206 break; 4207 } 4208 } 4209 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) { 4210 return Corrected; 4211 } 4212 } 4213 } 4214 return TypoCorrection(); 4215} 4216 4217/// ConvertArgumentsForCall - Converts the arguments specified in 4218/// Args/NumArgs to the parameter types of the function FDecl with 4219/// function prototype Proto. Call is the call expression itself, and 4220/// Fn is the function expression. For a C++ member function, this 4221/// routine does not attempt to convert the object argument. Returns 4222/// true if the call is ill-formed. 4223bool 4224Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, 4225 FunctionDecl *FDecl, 4226 const FunctionProtoType *Proto, 4227 ArrayRef<Expr *> Args, 4228 SourceLocation RParenLoc, 4229 bool IsExecConfig) { 4230 // Bail out early if calling a builtin with custom typechecking. 4231 // We don't need to do this in the 4232 if (FDecl) 4233 if (unsigned ID = FDecl->getBuiltinID()) 4234 if (Context.BuiltinInfo.hasCustomTypechecking(ID)) 4235 return false; 4236 4237 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by 4238 // assignment, to the types of the corresponding parameter, ... 4239 unsigned NumParams = Proto->getNumParams(); 4240 bool Invalid = false; 4241 unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumParams; 4242 unsigned FnKind = Fn->getType()->isBlockPointerType() 4243 ? 1 /* block */ 4244 : (IsExecConfig ? 3 /* kernel function (exec config) */ 4245 : 0 /* function */); 4246 4247 // If too few arguments are available (and we don't have default 4248 // arguments for the remaining parameters), don't make the call. 4249 if (Args.size() < NumParams) { 4250 if (Args.size() < MinArgs) { 4251 TypoCorrection TC; 4252 if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) { 4253 unsigned diag_id = 4254 MinArgs == NumParams && !Proto->isVariadic() 4255 ? diag::err_typecheck_call_too_few_args_suggest 4256 : diag::err_typecheck_call_too_few_args_at_least_suggest; 4257 diagnoseTypo(TC, PDiag(diag_id) << FnKind << MinArgs 4258 << static_cast<unsigned>(Args.size()) 4259 << TC.getCorrectionRange()); 4260 } else if (MinArgs == 1 && FDecl && FDecl->getParamDecl(0)->getDeclName()) 4261 Diag(RParenLoc, 4262 MinArgs == NumParams && !Proto->isVariadic() 4263 ? diag::err_typecheck_call_too_few_args_one 4264 : diag::err_typecheck_call_too_few_args_at_least_one) 4265 << FnKind << FDecl->getParamDecl(0) << Fn->getSourceRange(); 4266 else 4267 Diag(RParenLoc, MinArgs == NumParams && !Proto->isVariadic() 4268 ? diag::err_typecheck_call_too_few_args 4269 : diag::err_typecheck_call_too_few_args_at_least) 4270 << FnKind << MinArgs << static_cast<unsigned>(Args.size()) 4271 << Fn->getSourceRange(); 4272 4273 // Emit the location of the prototype. 4274 if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig) 4275 Diag(FDecl->getLocStart(), diag::note_callee_decl) 4276 << FDecl; 4277 4278 return true; 4279 } 4280 Call->setNumArgs(Context, NumParams); 4281 } 4282 4283 // If too many are passed and not variadic, error on the extras and drop 4284 // them. 4285 if (Args.size() > NumParams) { 4286 if (!Proto->isVariadic()) { 4287 TypoCorrection TC; 4288 if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) { 4289 unsigned diag_id = 4290 MinArgs == NumParams && !Proto->isVariadic() 4291 ? diag::err_typecheck_call_too_many_args_suggest 4292 : diag::err_typecheck_call_too_many_args_at_most_suggest; 4293 diagnoseTypo(TC, PDiag(diag_id) << FnKind << NumParams 4294 << static_cast<unsigned>(Args.size()) 4295 << TC.getCorrectionRange()); 4296 } else if (NumParams == 1 && FDecl && 4297 FDecl->getParamDecl(0)->getDeclName()) 4298 Diag(Args[NumParams]->getLocStart(), 4299 MinArgs == NumParams 4300 ? diag::err_typecheck_call_too_many_args_one 4301 : diag::err_typecheck_call_too_many_args_at_most_one) 4302 << FnKind << FDecl->getParamDecl(0) 4303 << static_cast<unsigned>(Args.size()) << Fn->getSourceRange() 4304 << SourceRange(Args[NumParams]->getLocStart(), 4305 Args.back()->getLocEnd()); 4306 else 4307 Diag(Args[NumParams]->getLocStart(), 4308 MinArgs == NumParams 4309 ? diag::err_typecheck_call_too_many_args 4310 : diag::err_typecheck_call_too_many_args_at_most) 4311 << FnKind << NumParams << static_cast<unsigned>(Args.size()) 4312 << Fn->getSourceRange() 4313 << SourceRange(Args[NumParams]->getLocStart(), 4314 Args.back()->getLocEnd()); 4315 4316 // Emit the location of the prototype. 4317 if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig) 4318 Diag(FDecl->getLocStart(), diag::note_callee_decl) 4319 << FDecl; 4320 4321 // This deletes the extra arguments. 4322 Call->setNumArgs(Context, NumParams); 4323 return true; 4324 } 4325 } 4326 SmallVector<Expr *, 8> AllArgs; 4327 VariadicCallType CallType = getVariadicCallType(FDecl, Proto, Fn); 4328 4329 Invalid = GatherArgumentsForCall(Call->getLocStart(), FDecl, 4330 Proto, 0, Args, AllArgs, CallType); 4331 if (Invalid) 4332 return true; 4333 unsigned TotalNumArgs = AllArgs.size(); 4334 for (unsigned i = 0; i < TotalNumArgs; ++i) 4335 Call->setArg(i, AllArgs[i]); 4336 4337 return false; 4338} 4339 4340bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl, 4341 const FunctionProtoType *Proto, 4342 unsigned FirstParam, ArrayRef<Expr *> Args, 4343 SmallVectorImpl<Expr *> &AllArgs, 4344 VariadicCallType CallType, bool AllowExplicit, 4345 bool IsListInitialization) { 4346 unsigned NumParams = Proto->getNumParams(); 4347 bool Invalid = false; 4348 unsigned ArgIx = 0; 4349 // Continue to check argument types (even if we have too few/many args). 4350 for (unsigned i = FirstParam; i < NumParams; i++) { 4351 QualType ProtoArgType = Proto->getParamType(i); 4352 4353 Expr *Arg; 4354 ParmVarDecl *Param = FDecl ? FDecl->getParamDecl(i) : nullptr; 4355 if (ArgIx < Args.size()) { 4356 Arg = Args[ArgIx++]; 4357 4358 if (RequireCompleteType(Arg->getLocStart(), 4359 ProtoArgType, 4360 diag::err_call_incomplete_argument, Arg)) 4361 return true; 4362 4363 // Strip the unbridged-cast placeholder expression off, if applicable. 4364 bool CFAudited = false; 4365 if (Arg->getType() == Context.ARCUnbridgedCastTy && 4366 FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() && 4367 (!Param || !Param->hasAttr<CFConsumedAttr>())) 4368 Arg = stripARCUnbridgedCast(Arg); 4369 else if (getLangOpts().ObjCAutoRefCount && 4370 FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() && 4371 (!Param || !Param->hasAttr<CFConsumedAttr>())) 4372 CFAudited = true; 4373 4374 InitializedEntity Entity = 4375 Param ? InitializedEntity::InitializeParameter(Context, Param, 4376 ProtoArgType) 4377 : InitializedEntity::InitializeParameter( 4378 Context, ProtoArgType, Proto->isParamConsumed(i)); 4379 4380 // Remember that parameter belongs to a CF audited API. 4381 if (CFAudited) 4382 Entity.setParameterCFAudited(); 4383 4384 ExprResult ArgE = PerformCopyInitialization( 4385 Entity, SourceLocation(), Arg, IsListInitialization, AllowExplicit); 4386 if (ArgE.isInvalid()) 4387 return true; 4388 4389 Arg = ArgE.getAs<Expr>(); 4390 } else { 4391 assert(Param && "can't use default arguments without a known callee"); 4392 4393 ExprResult ArgExpr = 4394 BuildCXXDefaultArgExpr(CallLoc, FDecl, Param); 4395 if (ArgExpr.isInvalid()) 4396 return true; 4397 4398 Arg = ArgExpr.getAs<Expr>(); 4399 } 4400 4401 // Check for array bounds violations for each argument to the call. This 4402 // check only triggers warnings when the argument isn't a more complex Expr 4403 // with its own checking, such as a BinaryOperator. 4404 CheckArrayAccess(Arg); 4405 4406 // Check for violations of C99 static array rules (C99 6.7.5.3p7). 4407 CheckStaticArrayArgument(CallLoc, Param, Arg); 4408 4409 AllArgs.push_back(Arg); 4410 } 4411 4412 // If this is a variadic call, handle args passed through "...". 4413 if (CallType != VariadicDoesNotApply) { 4414 // Assume that extern "C" functions with variadic arguments that 4415 // return __unknown_anytype aren't *really* variadic. 4416 if (Proto->getReturnType() == Context.UnknownAnyTy && FDecl && 4417 FDecl->isExternC()) { 4418 for (unsigned i = ArgIx, e = Args.size(); i != e; ++i) { 4419 QualType paramType; // ignored 4420 ExprResult arg = checkUnknownAnyArg(CallLoc, Args[i], paramType); 4421 Invalid |= arg.isInvalid(); 4422 AllArgs.push_back(arg.get()); 4423 } 4424 4425 // Otherwise do argument promotion, (C99 6.5.2.2p7). 4426 } else { 4427 for (unsigned i = ArgIx, e = Args.size(); i != e; ++i) { 4428 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], CallType, 4429 FDecl); 4430 Invalid |= Arg.isInvalid(); 4431 AllArgs.push_back(Arg.get()); 4432 } 4433 } 4434 4435 // Check for array bounds violations. 4436 for (unsigned i = ArgIx, e = Args.size(); i != e; ++i) 4437 CheckArrayAccess(Args[i]); 4438 } 4439 return Invalid; 4440} 4441 4442static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD) { 4443 TypeLoc TL = PVD->getTypeSourceInfo()->getTypeLoc(); 4444 if (DecayedTypeLoc DTL = TL.getAs<DecayedTypeLoc>()) 4445 TL = DTL.getOriginalLoc(); 4446 if (ArrayTypeLoc ATL = TL.getAs<ArrayTypeLoc>()) 4447 S.Diag(PVD->getLocation(), diag::note_callee_static_array) 4448 << ATL.getLocalSourceRange(); 4449} 4450 4451/// CheckStaticArrayArgument - If the given argument corresponds to a static 4452/// array parameter, check that it is non-null, and that if it is formed by 4453/// array-to-pointer decay, the underlying array is sufficiently large. 4454/// 4455/// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the 4456/// array type derivation, then for each call to the function, the value of the 4457/// corresponding actual argument shall provide access to the first element of 4458/// an array with at least as many elements as specified by the size expression. 4459void 4460Sema::CheckStaticArrayArgument(SourceLocation CallLoc, 4461 ParmVarDecl *Param, 4462 const Expr *ArgExpr) { 4463 // Static array parameters are not supported in C++. 4464 if (!Param || getLangOpts().CPlusPlus) 4465 return; 4466 4467 QualType OrigTy = Param->getOriginalType(); 4468 4469 const ArrayType *AT = Context.getAsArrayType(OrigTy); 4470 if (!AT || AT->getSizeModifier() != ArrayType::Static) 4471 return; 4472 4473 if (ArgExpr->isNullPointerConstant(Context, 4474 Expr::NPC_NeverValueDependent)) { 4475 Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange(); 4476 DiagnoseCalleeStaticArrayParam(*this, Param); 4477 return; 4478 } 4479 4480 const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT); 4481 if (!CAT) 4482 return; 4483 4484 const ConstantArrayType *ArgCAT = 4485 Context.getAsConstantArrayType(ArgExpr->IgnoreParenImpCasts()->getType()); 4486 if (!ArgCAT) 4487 return; 4488 4489 if (ArgCAT->getSize().ult(CAT->getSize())) { 4490 Diag(CallLoc, diag::warn_static_array_too_small) 4491 << ArgExpr->getSourceRange() 4492 << (unsigned) ArgCAT->getSize().getZExtValue() 4493 << (unsigned) CAT->getSize().getZExtValue(); 4494 DiagnoseCalleeStaticArrayParam(*this, Param); 4495 } 4496} 4497 4498/// Given a function expression of unknown-any type, try to rebuild it 4499/// to have a function type. 4500static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn); 4501 4502/// Is the given type a placeholder that we need to lower out 4503/// immediately during argument processing? 4504static bool isPlaceholderToRemoveAsArg(QualType type) { 4505 // Placeholders are never sugared. 4506 const BuiltinType *placeholder = dyn_cast<BuiltinType>(type); 4507 if (!placeholder) return false; 4508 4509 switch (placeholder->getKind()) { 4510 // Ignore all the non-placeholder types. 4511#define PLACEHOLDER_TYPE(ID, SINGLETON_ID) 4512#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID: 4513#include "clang/AST/BuiltinTypes.def" 4514 return false; 4515 4516 // We cannot lower out overload sets; they might validly be resolved 4517 // by the call machinery. 4518 case BuiltinType::Overload: 4519 return false; 4520 4521 // Unbridged casts in ARC can be handled in some call positions and 4522 // should be left in place. 4523 case BuiltinType::ARCUnbridgedCast: 4524 return false; 4525 4526 // Pseudo-objects should be converted as soon as possible. 4527 case BuiltinType::PseudoObject: 4528 return true; 4529 4530 // The debugger mode could theoretically but currently does not try 4531 // to resolve unknown-typed arguments based on known parameter types. 4532 case BuiltinType::UnknownAny: 4533 return true; 4534 4535 // These are always invalid as call arguments and should be reported. 4536 case BuiltinType::BoundMember: 4537 case BuiltinType::BuiltinFn: 4538 return true; 4539 } 4540 llvm_unreachable("bad builtin type kind"); 4541} 4542 4543/// Check an argument list for placeholders that we won't try to 4544/// handle later. 4545static bool checkArgsForPlaceholders(Sema &S, MultiExprArg args) { 4546 // Apply this processing to all the arguments at once instead of 4547 // dying at the first failure. 4548 bool hasInvalid = false; 4549 for (size_t i = 0, e = args.size(); i != e; i++) { 4550 if (isPlaceholderToRemoveAsArg(args[i]->getType())) { 4551 ExprResult result = S.CheckPlaceholderExpr(args[i]); 4552 if (result.isInvalid()) hasInvalid = true; 4553 else args[i] = result.get(); 4554 } else if (hasInvalid) { 4555 (void)S.CorrectDelayedTyposInExpr(args[i]); 4556 } 4557 } 4558 return hasInvalid; 4559} 4560 4561/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments. 4562/// This provides the location of the left/right parens and a list of comma 4563/// locations. 4564ExprResult 4565Sema::ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, 4566 MultiExprArg ArgExprs, SourceLocation RParenLoc, 4567 Expr *ExecConfig, bool IsExecConfig) { 4568 // Since this might be a postfix expression, get rid of ParenListExprs. 4569 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn); 4570 if (Result.isInvalid()) return ExprError(); 4571 Fn = Result.get(); 4572 4573 if (checkArgsForPlaceholders(*this, ArgExprs)) 4574 return ExprError(); 4575 4576 if (getLangOpts().CPlusPlus) { 4577 // If this is a pseudo-destructor expression, build the call immediately. 4578 if (isa<CXXPseudoDestructorExpr>(Fn)) { 4579 if (!ArgExprs.empty()) { 4580 // Pseudo-destructor calls should not have any arguments. 4581 Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args) 4582 << FixItHint::CreateRemoval( 4583 SourceRange(ArgExprs[0]->getLocStart(), 4584 ArgExprs.back()->getLocEnd())); 4585 } 4586 4587 return new (Context) 4588 CallExpr(Context, Fn, None, Context.VoidTy, VK_RValue, RParenLoc); 4589 } 4590 if (Fn->getType() == Context.PseudoObjectTy) { 4591 ExprResult result = CheckPlaceholderExpr(Fn); 4592 if (result.isInvalid()) return ExprError(); 4593 Fn = result.get(); 4594 } 4595 4596 // Determine whether this is a dependent call inside a C++ template, 4597 // in which case we won't do any semantic analysis now. 4598 // FIXME: Will need to cache the results of name lookup (including ADL) in 4599 // Fn. 4600 bool Dependent = false; 4601 if (Fn->isTypeDependent()) 4602 Dependent = true; 4603 else if (Expr::hasAnyTypeDependentArguments(ArgExprs)) 4604 Dependent = true; 4605 4606 if (Dependent) { 4607 if (ExecConfig) { 4608 return new (Context) CUDAKernelCallExpr( 4609 Context, Fn, cast<CallExpr>(ExecConfig), ArgExprs, 4610 Context.DependentTy, VK_RValue, RParenLoc); 4611 } else { 4612 return new (Context) CallExpr( 4613 Context, Fn, ArgExprs, Context.DependentTy, VK_RValue, RParenLoc); 4614 } 4615 } 4616 4617 // Determine whether this is a call to an object (C++ [over.call.object]). 4618 if (Fn->getType()->isRecordType()) 4619 return BuildCallToObjectOfClassType(S, Fn, LParenLoc, ArgExprs, 4620 RParenLoc); 4621 4622 if (Fn->getType() == Context.UnknownAnyTy) { 4623 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 4624 if (result.isInvalid()) return ExprError(); 4625 Fn = result.get(); 4626 } 4627 4628 if (Fn->getType() == Context.BoundMemberTy) { 4629 return BuildCallToMemberFunction(S, Fn, LParenLoc, ArgExprs, RParenLoc); 4630 } 4631 } 4632 4633 // Check for overloaded calls. This can happen even in C due to extensions. 4634 if (Fn->getType() == Context.OverloadTy) { 4635 OverloadExpr::FindResult find = OverloadExpr::find(Fn); 4636 4637 // We aren't supposed to apply this logic for if there's an '&' involved. 4638 if (!find.HasFormOfMemberPointer) { 4639 OverloadExpr *ovl = find.Expression; 4640 if (isa<UnresolvedLookupExpr>(ovl)) { 4641 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(ovl); 4642 return BuildOverloadedCallExpr(S, Fn, ULE, LParenLoc, ArgExprs, 4643 RParenLoc, ExecConfig); 4644 } else { 4645 return BuildCallToMemberFunction(S, Fn, LParenLoc, ArgExprs, 4646 RParenLoc); 4647 } 4648 } 4649 } 4650 4651 // If we're directly calling a function, get the appropriate declaration. 4652 if (Fn->getType() == Context.UnknownAnyTy) { 4653 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 4654 if (result.isInvalid()) return ExprError(); 4655 Fn = result.get(); 4656 } 4657 4658 Expr *NakedFn = Fn->IgnoreParens(); 4659 4660 NamedDecl *NDecl = nullptr; 4661 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) 4662 if (UnOp->getOpcode() == UO_AddrOf) 4663 NakedFn = UnOp->getSubExpr()->IgnoreParens(); 4664 4665 if (isa<DeclRefExpr>(NakedFn)) 4666 NDecl = cast<DeclRefExpr>(NakedFn)->getDecl(); 4667 else if (isa<MemberExpr>(NakedFn)) 4668 NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl(); 4669 4670 if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) { 4671 if (FD->hasAttr<EnableIfAttr>()) { 4672 if (const EnableIfAttr *Attr = CheckEnableIf(FD, ArgExprs, true)) { 4673 Diag(Fn->getLocStart(), 4674 isa<CXXMethodDecl>(FD) ? 4675 diag::err_ovl_no_viable_member_function_in_call : 4676 diag::err_ovl_no_viable_function_in_call) 4677 << FD << FD->getSourceRange(); 4678 Diag(FD->getLocation(), 4679 diag::note_ovl_candidate_disabled_by_enable_if_attr) 4680 << Attr->getCond()->getSourceRange() << Attr->getMessage(); 4681 } 4682 } 4683 } 4684 4685 return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc, 4686 ExecConfig, IsExecConfig); 4687} 4688 4689/// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments. 4690/// 4691/// __builtin_astype( value, dst type ) 4692/// 4693ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, 4694 SourceLocation BuiltinLoc, 4695 SourceLocation RParenLoc) { 4696 ExprValueKind VK = VK_RValue; 4697 ExprObjectKind OK = OK_Ordinary; 4698 QualType DstTy = GetTypeFromParser(ParsedDestTy); 4699 QualType SrcTy = E->getType(); 4700 if (Context.getTypeSize(DstTy) != Context.getTypeSize(SrcTy)) 4701 return ExprError(Diag(BuiltinLoc, 4702 diag::err_invalid_astype_of_different_size) 4703 << DstTy 4704 << SrcTy 4705 << E->getSourceRange()); 4706 return new (Context) AsTypeExpr(E, DstTy, VK, OK, BuiltinLoc, RParenLoc); 4707} 4708 4709/// ActOnConvertVectorExpr - create a new convert-vector expression from the 4710/// provided arguments. 4711/// 4712/// __builtin_convertvector( value, dst type ) 4713/// 4714ExprResult Sema::ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy, 4715 SourceLocation BuiltinLoc, 4716 SourceLocation RParenLoc) { 4717 TypeSourceInfo *TInfo; 4718 GetTypeFromParser(ParsedDestTy, &TInfo); 4719 return SemaConvertVectorExpr(E, TInfo, BuiltinLoc, RParenLoc); 4720} 4721 4722/// BuildResolvedCallExpr - Build a call to a resolved expression, 4723/// i.e. an expression not of \p OverloadTy. The expression should 4724/// unary-convert to an expression of function-pointer or 4725/// block-pointer type. 4726/// 4727/// \param NDecl the declaration being called, if available 4728ExprResult 4729Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, 4730 SourceLocation LParenLoc, 4731 ArrayRef<Expr *> Args, 4732 SourceLocation RParenLoc, 4733 Expr *Config, bool IsExecConfig) { 4734 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl); 4735 unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0); 4736 4737 // Promote the function operand. 4738 // We special-case function promotion here because we only allow promoting 4739 // builtin functions to function pointers in the callee of a call. 4740 ExprResult Result; 4741 if (BuiltinID && 4742 Fn->getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn)) { 4743 Result = ImpCastExprToType(Fn, Context.getPointerType(FDecl->getType()), 4744 CK_BuiltinFnToFnPtr).get(); 4745 } else { 4746 Result = CallExprUnaryConversions(Fn); 4747 } 4748 if (Result.isInvalid()) 4749 return ExprError(); 4750 Fn = Result.get(); 4751 4752 // Make the call expr early, before semantic checks. This guarantees cleanup 4753 // of arguments and function on error. 4754 CallExpr *TheCall; 4755 if (Config) 4756 TheCall = new (Context) CUDAKernelCallExpr(Context, Fn, 4757 cast<CallExpr>(Config), Args, 4758 Context.BoolTy, VK_RValue, 4759 RParenLoc); 4760 else 4761 TheCall = new (Context) CallExpr(Context, Fn, Args, Context.BoolTy, 4762 VK_RValue, RParenLoc); 4763 4764 // Bail out early if calling a builtin with custom typechecking. 4765 if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID)) 4766 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall); 4767 4768 retry: 4769 const FunctionType *FuncT; 4770 if (const PointerType *PT = Fn->getType()->getAs<PointerType>()) { 4771 // C99 6.5.2.2p1 - "The expression that denotes the called function shall 4772 // have type pointer to function". 4773 FuncT = PT->getPointeeType()->getAs<FunctionType>(); 4774 if (!FuncT) 4775 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 4776 << Fn->getType() << Fn->getSourceRange()); 4777 } else if (const BlockPointerType *BPT = 4778 Fn->getType()->getAs<BlockPointerType>()) { 4779 FuncT = BPT->getPointeeType()->castAs<FunctionType>(); 4780 } else { 4781 // Handle calls to expressions of unknown-any type. 4782 if (Fn->getType() == Context.UnknownAnyTy) { 4783 ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn); 4784 if (rewrite.isInvalid()) return ExprError(); 4785 Fn = rewrite.get(); 4786 TheCall->setCallee(Fn); 4787 goto retry; 4788 } 4789 4790 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 4791 << Fn->getType() << Fn->getSourceRange()); 4792 } 4793 4794 if (getLangOpts().CUDA) { 4795 if (Config) { 4796 // CUDA: Kernel calls must be to global functions 4797 if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>()) 4798 return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function) 4799 << FDecl->getName() << Fn->getSourceRange()); 4800 4801 // CUDA: Kernel function must have 'void' return type 4802 if (!FuncT->getReturnType()->isVoidType()) 4803 return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return) 4804 << Fn->getType() << Fn->getSourceRange()); 4805 } else { 4806 // CUDA: Calls to global functions must be configured 4807 if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>()) 4808 return ExprError(Diag(LParenLoc, diag::err_global_call_not_config) 4809 << FDecl->getName() << Fn->getSourceRange()); 4810 } 4811 } 4812 4813 // Check for a valid return type 4814 if (CheckCallReturnType(FuncT->getReturnType(), Fn->getLocStart(), TheCall, 4815 FDecl)) 4816 return ExprError(); 4817 4818 // We know the result type of the call, set it. 4819 TheCall->setType(FuncT->getCallResultType(Context)); 4820 TheCall->setValueKind(Expr::getValueKindForType(FuncT->getReturnType())); 4821 4822 const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT); 4823 if (Proto) { 4824 if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, RParenLoc, 4825 IsExecConfig)) 4826 return ExprError(); 4827 } else { 4828 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!"); 4829 4830 if (FDecl) { 4831 // Check if we have too few/too many template arguments, based 4832 // on our knowledge of the function definition. 4833 const FunctionDecl *Def = nullptr; 4834 if (FDecl->hasBody(Def) && Args.size() != Def->param_size()) { 4835 Proto = Def->getType()->getAs<FunctionProtoType>(); 4836 if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->param_size())) 4837 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments) 4838 << (Args.size() > Def->param_size()) << FDecl << Fn->getSourceRange(); 4839 } 4840 4841 // If the function we're calling isn't a function prototype, but we have 4842 // a function prototype from a prior declaratiom, use that prototype. 4843 if (!FDecl->hasPrototype()) 4844 Proto = FDecl->getType()->getAs<FunctionProtoType>(); 4845 } 4846 4847 // Promote the arguments (C99 6.5.2.2p6). 4848 for (unsigned i = 0, e = Args.size(); i != e; i++) { 4849 Expr *Arg = Args[i]; 4850 4851 if (Proto && i < Proto->getNumParams()) { 4852 InitializedEntity Entity = InitializedEntity::InitializeParameter( 4853 Context, Proto->getParamType(i), Proto->isParamConsumed(i)); 4854 ExprResult ArgE = 4855 PerformCopyInitialization(Entity, SourceLocation(), Arg); 4856 if (ArgE.isInvalid()) 4857 return true; 4858 4859 Arg = ArgE.getAs<Expr>(); 4860 4861 } else { 4862 ExprResult ArgE = DefaultArgumentPromotion(Arg); 4863 4864 if (ArgE.isInvalid()) 4865 return true; 4866 4867 Arg = ArgE.getAs<Expr>(); 4868 } 4869 4870 if (RequireCompleteType(Arg->getLocStart(), 4871 Arg->getType(), 4872 diag::err_call_incomplete_argument, Arg)) 4873 return ExprError(); 4874 4875 TheCall->setArg(i, Arg); 4876 } 4877 } 4878 4879 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl)) 4880 if (!Method->isStatic()) 4881 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object) 4882 << Fn->getSourceRange()); 4883 4884 // Check for sentinels 4885 if (NDecl) 4886 DiagnoseSentinelCalls(NDecl, LParenLoc, Args); 4887 4888 // Do special checking on direct calls to functions. 4889 if (FDecl) { 4890 if (CheckFunctionCall(FDecl, TheCall, Proto)) 4891 return ExprError(); 4892 4893 if (BuiltinID) 4894 return CheckBuiltinFunctionCall(FDecl, BuiltinID, TheCall); 4895 } else if (NDecl) { 4896 if (CheckPointerCall(NDecl, TheCall, Proto)) 4897 return ExprError(); 4898 } else { 4899 if (CheckOtherCall(TheCall, Proto)) 4900 return ExprError(); 4901 } 4902 4903 return MaybeBindToTemporary(TheCall); 4904} 4905 4906ExprResult 4907Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, 4908 SourceLocation RParenLoc, Expr *InitExpr) { 4909 assert(Ty && "ActOnCompoundLiteral(): missing type"); 4910 // FIXME: put back this assert when initializers are worked out. 4911 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression"); 4912 4913 TypeSourceInfo *TInfo; 4914 QualType literalType = GetTypeFromParser(Ty, &TInfo); 4915 if (!TInfo) 4916 TInfo = Context.getTrivialTypeSourceInfo(literalType); 4917 4918 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr); 4919} 4920 4921ExprResult 4922Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, 4923 SourceLocation RParenLoc, Expr *LiteralExpr) { 4924 QualType literalType = TInfo->getType(); 4925 4926 if (literalType->isArrayType()) { 4927 if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType), 4928 diag::err_illegal_decl_array_incomplete_type, 4929 SourceRange(LParenLoc, 4930 LiteralExpr->getSourceRange().getEnd()))) 4931 return ExprError(); 4932 if (literalType->isVariableArrayType()) 4933 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init) 4934 << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())); 4935 } else if (!literalType->isDependentType() && 4936 RequireCompleteType(LParenLoc, literalType, 4937 diag::err_typecheck_decl_incomplete_type, 4938 SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd()))) 4939 return ExprError(); 4940 4941 InitializedEntity Entity 4942 = InitializedEntity::InitializeCompoundLiteralInit(TInfo); 4943 InitializationKind Kind 4944 = InitializationKind::CreateCStyleCast(LParenLoc, 4945 SourceRange(LParenLoc, RParenLoc), 4946 /*InitList=*/true); 4947 InitializationSequence InitSeq(*this, Entity, Kind, LiteralExpr); 4948 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, LiteralExpr, 4949 &literalType); 4950 if (Result.isInvalid()) 4951 return ExprError(); 4952 LiteralExpr = Result.get(); 4953 4954 bool isFileScope = getCurFunctionOrMethodDecl() == nullptr; 4955 if (isFileScope && 4956 !LiteralExpr->isTypeDependent() && 4957 !LiteralExpr->isValueDependent() && 4958 !literalType->isDependentType()) { // 6.5.2.5p3 4959 if (CheckForConstantInitializer(LiteralExpr, literalType)) 4960 return ExprError(); 4961 } 4962 4963 // In C, compound literals are l-values for some reason. 4964 ExprValueKind VK = getLangOpts().CPlusPlus ? VK_RValue : VK_LValue; 4965 4966 return MaybeBindToTemporary( 4967 new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType, 4968 VK, LiteralExpr, isFileScope)); 4969} 4970 4971ExprResult 4972Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, 4973 SourceLocation RBraceLoc) { 4974 // Immediately handle non-overload placeholders. Overloads can be 4975 // resolved contextually, but everything else here can't. 4976 for (unsigned I = 0, E = InitArgList.size(); I != E; ++I) { 4977 if (InitArgList[I]->getType()->isNonOverloadPlaceholderType()) { 4978 ExprResult result = CheckPlaceholderExpr(InitArgList[I]); 4979 4980 // Ignore failures; dropping the entire initializer list because 4981 // of one failure would be terrible for indexing/etc. 4982 if (result.isInvalid()) continue; 4983 4984 InitArgList[I] = result.get(); 4985 } 4986 } 4987 4988 // Semantic analysis for initializers is done by ActOnDeclarator() and 4989 // CheckInitializer() - it requires knowledge of the object being intialized. 4990 4991 InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList, 4992 RBraceLoc); 4993 E->setType(Context.VoidTy); // FIXME: just a place holder for now. 4994 return E; 4995} 4996 4997/// Do an explicit extend of the given block pointer if we're in ARC. 4998static void maybeExtendBlockObject(Sema &S, ExprResult &E) { 4999 assert(E.get()->getType()->isBlockPointerType()); 5000 assert(E.get()->isRValue()); 5001 5002 // Only do this in an r-value context. 5003 if (!S.getLangOpts().ObjCAutoRefCount) return; 5004 5005 E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), 5006 CK_ARCExtendBlockObject, E.get(), 5007 /*base path*/ nullptr, VK_RValue); 5008 S.ExprNeedsCleanups = true; 5009} 5010 5011/// Prepare a conversion of the given expression to an ObjC object 5012/// pointer type. 5013CastKind Sema::PrepareCastToObjCObjectPointer(ExprResult &E) { 5014 QualType type = E.get()->getType(); 5015 if (type->isObjCObjectPointerType()) { 5016 return CK_BitCast; 5017 } else if (type->isBlockPointerType()) { 5018 maybeExtendBlockObject(*this, E); 5019 return CK_BlockPointerToObjCPointerCast; 5020 } else { 5021 assert(type->isPointerType()); 5022 return CK_CPointerToObjCPointerCast; 5023 } 5024} 5025 5026/// Prepares for a scalar cast, performing all the necessary stages 5027/// except the final cast and returning the kind required. 5028CastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) { 5029 // Both Src and Dest are scalar types, i.e. arithmetic or pointer. 5030 // Also, callers should have filtered out the invalid cases with 5031 // pointers. Everything else should be possible. 5032 5033 QualType SrcTy = Src.get()->getType(); 5034 if (Context.hasSameUnqualifiedType(SrcTy, DestTy)) 5035 return CK_NoOp; 5036 5037 switch (Type::ScalarTypeKind SrcKind = SrcTy->getScalarTypeKind()) { 5038 case Type::STK_MemberPointer: 5039 llvm_unreachable("member pointer type in C"); 5040 5041 case Type::STK_CPointer: 5042 case Type::STK_BlockPointer: 5043 case Type::STK_ObjCObjectPointer: 5044 switch (DestTy->getScalarTypeKind()) { 5045 case Type::STK_CPointer: { 5046 unsigned SrcAS = SrcTy->getPointeeType().getAddressSpace(); 5047 unsigned DestAS = DestTy->getPointeeType().getAddressSpace(); 5048 if (SrcAS != DestAS) 5049 return CK_AddressSpaceConversion; 5050 return CK_BitCast; 5051 } 5052 case Type::STK_BlockPointer: 5053 return (SrcKind == Type::STK_BlockPointer 5054 ? CK_BitCast : CK_AnyPointerToBlockPointerCast); 5055 case Type::STK_ObjCObjectPointer: 5056 if (SrcKind == Type::STK_ObjCObjectPointer) 5057 return CK_BitCast; 5058 if (SrcKind == Type::STK_CPointer) 5059 return CK_CPointerToObjCPointerCast; 5060 maybeExtendBlockObject(*this, Src); 5061 return CK_BlockPointerToObjCPointerCast; 5062 case Type::STK_Bool: 5063 return CK_PointerToBoolean; 5064 case Type::STK_Integral: 5065 return CK_PointerToIntegral; 5066 case Type::STK_Floating: 5067 case Type::STK_FloatingComplex: 5068 case Type::STK_IntegralComplex: 5069 case Type::STK_MemberPointer: 5070 llvm_unreachable("illegal cast from pointer"); 5071 } 5072 llvm_unreachable("Should have returned before this"); 5073 5074 case Type::STK_Bool: // casting from bool is like casting from an integer 5075 case Type::STK_Integral: 5076 switch (DestTy->getScalarTypeKind()) { 5077 case Type::STK_CPointer: 5078 case Type::STK_ObjCObjectPointer: 5079 case Type::STK_BlockPointer: 5080 if (Src.get()->isNullPointerConstant(Context, 5081 Expr::NPC_ValueDependentIsNull)) 5082 return CK_NullToPointer; 5083 return CK_IntegralToPointer; 5084 case Type::STK_Bool: 5085 return CK_IntegralToBoolean; 5086 case Type::STK_Integral: 5087 return CK_IntegralCast; 5088 case Type::STK_Floating: 5089 return CK_IntegralToFloating; 5090 case Type::STK_IntegralComplex: 5091 Src = ImpCastExprToType(Src.get(), 5092 DestTy->castAs<ComplexType>()->getElementType(), 5093 CK_IntegralCast); 5094 return CK_IntegralRealToComplex; 5095 case Type::STK_FloatingComplex: 5096 Src = ImpCastExprToType(Src.get(), 5097 DestTy->castAs<ComplexType>()->getElementType(), 5098 CK_IntegralToFloating); 5099 return CK_FloatingRealToComplex; 5100 case Type::STK_MemberPointer: 5101 llvm_unreachable("member pointer type in C"); 5102 } 5103 llvm_unreachable("Should have returned before this"); 5104 5105 case Type::STK_Floating: 5106 switch (DestTy->getScalarTypeKind()) { 5107 case Type::STK_Floating: 5108 return CK_FloatingCast; 5109 case Type::STK_Bool: 5110 return CK_FloatingToBoolean; 5111 case Type::STK_Integral: 5112 return CK_FloatingToIntegral; 5113 case Type::STK_FloatingComplex: 5114 Src = ImpCastExprToType(Src.get(), 5115 DestTy->castAs<ComplexType>()->getElementType(), 5116 CK_FloatingCast); 5117 return CK_FloatingRealToComplex; 5118 case Type::STK_IntegralComplex: 5119 Src = ImpCastExprToType(Src.get(), 5120 DestTy->castAs<ComplexType>()->getElementType(), 5121 CK_FloatingToIntegral); 5122 return CK_IntegralRealToComplex; 5123 case Type::STK_CPointer: 5124 case Type::STK_ObjCObjectPointer: 5125 case Type::STK_BlockPointer: 5126 llvm_unreachable("valid float->pointer cast?"); 5127 case Type::STK_MemberPointer: 5128 llvm_unreachable("member pointer type in C"); 5129 } 5130 llvm_unreachable("Should have returned before this"); 5131 5132 case Type::STK_FloatingComplex: 5133 switch (DestTy->getScalarTypeKind()) { 5134 case Type::STK_FloatingComplex: 5135 return CK_FloatingComplexCast; 5136 case Type::STK_IntegralComplex: 5137 return CK_FloatingComplexToIntegralComplex; 5138 case Type::STK_Floating: { 5139 QualType ET = SrcTy->castAs<ComplexType>()->getElementType(); 5140 if (Context.hasSameType(ET, DestTy)) 5141 return CK_FloatingComplexToReal; 5142 Src = ImpCastExprToType(Src.get(), ET, CK_FloatingComplexToReal); 5143 return CK_FloatingCast; 5144 } 5145 case Type::STK_Bool: 5146 return CK_FloatingComplexToBoolean; 5147 case Type::STK_Integral: 5148 Src = ImpCastExprToType(Src.get(), 5149 SrcTy->castAs<ComplexType>()->getElementType(), 5150 CK_FloatingComplexToReal); 5151 return CK_FloatingToIntegral; 5152 case Type::STK_CPointer: 5153 case Type::STK_ObjCObjectPointer: 5154 case Type::STK_BlockPointer: 5155 llvm_unreachable("valid complex float->pointer cast?"); 5156 case Type::STK_MemberPointer: 5157 llvm_unreachable("member pointer type in C"); 5158 } 5159 llvm_unreachable("Should have returned before this"); 5160 5161 case Type::STK_IntegralComplex: 5162 switch (DestTy->getScalarTypeKind()) { 5163 case Type::STK_FloatingComplex: 5164 return CK_IntegralComplexToFloatingComplex; 5165 case Type::STK_IntegralComplex: 5166 return CK_IntegralComplexCast; 5167 case Type::STK_Integral: { 5168 QualType ET = SrcTy->castAs<ComplexType>()->getElementType(); 5169 if (Context.hasSameType(ET, DestTy)) 5170 return CK_IntegralComplexToReal; 5171 Src = ImpCastExprToType(Src.get(), ET, CK_IntegralComplexToReal); 5172 return CK_IntegralCast; 5173 } 5174 case Type::STK_Bool: 5175 return CK_IntegralComplexToBoolean; 5176 case Type::STK_Floating: 5177 Src = ImpCastExprToType(Src.get(), 5178 SrcTy->castAs<ComplexType>()->getElementType(), 5179 CK_IntegralComplexToReal); 5180 return CK_IntegralToFloating; 5181 case Type::STK_CPointer: 5182 case Type::STK_ObjCObjectPointer: 5183 case Type::STK_BlockPointer: 5184 llvm_unreachable("valid complex int->pointer cast?"); 5185 case Type::STK_MemberPointer: 5186 llvm_unreachable("member pointer type in C"); 5187 } 5188 llvm_unreachable("Should have returned before this"); 5189 } 5190 5191 llvm_unreachable("Unhandled scalar cast"); 5192} 5193 5194static bool breakDownVectorType(QualType type, uint64_t &len, 5195 QualType &eltType) { 5196 // Vectors are simple. 5197 if (const VectorType *vecType = type->getAs<VectorType>()) { 5198 len = vecType->getNumElements(); 5199 eltType = vecType->getElementType(); 5200 assert(eltType->isScalarType()); 5201 return true; 5202 } 5203 5204 // We allow lax conversion to and from non-vector types, but only if 5205 // they're real types (i.e. non-complex, non-pointer scalar types). 5206 if (!type->isRealType()) return false; 5207 5208 len = 1; 5209 eltType = type; 5210 return true; 5211} 5212 5213static bool VectorTypesMatch(Sema &S, QualType srcTy, QualType destTy) { 5214 uint64_t srcLen, destLen; 5215 QualType srcElt, destElt; 5216 if (!breakDownVectorType(srcTy, srcLen, srcElt)) return false; 5217 if (!breakDownVectorType(destTy, destLen, destElt)) return false; 5218 5219 // ASTContext::getTypeSize will return the size rounded up to a 5220 // power of 2, so instead of using that, we need to use the raw 5221 // element size multiplied by the element count. 5222 uint64_t srcEltSize = S.Context.getTypeSize(srcElt); 5223 uint64_t destEltSize = S.Context.getTypeSize(destElt); 5224 5225 return (srcLen * srcEltSize == destLen * destEltSize); 5226} 5227 5228/// Is this a legal conversion between two known vector types? 5229bool Sema::isLaxVectorConversion(QualType srcTy, QualType destTy) { 5230 assert(destTy->isVectorType() || srcTy->isVectorType()); 5231 5232 if (!Context.getLangOpts().LaxVectorConversions) 5233 return false; 5234 return VectorTypesMatch(*this, srcTy, destTy); 5235} 5236 5237bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, 5238 CastKind &Kind) { 5239 assert(VectorTy->isVectorType() && "Not a vector type!"); 5240 5241 if (Ty->isVectorType() || Ty->isIntegerType()) { 5242 if (!VectorTypesMatch(*this, Ty, VectorTy)) 5243 return Diag(R.getBegin(), 5244 Ty->isVectorType() ? 5245 diag::err_invalid_conversion_between_vectors : 5246 diag::err_invalid_conversion_between_vector_and_integer) 5247 << VectorTy << Ty << R; 5248 } else 5249 return Diag(R.getBegin(), 5250 diag::err_invalid_conversion_between_vector_and_scalar) 5251 << VectorTy << Ty << R; 5252 5253 Kind = CK_BitCast; 5254 return false; 5255} 5256 5257ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy, 5258 Expr *CastExpr, CastKind &Kind) { 5259 assert(DestTy->isExtVectorType() && "Not an extended vector type!"); 5260 5261 QualType SrcTy = CastExpr->getType(); 5262 5263 // If SrcTy is a VectorType, the total size must match to explicitly cast to 5264 // an ExtVectorType. 5265 // In OpenCL, casts between vectors of different types are not allowed. 5266 // (See OpenCL 6.2). 5267 if (SrcTy->isVectorType()) { 5268 if (!VectorTypesMatch(*this, SrcTy, DestTy) 5269 || (getLangOpts().OpenCL && 5270 (DestTy.getCanonicalType() != SrcTy.getCanonicalType()))) { 5271 Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors) 5272 << DestTy << SrcTy << R; 5273 return ExprError(); 5274 } 5275 Kind = CK_BitCast; 5276 return CastExpr; 5277 } 5278 5279 // All non-pointer scalars can be cast to ExtVector type. The appropriate 5280 // conversion will take place first from scalar to elt type, and then 5281 // splat from elt type to vector. 5282 if (SrcTy->isPointerType()) 5283 return Diag(R.getBegin(), 5284 diag::err_invalid_conversion_between_vector_and_scalar) 5285 << DestTy << SrcTy << R; 5286 5287 QualType DestElemTy = DestTy->getAs<ExtVectorType>()->getElementType(); 5288 ExprResult CastExprRes = CastExpr; 5289 CastKind CK = PrepareScalarCast(CastExprRes, DestElemTy); 5290 if (CastExprRes.isInvalid()) 5291 return ExprError(); 5292 CastExpr = ImpCastExprToType(CastExprRes.get(), DestElemTy, CK).get(); 5293 5294 Kind = CK_VectorSplat; 5295 return CastExpr; 5296} 5297 5298ExprResult 5299Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, 5300 Declarator &D, ParsedType &Ty, 5301 SourceLocation RParenLoc, Expr *CastExpr) { 5302 assert(!D.isInvalidType() && (CastExpr != nullptr) && 5303 "ActOnCastExpr(): missing type or expr"); 5304 5305 TypeSourceInfo *castTInfo = GetTypeForDeclaratorCast(D, CastExpr->getType()); 5306 if (D.isInvalidType()) 5307 return ExprError(); 5308 5309 if (getLangOpts().CPlusPlus) { 5310 // Check that there are no default arguments (C++ only). 5311 CheckExtraCXXDefaultArguments(D); 5312 } else { 5313 // Make sure any TypoExprs have been dealt with. 5314 ExprResult Res = CorrectDelayedTyposInExpr(CastExpr); 5315 if (!Res.isUsable()) 5316 return ExprError(); 5317 CastExpr = Res.get(); 5318 } 5319 5320 checkUnusedDeclAttributes(D); 5321 5322 QualType castType = castTInfo->getType(); 5323 Ty = CreateParsedType(castType, castTInfo); 5324 5325 bool isVectorLiteral = false; 5326 5327 // Check for an altivec or OpenCL literal, 5328 // i.e. all the elements are integer constants. 5329 ParenExpr *PE = dyn_cast<ParenExpr>(CastExpr); 5330 ParenListExpr *PLE = dyn_cast<ParenListExpr>(CastExpr); 5331 if ((getLangOpts().AltiVec || getLangOpts().OpenCL) 5332 && castType->isVectorType() && (PE || PLE)) { 5333 if (PLE && PLE->getNumExprs() == 0) { 5334 Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer); 5335 return ExprError(); 5336 } 5337 if (PE || PLE->getNumExprs() == 1) { 5338 Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0)); 5339 if (!E->getType()->isVectorType()) 5340 isVectorLiteral = true; 5341 } 5342 else 5343 isVectorLiteral = true; 5344 } 5345 5346 // If this is a vector initializer, '(' type ')' '(' init, ..., init ')' 5347 // then handle it as such. 5348 if (isVectorLiteral) 5349 return BuildVectorLiteral(LParenLoc, RParenLoc, CastExpr, castTInfo); 5350 5351 // If the Expr being casted is a ParenListExpr, handle it specially. 5352 // This is not an AltiVec-style cast, so turn the ParenListExpr into a 5353 // sequence of BinOp comma operators. 5354 if (isa<ParenListExpr>(CastExpr)) { 5355 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr); 5356 if (Result.isInvalid()) return ExprError(); 5357 CastExpr = Result.get(); 5358 } 5359 5360 if (getLangOpts().CPlusPlus && !castType->isVoidType() && 5361 !getSourceManager().isInSystemMacro(LParenLoc)) 5362 Diag(LParenLoc, diag::warn_old_style_cast) << CastExpr->getSourceRange(); 5363 5364 CheckTollFreeBridgeCast(castType, CastExpr); 5365 5366 CheckObjCBridgeRelatedCast(castType, CastExpr); 5367 5368 return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, CastExpr); 5369} 5370 5371ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc, 5372 SourceLocation RParenLoc, Expr *E, 5373 TypeSourceInfo *TInfo) { 5374 assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) && 5375 "Expected paren or paren list expression"); 5376 5377 Expr **exprs; 5378 unsigned numExprs; 5379 Expr *subExpr; 5380 SourceLocation LiteralLParenLoc, LiteralRParenLoc; 5381 if (ParenListExpr *PE = dyn_cast<ParenListExpr>(E)) { 5382 LiteralLParenLoc = PE->getLParenLoc(); 5383 LiteralRParenLoc = PE->getRParenLoc(); 5384 exprs = PE->getExprs(); 5385 numExprs = PE->getNumExprs(); 5386 } else { // isa<ParenExpr> by assertion at function entrance 5387 LiteralLParenLoc = cast<ParenExpr>(E)->getLParen(); 5388 LiteralRParenLoc = cast<ParenExpr>(E)->getRParen(); 5389 subExpr = cast<ParenExpr>(E)->getSubExpr(); 5390 exprs = &subExpr; 5391 numExprs = 1; 5392 } 5393 5394 QualType Ty = TInfo->getType(); 5395 assert(Ty->isVectorType() && "Expected vector type"); 5396 5397 SmallVector<Expr *, 8> initExprs; 5398 const VectorType *VTy = Ty->getAs<VectorType>(); 5399 unsigned numElems = Ty->getAs<VectorType>()->getNumElements(); 5400 5401 // '(...)' form of vector initialization in AltiVec: the number of 5402 // initializers must be one or must match the size of the vector. 5403 // If a single value is specified in the initializer then it will be 5404 // replicated to all the components of the vector 5405 if (VTy->getVectorKind() == VectorType::AltiVecVector) { 5406 // The number of initializers must be one or must match the size of the 5407 // vector. If a single value is specified in the initializer then it will 5408 // be replicated to all the components of the vector 5409 if (numExprs == 1) { 5410 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 5411 ExprResult Literal = DefaultLvalueConversion(exprs[0]); 5412 if (Literal.isInvalid()) 5413 return ExprError(); 5414 Literal = ImpCastExprToType(Literal.get(), ElemTy, 5415 PrepareScalarCast(Literal, ElemTy)); 5416 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get()); 5417 } 5418 else if (numExprs < numElems) { 5419 Diag(E->getExprLoc(), 5420 diag::err_incorrect_number_of_vector_initializers); 5421 return ExprError(); 5422 } 5423 else 5424 initExprs.append(exprs, exprs + numExprs); 5425 } 5426 else { 5427 // For OpenCL, when the number of initializers is a single value, 5428 // it will be replicated to all components of the vector. 5429 if (getLangOpts().OpenCL && 5430 VTy->getVectorKind() == VectorType::GenericVector && 5431 numExprs == 1) { 5432 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 5433 ExprResult Literal = DefaultLvalueConversion(exprs[0]); 5434 if (Literal.isInvalid()) 5435 return ExprError(); 5436 Literal = ImpCastExprToType(Literal.get(), ElemTy, 5437 PrepareScalarCast(Literal, ElemTy)); 5438 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get()); 5439 } 5440 5441 initExprs.append(exprs, exprs + numExprs); 5442 } 5443 // FIXME: This means that pretty-printing the final AST will produce curly 5444 // braces instead of the original commas. 5445 InitListExpr *initE = new (Context) InitListExpr(Context, LiteralLParenLoc, 5446 initExprs, LiteralRParenLoc); 5447 initE->setType(Ty); 5448 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE); 5449} 5450 5451/// This is not an AltiVec-style cast or or C++ direct-initialization, so turn 5452/// the ParenListExpr into a sequence of comma binary operators. 5453ExprResult 5454Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *OrigExpr) { 5455 ParenListExpr *E = dyn_cast<ParenListExpr>(OrigExpr); 5456 if (!E) 5457 return OrigExpr; 5458 5459 ExprResult Result(E->getExpr(0)); 5460 5461 for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i) 5462 Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(), 5463 E->getExpr(i)); 5464 5465 if (Result.isInvalid()) return ExprError(); 5466 5467 return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get()); 5468} 5469 5470ExprResult Sema::ActOnParenListExpr(SourceLocation L, 5471 SourceLocation R, 5472 MultiExprArg Val) { 5473 Expr *expr = new (Context) ParenListExpr(Context, L, Val, R); 5474 return expr; 5475} 5476 5477/// \brief Emit a specialized diagnostic when one expression is a null pointer 5478/// constant and the other is not a pointer. Returns true if a diagnostic is 5479/// emitted. 5480bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, 5481 SourceLocation QuestionLoc) { 5482 Expr *NullExpr = LHSExpr; 5483 Expr *NonPointerExpr = RHSExpr; 5484 Expr::NullPointerConstantKind NullKind = 5485 NullExpr->isNullPointerConstant(Context, 5486 Expr::NPC_ValueDependentIsNotNull); 5487 5488 if (NullKind == Expr::NPCK_NotNull) { 5489 NullExpr = RHSExpr; 5490 NonPointerExpr = LHSExpr; 5491 NullKind = 5492 NullExpr->isNullPointerConstant(Context, 5493 Expr::NPC_ValueDependentIsNotNull); 5494 } 5495 5496 if (NullKind == Expr::NPCK_NotNull) 5497 return false; 5498 5499 if (NullKind == Expr::NPCK_ZeroExpression) 5500 return false; 5501 5502 if (NullKind == Expr::NPCK_ZeroLiteral) { 5503 // In this case, check to make sure that we got here from a "NULL" 5504 // string in the source code. 5505 NullExpr = NullExpr->IgnoreParenImpCasts(); 5506 SourceLocation loc = NullExpr->getExprLoc(); 5507 if (!findMacroSpelling(loc, "NULL")) 5508 return false; 5509 } 5510 5511 int DiagType = (NullKind == Expr::NPCK_CXX11_nullptr); 5512 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null) 5513 << NonPointerExpr->getType() << DiagType 5514 << NonPointerExpr->getSourceRange(); 5515 return true; 5516} 5517 5518/// \brief Return false if the condition expression is valid, true otherwise. 5519static bool checkCondition(Sema &S, Expr *Cond) { 5520 QualType CondTy = Cond->getType(); 5521 5522 // C99 6.5.15p2 5523 if (CondTy->isScalarType()) return false; 5524 5525 // OpenCL v1.1 s6.3.i says the condition is allowed to be a vector or scalar. 5526 if (S.getLangOpts().OpenCL && CondTy->isVectorType()) 5527 return false; 5528 5529 // Emit the proper error message. 5530 S.Diag(Cond->getLocStart(), S.getLangOpts().OpenCL ? 5531 diag::err_typecheck_cond_expect_scalar : 5532 diag::err_typecheck_cond_expect_scalar_or_vector) 5533 << CondTy; 5534 return true; 5535} 5536 5537/// \brief Return false if the two expressions can be converted to a vector, 5538/// true otherwise 5539static bool checkConditionalConvertScalarsToVectors(Sema &S, ExprResult &LHS, 5540 ExprResult &RHS, 5541 QualType CondTy) { 5542 // Both operands should be of scalar type. 5543 if (!LHS.get()->getType()->isScalarType()) { 5544 S.Diag(LHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 5545 << CondTy; 5546 return true; 5547 } 5548 if (!RHS.get()->getType()->isScalarType()) { 5549 S.Diag(RHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 5550 << CondTy; 5551 return true; 5552 } 5553 5554 // Implicity convert these scalars to the type of the condition. 5555 LHS = S.ImpCastExprToType(LHS.get(), CondTy, CK_IntegralCast); 5556 RHS = S.ImpCastExprToType(RHS.get(), CondTy, CK_IntegralCast); 5557 return false; 5558} 5559 5560/// \brief Handle when one or both operands are void type. 5561static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS, 5562 ExprResult &RHS) { 5563 Expr *LHSExpr = LHS.get(); 5564 Expr *RHSExpr = RHS.get(); 5565 5566 if (!LHSExpr->getType()->isVoidType()) 5567 S.Diag(RHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 5568 << RHSExpr->getSourceRange(); 5569 if (!RHSExpr->getType()->isVoidType()) 5570 S.Diag(LHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 5571 << LHSExpr->getSourceRange(); 5572 LHS = S.ImpCastExprToType(LHS.get(), S.Context.VoidTy, CK_ToVoid); 5573 RHS = S.ImpCastExprToType(RHS.get(), S.Context.VoidTy, CK_ToVoid); 5574 return S.Context.VoidTy; 5575} 5576 5577/// \brief Return false if the NullExpr can be promoted to PointerTy, 5578/// true otherwise. 5579static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, 5580 QualType PointerTy) { 5581 if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) || 5582 !NullExpr.get()->isNullPointerConstant(S.Context, 5583 Expr::NPC_ValueDependentIsNull)) 5584 return true; 5585 5586 NullExpr = S.ImpCastExprToType(NullExpr.get(), PointerTy, CK_NullToPointer); 5587 return false; 5588} 5589 5590/// \brief Checks compatibility between two pointers and return the resulting 5591/// type. 5592static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, 5593 ExprResult &RHS, 5594 SourceLocation Loc) { 5595 QualType LHSTy = LHS.get()->getType(); 5596 QualType RHSTy = RHS.get()->getType(); 5597 5598 if (S.Context.hasSameType(LHSTy, RHSTy)) { 5599 // Two identical pointers types are always compatible. 5600 return LHSTy; 5601 } 5602 5603 QualType lhptee, rhptee; 5604 5605 // Get the pointee types. 5606 bool IsBlockPointer = false; 5607 if (const BlockPointerType *LHSBTy = LHSTy->getAs<BlockPointerType>()) { 5608 lhptee = LHSBTy->getPointeeType(); 5609 rhptee = RHSTy->castAs<BlockPointerType>()->getPointeeType(); 5610 IsBlockPointer = true; 5611 } else { 5612 lhptee = LHSTy->castAs<PointerType>()->getPointeeType(); 5613 rhptee = RHSTy->castAs<PointerType>()->getPointeeType(); 5614 } 5615 5616 // C99 6.5.15p6: If both operands are pointers to compatible types or to 5617 // differently qualified versions of compatible types, the result type is 5618 // a pointer to an appropriately qualified version of the composite 5619 // type. 5620 5621 // Only CVR-qualifiers exist in the standard, and the differently-qualified 5622 // clause doesn't make sense for our extensions. E.g. address space 2 should 5623 // be incompatible with address space 3: they may live on different devices or 5624 // anything. 5625 Qualifiers lhQual = lhptee.getQualifiers(); 5626 Qualifiers rhQual = rhptee.getQualifiers(); 5627 5628 unsigned MergedCVRQual = lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers(); 5629 lhQual.removeCVRQualifiers(); 5630 rhQual.removeCVRQualifiers(); 5631 5632 lhptee = S.Context.getQualifiedType(lhptee.getUnqualifiedType(), lhQual); 5633 rhptee = S.Context.getQualifiedType(rhptee.getUnqualifiedType(), rhQual); 5634 5635 QualType CompositeTy = S.Context.mergeTypes(lhptee, rhptee); 5636 5637 if (CompositeTy.isNull()) { 5638 S.Diag(Loc, diag::ext_typecheck_cond_incompatible_pointers) 5639 << LHSTy << RHSTy << LHS.get()->getSourceRange() 5640 << RHS.get()->getSourceRange(); 5641 // In this situation, we assume void* type. No especially good 5642 // reason, but this is what gcc does, and we do have to pick 5643 // to get a consistent AST. 5644 QualType incompatTy = S.Context.getPointerType(S.Context.VoidTy); 5645 LHS = S.ImpCastExprToType(LHS.get(), incompatTy, CK_BitCast); 5646 RHS = S.ImpCastExprToType(RHS.get(), incompatTy, CK_BitCast); 5647 return incompatTy; 5648 } 5649 5650 // The pointer types are compatible. 5651 QualType ResultTy = CompositeTy.withCVRQualifiers(MergedCVRQual); 5652 if (IsBlockPointer) 5653 ResultTy = S.Context.getBlockPointerType(ResultTy); 5654 else 5655 ResultTy = S.Context.getPointerType(ResultTy); 5656 5657 LHS = S.ImpCastExprToType(LHS.get(), ResultTy, CK_BitCast); 5658 RHS = S.ImpCastExprToType(RHS.get(), ResultTy, CK_BitCast); 5659 return ResultTy; 5660} 5661 5662/// \brief Returns true if QT is quelified-id and implements 'NSObject' and/or 5663/// 'NSCopying' protocols (and nothing else); or QT is an NSObject and optionally 5664/// implements 'NSObject' and/or NSCopying' protocols (and nothing else). 5665static bool isObjCPtrBlockCompatible(Sema &S, ASTContext &C, QualType QT) { 5666 if (QT->isObjCIdType()) 5667 return true; 5668 5669 const ObjCObjectPointerType *OPT = QT->getAs<ObjCObjectPointerType>(); 5670 if (!OPT) 5671 return false; 5672 5673 if (ObjCInterfaceDecl *ID = OPT->getInterfaceDecl()) 5674 if (ID->getIdentifier() != &C.Idents.get("NSObject")) 5675 return false; 5676 5677 ObjCProtocolDecl* PNSCopying = 5678 S.LookupProtocol(&C.Idents.get("NSCopying"), SourceLocation()); 5679 ObjCProtocolDecl* PNSObject = 5680 S.LookupProtocol(&C.Idents.get("NSObject"), SourceLocation()); 5681 5682 for (auto *Proto : OPT->quals()) { 5683 if ((PNSCopying && declaresSameEntity(Proto, PNSCopying)) || 5684 (PNSObject && declaresSameEntity(Proto, PNSObject))) 5685 ; 5686 else 5687 return false; 5688 } 5689 return true; 5690} 5691 5692/// \brief Return the resulting type when the operands are both block pointers. 5693static QualType checkConditionalBlockPointerCompatibility(Sema &S, 5694 ExprResult &LHS, 5695 ExprResult &RHS, 5696 SourceLocation Loc) { 5697 QualType LHSTy = LHS.get()->getType(); 5698 QualType RHSTy = RHS.get()->getType(); 5699 5700 if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) { 5701 if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) { 5702 QualType destType = S.Context.getPointerType(S.Context.VoidTy); 5703 LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast); 5704 RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast); 5705 return destType; 5706 } 5707 S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 5708 << LHSTy << RHSTy << LHS.get()->getSourceRange() 5709 << RHS.get()->getSourceRange(); 5710 return QualType(); 5711 } 5712 5713 // We have 2 block pointer types. 5714 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 5715} 5716 5717/// \brief Return the resulting type when the operands are both pointers. 5718static QualType 5719checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, 5720 ExprResult &RHS, 5721 SourceLocation Loc) { 5722 // get the pointer types 5723 QualType LHSTy = LHS.get()->getType(); 5724 QualType RHSTy = RHS.get()->getType(); 5725 5726 // get the "pointed to" types 5727 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 5728 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 5729 5730 // ignore qualifiers on void (C99 6.5.15p3, clause 6) 5731 if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) { 5732 // Figure out necessary qualifiers (C99 6.5.15p6) 5733 QualType destPointee 5734 = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 5735 QualType destType = S.Context.getPointerType(destPointee); 5736 // Add qualifiers if necessary. 5737 LHS = S.ImpCastExprToType(LHS.get(), destType, CK_NoOp); 5738 // Promote to void*. 5739 RHS = S.ImpCastExprToType(RHS.get(), destType, CK_BitCast); 5740 return destType; 5741 } 5742 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) { 5743 QualType destPointee 5744 = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 5745 QualType destType = S.Context.getPointerType(destPointee); 5746 // Add qualifiers if necessary. 5747 RHS = S.ImpCastExprToType(RHS.get(), destType, CK_NoOp); 5748 // Promote to void*. 5749 LHS = S.ImpCastExprToType(LHS.get(), destType, CK_BitCast); 5750 return destType; 5751 } 5752 5753 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 5754} 5755 5756/// \brief Return false if the first expression is not an integer and the second 5757/// expression is not a pointer, true otherwise. 5758static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, 5759 Expr* PointerExpr, SourceLocation Loc, 5760 bool IsIntFirstExpr) { 5761 if (!PointerExpr->getType()->isPointerType() || 5762 !Int.get()->getType()->isIntegerType()) 5763 return false; 5764 5765 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr; 5766 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get(); 5767 5768 S.Diag(Loc, diag::ext_typecheck_cond_pointer_integer_mismatch) 5769 << Expr1->getType() << Expr2->getType() 5770 << Expr1->getSourceRange() << Expr2->getSourceRange(); 5771 Int = S.ImpCastExprToType(Int.get(), PointerExpr->getType(), 5772 CK_IntegralToPointer); 5773 return true; 5774} 5775 5776/// Note that LHS is not null here, even if this is the gnu "x ?: y" extension. 5777/// In that case, LHS = cond. 5778/// C99 6.5.15 5779QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, 5780 ExprResult &RHS, ExprValueKind &VK, 5781 ExprObjectKind &OK, 5782 SourceLocation QuestionLoc) { 5783 5784 ExprResult LHSResult = CheckPlaceholderExpr(LHS.get()); 5785 if (!LHSResult.isUsable()) return QualType(); 5786 LHS = LHSResult; 5787 5788 ExprResult RHSResult = CheckPlaceholderExpr(RHS.get()); 5789 if (!RHSResult.isUsable()) return QualType(); 5790 RHS = RHSResult; 5791 5792 // C++ is sufficiently different to merit its own checker. 5793 if (getLangOpts().CPlusPlus) 5794 return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc); 5795 5796 VK = VK_RValue; 5797 OK = OK_Ordinary; 5798 5799 // First, check the condition. 5800 Cond = UsualUnaryConversions(Cond.get()); 5801 if (Cond.isInvalid()) 5802 return QualType(); 5803 if (checkCondition(*this, Cond.get())) 5804 return QualType(); 5805 5806 // Now check the two expressions. 5807 if (LHS.get()->getType()->isVectorType() || 5808 RHS.get()->getType()->isVectorType()) 5809 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false); 5810 5811 QualType ResTy = UsualArithmeticConversions(LHS, RHS); 5812 if (LHS.isInvalid() || RHS.isInvalid()) 5813 return QualType(); 5814 5815 QualType CondTy = Cond.get()->getType(); 5816 QualType LHSTy = LHS.get()->getType(); 5817 QualType RHSTy = RHS.get()->getType(); 5818 5819 // If the condition is a vector, and both operands are scalar, 5820 // attempt to implicity convert them to the vector type to act like the 5821 // built in select. (OpenCL v1.1 s6.3.i) 5822 if (getLangOpts().OpenCL && CondTy->isVectorType()) 5823 if (checkConditionalConvertScalarsToVectors(*this, LHS, RHS, CondTy)) 5824 return QualType(); 5825 5826 // If both operands have arithmetic type, do the usual arithmetic conversions 5827 // to find a common type: C99 6.5.15p3,5. 5828 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) { 5829 LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy)); 5830 RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy)); 5831 5832 return ResTy; 5833 } 5834 5835 // If both operands are the same structure or union type, the result is that 5836 // type. 5837 if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3 5838 if (const RecordType *RHSRT = RHSTy->getAs<RecordType>()) 5839 if (LHSRT->getDecl() == RHSRT->getDecl()) 5840 // "If both the operands have structure or union type, the result has 5841 // that type." This implies that CV qualifiers are dropped. 5842 return LHSTy.getUnqualifiedType(); 5843 // FIXME: Type of conditional expression must be complete in C mode. 5844 } 5845 5846 // C99 6.5.15p5: "If both operands have void type, the result has void type." 5847 // The following || allows only one side to be void (a GCC-ism). 5848 if (LHSTy->isVoidType() || RHSTy->isVoidType()) { 5849 return checkConditionalVoidType(*this, LHS, RHS); 5850 } 5851 5852 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has 5853 // the type of the other operand." 5854 if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy; 5855 if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy; 5856 5857 // All objective-c pointer type analysis is done here. 5858 QualType compositeType = FindCompositeObjCPointerType(LHS, RHS, 5859 QuestionLoc); 5860 if (LHS.isInvalid() || RHS.isInvalid()) 5861 return QualType(); 5862 if (!compositeType.isNull()) 5863 return compositeType; 5864 5865 5866 // Handle block pointer types. 5867 if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) 5868 return checkConditionalBlockPointerCompatibility(*this, LHS, RHS, 5869 QuestionLoc); 5870 5871 // Check constraints for C object pointers types (C99 6.5.15p3,6). 5872 if (LHSTy->isPointerType() && RHSTy->isPointerType()) 5873 return checkConditionalObjectPointersCompatibility(*this, LHS, RHS, 5874 QuestionLoc); 5875 5876 // GCC compatibility: soften pointer/integer mismatch. Note that 5877 // null pointers have been filtered out by this point. 5878 if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc, 5879 /*isIntFirstExpr=*/true)) 5880 return RHSTy; 5881 if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc, 5882 /*isIntFirstExpr=*/false)) 5883 return LHSTy; 5884 5885 // Emit a better diagnostic if one of the expressions is a null pointer 5886 // constant and the other is not a pointer type. In this case, the user most 5887 // likely forgot to take the address of the other expression. 5888 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc)) 5889 return QualType(); 5890 5891 // Otherwise, the operands are not compatible. 5892 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 5893 << LHSTy << RHSTy << LHS.get()->getSourceRange() 5894 << RHS.get()->getSourceRange(); 5895 return QualType(); 5896} 5897 5898/// FindCompositeObjCPointerType - Helper method to find composite type of 5899/// two objective-c pointer types of the two input expressions. 5900QualType Sema::FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, 5901 SourceLocation QuestionLoc) { 5902 QualType LHSTy = LHS.get()->getType(); 5903 QualType RHSTy = RHS.get()->getType(); 5904 5905 // Handle things like Class and struct objc_class*. Here we case the result 5906 // to the pseudo-builtin, because that will be implicitly cast back to the 5907 // redefinition type if an attempt is made to access its fields. 5908 if (LHSTy->isObjCClassType() && 5909 (Context.hasSameType(RHSTy, Context.getObjCClassRedefinitionType()))) { 5910 RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast); 5911 return LHSTy; 5912 } 5913 if (RHSTy->isObjCClassType() && 5914 (Context.hasSameType(LHSTy, Context.getObjCClassRedefinitionType()))) { 5915 LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast); 5916 return RHSTy; 5917 } 5918 // And the same for struct objc_object* / id 5919 if (LHSTy->isObjCIdType() && 5920 (Context.hasSameType(RHSTy, Context.getObjCIdRedefinitionType()))) { 5921 RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_CPointerToObjCPointerCast); 5922 return LHSTy; 5923 } 5924 if (RHSTy->isObjCIdType() && 5925 (Context.hasSameType(LHSTy, Context.getObjCIdRedefinitionType()))) { 5926 LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_CPointerToObjCPointerCast); 5927 return RHSTy; 5928 } 5929 // And the same for struct objc_selector* / SEL 5930 if (Context.isObjCSelType(LHSTy) && 5931 (Context.hasSameType(RHSTy, Context.getObjCSelRedefinitionType()))) { 5932 RHS = ImpCastExprToType(RHS.get(), LHSTy, CK_BitCast); 5933 return LHSTy; 5934 } 5935 if (Context.isObjCSelType(RHSTy) && 5936 (Context.hasSameType(LHSTy, Context.getObjCSelRedefinitionType()))) { 5937 LHS = ImpCastExprToType(LHS.get(), RHSTy, CK_BitCast); 5938 return RHSTy; 5939 } 5940 // Check constraints for Objective-C object pointers types. 5941 if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) { 5942 5943 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) { 5944 // Two identical object pointer types are always compatible. 5945 return LHSTy; 5946 } 5947 const ObjCObjectPointerType *LHSOPT = LHSTy->castAs<ObjCObjectPointerType>(); 5948 const ObjCObjectPointerType *RHSOPT = RHSTy->castAs<ObjCObjectPointerType>(); 5949 QualType compositeType = LHSTy; 5950 5951 // If both operands are interfaces and either operand can be 5952 // assigned to the other, use that type as the composite 5953 // type. This allows 5954 // xxx ? (A*) a : (B*) b 5955 // where B is a subclass of A. 5956 // 5957 // Additionally, as for assignment, if either type is 'id' 5958 // allow silent coercion. Finally, if the types are 5959 // incompatible then make sure to use 'id' as the composite 5960 // type so the result is acceptable for sending messages to. 5961 5962 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'. 5963 // It could return the composite type. 5964 if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) { 5965 compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy; 5966 } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) { 5967 compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy; 5968 } else if ((LHSTy->isObjCQualifiedIdType() || 5969 RHSTy->isObjCQualifiedIdType()) && 5970 Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) { 5971 // Need to handle "id<xx>" explicitly. 5972 // GCC allows qualified id and any Objective-C type to devolve to 5973 // id. Currently localizing to here until clear this should be 5974 // part of ObjCQualifiedIdTypesAreCompatible. 5975 compositeType = Context.getObjCIdType(); 5976 } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) { 5977 compositeType = Context.getObjCIdType(); 5978 } else if (!(compositeType = 5979 Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull()) 5980 ; 5981 else { 5982 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands) 5983 << LHSTy << RHSTy 5984 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5985 QualType incompatTy = Context.getObjCIdType(); 5986 LHS = ImpCastExprToType(LHS.get(), incompatTy, CK_BitCast); 5987 RHS = ImpCastExprToType(RHS.get(), incompatTy, CK_BitCast); 5988 return incompatTy; 5989 } 5990 // The object pointer types are compatible. 5991 LHS = ImpCastExprToType(LHS.get(), compositeType, CK_BitCast); 5992 RHS = ImpCastExprToType(RHS.get(), compositeType, CK_BitCast); 5993 return compositeType; 5994 } 5995 // Check Objective-C object pointer types and 'void *' 5996 if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) { 5997 if (getLangOpts().ObjCAutoRefCount) { 5998 // ARC forbids the implicit conversion of object pointers to 'void *', 5999 // so these types are not compatible. 6000 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy 6001 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6002 LHS = RHS = true; 6003 return QualType(); 6004 } 6005 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 6006 QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 6007 QualType destPointee 6008 = Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 6009 QualType destType = Context.getPointerType(destPointee); 6010 // Add qualifiers if necessary. 6011 LHS = ImpCastExprToType(LHS.get(), destType, CK_NoOp); 6012 // Promote to void*. 6013 RHS = ImpCastExprToType(RHS.get(), destType, CK_BitCast); 6014 return destType; 6015 } 6016 if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) { 6017 if (getLangOpts().ObjCAutoRefCount) { 6018 // ARC forbids the implicit conversion of object pointers to 'void *', 6019 // so these types are not compatible. 6020 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy 6021 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6022 LHS = RHS = true; 6023 return QualType(); 6024 } 6025 QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 6026 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 6027 QualType destPointee 6028 = Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 6029 QualType destType = Context.getPointerType(destPointee); 6030 // Add qualifiers if necessary. 6031 RHS = ImpCastExprToType(RHS.get(), destType, CK_NoOp); 6032 // Promote to void*. 6033 LHS = ImpCastExprToType(LHS.get(), destType, CK_BitCast); 6034 return destType; 6035 } 6036 return QualType(); 6037} 6038 6039/// SuggestParentheses - Emit a note with a fixit hint that wraps 6040/// ParenRange in parentheses. 6041static void SuggestParentheses(Sema &Self, SourceLocation Loc, 6042 const PartialDiagnostic &Note, 6043 SourceRange ParenRange) { 6044 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(ParenRange.getEnd()); 6045 if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() && 6046 EndLoc.isValid()) { 6047 Self.Diag(Loc, Note) 6048 << FixItHint::CreateInsertion(ParenRange.getBegin(), "(") 6049 << FixItHint::CreateInsertion(EndLoc, ")"); 6050 } else { 6051 // We can't display the parentheses, so just show the bare note. 6052 Self.Diag(Loc, Note) << ParenRange; 6053 } 6054} 6055 6056static bool IsArithmeticOp(BinaryOperatorKind Opc) { 6057 return Opc >= BO_Mul && Opc <= BO_Shr; 6058} 6059 6060/// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary 6061/// expression, either using a built-in or overloaded operator, 6062/// and sets *OpCode to the opcode and *RHSExprs to the right-hand side 6063/// expression. 6064static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode, 6065 Expr **RHSExprs) { 6066 // Don't strip parenthesis: we should not warn if E is in parenthesis. 6067 E = E->IgnoreImpCasts(); 6068 E = E->IgnoreConversionOperator(); 6069 E = E->IgnoreImpCasts(); 6070 6071 // Built-in binary operator. 6072 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) { 6073 if (IsArithmeticOp(OP->getOpcode())) { 6074 *Opcode = OP->getOpcode(); 6075 *RHSExprs = OP->getRHS(); 6076 return true; 6077 } 6078 } 6079 6080 // Overloaded operator. 6081 if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(E)) { 6082 if (Call->getNumArgs() != 2) 6083 return false; 6084 6085 // Make sure this is really a binary operator that is safe to pass into 6086 // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op. 6087 OverloadedOperatorKind OO = Call->getOperator(); 6088 if (OO < OO_Plus || OO > OO_Arrow || 6089 OO == OO_PlusPlus || OO == OO_MinusMinus) 6090 return false; 6091 6092 BinaryOperatorKind OpKind = BinaryOperator::getOverloadedOpcode(OO); 6093 if (IsArithmeticOp(OpKind)) { 6094 *Opcode = OpKind; 6095 *RHSExprs = Call->getArg(1); 6096 return true; 6097 } 6098 } 6099 6100 return false; 6101} 6102 6103static bool IsLogicOp(BinaryOperatorKind Opc) { 6104 return (Opc >= BO_LT && Opc <= BO_NE) || (Opc >= BO_LAnd && Opc <= BO_LOr); 6105} 6106 6107/// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type 6108/// or is a logical expression such as (x==y) which has int type, but is 6109/// commonly interpreted as boolean. 6110static bool ExprLooksBoolean(Expr *E) { 6111 E = E->IgnoreParenImpCasts(); 6112 6113 if (E->getType()->isBooleanType()) 6114 return true; 6115 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) 6116 return IsLogicOp(OP->getOpcode()); 6117 if (UnaryOperator *OP = dyn_cast<UnaryOperator>(E)) 6118 return OP->getOpcode() == UO_LNot; 6119 6120 return false; 6121} 6122 6123/// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator 6124/// and binary operator are mixed in a way that suggests the programmer assumed 6125/// the conditional operator has higher precedence, for example: 6126/// "int x = a + someBinaryCondition ? 1 : 2". 6127static void DiagnoseConditionalPrecedence(Sema &Self, 6128 SourceLocation OpLoc, 6129 Expr *Condition, 6130 Expr *LHSExpr, 6131 Expr *RHSExpr) { 6132 BinaryOperatorKind CondOpcode; 6133 Expr *CondRHS; 6134 6135 if (!IsArithmeticBinaryExpr(Condition, &CondOpcode, &CondRHS)) 6136 return; 6137 if (!ExprLooksBoolean(CondRHS)) 6138 return; 6139 6140 // The condition is an arithmetic binary expression, with a right- 6141 // hand side that looks boolean, so warn. 6142 6143 Self.Diag(OpLoc, diag::warn_precedence_conditional) 6144 << Condition->getSourceRange() 6145 << BinaryOperator::getOpcodeStr(CondOpcode); 6146 6147 SuggestParentheses(Self, OpLoc, 6148 Self.PDiag(diag::note_precedence_silence) 6149 << BinaryOperator::getOpcodeStr(CondOpcode), 6150 SourceRange(Condition->getLocStart(), Condition->getLocEnd())); 6151 6152 SuggestParentheses(Self, OpLoc, 6153 Self.PDiag(diag::note_precedence_conditional_first), 6154 SourceRange(CondRHS->getLocStart(), RHSExpr->getLocEnd())); 6155} 6156 6157/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null 6158/// in the case of a the GNU conditional expr extension. 6159ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc, 6160 SourceLocation ColonLoc, 6161 Expr *CondExpr, Expr *LHSExpr, 6162 Expr *RHSExpr) { 6163 if (!getLangOpts().CPlusPlus) { 6164 // C cannot handle TypoExpr nodes in the condition because it 6165 // doesn't handle dependent types properly, so make sure any TypoExprs have 6166 // been dealt with before checking the operands. 6167 ExprResult CondResult = CorrectDelayedTyposInExpr(CondExpr); 6168 if (!CondResult.isUsable()) return ExprError(); 6169 CondExpr = CondResult.get(); 6170 } 6171 6172 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS 6173 // was the condition. 6174 OpaqueValueExpr *opaqueValue = nullptr; 6175 Expr *commonExpr = nullptr; 6176 if (!LHSExpr) { 6177 commonExpr = CondExpr; 6178 // Lower out placeholder types first. This is important so that we don't 6179 // try to capture a placeholder. This happens in few cases in C++; such 6180 // as Objective-C++'s dictionary subscripting syntax. 6181 if (commonExpr->hasPlaceholderType()) { 6182 ExprResult result = CheckPlaceholderExpr(commonExpr); 6183 if (!result.isUsable()) return ExprError(); 6184 commonExpr = result.get(); 6185 } 6186 // We usually want to apply unary conversions *before* saving, except 6187 // in the special case of a C++ l-value conditional. 6188 if (!(getLangOpts().CPlusPlus 6189 && !commonExpr->isTypeDependent() 6190 && commonExpr->getValueKind() == RHSExpr->getValueKind() 6191 && commonExpr->isGLValue() 6192 && commonExpr->isOrdinaryOrBitFieldObject() 6193 && RHSExpr->isOrdinaryOrBitFieldObject() 6194 && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) { 6195 ExprResult commonRes = UsualUnaryConversions(commonExpr); 6196 if (commonRes.isInvalid()) 6197 return ExprError(); 6198 commonExpr = commonRes.get(); 6199 } 6200 6201 opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(), 6202 commonExpr->getType(), 6203 commonExpr->getValueKind(), 6204 commonExpr->getObjectKind(), 6205 commonExpr); 6206 LHSExpr = CondExpr = opaqueValue; 6207 } 6208 6209 ExprValueKind VK = VK_RValue; 6210 ExprObjectKind OK = OK_Ordinary; 6211 ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr; 6212 QualType result = CheckConditionalOperands(Cond, LHS, RHS, 6213 VK, OK, QuestionLoc); 6214 if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() || 6215 RHS.isInvalid()) 6216 return ExprError(); 6217 6218 DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(), 6219 RHS.get()); 6220 6221 if (!commonExpr) 6222 return new (Context) 6223 ConditionalOperator(Cond.get(), QuestionLoc, LHS.get(), ColonLoc, 6224 RHS.get(), result, VK, OK); 6225 6226 return new (Context) BinaryConditionalOperator( 6227 commonExpr, opaqueValue, Cond.get(), LHS.get(), RHS.get(), QuestionLoc, 6228 ColonLoc, result, VK, OK); 6229} 6230 6231// checkPointerTypesForAssignment - This is a very tricky routine (despite 6232// being closely modeled after the C99 spec:-). The odd characteristic of this 6233// routine is it effectively iqnores the qualifiers on the top level pointee. 6234// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3]. 6235// FIXME: add a couple examples in this comment. 6236static Sema::AssignConvertType 6237checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) { 6238 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 6239 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 6240 6241 // get the "pointed to" type (ignoring qualifiers at the top level) 6242 const Type *lhptee, *rhptee; 6243 Qualifiers lhq, rhq; 6244 std::tie(lhptee, lhq) = 6245 cast<PointerType>(LHSType)->getPointeeType().split().asPair(); 6246 std::tie(rhptee, rhq) = 6247 cast<PointerType>(RHSType)->getPointeeType().split().asPair(); 6248 6249 Sema::AssignConvertType ConvTy = Sema::Compatible; 6250 6251 // C99 6.5.16.1p1: This following citation is common to constraints 6252 // 3 & 4 (below). ...and the type *pointed to* by the left has all the 6253 // qualifiers of the type *pointed to* by the right; 6254 6255 // As a special case, 'non-__weak A *' -> 'non-__weak const *' is okay. 6256 if (lhq.getObjCLifetime() != rhq.getObjCLifetime() && 6257 lhq.compatiblyIncludesObjCLifetime(rhq)) { 6258 // Ignore lifetime for further calculation. 6259 lhq.removeObjCLifetime(); 6260 rhq.removeObjCLifetime(); 6261 } 6262 6263 if (!lhq.compatiblyIncludes(rhq)) { 6264 // Treat address-space mismatches as fatal. TODO: address subspaces 6265 if (!lhq.isAddressSpaceSupersetOf(rhq)) 6266 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 6267 6268 // It's okay to add or remove GC or lifetime qualifiers when converting to 6269 // and from void*. 6270 else if (lhq.withoutObjCGCAttr().withoutObjCLifetime() 6271 .compatiblyIncludes( 6272 rhq.withoutObjCGCAttr().withoutObjCLifetime()) 6273 && (lhptee->isVoidType() || rhptee->isVoidType())) 6274 ; // keep old 6275 6276 // Treat lifetime mismatches as fatal. 6277 else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) 6278 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 6279 6280 // For GCC compatibility, other qualifier mismatches are treated 6281 // as still compatible in C. 6282 else ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 6283 } 6284 6285 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or 6286 // incomplete type and the other is a pointer to a qualified or unqualified 6287 // version of void... 6288 if (lhptee->isVoidType()) { 6289 if (rhptee->isIncompleteOrObjectType()) 6290 return ConvTy; 6291 6292 // As an extension, we allow cast to/from void* to function pointer. 6293 assert(rhptee->isFunctionType()); 6294 return Sema::FunctionVoidPointer; 6295 } 6296 6297 if (rhptee->isVoidType()) { 6298 if (lhptee->isIncompleteOrObjectType()) 6299 return ConvTy; 6300 6301 // As an extension, we allow cast to/from void* to function pointer. 6302 assert(lhptee->isFunctionType()); 6303 return Sema::FunctionVoidPointer; 6304 } 6305 6306 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or 6307 // unqualified versions of compatible types, ... 6308 QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0); 6309 if (!S.Context.typesAreCompatible(ltrans, rtrans)) { 6310 // Check if the pointee types are compatible ignoring the sign. 6311 // We explicitly check for char so that we catch "char" vs 6312 // "unsigned char" on systems where "char" is unsigned. 6313 if (lhptee->isCharType()) 6314 ltrans = S.Context.UnsignedCharTy; 6315 else if (lhptee->hasSignedIntegerRepresentation()) 6316 ltrans = S.Context.getCorrespondingUnsignedType(ltrans); 6317 6318 if (rhptee->isCharType()) 6319 rtrans = S.Context.UnsignedCharTy; 6320 else if (rhptee->hasSignedIntegerRepresentation()) 6321 rtrans = S.Context.getCorrespondingUnsignedType(rtrans); 6322 6323 if (ltrans == rtrans) { 6324 // Types are compatible ignoring the sign. Qualifier incompatibility 6325 // takes priority over sign incompatibility because the sign 6326 // warning can be disabled. 6327 if (ConvTy != Sema::Compatible) 6328 return ConvTy; 6329 6330 return Sema::IncompatiblePointerSign; 6331 } 6332 6333 // If we are a multi-level pointer, it's possible that our issue is simply 6334 // one of qualification - e.g. char ** -> const char ** is not allowed. If 6335 // the eventual target type is the same and the pointers have the same 6336 // level of indirection, this must be the issue. 6337 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) { 6338 do { 6339 lhptee = cast<PointerType>(lhptee)->getPointeeType().getTypePtr(); 6340 rhptee = cast<PointerType>(rhptee)->getPointeeType().getTypePtr(); 6341 } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)); 6342 6343 if (lhptee == rhptee) 6344 return Sema::IncompatibleNestedPointerQualifiers; 6345 } 6346 6347 // General pointer incompatibility takes priority over qualifiers. 6348 return Sema::IncompatiblePointer; 6349 } 6350 if (!S.getLangOpts().CPlusPlus && 6351 S.IsNoReturnConversion(ltrans, rtrans, ltrans)) 6352 return Sema::IncompatiblePointer; 6353 return ConvTy; 6354} 6355 6356/// checkBlockPointerTypesForAssignment - This routine determines whether two 6357/// block pointer types are compatible or whether a block and normal pointer 6358/// are compatible. It is more restrict than comparing two function pointer 6359// types. 6360static Sema::AssignConvertType 6361checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType, 6362 QualType RHSType) { 6363 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 6364 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 6365 6366 QualType lhptee, rhptee; 6367 6368 // get the "pointed to" type (ignoring qualifiers at the top level) 6369 lhptee = cast<BlockPointerType>(LHSType)->getPointeeType(); 6370 rhptee = cast<BlockPointerType>(RHSType)->getPointeeType(); 6371 6372 // In C++, the types have to match exactly. 6373 if (S.getLangOpts().CPlusPlus) 6374 return Sema::IncompatibleBlockPointer; 6375 6376 Sema::AssignConvertType ConvTy = Sema::Compatible; 6377 6378 // For blocks we enforce that qualifiers are identical. 6379 if (lhptee.getLocalQualifiers() != rhptee.getLocalQualifiers()) 6380 ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 6381 6382 if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType)) 6383 return Sema::IncompatibleBlockPointer; 6384 6385 return ConvTy; 6386} 6387 6388/// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types 6389/// for assignment compatibility. 6390static Sema::AssignConvertType 6391checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType, 6392 QualType RHSType) { 6393 assert(LHSType.isCanonical() && "LHS was not canonicalized!"); 6394 assert(RHSType.isCanonical() && "RHS was not canonicalized!"); 6395 6396 if (LHSType->isObjCBuiltinType()) { 6397 // Class is not compatible with ObjC object pointers. 6398 if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() && 6399 !RHSType->isObjCQualifiedClassType()) 6400 return Sema::IncompatiblePointer; 6401 return Sema::Compatible; 6402 } 6403 if (RHSType->isObjCBuiltinType()) { 6404 if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() && 6405 !LHSType->isObjCQualifiedClassType()) 6406 return Sema::IncompatiblePointer; 6407 return Sema::Compatible; 6408 } 6409 QualType lhptee = LHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 6410 QualType rhptee = RHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 6411 6412 if (!lhptee.isAtLeastAsQualifiedAs(rhptee) && 6413 // make an exception for id<P> 6414 !LHSType->isObjCQualifiedIdType()) 6415 return Sema::CompatiblePointerDiscardsQualifiers; 6416 6417 if (S.Context.typesAreCompatible(LHSType, RHSType)) 6418 return Sema::Compatible; 6419 if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType()) 6420 return Sema::IncompatibleObjCQualifiedId; 6421 return Sema::IncompatiblePointer; 6422} 6423 6424Sema::AssignConvertType 6425Sema::CheckAssignmentConstraints(SourceLocation Loc, 6426 QualType LHSType, QualType RHSType) { 6427 // Fake up an opaque expression. We don't actually care about what 6428 // cast operations are required, so if CheckAssignmentConstraints 6429 // adds casts to this they'll be wasted, but fortunately that doesn't 6430 // usually happen on valid code. 6431 OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue); 6432 ExprResult RHSPtr = &RHSExpr; 6433 CastKind K = CK_Invalid; 6434 6435 return CheckAssignmentConstraints(LHSType, RHSPtr, K); 6436} 6437 6438/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently 6439/// has code to accommodate several GCC extensions when type checking 6440/// pointers. Here are some objectionable examples that GCC considers warnings: 6441/// 6442/// int a, *pint; 6443/// short *pshort; 6444/// struct foo *pfoo; 6445/// 6446/// pint = pshort; // warning: assignment from incompatible pointer type 6447/// a = pint; // warning: assignment makes integer from pointer without a cast 6448/// pint = a; // warning: assignment makes pointer from integer without a cast 6449/// pint = pfoo; // warning: assignment from incompatible pointer type 6450/// 6451/// As a result, the code for dealing with pointers is more complex than the 6452/// C99 spec dictates. 6453/// 6454/// Sets 'Kind' for any result kind except Incompatible. 6455Sema::AssignConvertType 6456Sema::CheckAssignmentConstraints(QualType LHSType, ExprResult &RHS, 6457 CastKind &Kind) { 6458 QualType RHSType = RHS.get()->getType(); 6459 QualType OrigLHSType = LHSType; 6460 6461 // Get canonical types. We're not formatting these types, just comparing 6462 // them. 6463 LHSType = Context.getCanonicalType(LHSType).getUnqualifiedType(); 6464 RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType(); 6465 6466 // Common case: no conversion required. 6467 if (LHSType == RHSType) { 6468 Kind = CK_NoOp; 6469 return Compatible; 6470 } 6471 6472 // If we have an atomic type, try a non-atomic assignment, then just add an 6473 // atomic qualification step. 6474 if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) { 6475 Sema::AssignConvertType result = 6476 CheckAssignmentConstraints(AtomicTy->getValueType(), RHS, Kind); 6477 if (result != Compatible) 6478 return result; 6479 if (Kind != CK_NoOp) 6480 RHS = ImpCastExprToType(RHS.get(), AtomicTy->getValueType(), Kind); 6481 Kind = CK_NonAtomicToAtomic; 6482 return Compatible; 6483 } 6484 6485 // If the left-hand side is a reference type, then we are in a 6486 // (rare!) case where we've allowed the use of references in C, 6487 // e.g., as a parameter type in a built-in function. In this case, 6488 // just make sure that the type referenced is compatible with the 6489 // right-hand side type. The caller is responsible for adjusting 6490 // LHSType so that the resulting expression does not have reference 6491 // type. 6492 if (const ReferenceType *LHSTypeRef = LHSType->getAs<ReferenceType>()) { 6493 if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) { 6494 Kind = CK_LValueBitCast; 6495 return Compatible; 6496 } 6497 return Incompatible; 6498 } 6499 6500 // Allow scalar to ExtVector assignments, and assignments of an ExtVector type 6501 // to the same ExtVector type. 6502 if (LHSType->isExtVectorType()) { 6503 if (RHSType->isExtVectorType()) 6504 return Incompatible; 6505 if (RHSType->isArithmeticType()) { 6506 // CK_VectorSplat does T -> vector T, so first cast to the 6507 // element type. 6508 QualType elType = cast<ExtVectorType>(LHSType)->getElementType(); 6509 if (elType != RHSType) { 6510 Kind = PrepareScalarCast(RHS, elType); 6511 RHS = ImpCastExprToType(RHS.get(), elType, Kind); 6512 } 6513 Kind = CK_VectorSplat; 6514 return Compatible; 6515 } 6516 } 6517 6518 // Conversions to or from vector type. 6519 if (LHSType->isVectorType() || RHSType->isVectorType()) { 6520 if (LHSType->isVectorType() && RHSType->isVectorType()) { 6521 // Allow assignments of an AltiVec vector type to an equivalent GCC 6522 // vector type and vice versa 6523 if (Context.areCompatibleVectorTypes(LHSType, RHSType)) { 6524 Kind = CK_BitCast; 6525 return Compatible; 6526 } 6527 6528 // If we are allowing lax vector conversions, and LHS and RHS are both 6529 // vectors, the total size only needs to be the same. This is a bitcast; 6530 // no bits are changed but the result type is different. 6531 if (isLaxVectorConversion(RHSType, LHSType)) { 6532 Kind = CK_BitCast; 6533 return IncompatibleVectors; 6534 } 6535 } 6536 return Incompatible; 6537 } 6538 6539 // Arithmetic conversions. 6540 if (LHSType->isArithmeticType() && RHSType->isArithmeticType() && 6541 !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) { 6542 Kind = PrepareScalarCast(RHS, LHSType); 6543 return Compatible; 6544 } 6545 6546 // Conversions to normal pointers. 6547 if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) { 6548 // U* -> T* 6549 if (isa<PointerType>(RHSType)) { 6550 unsigned AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace(); 6551 unsigned AddrSpaceR = RHSType->getPointeeType().getAddressSpace(); 6552 Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast; 6553 return checkPointerTypesForAssignment(*this, LHSType, RHSType); 6554 } 6555 6556 // int -> T* 6557 if (RHSType->isIntegerType()) { 6558 Kind = CK_IntegralToPointer; // FIXME: null? 6559 return IntToPointer; 6560 } 6561 6562 // C pointers are not compatible with ObjC object pointers, 6563 // with two exceptions: 6564 if (isa<ObjCObjectPointerType>(RHSType)) { 6565 // - conversions to void* 6566 if (LHSPointer->getPointeeType()->isVoidType()) { 6567 Kind = CK_BitCast; 6568 return Compatible; 6569 } 6570 6571 // - conversions from 'Class' to the redefinition type 6572 if (RHSType->isObjCClassType() && 6573 Context.hasSameType(LHSType, 6574 Context.getObjCClassRedefinitionType())) { 6575 Kind = CK_BitCast; 6576 return Compatible; 6577 } 6578 6579 Kind = CK_BitCast; 6580 return IncompatiblePointer; 6581 } 6582 6583 // U^ -> void* 6584 if (RHSType->getAs<BlockPointerType>()) { 6585 if (LHSPointer->getPointeeType()->isVoidType()) { 6586 Kind = CK_BitCast; 6587 return Compatible; 6588 } 6589 } 6590 6591 return Incompatible; 6592 } 6593 6594 // Conversions to block pointers. 6595 if (isa<BlockPointerType>(LHSType)) { 6596 // U^ -> T^ 6597 if (RHSType->isBlockPointerType()) { 6598 Kind = CK_BitCast; 6599 return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType); 6600 } 6601 6602 // int or null -> T^ 6603 if (RHSType->isIntegerType()) { 6604 Kind = CK_IntegralToPointer; // FIXME: null 6605 return IntToBlockPointer; 6606 } 6607 6608 // id -> T^ 6609 if (getLangOpts().ObjC1 && RHSType->isObjCIdType()) { 6610 Kind = CK_AnyPointerToBlockPointerCast; 6611 return Compatible; 6612 } 6613 6614 // void* -> T^ 6615 if (const PointerType *RHSPT = RHSType->getAs<PointerType>()) 6616 if (RHSPT->getPointeeType()->isVoidType()) { 6617 Kind = CK_AnyPointerToBlockPointerCast; 6618 return Compatible; 6619 } 6620 6621 return Incompatible; 6622 } 6623 6624 // Conversions to Objective-C pointers. 6625 if (isa<ObjCObjectPointerType>(LHSType)) { 6626 // A* -> B* 6627 if (RHSType->isObjCObjectPointerType()) { 6628 Kind = CK_BitCast; 6629 Sema::AssignConvertType result = 6630 checkObjCPointerTypesForAssignment(*this, LHSType, RHSType); 6631 if (getLangOpts().ObjCAutoRefCount && 6632 result == Compatible && 6633 !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType)) 6634 result = IncompatibleObjCWeakRef; 6635 return result; 6636 } 6637 6638 // int or null -> A* 6639 if (RHSType->isIntegerType()) { 6640 Kind = CK_IntegralToPointer; // FIXME: null 6641 return IntToPointer; 6642 } 6643 6644 // In general, C pointers are not compatible with ObjC object pointers, 6645 // with two exceptions: 6646 if (isa<PointerType>(RHSType)) { 6647 Kind = CK_CPointerToObjCPointerCast; 6648 6649 // - conversions from 'void*' 6650 if (RHSType->isVoidPointerType()) { 6651 return Compatible; 6652 } 6653 6654 // - conversions to 'Class' from its redefinition type 6655 if (LHSType->isObjCClassType() && 6656 Context.hasSameType(RHSType, 6657 Context.getObjCClassRedefinitionType())) { 6658 return Compatible; 6659 } 6660 6661 return IncompatiblePointer; 6662 } 6663 6664 // Only under strict condition T^ is compatible with an Objective-C pointer. 6665 if (RHSType->isBlockPointerType() && 6666 isObjCPtrBlockCompatible(*this, Context, LHSType)) { 6667 maybeExtendBlockObject(*this, RHS); 6668 Kind = CK_BlockPointerToObjCPointerCast; 6669 return Compatible; 6670 } 6671 6672 return Incompatible; 6673 } 6674 6675 // Conversions from pointers that are not covered by the above. 6676 if (isa<PointerType>(RHSType)) { 6677 // T* -> _Bool 6678 if (LHSType == Context.BoolTy) { 6679 Kind = CK_PointerToBoolean; 6680 return Compatible; 6681 } 6682 6683 // T* -> int 6684 if (LHSType->isIntegerType()) { 6685 Kind = CK_PointerToIntegral; 6686 return PointerToInt; 6687 } 6688 6689 return Incompatible; 6690 } 6691 6692 // Conversions from Objective-C pointers that are not covered by the above. 6693 if (isa<ObjCObjectPointerType>(RHSType)) { 6694 // T* -> _Bool 6695 if (LHSType == Context.BoolTy) { 6696 Kind = CK_PointerToBoolean; 6697 return Compatible; 6698 } 6699 6700 // T* -> int 6701 if (LHSType->isIntegerType()) { 6702 Kind = CK_PointerToIntegral; 6703 return PointerToInt; 6704 } 6705 6706 return Incompatible; 6707 } 6708 6709 // struct A -> struct B 6710 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) { 6711 if (Context.typesAreCompatible(LHSType, RHSType)) { 6712 Kind = CK_NoOp; 6713 return Compatible; 6714 } 6715 } 6716 6717 return Incompatible; 6718} 6719 6720/// \brief Constructs a transparent union from an expression that is 6721/// used to initialize the transparent union. 6722static void ConstructTransparentUnion(Sema &S, ASTContext &C, 6723 ExprResult &EResult, QualType UnionType, 6724 FieldDecl *Field) { 6725 // Build an initializer list that designates the appropriate member 6726 // of the transparent union. 6727 Expr *E = EResult.get(); 6728 InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(), 6729 E, SourceLocation()); 6730 Initializer->setType(UnionType); 6731 Initializer->setInitializedFieldInUnion(Field); 6732 6733 // Build a compound literal constructing a value of the transparent 6734 // union type from this initializer list. 6735 TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType); 6736 EResult = new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType, 6737 VK_RValue, Initializer, false); 6738} 6739 6740Sema::AssignConvertType 6741Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, 6742 ExprResult &RHS) { 6743 QualType RHSType = RHS.get()->getType(); 6744 6745 // If the ArgType is a Union type, we want to handle a potential 6746 // transparent_union GCC extension. 6747 const RecordType *UT = ArgType->getAsUnionType(); 6748 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>()) 6749 return Incompatible; 6750 6751 // The field to initialize within the transparent union. 6752 RecordDecl *UD = UT->getDecl(); 6753 FieldDecl *InitField = nullptr; 6754 // It's compatible if the expression matches any of the fields. 6755 for (auto *it : UD->fields()) { 6756 if (it->getType()->isPointerType()) { 6757 // If the transparent union contains a pointer type, we allow: 6758 // 1) void pointer 6759 // 2) null pointer constant 6760 if (RHSType->isPointerType()) 6761 if (RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) { 6762 RHS = ImpCastExprToType(RHS.get(), it->getType(), CK_BitCast); 6763 InitField = it; 6764 break; 6765 } 6766 6767 if (RHS.get()->isNullPointerConstant(Context, 6768 Expr::NPC_ValueDependentIsNull)) { 6769 RHS = ImpCastExprToType(RHS.get(), it->getType(), 6770 CK_NullToPointer); 6771 InitField = it; 6772 break; 6773 } 6774 } 6775 6776 CastKind Kind = CK_Invalid; 6777 if (CheckAssignmentConstraints(it->getType(), RHS, Kind) 6778 == Compatible) { 6779 RHS = ImpCastExprToType(RHS.get(), it->getType(), Kind); 6780 InitField = it; 6781 break; 6782 } 6783 } 6784 6785 if (!InitField) 6786 return Incompatible; 6787 6788 ConstructTransparentUnion(*this, Context, RHS, ArgType, InitField); 6789 return Compatible; 6790} 6791 6792Sema::AssignConvertType 6793Sema::CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, 6794 bool Diagnose, 6795 bool DiagnoseCFAudited) { 6796 if (getLangOpts().CPlusPlus) { 6797 if (!LHSType->isRecordType() && !LHSType->isAtomicType()) { 6798 // C++ 5.17p3: If the left operand is not of class type, the 6799 // expression is implicitly converted (C++ 4) to the 6800 // cv-unqualified type of the left operand. 6801 ExprResult Res; 6802 if (Diagnose) { 6803 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 6804 AA_Assigning); 6805 } else { 6806 ImplicitConversionSequence ICS = 6807 TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 6808 /*SuppressUserConversions=*/false, 6809 /*AllowExplicit=*/false, 6810 /*InOverloadResolution=*/false, 6811 /*CStyle=*/false, 6812 /*AllowObjCWritebackConversion=*/false); 6813 if (ICS.isFailure()) 6814 return Incompatible; 6815 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 6816 ICS, AA_Assigning); 6817 } 6818 if (Res.isInvalid()) 6819 return Incompatible; 6820 Sema::AssignConvertType result = Compatible; 6821 if (getLangOpts().ObjCAutoRefCount && 6822 !CheckObjCARCUnavailableWeakConversion(LHSType, 6823 RHS.get()->getType())) 6824 result = IncompatibleObjCWeakRef; 6825 RHS = Res; 6826 return result; 6827 } 6828 6829 // FIXME: Currently, we fall through and treat C++ classes like C 6830 // structures. 6831 // FIXME: We also fall through for atomics; not sure what should 6832 // happen there, though. 6833 } 6834 6835 // C99 6.5.16.1p1: the left operand is a pointer and the right is 6836 // a null pointer constant. 6837 if ((LHSType->isPointerType() || LHSType->isObjCObjectPointerType() || 6838 LHSType->isBlockPointerType()) && 6839 RHS.get()->isNullPointerConstant(Context, 6840 Expr::NPC_ValueDependentIsNull)) { 6841 CastKind Kind; 6842 CXXCastPath Path; 6843 CheckPointerConversion(RHS.get(), LHSType, Kind, Path, false); 6844 RHS = ImpCastExprToType(RHS.get(), LHSType, Kind, VK_RValue, &Path); 6845 return Compatible; 6846 } 6847 6848 // This check seems unnatural, however it is necessary to ensure the proper 6849 // conversion of functions/arrays. If the conversion were done for all 6850 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary 6851 // expressions that suppress this implicit conversion (&, sizeof). 6852 // 6853 // Suppress this for references: C++ 8.5.3p5. 6854 if (!LHSType->isReferenceType()) { 6855 RHS = DefaultFunctionArrayLvalueConversion(RHS.get()); 6856 if (RHS.isInvalid()) 6857 return Incompatible; 6858 } 6859 6860 Expr *PRE = RHS.get()->IgnoreParenCasts(); 6861 if (ObjCProtocolExpr *OPE = dyn_cast<ObjCProtocolExpr>(PRE)) { 6862 ObjCProtocolDecl *PDecl = OPE->getProtocol(); 6863 if (PDecl && !PDecl->hasDefinition()) { 6864 Diag(PRE->getExprLoc(), diag::warn_atprotocol_protocol) << PDecl->getName(); 6865 Diag(PDecl->getLocation(), diag::note_entity_declared_at) << PDecl; 6866 } 6867 } 6868 6869 CastKind Kind = CK_Invalid; 6870 Sema::AssignConvertType result = 6871 CheckAssignmentConstraints(LHSType, RHS, Kind); 6872 6873 // C99 6.5.16.1p2: The value of the right operand is converted to the 6874 // type of the assignment expression. 6875 // CheckAssignmentConstraints allows the left-hand side to be a reference, 6876 // so that we can use references in built-in functions even in C. 6877 // The getNonReferenceType() call makes sure that the resulting expression 6878 // does not have reference type. 6879 if (result != Incompatible && RHS.get()->getType() != LHSType) { 6880 QualType Ty = LHSType.getNonLValueExprType(Context); 6881 Expr *E = RHS.get(); 6882 if (getLangOpts().ObjCAutoRefCount) 6883 CheckObjCARCConversion(SourceRange(), Ty, E, CCK_ImplicitConversion, 6884 DiagnoseCFAudited); 6885 if (getLangOpts().ObjC1 && 6886 (CheckObjCBridgeRelatedConversions(E->getLocStart(), 6887 LHSType, E->getType(), E) || 6888 ConversionToObjCStringLiteralCheck(LHSType, E))) { 6889 RHS = E; 6890 return Compatible; 6891 } 6892 6893 RHS = ImpCastExprToType(E, Ty, Kind); 6894 } 6895 return result; 6896} 6897 6898QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &LHS, 6899 ExprResult &RHS) { 6900 Diag(Loc, diag::err_typecheck_invalid_operands) 6901 << LHS.get()->getType() << RHS.get()->getType() 6902 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6903 return QualType(); 6904} 6905 6906/// Try to convert a value of non-vector type to a vector type by converting 6907/// the type to the element type of the vector and then performing a splat. 6908/// If the language is OpenCL, we only use conversions that promote scalar 6909/// rank; for C, Obj-C, and C++ we allow any real scalar conversion except 6910/// for float->int. 6911/// 6912/// \param scalar - if non-null, actually perform the conversions 6913/// \return true if the operation fails (but without diagnosing the failure) 6914static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar, 6915 QualType scalarTy, 6916 QualType vectorEltTy, 6917 QualType vectorTy) { 6918 // The conversion to apply to the scalar before splatting it, 6919 // if necessary. 6920 CastKind scalarCast = CK_Invalid; 6921 6922 if (vectorEltTy->isIntegralType(S.Context)) { 6923 if (!scalarTy->isIntegralType(S.Context)) 6924 return true; 6925 if (S.getLangOpts().OpenCL && 6926 S.Context.getIntegerTypeOrder(vectorEltTy, scalarTy) < 0) 6927 return true; 6928 scalarCast = CK_IntegralCast; 6929 } else if (vectorEltTy->isRealFloatingType()) { 6930 if (scalarTy->isRealFloatingType()) { 6931 if (S.getLangOpts().OpenCL && 6932 S.Context.getFloatingTypeOrder(vectorEltTy, scalarTy) < 0) 6933 return true; 6934 scalarCast = CK_FloatingCast; 6935 } 6936 else if (scalarTy->isIntegralType(S.Context)) 6937 scalarCast = CK_IntegralToFloating; 6938 else 6939 return true; 6940 } else { 6941 return true; 6942 } 6943 6944 // Adjust scalar if desired. 6945 if (scalar) { 6946 if (scalarCast != CK_Invalid) 6947 *scalar = S.ImpCastExprToType(scalar->get(), vectorEltTy, scalarCast); 6948 *scalar = S.ImpCastExprToType(scalar->get(), vectorTy, CK_VectorSplat); 6949 } 6950 return false; 6951} 6952 6953QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, 6954 SourceLocation Loc, bool IsCompAssign) { 6955 if (!IsCompAssign) { 6956 LHS = DefaultFunctionArrayLvalueConversion(LHS.get()); 6957 if (LHS.isInvalid()) 6958 return QualType(); 6959 } 6960 RHS = DefaultFunctionArrayLvalueConversion(RHS.get()); 6961 if (RHS.isInvalid()) 6962 return QualType(); 6963 6964 // For conversion purposes, we ignore any qualifiers. 6965 // For example, "const float" and "float" are equivalent. 6966 QualType LHSType = LHS.get()->getType().getUnqualifiedType(); 6967 QualType RHSType = RHS.get()->getType().getUnqualifiedType(); 6968 6969 // If the vector types are identical, return. 6970 if (Context.hasSameType(LHSType, RHSType)) 6971 return LHSType; 6972 6973 const VectorType *LHSVecType = LHSType->getAs<VectorType>(); 6974 const VectorType *RHSVecType = RHSType->getAs<VectorType>(); 6975 assert(LHSVecType || RHSVecType); 6976 6977 // If we have compatible AltiVec and GCC vector types, use the AltiVec type. 6978 if (LHSVecType && RHSVecType && 6979 Context.areCompatibleVectorTypes(LHSType, RHSType)) { 6980 if (isa<ExtVectorType>(LHSVecType)) { 6981 RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); 6982 return LHSType; 6983 } 6984 6985 if (!IsCompAssign) 6986 LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast); 6987 return RHSType; 6988 } 6989 6990 // If there's an ext-vector type and a scalar, try to convert the scalar to 6991 // the vector element type and splat. 6992 if (!RHSVecType && isa<ExtVectorType>(LHSVecType)) { 6993 if (!tryVectorConvertAndSplat(*this, &RHS, RHSType, 6994 LHSVecType->getElementType(), LHSType)) 6995 return LHSType; 6996 } 6997 if (!LHSVecType && isa<ExtVectorType>(RHSVecType)) { 6998 if (!tryVectorConvertAndSplat(*this, (IsCompAssign ? nullptr : &LHS), 6999 LHSType, RHSVecType->getElementType(), 7000 RHSType)) 7001 return RHSType; 7002 } 7003 7004 // If we're allowing lax vector conversions, only the total (data) size 7005 // needs to be the same. 7006 // FIXME: Should we really be allowing this? 7007 // FIXME: We really just pick the LHS type arbitrarily? 7008 if (isLaxVectorConversion(RHSType, LHSType)) { 7009 QualType resultType = LHSType; 7010 RHS = ImpCastExprToType(RHS.get(), resultType, CK_BitCast); 7011 return resultType; 7012 } 7013 7014 // Okay, the expression is invalid. 7015 7016 // If there's a non-vector, non-real operand, diagnose that. 7017 if ((!RHSVecType && !RHSType->isRealType()) || 7018 (!LHSVecType && !LHSType->isRealType())) { 7019 Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar) 7020 << LHSType << RHSType 7021 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7022 return QualType(); 7023 } 7024 7025 // Otherwise, use the generic diagnostic. 7026 Diag(Loc, diag::err_typecheck_vector_not_convertable) 7027 << LHSType << RHSType 7028 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7029 return QualType(); 7030} 7031 7032// checkArithmeticNull - Detect when a NULL constant is used improperly in an 7033// expression. These are mainly cases where the null pointer is used as an 7034// integer instead of a pointer. 7035static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, 7036 SourceLocation Loc, bool IsCompare) { 7037 // The canonical way to check for a GNU null is with isNullPointerConstant, 7038 // but we use a bit of a hack here for speed; this is a relatively 7039 // hot path, and isNullPointerConstant is slow. 7040 bool LHSNull = isa<GNUNullExpr>(LHS.get()->IgnoreParenImpCasts()); 7041 bool RHSNull = isa<GNUNullExpr>(RHS.get()->IgnoreParenImpCasts()); 7042 7043 QualType NonNullType = LHSNull ? RHS.get()->getType() : LHS.get()->getType(); 7044 7045 // Avoid analyzing cases where the result will either be invalid (and 7046 // diagnosed as such) or entirely valid and not something to warn about. 7047 if ((!LHSNull && !RHSNull) || NonNullType->isBlockPointerType() || 7048 NonNullType->isMemberPointerType() || NonNullType->isFunctionType()) 7049 return; 7050 7051 // Comparison operations would not make sense with a null pointer no matter 7052 // what the other expression is. 7053 if (!IsCompare) { 7054 S.Diag(Loc, diag::warn_null_in_arithmetic_operation) 7055 << (LHSNull ? LHS.get()->getSourceRange() : SourceRange()) 7056 << (RHSNull ? RHS.get()->getSourceRange() : SourceRange()); 7057 return; 7058 } 7059 7060 // The rest of the operations only make sense with a null pointer 7061 // if the other expression is a pointer. 7062 if (LHSNull == RHSNull || NonNullType->isAnyPointerType() || 7063 NonNullType->canDecayToPointerType()) 7064 return; 7065 7066 S.Diag(Loc, diag::warn_null_in_comparison_operation) 7067 << LHSNull /* LHS is NULL */ << NonNullType 7068 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7069} 7070 7071QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS, 7072 SourceLocation Loc, 7073 bool IsCompAssign, bool IsDiv) { 7074 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7075 7076 if (LHS.get()->getType()->isVectorType() || 7077 RHS.get()->getType()->isVectorType()) 7078 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 7079 7080 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign); 7081 if (LHS.isInvalid() || RHS.isInvalid()) 7082 return QualType(); 7083 7084 7085 if (compType.isNull() || !compType->isArithmeticType()) 7086 return InvalidOperands(Loc, LHS, RHS); 7087 7088 // Check for division by zero. 7089 llvm::APSInt RHSValue; 7090 if (IsDiv && !RHS.get()->isValueDependent() && 7091 RHS.get()->EvaluateAsInt(RHSValue, Context) && RHSValue == 0) 7092 DiagRuntimeBehavior(Loc, RHS.get(), 7093 PDiag(diag::warn_division_by_zero) 7094 << RHS.get()->getSourceRange()); 7095 7096 return compType; 7097} 7098 7099QualType Sema::CheckRemainderOperands( 7100 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { 7101 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7102 7103 if (LHS.get()->getType()->isVectorType() || 7104 RHS.get()->getType()->isVectorType()) { 7105 if (LHS.get()->getType()->hasIntegerRepresentation() && 7106 RHS.get()->getType()->hasIntegerRepresentation()) 7107 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 7108 return InvalidOperands(Loc, LHS, RHS); 7109 } 7110 7111 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign); 7112 if (LHS.isInvalid() || RHS.isInvalid()) 7113 return QualType(); 7114 7115 if (compType.isNull() || !compType->isIntegerType()) 7116 return InvalidOperands(Loc, LHS, RHS); 7117 7118 // Check for remainder by zero. 7119 llvm::APSInt RHSValue; 7120 if (!RHS.get()->isValueDependent() && 7121 RHS.get()->EvaluateAsInt(RHSValue, Context) && RHSValue == 0) 7122 DiagRuntimeBehavior(Loc, RHS.get(), 7123 PDiag(diag::warn_remainder_by_zero) 7124 << RHS.get()->getSourceRange()); 7125 7126 return compType; 7127} 7128 7129/// \brief Diagnose invalid arithmetic on two void pointers. 7130static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, 7131 Expr *LHSExpr, Expr *RHSExpr) { 7132 S.Diag(Loc, S.getLangOpts().CPlusPlus 7133 ? diag::err_typecheck_pointer_arith_void_type 7134 : diag::ext_gnu_void_ptr) 7135 << 1 /* two pointers */ << LHSExpr->getSourceRange() 7136 << RHSExpr->getSourceRange(); 7137} 7138 7139/// \brief Diagnose invalid arithmetic on a void pointer. 7140static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, 7141 Expr *Pointer) { 7142 S.Diag(Loc, S.getLangOpts().CPlusPlus 7143 ? diag::err_typecheck_pointer_arith_void_type 7144 : diag::ext_gnu_void_ptr) 7145 << 0 /* one pointer */ << Pointer->getSourceRange(); 7146} 7147 7148/// \brief Diagnose invalid arithmetic on two function pointers. 7149static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, 7150 Expr *LHS, Expr *RHS) { 7151 assert(LHS->getType()->isAnyPointerType()); 7152 assert(RHS->getType()->isAnyPointerType()); 7153 S.Diag(Loc, S.getLangOpts().CPlusPlus 7154 ? diag::err_typecheck_pointer_arith_function_type 7155 : diag::ext_gnu_ptr_func_arith) 7156 << 1 /* two pointers */ << LHS->getType()->getPointeeType() 7157 // We only show the second type if it differs from the first. 7158 << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(), 7159 RHS->getType()) 7160 << RHS->getType()->getPointeeType() 7161 << LHS->getSourceRange() << RHS->getSourceRange(); 7162} 7163 7164/// \brief Diagnose invalid arithmetic on a function pointer. 7165static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, 7166 Expr *Pointer) { 7167 assert(Pointer->getType()->isAnyPointerType()); 7168 S.Diag(Loc, S.getLangOpts().CPlusPlus 7169 ? diag::err_typecheck_pointer_arith_function_type 7170 : diag::ext_gnu_ptr_func_arith) 7171 << 0 /* one pointer */ << Pointer->getType()->getPointeeType() 7172 << 0 /* one pointer, so only one type */ 7173 << Pointer->getSourceRange(); 7174} 7175 7176/// \brief Emit error if Operand is incomplete pointer type 7177/// 7178/// \returns True if pointer has incomplete type 7179static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, 7180 Expr *Operand) { 7181 assert(Operand->getType()->isAnyPointerType() && 7182 !Operand->getType()->isDependentType()); 7183 QualType PointeeTy = Operand->getType()->getPointeeType(); 7184 return S.RequireCompleteType(Loc, PointeeTy, 7185 diag::err_typecheck_arithmetic_incomplete_type, 7186 PointeeTy, Operand->getSourceRange()); 7187} 7188 7189/// \brief Check the validity of an arithmetic pointer operand. 7190/// 7191/// If the operand has pointer type, this code will check for pointer types 7192/// which are invalid in arithmetic operations. These will be diagnosed 7193/// appropriately, including whether or not the use is supported as an 7194/// extension. 7195/// 7196/// \returns True when the operand is valid to use (even if as an extension). 7197static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc, 7198 Expr *Operand) { 7199 if (!Operand->getType()->isAnyPointerType()) return true; 7200 7201 QualType PointeeTy = Operand->getType()->getPointeeType(); 7202 if (PointeeTy->isVoidType()) { 7203 diagnoseArithmeticOnVoidPointer(S, Loc, Operand); 7204 return !S.getLangOpts().CPlusPlus; 7205 } 7206 if (PointeeTy->isFunctionType()) { 7207 diagnoseArithmeticOnFunctionPointer(S, Loc, Operand); 7208 return !S.getLangOpts().CPlusPlus; 7209 } 7210 7211 if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false; 7212 7213 return true; 7214} 7215 7216/// \brief Check the validity of a binary arithmetic operation w.r.t. pointer 7217/// operands. 7218/// 7219/// This routine will diagnose any invalid arithmetic on pointer operands much 7220/// like \see checkArithmeticOpPointerOperand. However, it has special logic 7221/// for emitting a single diagnostic even for operations where both LHS and RHS 7222/// are (potentially problematic) pointers. 7223/// 7224/// \returns True when the operand is valid to use (even if as an extension). 7225static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc, 7226 Expr *LHSExpr, Expr *RHSExpr) { 7227 bool isLHSPointer = LHSExpr->getType()->isAnyPointerType(); 7228 bool isRHSPointer = RHSExpr->getType()->isAnyPointerType(); 7229 if (!isLHSPointer && !isRHSPointer) return true; 7230 7231 QualType LHSPointeeTy, RHSPointeeTy; 7232 if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType(); 7233 if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType(); 7234 7235 // if both are pointers check if operation is valid wrt address spaces 7236 if (isLHSPointer && isRHSPointer) { 7237 const PointerType *lhsPtr = LHSExpr->getType()->getAs<PointerType>(); 7238 const PointerType *rhsPtr = RHSExpr->getType()->getAs<PointerType>(); 7239 if (!lhsPtr->isAddressSpaceOverlapping(*rhsPtr)) { 7240 S.Diag(Loc, 7241 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers) 7242 << LHSExpr->getType() << RHSExpr->getType() << 1 /*arithmetic op*/ 7243 << LHSExpr->getSourceRange() << RHSExpr->getSourceRange(); 7244 return false; 7245 } 7246 } 7247 7248 // Check for arithmetic on pointers to incomplete types. 7249 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType(); 7250 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType(); 7251 if (isLHSVoidPtr || isRHSVoidPtr) { 7252 if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr); 7253 else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr); 7254 else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr); 7255 7256 return !S.getLangOpts().CPlusPlus; 7257 } 7258 7259 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType(); 7260 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType(); 7261 if (isLHSFuncPtr || isRHSFuncPtr) { 7262 if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr); 7263 else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, 7264 RHSExpr); 7265 else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr); 7266 7267 return !S.getLangOpts().CPlusPlus; 7268 } 7269 7270 if (isLHSPointer && checkArithmeticIncompletePointerType(S, Loc, LHSExpr)) 7271 return false; 7272 if (isRHSPointer && checkArithmeticIncompletePointerType(S, Loc, RHSExpr)) 7273 return false; 7274 7275 return true; 7276} 7277 7278/// diagnoseStringPlusInt - Emit a warning when adding an integer to a string 7279/// literal. 7280static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc, 7281 Expr *LHSExpr, Expr *RHSExpr) { 7282 StringLiteral* StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts()); 7283 Expr* IndexExpr = RHSExpr; 7284 if (!StrExpr) { 7285 StrExpr = dyn_cast<StringLiteral>(RHSExpr->IgnoreImpCasts()); 7286 IndexExpr = LHSExpr; 7287 } 7288 7289 bool IsStringPlusInt = StrExpr && 7290 IndexExpr->getType()->isIntegralOrUnscopedEnumerationType(); 7291 if (!IsStringPlusInt || IndexExpr->isValueDependent()) 7292 return; 7293 7294 llvm::APSInt index; 7295 if (IndexExpr->EvaluateAsInt(index, Self.getASTContext())) { 7296 unsigned StrLenWithNull = StrExpr->getLength() + 1; 7297 if (index.isNonNegative() && 7298 index <= llvm::APSInt(llvm::APInt(index.getBitWidth(), StrLenWithNull), 7299 index.isUnsigned())) 7300 return; 7301 } 7302 7303 SourceRange DiagRange(LHSExpr->getLocStart(), RHSExpr->getLocEnd()); 7304 Self.Diag(OpLoc, diag::warn_string_plus_int) 7305 << DiagRange << IndexExpr->IgnoreImpCasts()->getType(); 7306 7307 // Only print a fixit for "str" + int, not for int + "str". 7308 if (IndexExpr == RHSExpr) { 7309 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(RHSExpr->getLocEnd()); 7310 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence) 7311 << FixItHint::CreateInsertion(LHSExpr->getLocStart(), "&") 7312 << FixItHint::CreateReplacement(SourceRange(OpLoc), "[") 7313 << FixItHint::CreateInsertion(EndLoc, "]"); 7314 } else 7315 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence); 7316} 7317 7318/// \brief Emit a warning when adding a char literal to a string. 7319static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc, 7320 Expr *LHSExpr, Expr *RHSExpr) { 7321 const Expr *StringRefExpr = LHSExpr; 7322 const CharacterLiteral *CharExpr = 7323 dyn_cast<CharacterLiteral>(RHSExpr->IgnoreImpCasts()); 7324 7325 if (!CharExpr) { 7326 CharExpr = dyn_cast<CharacterLiteral>(LHSExpr->IgnoreImpCasts()); 7327 StringRefExpr = RHSExpr; 7328 } 7329 7330 if (!CharExpr || !StringRefExpr) 7331 return; 7332 7333 const QualType StringType = StringRefExpr->getType(); 7334 7335 // Return if not a PointerType. 7336 if (!StringType->isAnyPointerType()) 7337 return; 7338 7339 // Return if not a CharacterType. 7340 if (!StringType->getPointeeType()->isAnyCharacterType()) 7341 return; 7342 7343 ASTContext &Ctx = Self.getASTContext(); 7344 SourceRange DiagRange(LHSExpr->getLocStart(), RHSExpr->getLocEnd()); 7345 7346 const QualType CharType = CharExpr->getType(); 7347 if (!CharType->isAnyCharacterType() && 7348 CharType->isIntegerType() && 7349 llvm::isUIntN(Ctx.getCharWidth(), CharExpr->getValue())) { 7350 Self.Diag(OpLoc, diag::warn_string_plus_char) 7351 << DiagRange << Ctx.CharTy; 7352 } else { 7353 Self.Diag(OpLoc, diag::warn_string_plus_char) 7354 << DiagRange << CharExpr->getType(); 7355 } 7356 7357 // Only print a fixit for str + char, not for char + str. 7358 if (isa<CharacterLiteral>(RHSExpr->IgnoreImpCasts())) { 7359 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(RHSExpr->getLocEnd()); 7360 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence) 7361 << FixItHint::CreateInsertion(LHSExpr->getLocStart(), "&") 7362 << FixItHint::CreateReplacement(SourceRange(OpLoc), "[") 7363 << FixItHint::CreateInsertion(EndLoc, "]"); 7364 } else { 7365 Self.Diag(OpLoc, diag::note_string_plus_scalar_silence); 7366 } 7367} 7368 7369/// \brief Emit error when two pointers are incompatible. 7370static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, 7371 Expr *LHSExpr, Expr *RHSExpr) { 7372 assert(LHSExpr->getType()->isAnyPointerType()); 7373 assert(RHSExpr->getType()->isAnyPointerType()); 7374 S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible) 7375 << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange() 7376 << RHSExpr->getSourceRange(); 7377} 7378 7379QualType Sema::CheckAdditionOperands( // C99 6.5.6 7380 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc, 7381 QualType* CompLHSTy) { 7382 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7383 7384 if (LHS.get()->getType()->isVectorType() || 7385 RHS.get()->getType()->isVectorType()) { 7386 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy); 7387 if (CompLHSTy) *CompLHSTy = compType; 7388 return compType; 7389 } 7390 7391 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy); 7392 if (LHS.isInvalid() || RHS.isInvalid()) 7393 return QualType(); 7394 7395 // Diagnose "string literal" '+' int and string '+' "char literal". 7396 if (Opc == BO_Add) { 7397 diagnoseStringPlusInt(*this, Loc, LHS.get(), RHS.get()); 7398 diagnoseStringPlusChar(*this, Loc, LHS.get(), RHS.get()); 7399 } 7400 7401 // handle the common case first (both operands are arithmetic). 7402 if (!compType.isNull() && compType->isArithmeticType()) { 7403 if (CompLHSTy) *CompLHSTy = compType; 7404 return compType; 7405 } 7406 7407 // Type-checking. Ultimately the pointer's going to be in PExp; 7408 // note that we bias towards the LHS being the pointer. 7409 Expr *PExp = LHS.get(), *IExp = RHS.get(); 7410 7411 bool isObjCPointer; 7412 if (PExp->getType()->isPointerType()) { 7413 isObjCPointer = false; 7414 } else if (PExp->getType()->isObjCObjectPointerType()) { 7415 isObjCPointer = true; 7416 } else { 7417 std::swap(PExp, IExp); 7418 if (PExp->getType()->isPointerType()) { 7419 isObjCPointer = false; 7420 } else if (PExp->getType()->isObjCObjectPointerType()) { 7421 isObjCPointer = true; 7422 } else { 7423 return InvalidOperands(Loc, LHS, RHS); 7424 } 7425 } 7426 assert(PExp->getType()->isAnyPointerType()); 7427 7428 if (!IExp->getType()->isIntegerType()) 7429 return InvalidOperands(Loc, LHS, RHS); 7430 7431 if (!checkArithmeticOpPointerOperand(*this, Loc, PExp)) 7432 return QualType(); 7433 7434 if (isObjCPointer && checkArithmeticOnObjCPointer(*this, Loc, PExp)) 7435 return QualType(); 7436 7437 // Check array bounds for pointer arithemtic 7438 CheckArrayAccess(PExp, IExp); 7439 7440 if (CompLHSTy) { 7441 QualType LHSTy = Context.isPromotableBitField(LHS.get()); 7442 if (LHSTy.isNull()) { 7443 LHSTy = LHS.get()->getType(); 7444 if (LHSTy->isPromotableIntegerType()) 7445 LHSTy = Context.getPromotedIntegerType(LHSTy); 7446 } 7447 *CompLHSTy = LHSTy; 7448 } 7449 7450 return PExp->getType(); 7451} 7452 7453// C99 6.5.6 7454QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS, 7455 SourceLocation Loc, 7456 QualType* CompLHSTy) { 7457 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7458 7459 if (LHS.get()->getType()->isVectorType() || 7460 RHS.get()->getType()->isVectorType()) { 7461 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy); 7462 if (CompLHSTy) *CompLHSTy = compType; 7463 return compType; 7464 } 7465 7466 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy); 7467 if (LHS.isInvalid() || RHS.isInvalid()) 7468 return QualType(); 7469 7470 // Enforce type constraints: C99 6.5.6p3. 7471 7472 // Handle the common case first (both operands are arithmetic). 7473 if (!compType.isNull() && compType->isArithmeticType()) { 7474 if (CompLHSTy) *CompLHSTy = compType; 7475 return compType; 7476 } 7477 7478 // Either ptr - int or ptr - ptr. 7479 if (LHS.get()->getType()->isAnyPointerType()) { 7480 QualType lpointee = LHS.get()->getType()->getPointeeType(); 7481 7482 // Diagnose bad cases where we step over interface counts. 7483 if (LHS.get()->getType()->isObjCObjectPointerType() && 7484 checkArithmeticOnObjCPointer(*this, Loc, LHS.get())) 7485 return QualType(); 7486 7487 // The result type of a pointer-int computation is the pointer type. 7488 if (RHS.get()->getType()->isIntegerType()) { 7489 if (!checkArithmeticOpPointerOperand(*this, Loc, LHS.get())) 7490 return QualType(); 7491 7492 // Check array bounds for pointer arithemtic 7493 CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/nullptr, 7494 /*AllowOnePastEnd*/true, /*IndexNegated*/true); 7495 7496 if (CompLHSTy) *CompLHSTy = LHS.get()->getType(); 7497 return LHS.get()->getType(); 7498 } 7499 7500 // Handle pointer-pointer subtractions. 7501 if (const PointerType *RHSPTy 7502 = RHS.get()->getType()->getAs<PointerType>()) { 7503 QualType rpointee = RHSPTy->getPointeeType(); 7504 7505 if (getLangOpts().CPlusPlus) { 7506 // Pointee types must be the same: C++ [expr.add] 7507 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) { 7508 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get()); 7509 } 7510 } else { 7511 // Pointee types must be compatible C99 6.5.6p3 7512 if (!Context.typesAreCompatible( 7513 Context.getCanonicalType(lpointee).getUnqualifiedType(), 7514 Context.getCanonicalType(rpointee).getUnqualifiedType())) { 7515 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get()); 7516 return QualType(); 7517 } 7518 } 7519 7520 if (!checkArithmeticBinOpPointerOperands(*this, Loc, 7521 LHS.get(), RHS.get())) 7522 return QualType(); 7523 7524 // The pointee type may have zero size. As an extension, a structure or 7525 // union may have zero size or an array may have zero length. In this 7526 // case subtraction does not make sense. 7527 if (!rpointee->isVoidType() && !rpointee->isFunctionType()) { 7528 CharUnits ElementSize = Context.getTypeSizeInChars(rpointee); 7529 if (ElementSize.isZero()) { 7530 Diag(Loc,diag::warn_sub_ptr_zero_size_types) 7531 << rpointee.getUnqualifiedType() 7532 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7533 } 7534 } 7535 7536 if (CompLHSTy) *CompLHSTy = LHS.get()->getType(); 7537 return Context.getPointerDiffType(); 7538 } 7539 } 7540 7541 return InvalidOperands(Loc, LHS, RHS); 7542} 7543 7544static bool isScopedEnumerationType(QualType T) { 7545 if (const EnumType *ET = T->getAs<EnumType>()) 7546 return ET->getDecl()->isScoped(); 7547 return false; 7548} 7549 7550static void DiagnoseBadShiftValues(Sema& S, ExprResult &LHS, ExprResult &RHS, 7551 SourceLocation Loc, unsigned Opc, 7552 QualType LHSType) { 7553 // OpenCL 6.3j: shift values are effectively % word size of LHS (more defined), 7554 // so skip remaining warnings as we don't want to modify values within Sema. 7555 if (S.getLangOpts().OpenCL) 7556 return; 7557 7558 llvm::APSInt Right; 7559 // Check right/shifter operand 7560 if (RHS.get()->isValueDependent() || 7561 !RHS.get()->isIntegerConstantExpr(Right, S.Context)) 7562 return; 7563 7564 if (Right.isNegative()) { 7565 S.DiagRuntimeBehavior(Loc, RHS.get(), 7566 S.PDiag(diag::warn_shift_negative) 7567 << RHS.get()->getSourceRange()); 7568 return; 7569 } 7570 llvm::APInt LeftBits(Right.getBitWidth(), 7571 S.Context.getTypeSize(LHS.get()->getType())); 7572 if (Right.uge(LeftBits)) { 7573 S.DiagRuntimeBehavior(Loc, RHS.get(), 7574 S.PDiag(diag::warn_shift_gt_typewidth) 7575 << RHS.get()->getSourceRange()); 7576 return; 7577 } 7578 if (Opc != BO_Shl) 7579 return; 7580 7581 // When left shifting an ICE which is signed, we can check for overflow which 7582 // according to C++ has undefined behavior ([expr.shift] 5.8/2). Unsigned 7583 // integers have defined behavior modulo one more than the maximum value 7584 // representable in the result type, so never warn for those. 7585 llvm::APSInt Left; 7586 if (LHS.get()->isValueDependent() || 7587 !LHS.get()->isIntegerConstantExpr(Left, S.Context) || 7588 LHSType->hasUnsignedIntegerRepresentation()) 7589 return; 7590 llvm::APInt ResultBits = 7591 static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits(); 7592 if (LeftBits.uge(ResultBits)) 7593 return; 7594 llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue()); 7595 Result = Result.shl(Right); 7596 7597 // Print the bit representation of the signed integer as an unsigned 7598 // hexadecimal number. 7599 SmallString<40> HexResult; 7600 Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true); 7601 7602 // If we are only missing a sign bit, this is less likely to result in actual 7603 // bugs -- if the result is cast back to an unsigned type, it will have the 7604 // expected value. Thus we place this behind a different warning that can be 7605 // turned off separately if needed. 7606 if (LeftBits == ResultBits - 1) { 7607 S.Diag(Loc, diag::warn_shift_result_sets_sign_bit) 7608 << HexResult.str() << LHSType 7609 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7610 return; 7611 } 7612 7613 S.Diag(Loc, diag::warn_shift_result_gt_typewidth) 7614 << HexResult.str() << Result.getMinSignedBits() << LHSType 7615 << Left.getBitWidth() << LHS.get()->getSourceRange() 7616 << RHS.get()->getSourceRange(); 7617} 7618 7619// C99 6.5.7 7620QualType Sema::CheckShiftOperands(ExprResult &LHS, ExprResult &RHS, 7621 SourceLocation Loc, unsigned Opc, 7622 bool IsCompAssign) { 7623 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7624 7625 // Vector shifts promote their scalar inputs to vector type. 7626 if (LHS.get()->getType()->isVectorType() || 7627 RHS.get()->getType()->isVectorType()) 7628 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 7629 7630 // Shifts don't perform usual arithmetic conversions, they just do integer 7631 // promotions on each operand. C99 6.5.7p3 7632 7633 // For the LHS, do usual unary conversions, but then reset them away 7634 // if this is a compound assignment. 7635 ExprResult OldLHS = LHS; 7636 LHS = UsualUnaryConversions(LHS.get()); 7637 if (LHS.isInvalid()) 7638 return QualType(); 7639 QualType LHSType = LHS.get()->getType(); 7640 if (IsCompAssign) LHS = OldLHS; 7641 7642 // The RHS is simpler. 7643 RHS = UsualUnaryConversions(RHS.get()); 7644 if (RHS.isInvalid()) 7645 return QualType(); 7646 QualType RHSType = RHS.get()->getType(); 7647 7648 // C99 6.5.7p2: Each of the operands shall have integer type. 7649 if (!LHSType->hasIntegerRepresentation() || 7650 !RHSType->hasIntegerRepresentation()) 7651 return InvalidOperands(Loc, LHS, RHS); 7652 7653 // C++0x: Don't allow scoped enums. FIXME: Use something better than 7654 // hasIntegerRepresentation() above instead of this. 7655 if (isScopedEnumerationType(LHSType) || 7656 isScopedEnumerationType(RHSType)) { 7657 return InvalidOperands(Loc, LHS, RHS); 7658 } 7659 // Sanity-check shift operands 7660 DiagnoseBadShiftValues(*this, LHS, RHS, Loc, Opc, LHSType); 7661 7662 // "The type of the result is that of the promoted left operand." 7663 return LHSType; 7664} 7665 7666static bool IsWithinTemplateSpecialization(Decl *D) { 7667 if (DeclContext *DC = D->getDeclContext()) { 7668 if (isa<ClassTemplateSpecializationDecl>(DC)) 7669 return true; 7670 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) 7671 return FD->isFunctionTemplateSpecialization(); 7672 } 7673 return false; 7674} 7675 7676/// If two different enums are compared, raise a warning. 7677static void checkEnumComparison(Sema &S, SourceLocation Loc, Expr *LHS, 7678 Expr *RHS) { 7679 QualType LHSStrippedType = LHS->IgnoreParenImpCasts()->getType(); 7680 QualType RHSStrippedType = RHS->IgnoreParenImpCasts()->getType(); 7681 7682 const EnumType *LHSEnumType = LHSStrippedType->getAs<EnumType>(); 7683 if (!LHSEnumType) 7684 return; 7685 const EnumType *RHSEnumType = RHSStrippedType->getAs<EnumType>(); 7686 if (!RHSEnumType) 7687 return; 7688 7689 // Ignore anonymous enums. 7690 if (!LHSEnumType->getDecl()->getIdentifier()) 7691 return; 7692 if (!RHSEnumType->getDecl()->getIdentifier()) 7693 return; 7694 7695 if (S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType)) 7696 return; 7697 7698 S.Diag(Loc, diag::warn_comparison_of_mixed_enum_types) 7699 << LHSStrippedType << RHSStrippedType 7700 << LHS->getSourceRange() << RHS->getSourceRange(); 7701} 7702 7703/// \brief Diagnose bad pointer comparisons. 7704static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, 7705 ExprResult &LHS, ExprResult &RHS, 7706 bool IsError) { 7707 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers 7708 : diag::ext_typecheck_comparison_of_distinct_pointers) 7709 << LHS.get()->getType() << RHS.get()->getType() 7710 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7711} 7712 7713/// \brief Returns false if the pointers are converted to a composite type, 7714/// true otherwise. 7715static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc, 7716 ExprResult &LHS, ExprResult &RHS) { 7717 // C++ [expr.rel]p2: 7718 // [...] Pointer conversions (4.10) and qualification 7719 // conversions (4.4) are performed on pointer operands (or on 7720 // a pointer operand and a null pointer constant) to bring 7721 // them to their composite pointer type. [...] 7722 // 7723 // C++ [expr.eq]p1 uses the same notion for (in)equality 7724 // comparisons of pointers. 7725 7726 // C++ [expr.eq]p2: 7727 // In addition, pointers to members can be compared, or a pointer to 7728 // member and a null pointer constant. Pointer to member conversions 7729 // (4.11) and qualification conversions (4.4) are performed to bring 7730 // them to a common type. If one operand is a null pointer constant, 7731 // the common type is the type of the other operand. Otherwise, the 7732 // common type is a pointer to member type similar (4.4) to the type 7733 // of one of the operands, with a cv-qualification signature (4.4) 7734 // that is the union of the cv-qualification signatures of the operand 7735 // types. 7736 7737 QualType LHSType = LHS.get()->getType(); 7738 QualType RHSType = RHS.get()->getType(); 7739 assert((LHSType->isPointerType() && RHSType->isPointerType()) || 7740 (LHSType->isMemberPointerType() && RHSType->isMemberPointerType())); 7741 7742 bool NonStandardCompositeType = false; 7743 bool *BoolPtr = S.isSFINAEContext() ? nullptr : &NonStandardCompositeType; 7744 QualType T = S.FindCompositePointerType(Loc, LHS, RHS, BoolPtr); 7745 if (T.isNull()) { 7746 diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true); 7747 return true; 7748 } 7749 7750 if (NonStandardCompositeType) 7751 S.Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard) 7752 << LHSType << RHSType << T << LHS.get()->getSourceRange() 7753 << RHS.get()->getSourceRange(); 7754 7755 LHS = S.ImpCastExprToType(LHS.get(), T, CK_BitCast); 7756 RHS = S.ImpCastExprToType(RHS.get(), T, CK_BitCast); 7757 return false; 7758} 7759 7760static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc, 7761 ExprResult &LHS, 7762 ExprResult &RHS, 7763 bool IsError) { 7764 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void 7765 : diag::ext_typecheck_comparison_of_fptr_to_void) 7766 << LHS.get()->getType() << RHS.get()->getType() 7767 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 7768} 7769 7770static bool isObjCObjectLiteral(ExprResult &E) { 7771 switch (E.get()->IgnoreParenImpCasts()->getStmtClass()) { 7772 case Stmt::ObjCArrayLiteralClass: 7773 case Stmt::ObjCDictionaryLiteralClass: 7774 case Stmt::ObjCStringLiteralClass: 7775 case Stmt::ObjCBoxedExprClass: 7776 return true; 7777 default: 7778 // Note that ObjCBoolLiteral is NOT an object literal! 7779 return false; 7780 } 7781} 7782 7783static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) { 7784 const ObjCObjectPointerType *Type = 7785 LHS->getType()->getAs<ObjCObjectPointerType>(); 7786 7787 // If this is not actually an Objective-C object, bail out. 7788 if (!Type) 7789 return false; 7790 7791 // Get the LHS object's interface type. 7792 QualType InterfaceType = Type->getPointeeType(); 7793 if (const ObjCObjectType *iQFaceTy = 7794 InterfaceType->getAsObjCQualifiedInterfaceType()) 7795 InterfaceType = iQFaceTy->getBaseType(); 7796 7797 // If the RHS isn't an Objective-C object, bail out. 7798 if (!RHS->getType()->isObjCObjectPointerType()) 7799 return false; 7800 7801 // Try to find the -isEqual: method. 7802 Selector IsEqualSel = S.NSAPIObj->getIsEqualSelector(); 7803 ObjCMethodDecl *Method = S.LookupMethodInObjectType(IsEqualSel, 7804 InterfaceType, 7805 /*instance=*/true); 7806 if (!Method) { 7807 if (Type->isObjCIdType()) { 7808 // For 'id', just check the global pool. 7809 Method = S.LookupInstanceMethodInGlobalPool(IsEqualSel, SourceRange(), 7810 /*receiverId=*/true, 7811 /*warn=*/false); 7812 } else { 7813 // Check protocols. 7814 Method = S.LookupMethodInQualifiedType(IsEqualSel, Type, 7815 /*instance=*/true); 7816 } 7817 } 7818 7819 if (!Method) 7820 return false; 7821 7822 QualType T = Method->parameters()[0]->getType(); 7823 if (!T->isObjCObjectPointerType()) 7824 return false; 7825 7826 QualType R = Method->getReturnType(); 7827 if (!R->isScalarType()) 7828 return false; 7829 7830 return true; 7831} 7832 7833Sema::ObjCLiteralKind Sema::CheckLiteralKind(Expr *FromE) { 7834 FromE = FromE->IgnoreParenImpCasts(); 7835 switch (FromE->getStmtClass()) { 7836 default: 7837 break; 7838 case Stmt::ObjCStringLiteralClass: 7839 // "string literal" 7840 return LK_String; 7841 case Stmt::ObjCArrayLiteralClass: 7842 // "array literal" 7843 return LK_Array; 7844 case Stmt::ObjCDictionaryLiteralClass: 7845 // "dictionary literal" 7846 return LK_Dictionary; 7847 case Stmt::BlockExprClass: 7848 return LK_Block; 7849 case Stmt::ObjCBoxedExprClass: { 7850 Expr *Inner = cast<ObjCBoxedExpr>(FromE)->getSubExpr()->IgnoreParens(); 7851 switch (Inner->getStmtClass()) { 7852 case Stmt::IntegerLiteralClass: 7853 case Stmt::FloatingLiteralClass: 7854 case Stmt::CharacterLiteralClass: 7855 case Stmt::ObjCBoolLiteralExprClass: 7856 case Stmt::CXXBoolLiteralExprClass: 7857 // "numeric literal" 7858 return LK_Numeric; 7859 case Stmt::ImplicitCastExprClass: { 7860 CastKind CK = cast<CastExpr>(Inner)->getCastKind(); 7861 // Boolean literals can be represented by implicit casts. 7862 if (CK == CK_IntegralToBoolean || CK == CK_IntegralCast) 7863 return LK_Numeric; 7864 break; 7865 } 7866 default: 7867 break; 7868 } 7869 return LK_Boxed; 7870 } 7871 } 7872 return LK_None; 7873} 7874 7875static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc, 7876 ExprResult &LHS, ExprResult &RHS, 7877 BinaryOperator::Opcode Opc){ 7878 Expr *Literal; 7879 Expr *Other; 7880 if (isObjCObjectLiteral(LHS)) { 7881 Literal = LHS.get(); 7882 Other = RHS.get(); 7883 } else { 7884 Literal = RHS.get(); 7885 Other = LHS.get(); 7886 } 7887 7888 // Don't warn on comparisons against nil. 7889 Other = Other->IgnoreParenCasts(); 7890 if (Other->isNullPointerConstant(S.getASTContext(), 7891 Expr::NPC_ValueDependentIsNotNull)) 7892 return; 7893 7894 // This should be kept in sync with warn_objc_literal_comparison. 7895 // LK_String should always be after the other literals, since it has its own 7896 // warning flag. 7897 Sema::ObjCLiteralKind LiteralKind = S.CheckLiteralKind(Literal); 7898 assert(LiteralKind != Sema::LK_Block); 7899 if (LiteralKind == Sema::LK_None) { 7900 llvm_unreachable("Unknown Objective-C object literal kind"); 7901 } 7902 7903 if (LiteralKind == Sema::LK_String) 7904 S.Diag(Loc, diag::warn_objc_string_literal_comparison) 7905 << Literal->getSourceRange(); 7906 else 7907 S.Diag(Loc, diag::warn_objc_literal_comparison) 7908 << LiteralKind << Literal->getSourceRange(); 7909 7910 if (BinaryOperator::isEqualityOp(Opc) && 7911 hasIsEqualMethod(S, LHS.get(), RHS.get())) { 7912 SourceLocation Start = LHS.get()->getLocStart(); 7913 SourceLocation End = S.PP.getLocForEndOfToken(RHS.get()->getLocEnd()); 7914 CharSourceRange OpRange = 7915 CharSourceRange::getCharRange(Loc, S.PP.getLocForEndOfToken(Loc)); 7916 7917 S.Diag(Loc, diag::note_objc_literal_comparison_isequal) 7918 << FixItHint::CreateInsertion(Start, Opc == BO_EQ ? "[" : "![") 7919 << FixItHint::CreateReplacement(OpRange, " isEqual:") 7920 << FixItHint::CreateInsertion(End, "]"); 7921 } 7922} 7923 7924static void diagnoseLogicalNotOnLHSofComparison(Sema &S, ExprResult &LHS, 7925 ExprResult &RHS, 7926 SourceLocation Loc, 7927 unsigned OpaqueOpc) { 7928 // This checking requires bools. 7929 if (!S.getLangOpts().Bool) return; 7930 7931 // Check that left hand side is !something. 7932 UnaryOperator *UO = dyn_cast<UnaryOperator>(LHS.get()->IgnoreImpCasts()); 7933 if (!UO || UO->getOpcode() != UO_LNot) return; 7934 7935 // Only check if the right hand side is non-bool arithmetic type. 7936 if (RHS.get()->getType()->isBooleanType()) return; 7937 7938 // Make sure that the something in !something is not bool. 7939 Expr *SubExpr = UO->getSubExpr()->IgnoreImpCasts(); 7940 if (SubExpr->getType()->isBooleanType()) return; 7941 7942 // Emit warning. 7943 S.Diag(UO->getOperatorLoc(), diag::warn_logical_not_on_lhs_of_comparison) 7944 << Loc; 7945 7946 // First note suggest !(x < y) 7947 SourceLocation FirstOpen = SubExpr->getLocStart(); 7948 SourceLocation FirstClose = RHS.get()->getLocEnd(); 7949 FirstClose = S.getPreprocessor().getLocForEndOfToken(FirstClose); 7950 if (FirstClose.isInvalid()) 7951 FirstOpen = SourceLocation(); 7952 S.Diag(UO->getOperatorLoc(), diag::note_logical_not_fix) 7953 << FixItHint::CreateInsertion(FirstOpen, "(") 7954 << FixItHint::CreateInsertion(FirstClose, ")"); 7955 7956 // Second note suggests (!x) < y 7957 SourceLocation SecondOpen = LHS.get()->getLocStart(); 7958 SourceLocation SecondClose = LHS.get()->getLocEnd(); 7959 SecondClose = S.getPreprocessor().getLocForEndOfToken(SecondClose); 7960 if (SecondClose.isInvalid()) 7961 SecondOpen = SourceLocation(); 7962 S.Diag(UO->getOperatorLoc(), diag::note_logical_not_silence_with_parens) 7963 << FixItHint::CreateInsertion(SecondOpen, "(") 7964 << FixItHint::CreateInsertion(SecondClose, ")"); 7965} 7966 7967// Get the decl for a simple expression: a reference to a variable, 7968// an implicit C++ field reference, or an implicit ObjC ivar reference. 7969static ValueDecl *getCompareDecl(Expr *E) { 7970 if (DeclRefExpr* DR = dyn_cast<DeclRefExpr>(E)) 7971 return DR->getDecl(); 7972 if (ObjCIvarRefExpr* Ivar = dyn_cast<ObjCIvarRefExpr>(E)) { 7973 if (Ivar->isFreeIvar()) 7974 return Ivar->getDecl(); 7975 } 7976 if (MemberExpr* Mem = dyn_cast<MemberExpr>(E)) { 7977 if (Mem->isImplicitAccess()) 7978 return Mem->getMemberDecl(); 7979 } 7980 return nullptr; 7981} 7982 7983// C99 6.5.8, C++ [expr.rel] 7984QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS, 7985 SourceLocation Loc, unsigned OpaqueOpc, 7986 bool IsRelational) { 7987 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/true); 7988 7989 BinaryOperatorKind Opc = (BinaryOperatorKind) OpaqueOpc; 7990 7991 // Handle vector comparisons separately. 7992 if (LHS.get()->getType()->isVectorType() || 7993 RHS.get()->getType()->isVectorType()) 7994 return CheckVectorCompareOperands(LHS, RHS, Loc, IsRelational); 7995 7996 QualType LHSType = LHS.get()->getType(); 7997 QualType RHSType = RHS.get()->getType(); 7998 7999 Expr *LHSStripped = LHS.get()->IgnoreParenImpCasts(); 8000 Expr *RHSStripped = RHS.get()->IgnoreParenImpCasts(); 8001 8002 checkEnumComparison(*this, Loc, LHS.get(), RHS.get()); 8003 diagnoseLogicalNotOnLHSofComparison(*this, LHS, RHS, Loc, OpaqueOpc); 8004 8005 if (!LHSType->hasFloatingRepresentation() && 8006 !(LHSType->isBlockPointerType() && IsRelational) && 8007 !LHS.get()->getLocStart().isMacroID() && 8008 !RHS.get()->getLocStart().isMacroID() && 8009 ActiveTemplateInstantiations.empty()) { 8010 // For non-floating point types, check for self-comparisons of the form 8011 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 8012 // often indicate logic errors in the program. 8013 // 8014 // NOTE: Don't warn about comparison expressions resulting from macro 8015 // expansion. Also don't warn about comparisons which are only self 8016 // comparisons within a template specialization. The warnings should catch 8017 // obvious cases in the definition of the template anyways. The idea is to 8018 // warn when the typed comparison operator will always evaluate to the same 8019 // result. 8020 ValueDecl *DL = getCompareDecl(LHSStripped); 8021 ValueDecl *DR = getCompareDecl(RHSStripped); 8022 if (DL && DR && DL == DR && !IsWithinTemplateSpecialization(DL)) { 8023 DiagRuntimeBehavior(Loc, nullptr, PDiag(diag::warn_comparison_always) 8024 << 0 // self- 8025 << (Opc == BO_EQ 8026 || Opc == BO_LE 8027 || Opc == BO_GE)); 8028 } else if (DL && DR && LHSType->isArrayType() && RHSType->isArrayType() && 8029 !DL->getType()->isReferenceType() && 8030 !DR->getType()->isReferenceType()) { 8031 // what is it always going to eval to? 8032 char always_evals_to; 8033 switch(Opc) { 8034 case BO_EQ: // e.g. array1 == array2 8035 always_evals_to = 0; // false 8036 break; 8037 case BO_NE: // e.g. array1 != array2 8038 always_evals_to = 1; // true 8039 break; 8040 default: 8041 // best we can say is 'a constant' 8042 always_evals_to = 2; // e.g. array1 <= array2 8043 break; 8044 } 8045 DiagRuntimeBehavior(Loc, nullptr, PDiag(diag::warn_comparison_always) 8046 << 1 // array 8047 << always_evals_to); 8048 } 8049 8050 if (isa<CastExpr>(LHSStripped)) 8051 LHSStripped = LHSStripped->IgnoreParenCasts(); 8052 if (isa<CastExpr>(RHSStripped)) 8053 RHSStripped = RHSStripped->IgnoreParenCasts(); 8054 8055 // Warn about comparisons against a string constant (unless the other 8056 // operand is null), the user probably wants strcmp. 8057 Expr *literalString = nullptr; 8058 Expr *literalStringStripped = nullptr; 8059 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) && 8060 !RHSStripped->isNullPointerConstant(Context, 8061 Expr::NPC_ValueDependentIsNull)) { 8062 literalString = LHS.get(); 8063 literalStringStripped = LHSStripped; 8064 } else if ((isa<StringLiteral>(RHSStripped) || 8065 isa<ObjCEncodeExpr>(RHSStripped)) && 8066 !LHSStripped->isNullPointerConstant(Context, 8067 Expr::NPC_ValueDependentIsNull)) { 8068 literalString = RHS.get(); 8069 literalStringStripped = RHSStripped; 8070 } 8071 8072 if (literalString) { 8073 DiagRuntimeBehavior(Loc, nullptr, 8074 PDiag(diag::warn_stringcompare) 8075 << isa<ObjCEncodeExpr>(literalStringStripped) 8076 << literalString->getSourceRange()); 8077 } 8078 } 8079 8080 // C99 6.5.8p3 / C99 6.5.9p4 8081 UsualArithmeticConversions(LHS, RHS); 8082 if (LHS.isInvalid() || RHS.isInvalid()) 8083 return QualType(); 8084 8085 LHSType = LHS.get()->getType(); 8086 RHSType = RHS.get()->getType(); 8087 8088 // The result of comparisons is 'bool' in C++, 'int' in C. 8089 QualType ResultTy = Context.getLogicalOperationType(); 8090 8091 if (IsRelational) { 8092 if (LHSType->isRealType() && RHSType->isRealType()) 8093 return ResultTy; 8094 } else { 8095 // Check for comparisons of floating point operands using != and ==. 8096 if (LHSType->hasFloatingRepresentation()) 8097 CheckFloatComparison(Loc, LHS.get(), RHS.get()); 8098 8099 if (LHSType->isArithmeticType() && RHSType->isArithmeticType()) 8100 return ResultTy; 8101 } 8102 8103 const Expr::NullPointerConstantKind LHSNullKind = 8104 LHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull); 8105 const Expr::NullPointerConstantKind RHSNullKind = 8106 RHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull); 8107 bool LHSIsNull = LHSNullKind != Expr::NPCK_NotNull; 8108 bool RHSIsNull = RHSNullKind != Expr::NPCK_NotNull; 8109 8110 if (!IsRelational && LHSIsNull != RHSIsNull) { 8111 bool IsEquality = Opc == BO_EQ; 8112 if (RHSIsNull) 8113 DiagnoseAlwaysNonNullPointer(LHS.get(), RHSNullKind, IsEquality, 8114 RHS.get()->getSourceRange()); 8115 else 8116 DiagnoseAlwaysNonNullPointer(RHS.get(), LHSNullKind, IsEquality, 8117 LHS.get()->getSourceRange()); 8118 } 8119 8120 // All of the following pointer-related warnings are GCC extensions, except 8121 // when handling null pointer constants. 8122 if (LHSType->isPointerType() && RHSType->isPointerType()) { // C99 6.5.8p2 8123 QualType LCanPointeeTy = 8124 LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType(); 8125 QualType RCanPointeeTy = 8126 RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType(); 8127 8128 if (getLangOpts().CPlusPlus) { 8129 if (LCanPointeeTy == RCanPointeeTy) 8130 return ResultTy; 8131 if (!IsRelational && 8132 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 8133 // Valid unless comparison between non-null pointer and function pointer 8134 // This is a gcc extension compatibility comparison. 8135 // In a SFINAE context, we treat this as a hard error to maintain 8136 // conformance with the C++ standard. 8137 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 8138 && !LHSIsNull && !RHSIsNull) { 8139 diagnoseFunctionPointerToVoidComparison( 8140 *this, Loc, LHS, RHS, /*isError*/ (bool)isSFINAEContext()); 8141 8142 if (isSFINAEContext()) 8143 return QualType(); 8144 8145 RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); 8146 return ResultTy; 8147 } 8148 } 8149 8150 if (convertPointersToCompositeType(*this, Loc, LHS, RHS)) 8151 return QualType(); 8152 else 8153 return ResultTy; 8154 } 8155 // C99 6.5.9p2 and C99 6.5.8p2 8156 if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(), 8157 RCanPointeeTy.getUnqualifiedType())) { 8158 // Valid unless a relational comparison of function pointers 8159 if (IsRelational && LCanPointeeTy->isFunctionType()) { 8160 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers) 8161 << LHSType << RHSType << LHS.get()->getSourceRange() 8162 << RHS.get()->getSourceRange(); 8163 } 8164 } else if (!IsRelational && 8165 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 8166 // Valid unless comparison between non-null pointer and function pointer 8167 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 8168 && !LHSIsNull && !RHSIsNull) 8169 diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS, 8170 /*isError*/false); 8171 } else { 8172 // Invalid 8173 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false); 8174 } 8175 if (LCanPointeeTy != RCanPointeeTy) { 8176 const PointerType *lhsPtr = LHSType->getAs<PointerType>(); 8177 if (!lhsPtr->isAddressSpaceOverlapping(*RHSType->getAs<PointerType>())) { 8178 Diag(Loc, 8179 diag::err_typecheck_op_on_nonoverlapping_address_space_pointers) 8180 << LHSType << RHSType << 0 /* comparison */ 8181 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 8182 } 8183 unsigned AddrSpaceL = LCanPointeeTy.getAddressSpace(); 8184 unsigned AddrSpaceR = RCanPointeeTy.getAddressSpace(); 8185 CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion 8186 : CK_BitCast; 8187 if (LHSIsNull && !RHSIsNull) 8188 LHS = ImpCastExprToType(LHS.get(), RHSType, Kind); 8189 else 8190 RHS = ImpCastExprToType(RHS.get(), LHSType, Kind); 8191 } 8192 return ResultTy; 8193 } 8194 8195 if (getLangOpts().CPlusPlus) { 8196 // Comparison of nullptr_t with itself. 8197 if (LHSType->isNullPtrType() && RHSType->isNullPtrType()) 8198 return ResultTy; 8199 8200 // Comparison of pointers with null pointer constants and equality 8201 // comparisons of member pointers to null pointer constants. 8202 if (RHSIsNull && 8203 ((LHSType->isAnyPointerType() || LHSType->isNullPtrType()) || 8204 (!IsRelational && 8205 (LHSType->isMemberPointerType() || LHSType->isBlockPointerType())))) { 8206 RHS = ImpCastExprToType(RHS.get(), LHSType, 8207 LHSType->isMemberPointerType() 8208 ? CK_NullToMemberPointer 8209 : CK_NullToPointer); 8210 return ResultTy; 8211 } 8212 if (LHSIsNull && 8213 ((RHSType->isAnyPointerType() || RHSType->isNullPtrType()) || 8214 (!IsRelational && 8215 (RHSType->isMemberPointerType() || RHSType->isBlockPointerType())))) { 8216 LHS = ImpCastExprToType(LHS.get(), RHSType, 8217 RHSType->isMemberPointerType() 8218 ? CK_NullToMemberPointer 8219 : CK_NullToPointer); 8220 return ResultTy; 8221 } 8222 8223 // Comparison of member pointers. 8224 if (!IsRelational && 8225 LHSType->isMemberPointerType() && RHSType->isMemberPointerType()) { 8226 if (convertPointersToCompositeType(*this, Loc, LHS, RHS)) 8227 return QualType(); 8228 else 8229 return ResultTy; 8230 } 8231 8232 // Handle scoped enumeration types specifically, since they don't promote 8233 // to integers. 8234 if (LHS.get()->getType()->isEnumeralType() && 8235 Context.hasSameUnqualifiedType(LHS.get()->getType(), 8236 RHS.get()->getType())) 8237 return ResultTy; 8238 } 8239 8240 // Handle block pointer types. 8241 if (!IsRelational && LHSType->isBlockPointerType() && 8242 RHSType->isBlockPointerType()) { 8243 QualType lpointee = LHSType->castAs<BlockPointerType>()->getPointeeType(); 8244 QualType rpointee = RHSType->castAs<BlockPointerType>()->getPointeeType(); 8245 8246 if (!LHSIsNull && !RHSIsNull && 8247 !Context.typesAreCompatible(lpointee, rpointee)) { 8248 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 8249 << LHSType << RHSType << LHS.get()->getSourceRange() 8250 << RHS.get()->getSourceRange(); 8251 } 8252 RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); 8253 return ResultTy; 8254 } 8255 8256 // Allow block pointers to be compared with null pointer constants. 8257 if (!IsRelational 8258 && ((LHSType->isBlockPointerType() && RHSType->isPointerType()) 8259 || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) { 8260 if (!LHSIsNull && !RHSIsNull) { 8261 if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>() 8262 ->getPointeeType()->isVoidType()) 8263 || (LHSType->isPointerType() && LHSType->castAs<PointerType>() 8264 ->getPointeeType()->isVoidType()))) 8265 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 8266 << LHSType << RHSType << LHS.get()->getSourceRange() 8267 << RHS.get()->getSourceRange(); 8268 } 8269 if (LHSIsNull && !RHSIsNull) 8270 LHS = ImpCastExprToType(LHS.get(), RHSType, 8271 RHSType->isPointerType() ? CK_BitCast 8272 : CK_AnyPointerToBlockPointerCast); 8273 else 8274 RHS = ImpCastExprToType(RHS.get(), LHSType, 8275 LHSType->isPointerType() ? CK_BitCast 8276 : CK_AnyPointerToBlockPointerCast); 8277 return ResultTy; 8278 } 8279 8280 if (LHSType->isObjCObjectPointerType() || 8281 RHSType->isObjCObjectPointerType()) { 8282 const PointerType *LPT = LHSType->getAs<PointerType>(); 8283 const PointerType *RPT = RHSType->getAs<PointerType>(); 8284 if (LPT || RPT) { 8285 bool LPtrToVoid = LPT ? LPT->getPointeeType()->isVoidType() : false; 8286 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() : false; 8287 8288 if (!LPtrToVoid && !RPtrToVoid && 8289 !Context.typesAreCompatible(LHSType, RHSType)) { 8290 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, 8291 /*isError*/false); 8292 } 8293 if (LHSIsNull && !RHSIsNull) { 8294 Expr *E = LHS.get(); 8295 if (getLangOpts().ObjCAutoRefCount) 8296 CheckObjCARCConversion(SourceRange(), RHSType, E, CCK_ImplicitConversion); 8297 LHS = ImpCastExprToType(E, RHSType, 8298 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast); 8299 } 8300 else { 8301 Expr *E = RHS.get(); 8302 if (getLangOpts().ObjCAutoRefCount) 8303 CheckObjCARCConversion(SourceRange(), LHSType, E, CCK_ImplicitConversion, false, 8304 Opc); 8305 RHS = ImpCastExprToType(E, LHSType, 8306 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast); 8307 } 8308 return ResultTy; 8309 } 8310 if (LHSType->isObjCObjectPointerType() && 8311 RHSType->isObjCObjectPointerType()) { 8312 if (!Context.areComparableObjCPointerTypes(LHSType, RHSType)) 8313 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, 8314 /*isError*/false); 8315 if (isObjCObjectLiteral(LHS) || isObjCObjectLiteral(RHS)) 8316 diagnoseObjCLiteralComparison(*this, Loc, LHS, RHS, Opc); 8317 8318 if (LHSIsNull && !RHSIsNull) 8319 LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast); 8320 else 8321 RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast); 8322 return ResultTy; 8323 } 8324 } 8325 if ((LHSType->isAnyPointerType() && RHSType->isIntegerType()) || 8326 (LHSType->isIntegerType() && RHSType->isAnyPointerType())) { 8327 unsigned DiagID = 0; 8328 bool isError = false; 8329 if (LangOpts.DebuggerSupport) { 8330 // Under a debugger, allow the comparison of pointers to integers, 8331 // since users tend to want to compare addresses. 8332 } else if ((LHSIsNull && LHSType->isIntegerType()) || 8333 (RHSIsNull && RHSType->isIntegerType())) { 8334 if (IsRelational && !getLangOpts().CPlusPlus) 8335 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero; 8336 } else if (IsRelational && !getLangOpts().CPlusPlus) 8337 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer; 8338 else if (getLangOpts().CPlusPlus) { 8339 DiagID = diag::err_typecheck_comparison_of_pointer_integer; 8340 isError = true; 8341 } else 8342 DiagID = diag::ext_typecheck_comparison_of_pointer_integer; 8343 8344 if (DiagID) { 8345 Diag(Loc, DiagID) 8346 << LHSType << RHSType << LHS.get()->getSourceRange() 8347 << RHS.get()->getSourceRange(); 8348 if (isError) 8349 return QualType(); 8350 } 8351 8352 if (LHSType->isIntegerType()) 8353 LHS = ImpCastExprToType(LHS.get(), RHSType, 8354 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 8355 else 8356 RHS = ImpCastExprToType(RHS.get(), LHSType, 8357 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 8358 return ResultTy; 8359 } 8360 8361 // Handle block pointers. 8362 if (!IsRelational && RHSIsNull 8363 && LHSType->isBlockPointerType() && RHSType->isIntegerType()) { 8364 RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer); 8365 return ResultTy; 8366 } 8367 if (!IsRelational && LHSIsNull 8368 && LHSType->isIntegerType() && RHSType->isBlockPointerType()) { 8369 LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer); 8370 return ResultTy; 8371 } 8372 8373 return InvalidOperands(Loc, LHS, RHS); 8374} 8375 8376 8377// Return a signed type that is of identical size and number of elements. 8378// For floating point vectors, return an integer type of identical size 8379// and number of elements. 8380QualType Sema::GetSignedVectorType(QualType V) { 8381 const VectorType *VTy = V->getAs<VectorType>(); 8382 unsigned TypeSize = Context.getTypeSize(VTy->getElementType()); 8383 if (TypeSize == Context.getTypeSize(Context.CharTy)) 8384 return Context.getExtVectorType(Context.CharTy, VTy->getNumElements()); 8385 else if (TypeSize == Context.getTypeSize(Context.ShortTy)) 8386 return Context.getExtVectorType(Context.ShortTy, VTy->getNumElements()); 8387 else if (TypeSize == Context.getTypeSize(Context.IntTy)) 8388 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements()); 8389 else if (TypeSize == Context.getTypeSize(Context.LongTy)) 8390 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements()); 8391 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) && 8392 "Unhandled vector element size in vector compare"); 8393 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements()); 8394} 8395 8396/// CheckVectorCompareOperands - vector comparisons are a clang extension that 8397/// operates on extended vector types. Instead of producing an IntTy result, 8398/// like a scalar comparison, a vector comparison produces a vector of integer 8399/// types. 8400QualType Sema::CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, 8401 SourceLocation Loc, 8402 bool IsRelational) { 8403 // Check to make sure we're operating on vectors of the same type and width, 8404 // Allowing one side to be a scalar of element type. 8405 QualType vType = CheckVectorOperands(LHS, RHS, Loc, /*isCompAssign*/false); 8406 if (vType.isNull()) 8407 return vType; 8408 8409 QualType LHSType = LHS.get()->getType(); 8410 8411 // If AltiVec, the comparison results in a numeric type, i.e. 8412 // bool for C++, int for C 8413 if (vType->getAs<VectorType>()->getVectorKind() == VectorType::AltiVecVector) 8414 return Context.getLogicalOperationType(); 8415 8416 // For non-floating point types, check for self-comparisons of the form 8417 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 8418 // often indicate logic errors in the program. 8419 if (!LHSType->hasFloatingRepresentation() && 8420 ActiveTemplateInstantiations.empty()) { 8421 if (DeclRefExpr* DRL 8422 = dyn_cast<DeclRefExpr>(LHS.get()->IgnoreParenImpCasts())) 8423 if (DeclRefExpr* DRR 8424 = dyn_cast<DeclRefExpr>(RHS.get()->IgnoreParenImpCasts())) 8425 if (DRL->getDecl() == DRR->getDecl()) 8426 DiagRuntimeBehavior(Loc, nullptr, 8427 PDiag(diag::warn_comparison_always) 8428 << 0 // self- 8429 << 2 // "a constant" 8430 ); 8431 } 8432 8433 // Check for comparisons of floating point operands using != and ==. 8434 if (!IsRelational && LHSType->hasFloatingRepresentation()) { 8435 assert (RHS.get()->getType()->hasFloatingRepresentation()); 8436 CheckFloatComparison(Loc, LHS.get(), RHS.get()); 8437 } 8438 8439 // Return a signed type for the vector. 8440 return GetSignedVectorType(LHSType); 8441} 8442 8443QualType Sema::CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, 8444 SourceLocation Loc) { 8445 // Ensure that either both operands are of the same vector type, or 8446 // one operand is of a vector type and the other is of its element type. 8447 QualType vType = CheckVectorOperands(LHS, RHS, Loc, false); 8448 if (vType.isNull()) 8449 return InvalidOperands(Loc, LHS, RHS); 8450 if (getLangOpts().OpenCL && getLangOpts().OpenCLVersion < 120 && 8451 vType->hasFloatingRepresentation()) 8452 return InvalidOperands(Loc, LHS, RHS); 8453 8454 return GetSignedVectorType(LHS.get()->getType()); 8455} 8456 8457inline QualType Sema::CheckBitwiseOperands( 8458 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { 8459 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 8460 8461 if (LHS.get()->getType()->isVectorType() || 8462 RHS.get()->getType()->isVectorType()) { 8463 if (LHS.get()->getType()->hasIntegerRepresentation() && 8464 RHS.get()->getType()->hasIntegerRepresentation()) 8465 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 8466 8467 return InvalidOperands(Loc, LHS, RHS); 8468 } 8469 8470 ExprResult LHSResult = LHS, RHSResult = RHS; 8471 QualType compType = UsualArithmeticConversions(LHSResult, RHSResult, 8472 IsCompAssign); 8473 if (LHSResult.isInvalid() || RHSResult.isInvalid()) 8474 return QualType(); 8475 LHS = LHSResult.get(); 8476 RHS = RHSResult.get(); 8477 8478 if (!compType.isNull() && compType->isIntegralOrUnscopedEnumerationType()) 8479 return compType; 8480 return InvalidOperands(Loc, LHS, RHS); 8481} 8482 8483inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14] 8484 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc) { 8485 8486 // Check vector operands differently. 8487 if (LHS.get()->getType()->isVectorType() || RHS.get()->getType()->isVectorType()) 8488 return CheckVectorLogicalOperands(LHS, RHS, Loc); 8489 8490 // Diagnose cases where the user write a logical and/or but probably meant a 8491 // bitwise one. We do this when the LHS is a non-bool integer and the RHS 8492 // is a constant. 8493 if (LHS.get()->getType()->isIntegerType() && 8494 !LHS.get()->getType()->isBooleanType() && 8495 RHS.get()->getType()->isIntegerType() && !RHS.get()->isValueDependent() && 8496 // Don't warn in macros or template instantiations. 8497 !Loc.isMacroID() && ActiveTemplateInstantiations.empty()) { 8498 // If the RHS can be constant folded, and if it constant folds to something 8499 // that isn't 0 or 1 (which indicate a potential logical operation that 8500 // happened to fold to true/false) then warn. 8501 // Parens on the RHS are ignored. 8502 llvm::APSInt Result; 8503 if (RHS.get()->EvaluateAsInt(Result, Context)) 8504 if ((getLangOpts().Bool && !RHS.get()->getType()->isBooleanType() && 8505 !RHS.get()->getExprLoc().isMacroID()) || 8506 (Result != 0 && Result != 1)) { 8507 Diag(Loc, diag::warn_logical_instead_of_bitwise) 8508 << RHS.get()->getSourceRange() 8509 << (Opc == BO_LAnd ? "&&" : "||"); 8510 // Suggest replacing the logical operator with the bitwise version 8511 Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator) 8512 << (Opc == BO_LAnd ? "&" : "|") 8513 << FixItHint::CreateReplacement(SourceRange( 8514 Loc, Lexer::getLocForEndOfToken(Loc, 0, getSourceManager(), 8515 getLangOpts())), 8516 Opc == BO_LAnd ? "&" : "|"); 8517 if (Opc == BO_LAnd) 8518 // Suggest replacing "Foo() && kNonZero" with "Foo()" 8519 Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant) 8520 << FixItHint::CreateRemoval( 8521 SourceRange( 8522 Lexer::getLocForEndOfToken(LHS.get()->getLocEnd(), 8523 0, getSourceManager(), 8524 getLangOpts()), 8525 RHS.get()->getLocEnd())); 8526 } 8527 } 8528 8529 if (!Context.getLangOpts().CPlusPlus) { 8530 // OpenCL v1.1 s6.3.g: The logical operators and (&&), or (||) do 8531 // not operate on the built-in scalar and vector float types. 8532 if (Context.getLangOpts().OpenCL && 8533 Context.getLangOpts().OpenCLVersion < 120) { 8534 if (LHS.get()->getType()->isFloatingType() || 8535 RHS.get()->getType()->isFloatingType()) 8536 return InvalidOperands(Loc, LHS, RHS); 8537 } 8538 8539 LHS = UsualUnaryConversions(LHS.get()); 8540 if (LHS.isInvalid()) 8541 return QualType(); 8542 8543 RHS = UsualUnaryConversions(RHS.get()); 8544 if (RHS.isInvalid()) 8545 return QualType(); 8546 8547 if (!LHS.get()->getType()->isScalarType() || 8548 !RHS.get()->getType()->isScalarType()) 8549 return InvalidOperands(Loc, LHS, RHS); 8550 8551 return Context.IntTy; 8552 } 8553 8554 // The following is safe because we only use this method for 8555 // non-overloadable operands. 8556 8557 // C++ [expr.log.and]p1 8558 // C++ [expr.log.or]p1 8559 // The operands are both contextually converted to type bool. 8560 ExprResult LHSRes = PerformContextuallyConvertToBool(LHS.get()); 8561 if (LHSRes.isInvalid()) 8562 return InvalidOperands(Loc, LHS, RHS); 8563 LHS = LHSRes; 8564 8565 ExprResult RHSRes = PerformContextuallyConvertToBool(RHS.get()); 8566 if (RHSRes.isInvalid()) 8567 return InvalidOperands(Loc, LHS, RHS); 8568 RHS = RHSRes; 8569 8570 // C++ [expr.log.and]p2 8571 // C++ [expr.log.or]p2 8572 // The result is a bool. 8573 return Context.BoolTy; 8574} 8575 8576static bool IsReadonlyMessage(Expr *E, Sema &S) { 8577 const MemberExpr *ME = dyn_cast<MemberExpr>(E); 8578 if (!ME) return false; 8579 if (!isa<FieldDecl>(ME->getMemberDecl())) return false; 8580 ObjCMessageExpr *Base = 8581 dyn_cast<ObjCMessageExpr>(ME->getBase()->IgnoreParenImpCasts()); 8582 if (!Base) return false; 8583 return Base->getMethodDecl() != nullptr; 8584} 8585 8586/// Is the given expression (which must be 'const') a reference to a 8587/// variable which was originally non-const, but which has become 8588/// 'const' due to being captured within a block? 8589enum NonConstCaptureKind { NCCK_None, NCCK_Block, NCCK_Lambda }; 8590static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) { 8591 assert(E->isLValue() && E->getType().isConstQualified()); 8592 E = E->IgnoreParens(); 8593 8594 // Must be a reference to a declaration from an enclosing scope. 8595 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 8596 if (!DRE) return NCCK_None; 8597 if (!DRE->refersToEnclosingVariableOrCapture()) return NCCK_None; 8598 8599 // The declaration must be a variable which is not declared 'const'. 8600 VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl()); 8601 if (!var) return NCCK_None; 8602 if (var->getType().isConstQualified()) return NCCK_None; 8603 assert(var->hasLocalStorage() && "capture added 'const' to non-local?"); 8604 8605 // Decide whether the first capture was for a block or a lambda. 8606 DeclContext *DC = S.CurContext, *Prev = nullptr; 8607 while (DC != var->getDeclContext()) { 8608 Prev = DC; 8609 DC = DC->getParent(); 8610 } 8611 // Unless we have an init-capture, we've gone one step too far. 8612 if (!var->isInitCapture()) 8613 DC = Prev; 8614 return (isa<BlockDecl>(DC) ? NCCK_Block : NCCK_Lambda); 8615} 8616 8617/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not, 8618/// emit an error and return true. If so, return false. 8619static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) { 8620 assert(!E->hasPlaceholderType(BuiltinType::PseudoObject)); 8621 SourceLocation OrigLoc = Loc; 8622 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context, 8623 &Loc); 8624 if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S)) 8625 IsLV = Expr::MLV_InvalidMessageExpression; 8626 if (IsLV == Expr::MLV_Valid) 8627 return false; 8628 8629 unsigned DiagID = 0; 8630 bool NeedType = false; 8631 switch (IsLV) { // C99 6.5.16p2 8632 case Expr::MLV_ConstQualified: 8633 DiagID = diag::err_typecheck_assign_const; 8634 8635 // Use a specialized diagnostic when we're assigning to an object 8636 // from an enclosing function or block. 8637 if (NonConstCaptureKind NCCK = isReferenceToNonConstCapture(S, E)) { 8638 if (NCCK == NCCK_Block) 8639 DiagID = diag::err_block_decl_ref_not_modifiable_lvalue; 8640 else 8641 DiagID = diag::err_lambda_decl_ref_not_modifiable_lvalue; 8642 break; 8643 } 8644 8645 // In ARC, use some specialized diagnostics for occasions where we 8646 // infer 'const'. These are always pseudo-strong variables. 8647 if (S.getLangOpts().ObjCAutoRefCount) { 8648 DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()); 8649 if (declRef && isa<VarDecl>(declRef->getDecl())) { 8650 VarDecl *var = cast<VarDecl>(declRef->getDecl()); 8651 8652 // Use the normal diagnostic if it's pseudo-__strong but the 8653 // user actually wrote 'const'. 8654 if (var->isARCPseudoStrong() && 8655 (!var->getTypeSourceInfo() || 8656 !var->getTypeSourceInfo()->getType().isConstQualified())) { 8657 // There are two pseudo-strong cases: 8658 // - self 8659 ObjCMethodDecl *method = S.getCurMethodDecl(); 8660 if (method && var == method->getSelfDecl()) 8661 DiagID = method->isClassMethod() 8662 ? diag::err_typecheck_arc_assign_self_class_method 8663 : diag::err_typecheck_arc_assign_self; 8664 8665 // - fast enumeration variables 8666 else 8667 DiagID = diag::err_typecheck_arr_assign_enumeration; 8668 8669 SourceRange Assign; 8670 if (Loc != OrigLoc) 8671 Assign = SourceRange(OrigLoc, OrigLoc); 8672 S.Diag(Loc, DiagID) << E->getSourceRange() << Assign; 8673 // We need to preserve the AST regardless, so migration tool 8674 // can do its job. 8675 return false; 8676 } 8677 } 8678 } 8679 8680 break; 8681 case Expr::MLV_ArrayType: 8682 case Expr::MLV_ArrayTemporary: 8683 DiagID = diag::err_typecheck_array_not_modifiable_lvalue; 8684 NeedType = true; 8685 break; 8686 case Expr::MLV_NotObjectType: 8687 DiagID = diag::err_typecheck_non_object_not_modifiable_lvalue; 8688 NeedType = true; 8689 break; 8690 case Expr::MLV_LValueCast: 8691 DiagID = diag::err_typecheck_lvalue_casts_not_supported; 8692 break; 8693 case Expr::MLV_Valid: 8694 llvm_unreachable("did not take early return for MLV_Valid"); 8695 case Expr::MLV_InvalidExpression: 8696 case Expr::MLV_MemberFunction: 8697 case Expr::MLV_ClassTemporary: 8698 DiagID = diag::err_typecheck_expression_not_modifiable_lvalue; 8699 break; 8700 case Expr::MLV_IncompleteType: 8701 case Expr::MLV_IncompleteVoidType: 8702 return S.RequireCompleteType(Loc, E->getType(), 8703 diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E); 8704 case Expr::MLV_DuplicateVectorComponents: 8705 DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue; 8706 break; 8707 case Expr::MLV_NoSetterProperty: 8708 llvm_unreachable("readonly properties should be processed differently"); 8709 case Expr::MLV_InvalidMessageExpression: 8710 DiagID = diag::error_readonly_message_assignment; 8711 break; 8712 case Expr::MLV_SubObjCPropertySetting: 8713 DiagID = diag::error_no_subobject_property_setting; 8714 break; 8715 } 8716 8717 SourceRange Assign; 8718 if (Loc != OrigLoc) 8719 Assign = SourceRange(OrigLoc, OrigLoc); 8720 if (NeedType) 8721 S.Diag(Loc, DiagID) << E->getType() << E->getSourceRange() << Assign; 8722 else 8723 S.Diag(Loc, DiagID) << E->getSourceRange() << Assign; 8724 return true; 8725} 8726 8727static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr, 8728 SourceLocation Loc, 8729 Sema &Sema) { 8730 // C / C++ fields 8731 MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr); 8732 MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr); 8733 if (ML && MR && ML->getMemberDecl() == MR->getMemberDecl()) { 8734 if (isa<CXXThisExpr>(ML->getBase()) && isa<CXXThisExpr>(MR->getBase())) 8735 Sema.Diag(Loc, diag::warn_identity_field_assign) << 0; 8736 } 8737 8738 // Objective-C instance variables 8739 ObjCIvarRefExpr *OL = dyn_cast<ObjCIvarRefExpr>(LHSExpr); 8740 ObjCIvarRefExpr *OR = dyn_cast<ObjCIvarRefExpr>(RHSExpr); 8741 if (OL && OR && OL->getDecl() == OR->getDecl()) { 8742 DeclRefExpr *RL = dyn_cast<DeclRefExpr>(OL->getBase()->IgnoreImpCasts()); 8743 DeclRefExpr *RR = dyn_cast<DeclRefExpr>(OR->getBase()->IgnoreImpCasts()); 8744 if (RL && RR && RL->getDecl() == RR->getDecl()) 8745 Sema.Diag(Loc, diag::warn_identity_field_assign) << 1; 8746 } 8747} 8748 8749// C99 6.5.16.1 8750QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, 8751 SourceLocation Loc, 8752 QualType CompoundType) { 8753 assert(!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject)); 8754 8755 // Verify that LHS is a modifiable lvalue, and emit error if not. 8756 if (CheckForModifiableLvalue(LHSExpr, Loc, *this)) 8757 return QualType(); 8758 8759 QualType LHSType = LHSExpr->getType(); 8760 QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() : 8761 CompoundType; 8762 AssignConvertType ConvTy; 8763 if (CompoundType.isNull()) { 8764 Expr *RHSCheck = RHS.get(); 8765 8766 CheckIdentityFieldAssignment(LHSExpr, RHSCheck, Loc, *this); 8767 8768 QualType LHSTy(LHSType); 8769 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS); 8770 if (RHS.isInvalid()) 8771 return QualType(); 8772 // Special case of NSObject attributes on c-style pointer types. 8773 if (ConvTy == IncompatiblePointer && 8774 ((Context.isObjCNSObjectType(LHSType) && 8775 RHSType->isObjCObjectPointerType()) || 8776 (Context.isObjCNSObjectType(RHSType) && 8777 LHSType->isObjCObjectPointerType()))) 8778 ConvTy = Compatible; 8779 8780 if (ConvTy == Compatible && 8781 LHSType->isObjCObjectType()) 8782 Diag(Loc, diag::err_objc_object_assignment) 8783 << LHSType; 8784 8785 // If the RHS is a unary plus or minus, check to see if they = and + are 8786 // right next to each other. If so, the user may have typo'd "x =+ 4" 8787 // instead of "x += 4". 8788 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck)) 8789 RHSCheck = ICE->getSubExpr(); 8790 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) { 8791 if ((UO->getOpcode() == UO_Plus || 8792 UO->getOpcode() == UO_Minus) && 8793 Loc.isFileID() && UO->getOperatorLoc().isFileID() && 8794 // Only if the two operators are exactly adjacent. 8795 Loc.getLocWithOffset(1) == UO->getOperatorLoc() && 8796 // And there is a space or other character before the subexpr of the 8797 // unary +/-. We don't want to warn on "x=-1". 8798 Loc.getLocWithOffset(2) != UO->getSubExpr()->getLocStart() && 8799 UO->getSubExpr()->getLocStart().isFileID()) { 8800 Diag(Loc, diag::warn_not_compound_assign) 8801 << (UO->getOpcode() == UO_Plus ? "+" : "-") 8802 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc()); 8803 } 8804 } 8805 8806 if (ConvTy == Compatible) { 8807 if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong) { 8808 // Warn about retain cycles where a block captures the LHS, but 8809 // not if the LHS is a simple variable into which the block is 8810 // being stored...unless that variable can be captured by reference! 8811 const Expr *InnerLHS = LHSExpr->IgnoreParenCasts(); 8812 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InnerLHS); 8813 if (!DRE || DRE->getDecl()->hasAttr<BlocksAttr>()) 8814 checkRetainCycles(LHSExpr, RHS.get()); 8815 8816 // It is safe to assign a weak reference into a strong variable. 8817 // Although this code can still have problems: 8818 // id x = self.weakProp; 8819 // id y = self.weakProp; 8820 // we do not warn to warn spuriously when 'x' and 'y' are on separate 8821 // paths through the function. This should be revisited if 8822 // -Wrepeated-use-of-weak is made flow-sensitive. 8823 if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, 8824 RHS.get()->getLocStart())) 8825 getCurFunction()->markSafeWeakUse(RHS.get()); 8826 8827 } else if (getLangOpts().ObjCAutoRefCount) { 8828 checkUnsafeExprAssigns(Loc, LHSExpr, RHS.get()); 8829 } 8830 } 8831 } else { 8832 // Compound assignment "x += y" 8833 ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType); 8834 } 8835 8836 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType, 8837 RHS.get(), AA_Assigning)) 8838 return QualType(); 8839 8840 CheckForNullPointerDereference(*this, LHSExpr); 8841 8842 // C99 6.5.16p3: The type of an assignment expression is the type of the 8843 // left operand unless the left operand has qualified type, in which case 8844 // it is the unqualified version of the type of the left operand. 8845 // C99 6.5.16.1p2: In simple assignment, the value of the right operand 8846 // is converted to the type of the assignment expression (above). 8847 // C++ 5.17p1: the type of the assignment expression is that of its left 8848 // operand. 8849 return (getLangOpts().CPlusPlus 8850 ? LHSType : LHSType.getUnqualifiedType()); 8851} 8852 8853// C99 6.5.17 8854static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, 8855 SourceLocation Loc) { 8856 LHS = S.CheckPlaceholderExpr(LHS.get()); 8857 RHS = S.CheckPlaceholderExpr(RHS.get()); 8858 if (LHS.isInvalid() || RHS.isInvalid()) 8859 return QualType(); 8860 8861 // C's comma performs lvalue conversion (C99 6.3.2.1) on both its 8862 // operands, but not unary promotions. 8863 // C++'s comma does not do any conversions at all (C++ [expr.comma]p1). 8864 8865 // So we treat the LHS as a ignored value, and in C++ we allow the 8866 // containing site to determine what should be done with the RHS. 8867 LHS = S.IgnoredValueConversions(LHS.get()); 8868 if (LHS.isInvalid()) 8869 return QualType(); 8870 8871 S.DiagnoseUnusedExprResult(LHS.get()); 8872 8873 if (!S.getLangOpts().CPlusPlus) { 8874 RHS = S.DefaultFunctionArrayLvalueConversion(RHS.get()); 8875 if (RHS.isInvalid()) 8876 return QualType(); 8877 if (!RHS.get()->getType()->isVoidType()) 8878 S.RequireCompleteType(Loc, RHS.get()->getType(), 8879 diag::err_incomplete_type); 8880 } 8881 8882 return RHS.get()->getType(); 8883} 8884 8885/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine 8886/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions. 8887static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, 8888 ExprValueKind &VK, 8889 ExprObjectKind &OK, 8890 SourceLocation OpLoc, 8891 bool IsInc, bool IsPrefix) { 8892 if (Op->isTypeDependent()) 8893 return S.Context.DependentTy; 8894 8895 QualType ResType = Op->getType(); 8896 // Atomic types can be used for increment / decrement where the non-atomic 8897 // versions can, so ignore the _Atomic() specifier for the purpose of 8898 // checking. 8899 if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>()) 8900 ResType = ResAtomicType->getValueType(); 8901 8902 assert(!ResType.isNull() && "no type for increment/decrement expression"); 8903 8904 if (S.getLangOpts().CPlusPlus && ResType->isBooleanType()) { 8905 // Decrement of bool is not allowed. 8906 if (!IsInc) { 8907 S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange(); 8908 return QualType(); 8909 } 8910 // Increment of bool sets it to true, but is deprecated. 8911 S.Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange(); 8912 } else if (S.getLangOpts().CPlusPlus && ResType->isEnumeralType()) { 8913 // Error on enum increments and decrements in C++ mode 8914 S.Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType; 8915 return QualType(); 8916 } else if (ResType->isRealType()) { 8917 // OK! 8918 } else if (ResType->isPointerType()) { 8919 // C99 6.5.2.4p2, 6.5.6p2 8920 if (!checkArithmeticOpPointerOperand(S, OpLoc, Op)) 8921 return QualType(); 8922 } else if (ResType->isObjCObjectPointerType()) { 8923 // On modern runtimes, ObjC pointer arithmetic is forbidden. 8924 // Otherwise, we just need a complete type. 8925 if (checkArithmeticIncompletePointerType(S, OpLoc, Op) || 8926 checkArithmeticOnObjCPointer(S, OpLoc, Op)) 8927 return QualType(); 8928 } else if (ResType->isAnyComplexType()) { 8929 // C99 does not support ++/-- on complex types, we allow as an extension. 8930 S.Diag(OpLoc, diag::ext_integer_increment_complex) 8931 << ResType << Op->getSourceRange(); 8932 } else if (ResType->isPlaceholderType()) { 8933 ExprResult PR = S.CheckPlaceholderExpr(Op); 8934 if (PR.isInvalid()) return QualType(); 8935 return CheckIncrementDecrementOperand(S, PR.get(), VK, OK, OpLoc, 8936 IsInc, IsPrefix); 8937 } else if (S.getLangOpts().AltiVec && ResType->isVectorType()) { 8938 // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 ) 8939 } else if(S.getLangOpts().OpenCL && ResType->isVectorType() && 8940 ResType->getAs<VectorType>()->getElementType()->isIntegerType()) { 8941 // OpenCL V1.2 6.3 says dec/inc ops operate on integer vector types. 8942 } else { 8943 S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement) 8944 << ResType << int(IsInc) << Op->getSourceRange(); 8945 return QualType(); 8946 } 8947 // At this point, we know we have a real, complex or pointer type. 8948 // Now make sure the operand is a modifiable lvalue. 8949 if (CheckForModifiableLvalue(Op, OpLoc, S)) 8950 return QualType(); 8951 // In C++, a prefix increment is the same type as the operand. Otherwise 8952 // (in C or with postfix), the increment is the unqualified type of the 8953 // operand. 8954 if (IsPrefix && S.getLangOpts().CPlusPlus) { 8955 VK = VK_LValue; 8956 OK = Op->getObjectKind(); 8957 return ResType; 8958 } else { 8959 VK = VK_RValue; 8960 return ResType.getUnqualifiedType(); 8961 } 8962} 8963 8964 8965/// getPrimaryDecl - Helper function for CheckAddressOfOperand(). 8966/// This routine allows us to typecheck complex/recursive expressions 8967/// where the declaration is needed for type checking. We only need to 8968/// handle cases when the expression references a function designator 8969/// or is an lvalue. Here are some examples: 8970/// - &(x) => x 8971/// - &*****f => f for f a function designator. 8972/// - &s.xx => s 8973/// - &s.zz[1].yy -> s, if zz is an array 8974/// - *(x + 1) -> x, if x is an array 8975/// - &"123"[2] -> 0 8976/// - & __real__ x -> x 8977static ValueDecl *getPrimaryDecl(Expr *E) { 8978 switch (E->getStmtClass()) { 8979 case Stmt::DeclRefExprClass: 8980 return cast<DeclRefExpr>(E)->getDecl(); 8981 case Stmt::MemberExprClass: 8982 // If this is an arrow operator, the address is an offset from 8983 // the base's value, so the object the base refers to is 8984 // irrelevant. 8985 if (cast<MemberExpr>(E)->isArrow()) 8986 return nullptr; 8987 // Otherwise, the expression refers to a part of the base 8988 return getPrimaryDecl(cast<MemberExpr>(E)->getBase()); 8989 case Stmt::ArraySubscriptExprClass: { 8990 // FIXME: This code shouldn't be necessary! We should catch the implicit 8991 // promotion of register arrays earlier. 8992 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase(); 8993 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) { 8994 if (ICE->getSubExpr()->getType()->isArrayType()) 8995 return getPrimaryDecl(ICE->getSubExpr()); 8996 } 8997 return nullptr; 8998 } 8999 case Stmt::UnaryOperatorClass: { 9000 UnaryOperator *UO = cast<UnaryOperator>(E); 9001 9002 switch(UO->getOpcode()) { 9003 case UO_Real: 9004 case UO_Imag: 9005 case UO_Extension: 9006 return getPrimaryDecl(UO->getSubExpr()); 9007 default: 9008 return nullptr; 9009 } 9010 } 9011 case Stmt::ParenExprClass: 9012 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr()); 9013 case Stmt::ImplicitCastExprClass: 9014 // If the result of an implicit cast is an l-value, we care about 9015 // the sub-expression; otherwise, the result here doesn't matter. 9016 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr()); 9017 default: 9018 return nullptr; 9019 } 9020} 9021 9022namespace { 9023 enum { 9024 AO_Bit_Field = 0, 9025 AO_Vector_Element = 1, 9026 AO_Property_Expansion = 2, 9027 AO_Register_Variable = 3, 9028 AO_No_Error = 4 9029 }; 9030} 9031/// \brief Diagnose invalid operand for address of operations. 9032/// 9033/// \param Type The type of operand which cannot have its address taken. 9034static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, 9035 Expr *E, unsigned Type) { 9036 S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange(); 9037} 9038 9039/// CheckAddressOfOperand - The operand of & must be either a function 9040/// designator or an lvalue designating an object. If it is an lvalue, the 9041/// object cannot be declared with storage class register or be a bit field. 9042/// Note: The usual conversions are *not* applied to the operand of the & 9043/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue. 9044/// In C++, the operand might be an overloaded function name, in which case 9045/// we allow the '&' but retain the overloaded-function type. 9046QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) { 9047 if (const BuiltinType *PTy = OrigOp.get()->getType()->getAsPlaceholderType()){ 9048 if (PTy->getKind() == BuiltinType::Overload) { 9049 Expr *E = OrigOp.get()->IgnoreParens(); 9050 if (!isa<OverloadExpr>(E)) { 9051 assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf); 9052 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function) 9053 << OrigOp.get()->getSourceRange(); 9054 return QualType(); 9055 } 9056 9057 OverloadExpr *Ovl = cast<OverloadExpr>(E); 9058 if (isa<UnresolvedMemberExpr>(Ovl)) 9059 if (!ResolveSingleFunctionTemplateSpecialization(Ovl)) { 9060 Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 9061 << OrigOp.get()->getSourceRange(); 9062 return QualType(); 9063 } 9064 9065 return Context.OverloadTy; 9066 } 9067 9068 if (PTy->getKind() == BuiltinType::UnknownAny) 9069 return Context.UnknownAnyTy; 9070 9071 if (PTy->getKind() == BuiltinType::BoundMember) { 9072 Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 9073 << OrigOp.get()->getSourceRange(); 9074 return QualType(); 9075 } 9076 9077 OrigOp = CheckPlaceholderExpr(OrigOp.get()); 9078 if (OrigOp.isInvalid()) return QualType(); 9079 } 9080 9081 if (OrigOp.get()->isTypeDependent()) 9082 return Context.DependentTy; 9083 9084 assert(!OrigOp.get()->getType()->isPlaceholderType()); 9085 9086 // Make sure to ignore parentheses in subsequent checks 9087 Expr *op = OrigOp.get()->IgnoreParens(); 9088 9089 // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed. 9090 if (LangOpts.OpenCL && op->getType()->isFunctionType()) { 9091 Diag(op->getExprLoc(), diag::err_opencl_taking_function_address); 9092 return QualType(); 9093 } 9094 9095 if (getLangOpts().C99) { 9096 // Implement C99-only parts of addressof rules. 9097 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) { 9098 if (uOp->getOpcode() == UO_Deref) 9099 // Per C99 6.5.3.2, the address of a deref always returns a valid result 9100 // (assuming the deref expression is valid). 9101 return uOp->getSubExpr()->getType(); 9102 } 9103 // Technically, there should be a check for array subscript 9104 // expressions here, but the result of one is always an lvalue anyway. 9105 } 9106 ValueDecl *dcl = getPrimaryDecl(op); 9107 Expr::LValueClassification lval = op->ClassifyLValue(Context); 9108 unsigned AddressOfError = AO_No_Error; 9109 9110 if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) { 9111 bool sfinae = (bool)isSFINAEContext(); 9112 Diag(OpLoc, isSFINAEContext() ? diag::err_typecheck_addrof_temporary 9113 : diag::ext_typecheck_addrof_temporary) 9114 << op->getType() << op->getSourceRange(); 9115 if (sfinae) 9116 return QualType(); 9117 // Materialize the temporary as an lvalue so that we can take its address. 9118 OrigOp = op = new (Context) 9119 MaterializeTemporaryExpr(op->getType(), OrigOp.get(), true); 9120 } else if (isa<ObjCSelectorExpr>(op)) { 9121 return Context.getPointerType(op->getType()); 9122 } else if (lval == Expr::LV_MemberFunction) { 9123 // If it's an instance method, make a member pointer. 9124 // The expression must have exactly the form &A::foo. 9125 9126 // If the underlying expression isn't a decl ref, give up. 9127 if (!isa<DeclRefExpr>(op)) { 9128 Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 9129 << OrigOp.get()->getSourceRange(); 9130 return QualType(); 9131 } 9132 DeclRefExpr *DRE = cast<DeclRefExpr>(op); 9133 CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl()); 9134 9135 // The id-expression was parenthesized. 9136 if (OrigOp.get() != DRE) { 9137 Diag(OpLoc, diag::err_parens_pointer_member_function) 9138 << OrigOp.get()->getSourceRange(); 9139 9140 // The method was named without a qualifier. 9141 } else if (!DRE->getQualifier()) { 9142 if (MD->getParent()->getName().empty()) 9143 Diag(OpLoc, diag::err_unqualified_pointer_member_function) 9144 << op->getSourceRange(); 9145 else { 9146 SmallString<32> Str; 9147 StringRef Qual = (MD->getParent()->getName() + "::").toStringRef(Str); 9148 Diag(OpLoc, diag::err_unqualified_pointer_member_function) 9149 << op->getSourceRange() 9150 << FixItHint::CreateInsertion(op->getSourceRange().getBegin(), Qual); 9151 } 9152 } 9153 9154 // Taking the address of a dtor is illegal per C++ [class.dtor]p2. 9155 if (isa<CXXDestructorDecl>(MD)) 9156 Diag(OpLoc, diag::err_typecheck_addrof_dtor) << op->getSourceRange(); 9157 9158 QualType MPTy = Context.getMemberPointerType( 9159 op->getType(), Context.getTypeDeclType(MD->getParent()).getTypePtr()); 9160 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) 9161 RequireCompleteType(OpLoc, MPTy, 0); 9162 return MPTy; 9163 } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) { 9164 // C99 6.5.3.2p1 9165 // The operand must be either an l-value or a function designator 9166 if (!op->getType()->isFunctionType()) { 9167 // Use a special diagnostic for loads from property references. 9168 if (isa<PseudoObjectExpr>(op)) { 9169 AddressOfError = AO_Property_Expansion; 9170 } else { 9171 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof) 9172 << op->getType() << op->getSourceRange(); 9173 return QualType(); 9174 } 9175 } 9176 } else if (op->getObjectKind() == OK_BitField) { // C99 6.5.3.2p1 9177 // The operand cannot be a bit-field 9178 AddressOfError = AO_Bit_Field; 9179 } else if (op->getObjectKind() == OK_VectorComponent) { 9180 // The operand cannot be an element of a vector 9181 AddressOfError = AO_Vector_Element; 9182 } else if (dcl) { // C99 6.5.3.2p1 9183 // We have an lvalue with a decl. Make sure the decl is not declared 9184 // with the register storage-class specifier. 9185 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) { 9186 // in C++ it is not error to take address of a register 9187 // variable (c++03 7.1.1P3) 9188 if (vd->getStorageClass() == SC_Register && 9189 !getLangOpts().CPlusPlus) { 9190 AddressOfError = AO_Register_Variable; 9191 } 9192 } else if (isa<FunctionTemplateDecl>(dcl)) { 9193 return Context.OverloadTy; 9194 } else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) { 9195 // Okay: we can take the address of a field. 9196 // Could be a pointer to member, though, if there is an explicit 9197 // scope qualifier for the class. 9198 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) { 9199 DeclContext *Ctx = dcl->getDeclContext(); 9200 if (Ctx && Ctx->isRecord()) { 9201 if (dcl->getType()->isReferenceType()) { 9202 Diag(OpLoc, 9203 diag::err_cannot_form_pointer_to_member_of_reference_type) 9204 << dcl->getDeclName() << dcl->getType(); 9205 return QualType(); 9206 } 9207 9208 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion()) 9209 Ctx = Ctx->getParent(); 9210 9211 QualType MPTy = Context.getMemberPointerType( 9212 op->getType(), 9213 Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr()); 9214 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) 9215 RequireCompleteType(OpLoc, MPTy, 0); 9216 return MPTy; 9217 } 9218 } 9219 } else if (!isa<FunctionDecl>(dcl) && !isa<NonTypeTemplateParmDecl>(dcl)) 9220 llvm_unreachable("Unknown/unexpected decl type"); 9221 } 9222 9223 if (AddressOfError != AO_No_Error) { 9224 diagnoseAddressOfInvalidType(*this, OpLoc, op, AddressOfError); 9225 return QualType(); 9226 } 9227 9228 if (lval == Expr::LV_IncompleteVoidType) { 9229 // Taking the address of a void variable is technically illegal, but we 9230 // allow it in cases which are otherwise valid. 9231 // Example: "extern void x; void* y = &x;". 9232 Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange(); 9233 } 9234 9235 // If the operand has type "type", the result has type "pointer to type". 9236 if (op->getType()->isObjCObjectType()) 9237 return Context.getObjCObjectPointerType(op->getType()); 9238 return Context.getPointerType(op->getType()); 9239} 9240 9241static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp) { 9242 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp); 9243 if (!DRE) 9244 return; 9245 const Decl *D = DRE->getDecl(); 9246 if (!D) 9247 return; 9248 const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D); 9249 if (!Param) 9250 return; 9251 if (const FunctionDecl* FD = dyn_cast<FunctionDecl>(Param->getDeclContext())) 9252 if (!FD->hasAttr<NonNullAttr>() && !Param->hasAttr<NonNullAttr>()) 9253 return; 9254 if (FunctionScopeInfo *FD = S.getCurFunction()) 9255 if (!FD->ModifiedNonNullParams.count(Param)) 9256 FD->ModifiedNonNullParams.insert(Param); 9257} 9258 9259/// CheckIndirectionOperand - Type check unary indirection (prefix '*'). 9260static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK, 9261 SourceLocation OpLoc) { 9262 if (Op->isTypeDependent()) 9263 return S.Context.DependentTy; 9264 9265 ExprResult ConvResult = S.UsualUnaryConversions(Op); 9266 if (ConvResult.isInvalid()) 9267 return QualType(); 9268 Op = ConvResult.get(); 9269 QualType OpTy = Op->getType(); 9270 QualType Result; 9271 9272 if (isa<CXXReinterpretCastExpr>(Op)) { 9273 QualType OpOrigType = Op->IgnoreParenCasts()->getType(); 9274 S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true, 9275 Op->getSourceRange()); 9276 } 9277 9278 if (const PointerType *PT = OpTy->getAs<PointerType>()) 9279 Result = PT->getPointeeType(); 9280 else if (const ObjCObjectPointerType *OPT = 9281 OpTy->getAs<ObjCObjectPointerType>()) 9282 Result = OPT->getPointeeType(); 9283 else { 9284 ExprResult PR = S.CheckPlaceholderExpr(Op); 9285 if (PR.isInvalid()) return QualType(); 9286 if (PR.get() != Op) 9287 return CheckIndirectionOperand(S, PR.get(), VK, OpLoc); 9288 } 9289 9290 if (Result.isNull()) { 9291 S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer) 9292 << OpTy << Op->getSourceRange(); 9293 return QualType(); 9294 } 9295 9296 // Note that per both C89 and C99, indirection is always legal, even if Result 9297 // is an incomplete type or void. It would be possible to warn about 9298 // dereferencing a void pointer, but it's completely well-defined, and such a 9299 // warning is unlikely to catch any mistakes. In C++, indirection is not valid 9300 // for pointers to 'void' but is fine for any other pointer type: 9301 // 9302 // C++ [expr.unary.op]p1: 9303 // [...] the expression to which [the unary * operator] is applied shall 9304 // be a pointer to an object type, or a pointer to a function type 9305 if (S.getLangOpts().CPlusPlus && Result->isVoidType()) 9306 S.Diag(OpLoc, diag::ext_typecheck_indirection_through_void_pointer) 9307 << OpTy << Op->getSourceRange(); 9308 9309 // Dereferences are usually l-values... 9310 VK = VK_LValue; 9311 9312 // ...except that certain expressions are never l-values in C. 9313 if (!S.getLangOpts().CPlusPlus && Result.isCForbiddenLValueType()) 9314 VK = VK_RValue; 9315 9316 return Result; 9317} 9318 9319BinaryOperatorKind Sema::ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind) { 9320 BinaryOperatorKind Opc; 9321 switch (Kind) { 9322 default: llvm_unreachable("Unknown binop!"); 9323 case tok::periodstar: Opc = BO_PtrMemD; break; 9324 case tok::arrowstar: Opc = BO_PtrMemI; break; 9325 case tok::star: Opc = BO_Mul; break; 9326 case tok::slash: Opc = BO_Div; break; 9327 case tok::percent: Opc = BO_Rem; break; 9328 case tok::plus: Opc = BO_Add; break; 9329 case tok::minus: Opc = BO_Sub; break; 9330 case tok::lessless: Opc = BO_Shl; break; 9331 case tok::greatergreater: Opc = BO_Shr; break; 9332 case tok::lessequal: Opc = BO_LE; break; 9333 case tok::less: Opc = BO_LT; break; 9334 case tok::greaterequal: Opc = BO_GE; break; 9335 case tok::greater: Opc = BO_GT; break; 9336 case tok::exclaimequal: Opc = BO_NE; break; 9337 case tok::equalequal: Opc = BO_EQ; break; 9338 case tok::amp: Opc = BO_And; break; 9339 case tok::caret: Opc = BO_Xor; break; 9340 case tok::pipe: Opc = BO_Or; break; 9341 case tok::ampamp: Opc = BO_LAnd; break; 9342 case tok::pipepipe: Opc = BO_LOr; break; 9343 case tok::equal: Opc = BO_Assign; break; 9344 case tok::starequal: Opc = BO_MulAssign; break; 9345 case tok::slashequal: Opc = BO_DivAssign; break; 9346 case tok::percentequal: Opc = BO_RemAssign; break; 9347 case tok::plusequal: Opc = BO_AddAssign; break; 9348 case tok::minusequal: Opc = BO_SubAssign; break; 9349 case tok::lesslessequal: Opc = BO_ShlAssign; break; 9350 case tok::greatergreaterequal: Opc = BO_ShrAssign; break; 9351 case tok::ampequal: Opc = BO_AndAssign; break; 9352 case tok::caretequal: Opc = BO_XorAssign; break; 9353 case tok::pipeequal: Opc = BO_OrAssign; break; 9354 case tok::comma: Opc = BO_Comma; break; 9355 } 9356 return Opc; 9357} 9358 9359static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode( 9360 tok::TokenKind Kind) { 9361 UnaryOperatorKind Opc; 9362 switch (Kind) { 9363 default: llvm_unreachable("Unknown unary op!"); 9364 case tok::plusplus: Opc = UO_PreInc; break; 9365 case tok::minusminus: Opc = UO_PreDec; break; 9366 case tok::amp: Opc = UO_AddrOf; break; 9367 case tok::star: Opc = UO_Deref; break; 9368 case tok::plus: Opc = UO_Plus; break; 9369 case tok::minus: Opc = UO_Minus; break; 9370 case tok::tilde: Opc = UO_Not; break; 9371 case tok::exclaim: Opc = UO_LNot; break; 9372 case tok::kw___real: Opc = UO_Real; break; 9373 case tok::kw___imag: Opc = UO_Imag; break; 9374 case tok::kw___extension__: Opc = UO_Extension; break; 9375 } 9376 return Opc; 9377} 9378 9379/// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself. 9380/// This warning is only emitted for builtin assignment operations. It is also 9381/// suppressed in the event of macro expansions. 9382static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr, 9383 SourceLocation OpLoc) { 9384 if (!S.ActiveTemplateInstantiations.empty()) 9385 return; 9386 if (OpLoc.isInvalid() || OpLoc.isMacroID()) 9387 return; 9388 LHSExpr = LHSExpr->IgnoreParenImpCasts(); 9389 RHSExpr = RHSExpr->IgnoreParenImpCasts(); 9390 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr); 9391 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr); 9392 if (!LHSDeclRef || !RHSDeclRef || 9393 LHSDeclRef->getLocation().isMacroID() || 9394 RHSDeclRef->getLocation().isMacroID()) 9395 return; 9396 const ValueDecl *LHSDecl = 9397 cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl()); 9398 const ValueDecl *RHSDecl = 9399 cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl()); 9400 if (LHSDecl != RHSDecl) 9401 return; 9402 if (LHSDecl->getType().isVolatileQualified()) 9403 return; 9404 if (const ReferenceType *RefTy = LHSDecl->getType()->getAs<ReferenceType>()) 9405 if (RefTy->getPointeeType().isVolatileQualified()) 9406 return; 9407 9408 S.Diag(OpLoc, diag::warn_self_assignment) 9409 << LHSDeclRef->getType() 9410 << LHSExpr->getSourceRange() << RHSExpr->getSourceRange(); 9411} 9412 9413/// Check if a bitwise-& is performed on an Objective-C pointer. This 9414/// is usually indicative of introspection within the Objective-C pointer. 9415static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R, 9416 SourceLocation OpLoc) { 9417 if (!S.getLangOpts().ObjC1) 9418 return; 9419 9420 const Expr *ObjCPointerExpr = nullptr, *OtherExpr = nullptr; 9421 const Expr *LHS = L.get(); 9422 const Expr *RHS = R.get(); 9423 9424 if (LHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) { 9425 ObjCPointerExpr = LHS; 9426 OtherExpr = RHS; 9427 } 9428 else if (RHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) { 9429 ObjCPointerExpr = RHS; 9430 OtherExpr = LHS; 9431 } 9432 9433 // This warning is deliberately made very specific to reduce false 9434 // positives with logic that uses '&' for hashing. This logic mainly 9435 // looks for code trying to introspect into tagged pointers, which 9436 // code should generally never do. 9437 if (ObjCPointerExpr && isa<IntegerLiteral>(OtherExpr->IgnoreParenCasts())) { 9438 unsigned Diag = diag::warn_objc_pointer_masking; 9439 // Determine if we are introspecting the result of performSelectorXXX. 9440 const Expr *Ex = ObjCPointerExpr->IgnoreParenCasts(); 9441 // Special case messages to -performSelector and friends, which 9442 // can return non-pointer values boxed in a pointer value. 9443 // Some clients may wish to silence warnings in this subcase. 9444 if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(Ex)) { 9445 Selector S = ME->getSelector(); 9446 StringRef SelArg0 = S.getNameForSlot(0); 9447 if (SelArg0.startswith("performSelector")) 9448 Diag = diag::warn_objc_pointer_masking_performSelector; 9449 } 9450 9451 S.Diag(OpLoc, Diag) 9452 << ObjCPointerExpr->getSourceRange(); 9453 } 9454} 9455 9456static NamedDecl *getDeclFromExpr(Expr *E) { 9457 if (!E) 9458 return nullptr; 9459 if (auto *DRE = dyn_cast<DeclRefExpr>(E)) 9460 return DRE->getDecl(); 9461 if (auto *ME = dyn_cast<MemberExpr>(E)) 9462 return ME->getMemberDecl(); 9463 if (auto *IRE = dyn_cast<ObjCIvarRefExpr>(E)) 9464 return IRE->getDecl(); 9465 return nullptr; 9466} 9467 9468/// CreateBuiltinBinOp - Creates a new built-in binary operation with 9469/// operator @p Opc at location @c TokLoc. This routine only supports 9470/// built-in operations; ActOnBinOp handles overloaded operators. 9471ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc, 9472 BinaryOperatorKind Opc, 9473 Expr *LHSExpr, Expr *RHSExpr) { 9474 if (getLangOpts().CPlusPlus11 && isa<InitListExpr>(RHSExpr)) { 9475 // The syntax only allows initializer lists on the RHS of assignment, 9476 // so we don't need to worry about accepting invalid code for 9477 // non-assignment operators. 9478 // C++11 5.17p9: 9479 // The meaning of x = {v} [...] is that of x = T(v) [...]. The meaning 9480 // of x = {} is x = T(). 9481 InitializationKind Kind = 9482 InitializationKind::CreateDirectList(RHSExpr->getLocStart()); 9483 InitializedEntity Entity = 9484 InitializedEntity::InitializeTemporary(LHSExpr->getType()); 9485 InitializationSequence InitSeq(*this, Entity, Kind, RHSExpr); 9486 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, RHSExpr); 9487 if (Init.isInvalid()) 9488 return Init; 9489 RHSExpr = Init.get(); 9490 } 9491 9492 ExprResult LHS = LHSExpr, RHS = RHSExpr; 9493 QualType ResultTy; // Result type of the binary operator. 9494 // The following two variables are used for compound assignment operators 9495 QualType CompLHSTy; // Type of LHS after promotions for computation 9496 QualType CompResultTy; // Type of computation result 9497 ExprValueKind VK = VK_RValue; 9498 ExprObjectKind OK = OK_Ordinary; 9499 9500 if (!getLangOpts().CPlusPlus) { 9501 // C cannot handle TypoExpr nodes on either side of a binop because it 9502 // doesn't handle dependent types properly, so make sure any TypoExprs have 9503 // been dealt with before checking the operands. 9504 LHS = CorrectDelayedTyposInExpr(LHSExpr); 9505 RHS = CorrectDelayedTyposInExpr(RHSExpr, [Opc, LHS](Expr *E) { 9506 if (Opc != BO_Assign) 9507 return ExprResult(E); 9508 // Avoid correcting the RHS to the same Expr as the LHS. 9509 Decl *D = getDeclFromExpr(E); 9510 return (D && D == getDeclFromExpr(LHS.get())) ? ExprError() : E; 9511 }); 9512 if (!LHS.isUsable() || !RHS.isUsable()) 9513 return ExprError(); 9514 } 9515 9516 switch (Opc) { 9517 case BO_Assign: 9518 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, QualType()); 9519 if (getLangOpts().CPlusPlus && 9520 LHS.get()->getObjectKind() != OK_ObjCProperty) { 9521 VK = LHS.get()->getValueKind(); 9522 OK = LHS.get()->getObjectKind(); 9523 } 9524 if (!ResultTy.isNull()) { 9525 DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc); 9526 DiagnoseSelfMove(LHS.get(), RHS.get(), OpLoc); 9527 } 9528 RecordModifiableNonNullParam(*this, LHS.get()); 9529 break; 9530 case BO_PtrMemD: 9531 case BO_PtrMemI: 9532 ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc, 9533 Opc == BO_PtrMemI); 9534 break; 9535 case BO_Mul: 9536 case BO_Div: 9537 ResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, false, 9538 Opc == BO_Div); 9539 break; 9540 case BO_Rem: 9541 ResultTy = CheckRemainderOperands(LHS, RHS, OpLoc); 9542 break; 9543 case BO_Add: 9544 ResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc); 9545 break; 9546 case BO_Sub: 9547 ResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc); 9548 break; 9549 case BO_Shl: 9550 case BO_Shr: 9551 ResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc); 9552 break; 9553 case BO_LE: 9554 case BO_LT: 9555 case BO_GE: 9556 case BO_GT: 9557 ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, true); 9558 break; 9559 case BO_EQ: 9560 case BO_NE: 9561 ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, false); 9562 break; 9563 case BO_And: 9564 checkObjCPointerIntrospection(*this, LHS, RHS, OpLoc); 9565 case BO_Xor: 9566 case BO_Or: 9567 ResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc); 9568 break; 9569 case BO_LAnd: 9570 case BO_LOr: 9571 ResultTy = CheckLogicalOperands(LHS, RHS, OpLoc, Opc); 9572 break; 9573 case BO_MulAssign: 9574 case BO_DivAssign: 9575 CompResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, true, 9576 Opc == BO_DivAssign); 9577 CompLHSTy = CompResultTy; 9578 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9579 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9580 break; 9581 case BO_RemAssign: 9582 CompResultTy = CheckRemainderOperands(LHS, RHS, OpLoc, true); 9583 CompLHSTy = CompResultTy; 9584 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9585 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9586 break; 9587 case BO_AddAssign: 9588 CompResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc, &CompLHSTy); 9589 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9590 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9591 break; 9592 case BO_SubAssign: 9593 CompResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc, &CompLHSTy); 9594 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9595 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9596 break; 9597 case BO_ShlAssign: 9598 case BO_ShrAssign: 9599 CompResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc, true); 9600 CompLHSTy = CompResultTy; 9601 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9602 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9603 break; 9604 case BO_AndAssign: 9605 case BO_OrAssign: // fallthrough 9606 DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc); 9607 case BO_XorAssign: 9608 CompResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, true); 9609 CompLHSTy = CompResultTy; 9610 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 9611 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 9612 break; 9613 case BO_Comma: 9614 ResultTy = CheckCommaOperands(*this, LHS, RHS, OpLoc); 9615 if (getLangOpts().CPlusPlus && !RHS.isInvalid()) { 9616 VK = RHS.get()->getValueKind(); 9617 OK = RHS.get()->getObjectKind(); 9618 } 9619 break; 9620 } 9621 if (ResultTy.isNull() || LHS.isInvalid() || RHS.isInvalid()) 9622 return ExprError(); 9623 9624 // Check for array bounds violations for both sides of the BinaryOperator 9625 CheckArrayAccess(LHS.get()); 9626 CheckArrayAccess(RHS.get()); 9627 9628 if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) { 9629 NamedDecl *ObjectSetClass = LookupSingleName(TUScope, 9630 &Context.Idents.get("object_setClass"), 9631 SourceLocation(), LookupOrdinaryName); 9632 if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.get())) { 9633 SourceLocation RHSLocEnd = PP.getLocForEndOfToken(RHS.get()->getLocEnd()); 9634 Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign) << 9635 FixItHint::CreateInsertion(LHS.get()->getLocStart(), "object_setClass(") << 9636 FixItHint::CreateReplacement(SourceRange(OISA->getOpLoc(), OpLoc), ",") << 9637 FixItHint::CreateInsertion(RHSLocEnd, ")"); 9638 } 9639 else 9640 Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign); 9641 } 9642 else if (const ObjCIvarRefExpr *OIRE = 9643 dyn_cast<ObjCIvarRefExpr>(LHS.get()->IgnoreParenCasts())) 9644 DiagnoseDirectIsaAccess(*this, OIRE, OpLoc, RHS.get()); 9645 9646 if (CompResultTy.isNull()) 9647 return new (Context) BinaryOperator(LHS.get(), RHS.get(), Opc, ResultTy, VK, 9648 OK, OpLoc, FPFeatures.fp_contract); 9649 if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() != 9650 OK_ObjCProperty) { 9651 VK = VK_LValue; 9652 OK = LHS.get()->getObjectKind(); 9653 } 9654 return new (Context) CompoundAssignOperator( 9655 LHS.get(), RHS.get(), Opc, ResultTy, VK, OK, CompLHSTy, CompResultTy, 9656 OpLoc, FPFeatures.fp_contract); 9657} 9658 9659/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison 9660/// operators are mixed in a way that suggests that the programmer forgot that 9661/// comparison operators have higher precedence. The most typical example of 9662/// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1". 9663static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, 9664 SourceLocation OpLoc, Expr *LHSExpr, 9665 Expr *RHSExpr) { 9666 BinaryOperator *LHSBO = dyn_cast<BinaryOperator>(LHSExpr); 9667 BinaryOperator *RHSBO = dyn_cast<BinaryOperator>(RHSExpr); 9668 9669 // Check that one of the sides is a comparison operator. 9670 bool isLeftComp = LHSBO && LHSBO->isComparisonOp(); 9671 bool isRightComp = RHSBO && RHSBO->isComparisonOp(); 9672 if (!isLeftComp && !isRightComp) 9673 return; 9674 9675 // Bitwise operations are sometimes used as eager logical ops. 9676 // Don't diagnose this. 9677 bool isLeftBitwise = LHSBO && LHSBO->isBitwiseOp(); 9678 bool isRightBitwise = RHSBO && RHSBO->isBitwiseOp(); 9679 if ((isLeftComp || isLeftBitwise) && (isRightComp || isRightBitwise)) 9680 return; 9681 9682 SourceRange DiagRange = isLeftComp ? SourceRange(LHSExpr->getLocStart(), 9683 OpLoc) 9684 : SourceRange(OpLoc, RHSExpr->getLocEnd()); 9685 StringRef OpStr = isLeftComp ? LHSBO->getOpcodeStr() : RHSBO->getOpcodeStr(); 9686 SourceRange ParensRange = isLeftComp ? 9687 SourceRange(LHSBO->getRHS()->getLocStart(), RHSExpr->getLocEnd()) 9688 : SourceRange(LHSExpr->getLocStart(), RHSBO->getLHS()->getLocEnd()); 9689 9690 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel) 9691 << DiagRange << BinaryOperator::getOpcodeStr(Opc) << OpStr; 9692 SuggestParentheses(Self, OpLoc, 9693 Self.PDiag(diag::note_precedence_silence) << OpStr, 9694 (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange()); 9695 SuggestParentheses(Self, OpLoc, 9696 Self.PDiag(diag::note_precedence_bitwise_first) 9697 << BinaryOperator::getOpcodeStr(Opc), 9698 ParensRange); 9699} 9700 9701/// \brief It accepts a '&' expr that is inside a '|' one. 9702/// Emit a diagnostic together with a fixit hint that wraps the '&' expression 9703/// in parentheses. 9704static void 9705EmitDiagnosticForBitwiseAndInBitwiseOr(Sema &Self, SourceLocation OpLoc, 9706 BinaryOperator *Bop) { 9707 assert(Bop->getOpcode() == BO_And); 9708 Self.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_and_in_bitwise_or) 9709 << Bop->getSourceRange() << OpLoc; 9710 SuggestParentheses(Self, Bop->getOperatorLoc(), 9711 Self.PDiag(diag::note_precedence_silence) 9712 << Bop->getOpcodeStr(), 9713 Bop->getSourceRange()); 9714} 9715 9716/// \brief It accepts a '&&' expr that is inside a '||' one. 9717/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression 9718/// in parentheses. 9719static void 9720EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, 9721 BinaryOperator *Bop) { 9722 assert(Bop->getOpcode() == BO_LAnd); 9723 Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or) 9724 << Bop->getSourceRange() << OpLoc; 9725 SuggestParentheses(Self, Bop->getOperatorLoc(), 9726 Self.PDiag(diag::note_precedence_silence) 9727 << Bop->getOpcodeStr(), 9728 Bop->getSourceRange()); 9729} 9730 9731/// \brief Returns true if the given expression can be evaluated as a constant 9732/// 'true'. 9733static bool EvaluatesAsTrue(Sema &S, Expr *E) { 9734 bool Res; 9735 return !E->isValueDependent() && 9736 E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res; 9737} 9738 9739/// \brief Returns true if the given expression can be evaluated as a constant 9740/// 'false'. 9741static bool EvaluatesAsFalse(Sema &S, Expr *E) { 9742 bool Res; 9743 return !E->isValueDependent() && 9744 E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res; 9745} 9746 9747/// \brief Look for '&&' in the left hand of a '||' expr. 9748static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, 9749 Expr *LHSExpr, Expr *RHSExpr) { 9750 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(LHSExpr)) { 9751 if (Bop->getOpcode() == BO_LAnd) { 9752 // If it's "a && b || 0" don't warn since the precedence doesn't matter. 9753 if (EvaluatesAsFalse(S, RHSExpr)) 9754 return; 9755 // If it's "1 && a || b" don't warn since the precedence doesn't matter. 9756 if (!EvaluatesAsTrue(S, Bop->getLHS())) 9757 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 9758 } else if (Bop->getOpcode() == BO_LOr) { 9759 if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) { 9760 // If it's "a || b && 1 || c" we didn't warn earlier for 9761 // "a || b && 1", but warn now. 9762 if (RBop->getOpcode() == BO_LAnd && EvaluatesAsTrue(S, RBop->getRHS())) 9763 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop); 9764 } 9765 } 9766 } 9767} 9768 9769/// \brief Look for '&&' in the right hand of a '||' expr. 9770static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, 9771 Expr *LHSExpr, Expr *RHSExpr) { 9772 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(RHSExpr)) { 9773 if (Bop->getOpcode() == BO_LAnd) { 9774 // If it's "0 || a && b" don't warn since the precedence doesn't matter. 9775 if (EvaluatesAsFalse(S, LHSExpr)) 9776 return; 9777 // If it's "a || b && 1" don't warn since the precedence doesn't matter. 9778 if (!EvaluatesAsTrue(S, Bop->getRHS())) 9779 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 9780 } 9781 } 9782} 9783 9784/// \brief Look for '&' in the left or right hand of a '|' expr. 9785static void DiagnoseBitwiseAndInBitwiseOr(Sema &S, SourceLocation OpLoc, 9786 Expr *OrArg) { 9787 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrArg)) { 9788 if (Bop->getOpcode() == BO_And) 9789 return EmitDiagnosticForBitwiseAndInBitwiseOr(S, OpLoc, Bop); 9790 } 9791} 9792 9793static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc, 9794 Expr *SubExpr, StringRef Shift) { 9795 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) { 9796 if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) { 9797 StringRef Op = Bop->getOpcodeStr(); 9798 S.Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift) 9799 << Bop->getSourceRange() << OpLoc << Shift << Op; 9800 SuggestParentheses(S, Bop->getOperatorLoc(), 9801 S.PDiag(diag::note_precedence_silence) << Op, 9802 Bop->getSourceRange()); 9803 } 9804 } 9805} 9806 9807static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, 9808 Expr *LHSExpr, Expr *RHSExpr) { 9809 CXXOperatorCallExpr *OCE = dyn_cast<CXXOperatorCallExpr>(LHSExpr); 9810 if (!OCE) 9811 return; 9812 9813 FunctionDecl *FD = OCE->getDirectCallee(); 9814 if (!FD || !FD->isOverloadedOperator()) 9815 return; 9816 9817 OverloadedOperatorKind Kind = FD->getOverloadedOperator(); 9818 if (Kind != OO_LessLess && Kind != OO_GreaterGreater) 9819 return; 9820 9821 S.Diag(OpLoc, diag::warn_overloaded_shift_in_comparison) 9822 << LHSExpr->getSourceRange() << RHSExpr->getSourceRange() 9823 << (Kind == OO_LessLess); 9824 SuggestParentheses(S, OCE->getOperatorLoc(), 9825 S.PDiag(diag::note_precedence_silence) 9826 << (Kind == OO_LessLess ? "<<" : ">>"), 9827 OCE->getSourceRange()); 9828 SuggestParentheses(S, OpLoc, 9829 S.PDiag(diag::note_evaluate_comparison_first), 9830 SourceRange(OCE->getArg(1)->getLocStart(), 9831 RHSExpr->getLocEnd())); 9832} 9833 9834/// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky 9835/// precedence. 9836static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc, 9837 SourceLocation OpLoc, Expr *LHSExpr, 9838 Expr *RHSExpr){ 9839 // Diagnose "arg1 'bitwise' arg2 'eq' arg3". 9840 if (BinaryOperator::isBitwiseOp(Opc)) 9841 DiagnoseBitwisePrecedence(Self, Opc, OpLoc, LHSExpr, RHSExpr); 9842 9843 // Diagnose "arg1 & arg2 | arg3" 9844 if (Opc == BO_Or && !OpLoc.isMacroID()/* Don't warn in macros. */) { 9845 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, LHSExpr); 9846 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, RHSExpr); 9847 } 9848 9849 // Warn about arg1 || arg2 && arg3, as GCC 4.3+ does. 9850 // We don't warn for 'assert(a || b && "bad")' since this is safe. 9851 if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) { 9852 DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, LHSExpr, RHSExpr); 9853 DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, LHSExpr, RHSExpr); 9854 } 9855 9856 if ((Opc == BO_Shl && LHSExpr->getType()->isIntegralType(Self.getASTContext())) 9857 || Opc == BO_Shr) { 9858 StringRef Shift = BinaryOperator::getOpcodeStr(Opc); 9859 DiagnoseAdditionInShift(Self, OpLoc, LHSExpr, Shift); 9860 DiagnoseAdditionInShift(Self, OpLoc, RHSExpr, Shift); 9861 } 9862 9863 // Warn on overloaded shift operators and comparisons, such as: 9864 // cout << 5 == 4; 9865 if (BinaryOperator::isComparisonOp(Opc)) 9866 DiagnoseShiftCompare(Self, OpLoc, LHSExpr, RHSExpr); 9867} 9868 9869// Binary Operators. 'Tok' is the token for the operator. 9870ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc, 9871 tok::TokenKind Kind, 9872 Expr *LHSExpr, Expr *RHSExpr) { 9873 BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind); 9874 assert(LHSExpr && "ActOnBinOp(): missing left expression"); 9875 assert(RHSExpr && "ActOnBinOp(): missing right expression"); 9876 9877 // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0" 9878 DiagnoseBinOpPrecedence(*this, Opc, TokLoc, LHSExpr, RHSExpr); 9879 9880 return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr); 9881} 9882 9883/// Build an overloaded binary operator expression in the given scope. 9884static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc, 9885 BinaryOperatorKind Opc, 9886 Expr *LHS, Expr *RHS) { 9887 // Find all of the overloaded operators visible from this 9888 // point. We perform both an operator-name lookup from the local 9889 // scope and an argument-dependent lookup based on the types of 9890 // the arguments. 9891 UnresolvedSet<16> Functions; 9892 OverloadedOperatorKind OverOp 9893 = BinaryOperator::getOverloadedOperator(Opc); 9894 if (Sc && OverOp != OO_None && OverOp != OO_Equal) 9895 S.LookupOverloadedOperatorName(OverOp, Sc, LHS->getType(), 9896 RHS->getType(), Functions); 9897 9898 // Build the (potentially-overloaded, potentially-dependent) 9899 // binary operation. 9900 return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS); 9901} 9902 9903ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc, 9904 BinaryOperatorKind Opc, 9905 Expr *LHSExpr, Expr *RHSExpr) { 9906 // We want to end up calling one of checkPseudoObjectAssignment 9907 // (if the LHS is a pseudo-object), BuildOverloadedBinOp (if 9908 // both expressions are overloadable or either is type-dependent), 9909 // or CreateBuiltinBinOp (in any other case). We also want to get 9910 // any placeholder types out of the way. 9911 9912 // Handle pseudo-objects in the LHS. 9913 if (const BuiltinType *pty = LHSExpr->getType()->getAsPlaceholderType()) { 9914 // Assignments with a pseudo-object l-value need special analysis. 9915 if (pty->getKind() == BuiltinType::PseudoObject && 9916 BinaryOperator::isAssignmentOp(Opc)) 9917 return checkPseudoObjectAssignment(S, OpLoc, Opc, LHSExpr, RHSExpr); 9918 9919 // Don't resolve overloads if the other type is overloadable. 9920 if (pty->getKind() == BuiltinType::Overload) { 9921 // We can't actually test that if we still have a placeholder, 9922 // though. Fortunately, none of the exceptions we see in that 9923 // code below are valid when the LHS is an overload set. Note 9924 // that an overload set can be dependently-typed, but it never 9925 // instantiates to having an overloadable type. 9926 ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr); 9927 if (resolvedRHS.isInvalid()) return ExprError(); 9928 RHSExpr = resolvedRHS.get(); 9929 9930 if (RHSExpr->isTypeDependent() || 9931 RHSExpr->getType()->isOverloadableType()) 9932 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9933 } 9934 9935 ExprResult LHS = CheckPlaceholderExpr(LHSExpr); 9936 if (LHS.isInvalid()) return ExprError(); 9937 LHSExpr = LHS.get(); 9938 } 9939 9940 // Handle pseudo-objects in the RHS. 9941 if (const BuiltinType *pty = RHSExpr->getType()->getAsPlaceholderType()) { 9942 // An overload in the RHS can potentially be resolved by the type 9943 // being assigned to. 9944 if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) { 9945 if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent()) 9946 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9947 9948 if (LHSExpr->getType()->isOverloadableType()) 9949 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9950 9951 return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr); 9952 } 9953 9954 // Don't resolve overloads if the other type is overloadable. 9955 if (pty->getKind() == BuiltinType::Overload && 9956 LHSExpr->getType()->isOverloadableType()) 9957 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9958 9959 ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr); 9960 if (!resolvedRHS.isUsable()) return ExprError(); 9961 RHSExpr = resolvedRHS.get(); 9962 } 9963 9964 if (getLangOpts().CPlusPlus) { 9965 // If either expression is type-dependent, always build an 9966 // overloaded op. 9967 if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent()) 9968 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9969 9970 // Otherwise, build an overloaded op if either expression has an 9971 // overloadable type. 9972 if (LHSExpr->getType()->isOverloadableType() || 9973 RHSExpr->getType()->isOverloadableType()) 9974 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 9975 } 9976 9977 // Build a built-in binary operation. 9978 return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr); 9979} 9980 9981ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc, 9982 UnaryOperatorKind Opc, 9983 Expr *InputExpr) { 9984 ExprResult Input = InputExpr; 9985 ExprValueKind VK = VK_RValue; 9986 ExprObjectKind OK = OK_Ordinary; 9987 QualType resultType; 9988 switch (Opc) { 9989 case UO_PreInc: 9990 case UO_PreDec: 9991 case UO_PostInc: 9992 case UO_PostDec: 9993 resultType = CheckIncrementDecrementOperand(*this, Input.get(), VK, OK, 9994 OpLoc, 9995 Opc == UO_PreInc || 9996 Opc == UO_PostInc, 9997 Opc == UO_PreInc || 9998 Opc == UO_PreDec); 9999 break; 10000 case UO_AddrOf: 10001 resultType = CheckAddressOfOperand(Input, OpLoc); 10002 RecordModifiableNonNullParam(*this, InputExpr); 10003 break; 10004 case UO_Deref: { 10005 Input = DefaultFunctionArrayLvalueConversion(Input.get()); 10006 if (Input.isInvalid()) return ExprError(); 10007 resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc); 10008 break; 10009 } 10010 case UO_Plus: 10011 case UO_Minus: 10012 Input = UsualUnaryConversions(Input.get()); 10013 if (Input.isInvalid()) return ExprError(); 10014 resultType = Input.get()->getType(); 10015 if (resultType->isDependentType()) 10016 break; 10017 if (resultType->isArithmeticType() || // C99 6.5.3.3p1 10018 resultType->isVectorType()) 10019 break; 10020 else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6 10021 Opc == UO_Plus && 10022 resultType->isPointerType()) 10023 break; 10024 10025 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10026 << resultType << Input.get()->getSourceRange()); 10027 10028 case UO_Not: // bitwise complement 10029 Input = UsualUnaryConversions(Input.get()); 10030 if (Input.isInvalid()) 10031 return ExprError(); 10032 resultType = Input.get()->getType(); 10033 if (resultType->isDependentType()) 10034 break; 10035 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension. 10036 if (resultType->isComplexType() || resultType->isComplexIntegerType()) 10037 // C99 does not support '~' for complex conjugation. 10038 Diag(OpLoc, diag::ext_integer_complement_complex) 10039 << resultType << Input.get()->getSourceRange(); 10040 else if (resultType->hasIntegerRepresentation()) 10041 break; 10042 else if (resultType->isExtVectorType()) { 10043 if (Context.getLangOpts().OpenCL) { 10044 // OpenCL v1.1 s6.3.f: The bitwise operator not (~) does not operate 10045 // on vector float types. 10046 QualType T = resultType->getAs<ExtVectorType>()->getElementType(); 10047 if (!T->isIntegerType()) 10048 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10049 << resultType << Input.get()->getSourceRange()); 10050 } 10051 break; 10052 } else { 10053 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10054 << resultType << Input.get()->getSourceRange()); 10055 } 10056 break; 10057 10058 case UO_LNot: // logical negation 10059 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5). 10060 Input = DefaultFunctionArrayLvalueConversion(Input.get()); 10061 if (Input.isInvalid()) return ExprError(); 10062 resultType = Input.get()->getType(); 10063 10064 // Though we still have to promote half FP to float... 10065 if (resultType->isHalfType() && !Context.getLangOpts().NativeHalfType) { 10066 Input = ImpCastExprToType(Input.get(), Context.FloatTy, CK_FloatingCast).get(); 10067 resultType = Context.FloatTy; 10068 } 10069 10070 if (resultType->isDependentType()) 10071 break; 10072 if (resultType->isScalarType() && !isScopedEnumerationType(resultType)) { 10073 // C99 6.5.3.3p1: ok, fallthrough; 10074 if (Context.getLangOpts().CPlusPlus) { 10075 // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9: 10076 // operand contextually converted to bool. 10077 Input = ImpCastExprToType(Input.get(), Context.BoolTy, 10078 ScalarTypeToBooleanCastKind(resultType)); 10079 } else if (Context.getLangOpts().OpenCL && 10080 Context.getLangOpts().OpenCLVersion < 120) { 10081 // OpenCL v1.1 6.3.h: The logical operator not (!) does not 10082 // operate on scalar float types. 10083 if (!resultType->isIntegerType()) 10084 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10085 << resultType << Input.get()->getSourceRange()); 10086 } 10087 } else if (resultType->isExtVectorType()) { 10088 if (Context.getLangOpts().OpenCL && 10089 Context.getLangOpts().OpenCLVersion < 120) { 10090 // OpenCL v1.1 6.3.h: The logical operator not (!) does not 10091 // operate on vector float types. 10092 QualType T = resultType->getAs<ExtVectorType>()->getElementType(); 10093 if (!T->isIntegerType()) 10094 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10095 << resultType << Input.get()->getSourceRange()); 10096 } 10097 // Vector logical not returns the signed variant of the operand type. 10098 resultType = GetSignedVectorType(resultType); 10099 break; 10100 } else { 10101 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 10102 << resultType << Input.get()->getSourceRange()); 10103 } 10104 10105 // LNot always has type int. C99 6.5.3.3p5. 10106 // In C++, it's bool. C++ 5.3.1p8 10107 resultType = Context.getLogicalOperationType(); 10108 break; 10109 case UO_Real: 10110 case UO_Imag: 10111 resultType = CheckRealImagOperand(*this, Input, OpLoc, Opc == UO_Real); 10112 // _Real maps ordinary l-values into ordinary l-values. _Imag maps ordinary 10113 // complex l-values to ordinary l-values and all other values to r-values. 10114 if (Input.isInvalid()) return ExprError(); 10115 if (Opc == UO_Real || Input.get()->getType()->isAnyComplexType()) { 10116 if (Input.get()->getValueKind() != VK_RValue && 10117 Input.get()->getObjectKind() == OK_Ordinary) 10118 VK = Input.get()->getValueKind(); 10119 } else if (!getLangOpts().CPlusPlus) { 10120 // In C, a volatile scalar is read by __imag. In C++, it is not. 10121 Input = DefaultLvalueConversion(Input.get()); 10122 } 10123 break; 10124 case UO_Extension: 10125 resultType = Input.get()->getType(); 10126 VK = Input.get()->getValueKind(); 10127 OK = Input.get()->getObjectKind(); 10128 break; 10129 } 10130 if (resultType.isNull() || Input.isInvalid()) 10131 return ExprError(); 10132 10133 // Check for array bounds violations in the operand of the UnaryOperator, 10134 // except for the '*' and '&' operators that have to be handled specially 10135 // by CheckArrayAccess (as there are special cases like &array[arraysize] 10136 // that are explicitly defined as valid by the standard). 10137 if (Opc != UO_AddrOf && Opc != UO_Deref) 10138 CheckArrayAccess(Input.get()); 10139 10140 return new (Context) 10141 UnaryOperator(Input.get(), Opc, resultType, VK, OK, OpLoc); 10142} 10143 10144/// \brief Determine whether the given expression is a qualified member 10145/// access expression, of a form that could be turned into a pointer to member 10146/// with the address-of operator. 10147static bool isQualifiedMemberAccess(Expr *E) { 10148 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 10149 if (!DRE->getQualifier()) 10150 return false; 10151 10152 ValueDecl *VD = DRE->getDecl(); 10153 if (!VD->isCXXClassMember()) 10154 return false; 10155 10156 if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD)) 10157 return true; 10158 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(VD)) 10159 return Method->isInstance(); 10160 10161 return false; 10162 } 10163 10164 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) { 10165 if (!ULE->getQualifier()) 10166 return false; 10167 10168 for (UnresolvedLookupExpr::decls_iterator D = ULE->decls_begin(), 10169 DEnd = ULE->decls_end(); 10170 D != DEnd; ++D) { 10171 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(*D)) { 10172 if (Method->isInstance()) 10173 return true; 10174 } else { 10175 // Overload set does not contain methods. 10176 break; 10177 } 10178 } 10179 10180 return false; 10181 } 10182 10183 return false; 10184} 10185 10186ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc, 10187 UnaryOperatorKind Opc, Expr *Input) { 10188 // First things first: handle placeholders so that the 10189 // overloaded-operator check considers the right type. 10190 if (const BuiltinType *pty = Input->getType()->getAsPlaceholderType()) { 10191 // Increment and decrement of pseudo-object references. 10192 if (pty->getKind() == BuiltinType::PseudoObject && 10193 UnaryOperator::isIncrementDecrementOp(Opc)) 10194 return checkPseudoObjectIncDec(S, OpLoc, Opc, Input); 10195 10196 // extension is always a builtin operator. 10197 if (Opc == UO_Extension) 10198 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 10199 10200 // & gets special logic for several kinds of placeholder. 10201 // The builtin code knows what to do. 10202 if (Opc == UO_AddrOf && 10203 (pty->getKind() == BuiltinType::Overload || 10204 pty->getKind() == BuiltinType::UnknownAny || 10205 pty->getKind() == BuiltinType::BoundMember)) 10206 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 10207 10208 // Anything else needs to be handled now. 10209 ExprResult Result = CheckPlaceholderExpr(Input); 10210 if (Result.isInvalid()) return ExprError(); 10211 Input = Result.get(); 10212 } 10213 10214 if (getLangOpts().CPlusPlus && Input->getType()->isOverloadableType() && 10215 UnaryOperator::getOverloadedOperator(Opc) != OO_None && 10216 !(Opc == UO_AddrOf && isQualifiedMemberAccess(Input))) { 10217 // Find all of the overloaded operators visible from this 10218 // point. We perform both an operator-name lookup from the local 10219 // scope and an argument-dependent lookup based on the types of 10220 // the arguments. 10221 UnresolvedSet<16> Functions; 10222 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc); 10223 if (S && OverOp != OO_None) 10224 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(), 10225 Functions); 10226 10227 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input); 10228 } 10229 10230 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 10231} 10232 10233// Unary Operators. 'Tok' is the token for the operator. 10234ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc, 10235 tok::TokenKind Op, Expr *Input) { 10236 return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input); 10237} 10238 10239/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo". 10240ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, 10241 LabelDecl *TheDecl) { 10242 TheDecl->markUsed(Context); 10243 // Create the AST node. The address of a label always has type 'void*'. 10244 return new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl, 10245 Context.getPointerType(Context.VoidTy)); 10246} 10247 10248/// Given the last statement in a statement-expression, check whether 10249/// the result is a producing expression (like a call to an 10250/// ns_returns_retained function) and, if so, rebuild it to hoist the 10251/// release out of the full-expression. Otherwise, return null. 10252/// Cannot fail. 10253static Expr *maybeRebuildARCConsumingStmt(Stmt *Statement) { 10254 // Should always be wrapped with one of these. 10255 ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(Statement); 10256 if (!cleanups) return nullptr; 10257 10258 ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(cleanups->getSubExpr()); 10259 if (!cast || cast->getCastKind() != CK_ARCConsumeObject) 10260 return nullptr; 10261 10262 // Splice out the cast. This shouldn't modify any interesting 10263 // features of the statement. 10264 Expr *producer = cast->getSubExpr(); 10265 assert(producer->getType() == cast->getType()); 10266 assert(producer->getValueKind() == cast->getValueKind()); 10267 cleanups->setSubExpr(producer); 10268 return cleanups; 10269} 10270 10271void Sema::ActOnStartStmtExpr() { 10272 PushExpressionEvaluationContext(ExprEvalContexts.back().Context); 10273} 10274 10275void Sema::ActOnStmtExprError() { 10276 // Note that function is also called by TreeTransform when leaving a 10277 // StmtExpr scope without rebuilding anything. 10278 10279 DiscardCleanupsInEvaluationContext(); 10280 PopExpressionEvaluationContext(); 10281} 10282 10283ExprResult 10284Sema::ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, 10285 SourceLocation RPLoc) { // "({..})" 10286 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!"); 10287 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt); 10288 10289 if (hasAnyUnrecoverableErrorsInThisFunction()) 10290 DiscardCleanupsInEvaluationContext(); 10291 assert(!ExprNeedsCleanups && "cleanups within StmtExpr not correctly bound!"); 10292 PopExpressionEvaluationContext(); 10293 10294 // FIXME: there are a variety of strange constraints to enforce here, for 10295 // example, it is not possible to goto into a stmt expression apparently. 10296 // More semantic analysis is needed. 10297 10298 // If there are sub-stmts in the compound stmt, take the type of the last one 10299 // as the type of the stmtexpr. 10300 QualType Ty = Context.VoidTy; 10301 bool StmtExprMayBindToTemp = false; 10302 if (!Compound->body_empty()) { 10303 Stmt *LastStmt = Compound->body_back(); 10304 LabelStmt *LastLabelStmt = nullptr; 10305 // If LastStmt is a label, skip down through into the body. 10306 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt)) { 10307 LastLabelStmt = Label; 10308 LastStmt = Label->getSubStmt(); 10309 } 10310 10311 if (Expr *LastE = dyn_cast<Expr>(LastStmt)) { 10312 // Do function/array conversion on the last expression, but not 10313 // lvalue-to-rvalue. However, initialize an unqualified type. 10314 ExprResult LastExpr = DefaultFunctionArrayConversion(LastE); 10315 if (LastExpr.isInvalid()) 10316 return ExprError(); 10317 Ty = LastExpr.get()->getType().getUnqualifiedType(); 10318 10319 if (!Ty->isDependentType() && !LastExpr.get()->isTypeDependent()) { 10320 // In ARC, if the final expression ends in a consume, splice 10321 // the consume out and bind it later. In the alternate case 10322 // (when dealing with a retainable type), the result 10323 // initialization will create a produce. In both cases the 10324 // result will be +1, and we'll need to balance that out with 10325 // a bind. 10326 if (Expr *rebuiltLastStmt 10327 = maybeRebuildARCConsumingStmt(LastExpr.get())) { 10328 LastExpr = rebuiltLastStmt; 10329 } else { 10330 LastExpr = PerformCopyInitialization( 10331 InitializedEntity::InitializeResult(LPLoc, 10332 Ty, 10333 false), 10334 SourceLocation(), 10335 LastExpr); 10336 } 10337 10338 if (LastExpr.isInvalid()) 10339 return ExprError(); 10340 if (LastExpr.get() != nullptr) { 10341 if (!LastLabelStmt) 10342 Compound->setLastStmt(LastExpr.get()); 10343 else 10344 LastLabelStmt->setSubStmt(LastExpr.get()); 10345 StmtExprMayBindToTemp = true; 10346 } 10347 } 10348 } 10349 } 10350 10351 // FIXME: Check that expression type is complete/non-abstract; statement 10352 // expressions are not lvalues. 10353 Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc); 10354 if (StmtExprMayBindToTemp) 10355 return MaybeBindToTemporary(ResStmtExpr); 10356 return ResStmtExpr; 10357} 10358 10359ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, 10360 TypeSourceInfo *TInfo, 10361 OffsetOfComponent *CompPtr, 10362 unsigned NumComponents, 10363 SourceLocation RParenLoc) { 10364 QualType ArgTy = TInfo->getType(); 10365 bool Dependent = ArgTy->isDependentType(); 10366 SourceRange TypeRange = TInfo->getTypeLoc().getLocalSourceRange(); 10367 10368 // We must have at least one component that refers to the type, and the first 10369 // one is known to be a field designator. Verify that the ArgTy represents 10370 // a struct/union/class. 10371 if (!Dependent && !ArgTy->isRecordType()) 10372 return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type) 10373 << ArgTy << TypeRange); 10374 10375 // Type must be complete per C99 7.17p3 because a declaring a variable 10376 // with an incomplete type would be ill-formed. 10377 if (!Dependent 10378 && RequireCompleteType(BuiltinLoc, ArgTy, 10379 diag::err_offsetof_incomplete_type, TypeRange)) 10380 return ExprError(); 10381 10382 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a 10383 // GCC extension, diagnose them. 10384 // FIXME: This diagnostic isn't actually visible because the location is in 10385 // a system header! 10386 if (NumComponents != 1) 10387 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator) 10388 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd); 10389 10390 bool DidWarnAboutNonPOD = false; 10391 QualType CurrentType = ArgTy; 10392 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode; 10393 SmallVector<OffsetOfNode, 4> Comps; 10394 SmallVector<Expr*, 4> Exprs; 10395 for (unsigned i = 0; i != NumComponents; ++i) { 10396 const OffsetOfComponent &OC = CompPtr[i]; 10397 if (OC.isBrackets) { 10398 // Offset of an array sub-field. TODO: Should we allow vector elements? 10399 if (!CurrentType->isDependentType()) { 10400 const ArrayType *AT = Context.getAsArrayType(CurrentType); 10401 if(!AT) 10402 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type) 10403 << CurrentType); 10404 CurrentType = AT->getElementType(); 10405 } else 10406 CurrentType = Context.DependentTy; 10407 10408 ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr*>(OC.U.E)); 10409 if (IdxRval.isInvalid()) 10410 return ExprError(); 10411 Expr *Idx = IdxRval.get(); 10412 10413 // The expression must be an integral expression. 10414 // FIXME: An integral constant expression? 10415 if (!Idx->isTypeDependent() && !Idx->isValueDependent() && 10416 !Idx->getType()->isIntegerType()) 10417 return ExprError(Diag(Idx->getLocStart(), 10418 diag::err_typecheck_subscript_not_integer) 10419 << Idx->getSourceRange()); 10420 10421 // Record this array index. 10422 Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd)); 10423 Exprs.push_back(Idx); 10424 continue; 10425 } 10426 10427 // Offset of a field. 10428 if (CurrentType->isDependentType()) { 10429 // We have the offset of a field, but we can't look into the dependent 10430 // type. Just record the identifier of the field. 10431 Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd)); 10432 CurrentType = Context.DependentTy; 10433 continue; 10434 } 10435 10436 // We need to have a complete type to look into. 10437 if (RequireCompleteType(OC.LocStart, CurrentType, 10438 diag::err_offsetof_incomplete_type)) 10439 return ExprError(); 10440 10441 // Look for the designated field. 10442 const RecordType *RC = CurrentType->getAs<RecordType>(); 10443 if (!RC) 10444 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type) 10445 << CurrentType); 10446 RecordDecl *RD = RC->getDecl(); 10447 10448 // C++ [lib.support.types]p5: 10449 // The macro offsetof accepts a restricted set of type arguments in this 10450 // International Standard. type shall be a POD structure or a POD union 10451 // (clause 9). 10452 // C++11 [support.types]p4: 10453 // If type is not a standard-layout class (Clause 9), the results are 10454 // undefined. 10455 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) { 10456 bool IsSafe = LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD(); 10457 unsigned DiagID = 10458 LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type 10459 : diag::ext_offsetof_non_pod_type; 10460 10461 if (!IsSafe && !DidWarnAboutNonPOD && 10462 DiagRuntimeBehavior(BuiltinLoc, nullptr, 10463 PDiag(DiagID) 10464 << SourceRange(CompPtr[0].LocStart, OC.LocEnd) 10465 << CurrentType)) 10466 DidWarnAboutNonPOD = true; 10467 } 10468 10469 // Look for the field. 10470 LookupResult R(*this, OC.U.IdentInfo, OC.LocStart, LookupMemberName); 10471 LookupQualifiedName(R, RD); 10472 FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>(); 10473 IndirectFieldDecl *IndirectMemberDecl = nullptr; 10474 if (!MemberDecl) { 10475 if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>())) 10476 MemberDecl = IndirectMemberDecl->getAnonField(); 10477 } 10478 10479 if (!MemberDecl) 10480 return ExprError(Diag(BuiltinLoc, diag::err_no_member) 10481 << OC.U.IdentInfo << RD << SourceRange(OC.LocStart, 10482 OC.LocEnd)); 10483 10484 // C99 7.17p3: 10485 // (If the specified member is a bit-field, the behavior is undefined.) 10486 // 10487 // We diagnose this as an error. 10488 if (MemberDecl->isBitField()) { 10489 Diag(OC.LocEnd, diag::err_offsetof_bitfield) 10490 << MemberDecl->getDeclName() 10491 << SourceRange(BuiltinLoc, RParenLoc); 10492 Diag(MemberDecl->getLocation(), diag::note_bitfield_decl); 10493 return ExprError(); 10494 } 10495 10496 RecordDecl *Parent = MemberDecl->getParent(); 10497 if (IndirectMemberDecl) 10498 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext()); 10499 10500 // If the member was found in a base class, introduce OffsetOfNodes for 10501 // the base class indirections. 10502 CXXBasePaths Paths; 10503 if (IsDerivedFrom(CurrentType, Context.getTypeDeclType(Parent), Paths)) { 10504 if (Paths.getDetectedVirtual()) { 10505 Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base) 10506 << MemberDecl->getDeclName() 10507 << SourceRange(BuiltinLoc, RParenLoc); 10508 return ExprError(); 10509 } 10510 10511 CXXBasePath &Path = Paths.front(); 10512 for (CXXBasePath::iterator B = Path.begin(), BEnd = Path.end(); 10513 B != BEnd; ++B) 10514 Comps.push_back(OffsetOfNode(B->Base)); 10515 } 10516 10517 if (IndirectMemberDecl) { 10518 for (auto *FI : IndirectMemberDecl->chain()) { 10519 assert(isa<FieldDecl>(FI)); 10520 Comps.push_back(OffsetOfNode(OC.LocStart, 10521 cast<FieldDecl>(FI), OC.LocEnd)); 10522 } 10523 } else 10524 Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd)); 10525 10526 CurrentType = MemberDecl->getType().getNonReferenceType(); 10527 } 10528 10529 return OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc, TInfo, 10530 Comps, Exprs, RParenLoc); 10531} 10532 10533ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S, 10534 SourceLocation BuiltinLoc, 10535 SourceLocation TypeLoc, 10536 ParsedType ParsedArgTy, 10537 OffsetOfComponent *CompPtr, 10538 unsigned NumComponents, 10539 SourceLocation RParenLoc) { 10540 10541 TypeSourceInfo *ArgTInfo; 10542 QualType ArgTy = GetTypeFromParser(ParsedArgTy, &ArgTInfo); 10543 if (ArgTy.isNull()) 10544 return ExprError(); 10545 10546 if (!ArgTInfo) 10547 ArgTInfo = Context.getTrivialTypeSourceInfo(ArgTy, TypeLoc); 10548 10549 return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, CompPtr, NumComponents, 10550 RParenLoc); 10551} 10552 10553 10554ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, 10555 Expr *CondExpr, 10556 Expr *LHSExpr, Expr *RHSExpr, 10557 SourceLocation RPLoc) { 10558 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)"); 10559 10560 ExprValueKind VK = VK_RValue; 10561 ExprObjectKind OK = OK_Ordinary; 10562 QualType resType; 10563 bool ValueDependent = false; 10564 bool CondIsTrue = false; 10565 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) { 10566 resType = Context.DependentTy; 10567 ValueDependent = true; 10568 } else { 10569 // The conditional expression is required to be a constant expression. 10570 llvm::APSInt condEval(32); 10571 ExprResult CondICE 10572 = VerifyIntegerConstantExpression(CondExpr, &condEval, 10573 diag::err_typecheck_choose_expr_requires_constant, false); 10574 if (CondICE.isInvalid()) 10575 return ExprError(); 10576 CondExpr = CondICE.get(); 10577 CondIsTrue = condEval.getZExtValue(); 10578 10579 // If the condition is > zero, then the AST type is the same as the LSHExpr. 10580 Expr *ActiveExpr = CondIsTrue ? LHSExpr : RHSExpr; 10581 10582 resType = ActiveExpr->getType(); 10583 ValueDependent = ActiveExpr->isValueDependent(); 10584 VK = ActiveExpr->getValueKind(); 10585 OK = ActiveExpr->getObjectKind(); 10586 } 10587 10588 return new (Context) 10589 ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, resType, VK, OK, RPLoc, 10590 CondIsTrue, resType->isDependentType(), ValueDependent); 10591} 10592 10593//===----------------------------------------------------------------------===// 10594// Clang Extensions. 10595//===----------------------------------------------------------------------===// 10596 10597/// ActOnBlockStart - This callback is invoked when a block literal is started. 10598void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope) { 10599 BlockDecl *Block = BlockDecl::Create(Context, CurContext, CaretLoc); 10600 10601 if (LangOpts.CPlusPlus) { 10602 Decl *ManglingContextDecl; 10603 if (MangleNumberingContext *MCtx = 10604 getCurrentMangleNumberContext(Block->getDeclContext(), 10605 ManglingContextDecl)) { 10606 unsigned ManglingNumber = MCtx->getManglingNumber(Block); 10607 Block->setBlockMangling(ManglingNumber, ManglingContextDecl); 10608 } 10609 } 10610 10611 PushBlockScope(CurScope, Block); 10612 CurContext->addDecl(Block); 10613 if (CurScope) 10614 PushDeclContext(CurScope, Block); 10615 else 10616 CurContext = Block; 10617 10618 getCurBlock()->HasImplicitReturnType = true; 10619 10620 // Enter a new evaluation context to insulate the block from any 10621 // cleanups from the enclosing full-expression. 10622 PushExpressionEvaluationContext(PotentiallyEvaluated); 10623} 10624 10625void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo, 10626 Scope *CurScope) { 10627 assert(ParamInfo.getIdentifier() == nullptr && 10628 "block-id should have no identifier!"); 10629 assert(ParamInfo.getContext() == Declarator::BlockLiteralContext); 10630 BlockScopeInfo *CurBlock = getCurBlock(); 10631 10632 TypeSourceInfo *Sig = GetTypeForDeclarator(ParamInfo, CurScope); 10633 QualType T = Sig->getType(); 10634 10635 // FIXME: We should allow unexpanded parameter packs here, but that would, 10636 // in turn, make the block expression contain unexpanded parameter packs. 10637 if (DiagnoseUnexpandedParameterPack(CaretLoc, Sig, UPPC_Block)) { 10638 // Drop the parameters. 10639 FunctionProtoType::ExtProtoInfo EPI; 10640 EPI.HasTrailingReturn = false; 10641 EPI.TypeQuals |= DeclSpec::TQ_const; 10642 T = Context.getFunctionType(Context.DependentTy, None, EPI); 10643 Sig = Context.getTrivialTypeSourceInfo(T); 10644 } 10645 10646 // GetTypeForDeclarator always produces a function type for a block 10647 // literal signature. Furthermore, it is always a FunctionProtoType 10648 // unless the function was written with a typedef. 10649 assert(T->isFunctionType() && 10650 "GetTypeForDeclarator made a non-function block signature"); 10651 10652 // Look for an explicit signature in that function type. 10653 FunctionProtoTypeLoc ExplicitSignature; 10654 10655 TypeLoc tmp = Sig->getTypeLoc().IgnoreParens(); 10656 if ((ExplicitSignature = tmp.getAs<FunctionProtoTypeLoc>())) { 10657 10658 // Check whether that explicit signature was synthesized by 10659 // GetTypeForDeclarator. If so, don't save that as part of the 10660 // written signature. 10661 if (ExplicitSignature.getLocalRangeBegin() == 10662 ExplicitSignature.getLocalRangeEnd()) { 10663 // This would be much cheaper if we stored TypeLocs instead of 10664 // TypeSourceInfos. 10665 TypeLoc Result = ExplicitSignature.getReturnLoc(); 10666 unsigned Size = Result.getFullDataSize(); 10667 Sig = Context.CreateTypeSourceInfo(Result.getType(), Size); 10668 Sig->getTypeLoc().initializeFullCopy(Result, Size); 10669 10670 ExplicitSignature = FunctionProtoTypeLoc(); 10671 } 10672 } 10673 10674 CurBlock->TheDecl->setSignatureAsWritten(Sig); 10675 CurBlock->FunctionType = T; 10676 10677 const FunctionType *Fn = T->getAs<FunctionType>(); 10678 QualType RetTy = Fn->getReturnType(); 10679 bool isVariadic = 10680 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic()); 10681 10682 CurBlock->TheDecl->setIsVariadic(isVariadic); 10683 10684 // Context.DependentTy is used as a placeholder for a missing block 10685 // return type. TODO: what should we do with declarators like: 10686 // ^ * { ... } 10687 // If the answer is "apply template argument deduction".... 10688 if (RetTy != Context.DependentTy) { 10689 CurBlock->ReturnType = RetTy; 10690 CurBlock->TheDecl->setBlockMissingReturnType(false); 10691 CurBlock->HasImplicitReturnType = false; 10692 } 10693 10694 // Push block parameters from the declarator if we had them. 10695 SmallVector<ParmVarDecl*, 8> Params; 10696 if (ExplicitSignature) { 10697 for (unsigned I = 0, E = ExplicitSignature.getNumParams(); I != E; ++I) { 10698 ParmVarDecl *Param = ExplicitSignature.getParam(I); 10699 if (Param->getIdentifier() == nullptr && 10700 !Param->isImplicit() && 10701 !Param->isInvalidDecl() && 10702 !getLangOpts().CPlusPlus) 10703 Diag(Param->getLocation(), diag::err_parameter_name_omitted); 10704 Params.push_back(Param); 10705 } 10706 10707 // Fake up parameter variables if we have a typedef, like 10708 // ^ fntype { ... } 10709 } else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) { 10710 for (const auto &I : Fn->param_types()) { 10711 ParmVarDecl *Param = BuildParmVarDeclForTypedef( 10712 CurBlock->TheDecl, ParamInfo.getLocStart(), I); 10713 Params.push_back(Param); 10714 } 10715 } 10716 10717 // Set the parameters on the block decl. 10718 if (!Params.empty()) { 10719 CurBlock->TheDecl->setParams(Params); 10720 CheckParmsForFunctionDef(CurBlock->TheDecl->param_begin(), 10721 CurBlock->TheDecl->param_end(), 10722 /*CheckParameterNames=*/false); 10723 } 10724 10725 // Finally we can process decl attributes. 10726 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo); 10727 10728 // Put the parameter variables in scope. 10729 for (auto AI : CurBlock->TheDecl->params()) { 10730 AI->setOwningFunction(CurBlock->TheDecl); 10731 10732 // If this has an identifier, add it to the scope stack. 10733 if (AI->getIdentifier()) { 10734 CheckShadow(CurBlock->TheScope, AI); 10735 10736 PushOnScopeChains(AI, CurBlock->TheScope); 10737 } 10738 } 10739} 10740 10741/// ActOnBlockError - If there is an error parsing a block, this callback 10742/// is invoked to pop the information about the block from the action impl. 10743void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) { 10744 // Leave the expression-evaluation context. 10745 DiscardCleanupsInEvaluationContext(); 10746 PopExpressionEvaluationContext(); 10747 10748 // Pop off CurBlock, handle nested blocks. 10749 PopDeclContext(); 10750 PopFunctionScopeInfo(); 10751} 10752 10753/// ActOnBlockStmtExpr - This is called when the body of a block statement 10754/// literal was successfully completed. ^(int x){...} 10755ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, 10756 Stmt *Body, Scope *CurScope) { 10757 // If blocks are disabled, emit an error. 10758 if (!LangOpts.Blocks) 10759 Diag(CaretLoc, diag::err_blocks_disable); 10760 10761 // Leave the expression-evaluation context. 10762 if (hasAnyUnrecoverableErrorsInThisFunction()) 10763 DiscardCleanupsInEvaluationContext(); 10764 assert(!ExprNeedsCleanups && "cleanups within block not correctly bound!"); 10765 PopExpressionEvaluationContext(); 10766 10767 BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back()); 10768 10769 if (BSI->HasImplicitReturnType) 10770 deduceClosureReturnType(*BSI); 10771 10772 PopDeclContext(); 10773 10774 QualType RetTy = Context.VoidTy; 10775 if (!BSI->ReturnType.isNull()) 10776 RetTy = BSI->ReturnType; 10777 10778 bool NoReturn = BSI->TheDecl->hasAttr<NoReturnAttr>(); 10779 QualType BlockTy; 10780 10781 // Set the captured variables on the block. 10782 // FIXME: Share capture structure between BlockDecl and CapturingScopeInfo! 10783 SmallVector<BlockDecl::Capture, 4> Captures; 10784 for (unsigned i = 0, e = BSI->Captures.size(); i != e; i++) { 10785 CapturingScopeInfo::Capture &Cap = BSI->Captures[i]; 10786 if (Cap.isThisCapture()) 10787 continue; 10788 BlockDecl::Capture NewCap(Cap.getVariable(), Cap.isBlockCapture(), 10789 Cap.isNested(), Cap.getInitExpr()); 10790 Captures.push_back(NewCap); 10791 } 10792 BSI->TheDecl->setCaptures(Context, Captures.begin(), Captures.end(), 10793 BSI->CXXThisCaptureIndex != 0); 10794 10795 // If the user wrote a function type in some form, try to use that. 10796 if (!BSI->FunctionType.isNull()) { 10797 const FunctionType *FTy = BSI->FunctionType->getAs<FunctionType>(); 10798 10799 FunctionType::ExtInfo Ext = FTy->getExtInfo(); 10800 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true); 10801 10802 // Turn protoless block types into nullary block types. 10803 if (isa<FunctionNoProtoType>(FTy)) { 10804 FunctionProtoType::ExtProtoInfo EPI; 10805 EPI.ExtInfo = Ext; 10806 BlockTy = Context.getFunctionType(RetTy, None, EPI); 10807 10808 // Otherwise, if we don't need to change anything about the function type, 10809 // preserve its sugar structure. 10810 } else if (FTy->getReturnType() == RetTy && 10811 (!NoReturn || FTy->getNoReturnAttr())) { 10812 BlockTy = BSI->FunctionType; 10813 10814 // Otherwise, make the minimal modifications to the function type. 10815 } else { 10816 const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy); 10817 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 10818 EPI.TypeQuals = 0; // FIXME: silently? 10819 EPI.ExtInfo = Ext; 10820 BlockTy = Context.getFunctionType(RetTy, FPT->getParamTypes(), EPI); 10821 } 10822 10823 // If we don't have a function type, just build one from nothing. 10824 } else { 10825 FunctionProtoType::ExtProtoInfo EPI; 10826 EPI.ExtInfo = FunctionType::ExtInfo().withNoReturn(NoReturn); 10827 BlockTy = Context.getFunctionType(RetTy, None, EPI); 10828 } 10829 10830 DiagnoseUnusedParameters(BSI->TheDecl->param_begin(), 10831 BSI->TheDecl->param_end()); 10832 BlockTy = Context.getBlockPointerType(BlockTy); 10833 10834 // If needed, diagnose invalid gotos and switches in the block. 10835 if (getCurFunction()->NeedsScopeChecking() && 10836 !PP.isCodeCompletionEnabled()) 10837 DiagnoseInvalidJumps(cast<CompoundStmt>(Body)); 10838 10839 BSI->TheDecl->setBody(cast<CompoundStmt>(Body)); 10840 10841 // Try to apply the named return value optimization. We have to check again 10842 // if we can do this, though, because blocks keep return statements around 10843 // to deduce an implicit return type. 10844 if (getLangOpts().CPlusPlus && RetTy->isRecordType() && 10845 !BSI->TheDecl->isDependentContext()) 10846 computeNRVO(Body, BSI); 10847 10848 BlockExpr *Result = new (Context) BlockExpr(BSI->TheDecl, BlockTy); 10849 AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy(); 10850 PopFunctionScopeInfo(&WP, Result->getBlockDecl(), Result); 10851 10852 // If the block isn't obviously global, i.e. it captures anything at 10853 // all, then we need to do a few things in the surrounding context: 10854 if (Result->getBlockDecl()->hasCaptures()) { 10855 // First, this expression has a new cleanup object. 10856 ExprCleanupObjects.push_back(Result->getBlockDecl()); 10857 ExprNeedsCleanups = true; 10858 10859 // It also gets a branch-protected scope if any of the captured 10860 // variables needs destruction. 10861 for (const auto &CI : Result->getBlockDecl()->captures()) { 10862 const VarDecl *var = CI.getVariable(); 10863 if (var->getType().isDestructedType() != QualType::DK_none) { 10864 getCurFunction()->setHasBranchProtectedScope(); 10865 break; 10866 } 10867 } 10868 } 10869 10870 return Result; 10871} 10872 10873ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc, 10874 Expr *E, ParsedType Ty, 10875 SourceLocation RPLoc) { 10876 TypeSourceInfo *TInfo; 10877 GetTypeFromParser(Ty, &TInfo); 10878 return BuildVAArgExpr(BuiltinLoc, E, TInfo, RPLoc); 10879} 10880 10881ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, 10882 Expr *E, TypeSourceInfo *TInfo, 10883 SourceLocation RPLoc) { 10884 Expr *OrigExpr = E; 10885 10886 // Get the va_list type 10887 QualType VaListType = Context.getBuiltinVaListType(); 10888 if (VaListType->isArrayType()) { 10889 // Deal with implicit array decay; for example, on x86-64, 10890 // va_list is an array, but it's supposed to decay to 10891 // a pointer for va_arg. 10892 VaListType = Context.getArrayDecayedType(VaListType); 10893 // Make sure the input expression also decays appropriately. 10894 ExprResult Result = UsualUnaryConversions(E); 10895 if (Result.isInvalid()) 10896 return ExprError(); 10897 E = Result.get(); 10898 } else if (VaListType->isRecordType() && getLangOpts().CPlusPlus) { 10899 // If va_list is a record type and we are compiling in C++ mode, 10900 // check the argument using reference binding. 10901 InitializedEntity Entity 10902 = InitializedEntity::InitializeParameter(Context, 10903 Context.getLValueReferenceType(VaListType), false); 10904 ExprResult Init = PerformCopyInitialization(Entity, SourceLocation(), E); 10905 if (Init.isInvalid()) 10906 return ExprError(); 10907 E = Init.getAs<Expr>(); 10908 } else { 10909 // Otherwise, the va_list argument must be an l-value because 10910 // it is modified by va_arg. 10911 if (!E->isTypeDependent() && 10912 CheckForModifiableLvalue(E, BuiltinLoc, *this)) 10913 return ExprError(); 10914 } 10915 10916 if (!E->isTypeDependent() && 10917 !Context.hasSameType(VaListType, E->getType())) { 10918 return ExprError(Diag(E->getLocStart(), 10919 diag::err_first_argument_to_va_arg_not_of_type_va_list) 10920 << OrigExpr->getType() << E->getSourceRange()); 10921 } 10922 10923 if (!TInfo->getType()->isDependentType()) { 10924 if (RequireCompleteType(TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(), 10925 diag::err_second_parameter_to_va_arg_incomplete, 10926 TInfo->getTypeLoc())) 10927 return ExprError(); 10928 10929 if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(), 10930 TInfo->getType(), 10931 diag::err_second_parameter_to_va_arg_abstract, 10932 TInfo->getTypeLoc())) 10933 return ExprError(); 10934 10935 if (!TInfo->getType().isPODType(Context)) { 10936 Diag(TInfo->getTypeLoc().getBeginLoc(), 10937 TInfo->getType()->isObjCLifetimeType() 10938 ? diag::warn_second_parameter_to_va_arg_ownership_qualified 10939 : diag::warn_second_parameter_to_va_arg_not_pod) 10940 << TInfo->getType() 10941 << TInfo->getTypeLoc().getSourceRange(); 10942 } 10943 10944 // Check for va_arg where arguments of the given type will be promoted 10945 // (i.e. this va_arg is guaranteed to have undefined behavior). 10946 QualType PromoteType; 10947 if (TInfo->getType()->isPromotableIntegerType()) { 10948 PromoteType = Context.getPromotedIntegerType(TInfo->getType()); 10949 if (Context.typesAreCompatible(PromoteType, TInfo->getType())) 10950 PromoteType = QualType(); 10951 } 10952 if (TInfo->getType()->isSpecificBuiltinType(BuiltinType::Float)) 10953 PromoteType = Context.DoubleTy; 10954 if (!PromoteType.isNull()) 10955 DiagRuntimeBehavior(TInfo->getTypeLoc().getBeginLoc(), E, 10956 PDiag(diag::warn_second_parameter_to_va_arg_never_compatible) 10957 << TInfo->getType() 10958 << PromoteType 10959 << TInfo->getTypeLoc().getSourceRange()); 10960 } 10961 10962 QualType T = TInfo->getType().getNonLValueExprType(Context); 10963 return new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T); 10964} 10965 10966ExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) { 10967 // The type of __null will be int or long, depending on the size of 10968 // pointers on the target. 10969 QualType Ty; 10970 unsigned pw = Context.getTargetInfo().getPointerWidth(0); 10971 if (pw == Context.getTargetInfo().getIntWidth()) 10972 Ty = Context.IntTy; 10973 else if (pw == Context.getTargetInfo().getLongWidth()) 10974 Ty = Context.LongTy; 10975 else if (pw == Context.getTargetInfo().getLongLongWidth()) 10976 Ty = Context.LongLongTy; 10977 else { 10978 llvm_unreachable("I don't know size of pointer!"); 10979 } 10980 10981 return new (Context) GNUNullExpr(Ty, TokenLoc); 10982} 10983 10984bool 10985Sema::ConversionToObjCStringLiteralCheck(QualType DstType, Expr *&Exp) { 10986 if (!getLangOpts().ObjC1) 10987 return false; 10988 10989 const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>(); 10990 if (!PT) 10991 return false; 10992 10993 if (!PT->isObjCIdType()) { 10994 // Check if the destination is the 'NSString' interface. 10995 const ObjCInterfaceDecl *ID = PT->getInterfaceDecl(); 10996 if (!ID || !ID->getIdentifier()->isStr("NSString")) 10997 return false; 10998 } 10999 11000 // Ignore any parens, implicit casts (should only be 11001 // array-to-pointer decays), and not-so-opaque values. The last is 11002 // important for making this trigger for property assignments. 11003 Expr *SrcExpr = Exp->IgnoreParenImpCasts(); 11004 if (OpaqueValueExpr *OV = dyn_cast<OpaqueValueExpr>(SrcExpr)) 11005 if (OV->getSourceExpr()) 11006 SrcExpr = OV->getSourceExpr()->IgnoreParenImpCasts(); 11007 11008 StringLiteral *SL = dyn_cast<StringLiteral>(SrcExpr); 11009 if (!SL || !SL->isAscii()) 11010 return false; 11011 Diag(SL->getLocStart(), diag::err_missing_atsign_prefix) 11012 << FixItHint::CreateInsertion(SL->getLocStart(), "@"); 11013 Exp = BuildObjCStringLiteral(SL->getLocStart(), SL).get(); 11014 return true; 11015} 11016 11017bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy, 11018 SourceLocation Loc, 11019 QualType DstType, QualType SrcType, 11020 Expr *SrcExpr, AssignmentAction Action, 11021 bool *Complained) { 11022 if (Complained) 11023 *Complained = false; 11024 11025 // Decode the result (notice that AST's are still created for extensions). 11026 bool CheckInferredResultType = false; 11027 bool isInvalid = false; 11028 unsigned DiagKind = 0; 11029 FixItHint Hint; 11030 ConversionFixItGenerator ConvHints; 11031 bool MayHaveConvFixit = false; 11032 bool MayHaveFunctionDiff = false; 11033 const ObjCInterfaceDecl *IFace = nullptr; 11034 const ObjCProtocolDecl *PDecl = nullptr; 11035 11036 switch (ConvTy) { 11037 case Compatible: 11038 DiagnoseAssignmentEnum(DstType, SrcType, SrcExpr); 11039 return false; 11040 11041 case PointerToInt: 11042 DiagKind = diag::ext_typecheck_convert_pointer_int; 11043 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 11044 MayHaveConvFixit = true; 11045 break; 11046 case IntToPointer: 11047 DiagKind = diag::ext_typecheck_convert_int_pointer; 11048 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 11049 MayHaveConvFixit = true; 11050 break; 11051 case IncompatiblePointer: 11052 DiagKind = 11053 (Action == AA_Passing_CFAudited ? 11054 diag::err_arc_typecheck_convert_incompatible_pointer : 11055 diag::ext_typecheck_convert_incompatible_pointer); 11056 CheckInferredResultType = DstType->isObjCObjectPointerType() && 11057 SrcType->isObjCObjectPointerType(); 11058 if (Hint.isNull() && !CheckInferredResultType) { 11059 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 11060 } 11061 else if (CheckInferredResultType) { 11062 SrcType = SrcType.getUnqualifiedType(); 11063 DstType = DstType.getUnqualifiedType(); 11064 } 11065 MayHaveConvFixit = true; 11066 break; 11067 case IncompatiblePointerSign: 11068 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign; 11069 break; 11070 case FunctionVoidPointer: 11071 DiagKind = diag::ext_typecheck_convert_pointer_void_func; 11072 break; 11073 case IncompatiblePointerDiscardsQualifiers: { 11074 // Perform array-to-pointer decay if necessary. 11075 if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType); 11076 11077 Qualifiers lhq = SrcType->getPointeeType().getQualifiers(); 11078 Qualifiers rhq = DstType->getPointeeType().getQualifiers(); 11079 if (lhq.getAddressSpace() != rhq.getAddressSpace()) { 11080 DiagKind = diag::err_typecheck_incompatible_address_space; 11081 break; 11082 11083 11084 } else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) { 11085 DiagKind = diag::err_typecheck_incompatible_ownership; 11086 break; 11087 } 11088 11089 llvm_unreachable("unknown error case for discarding qualifiers!"); 11090 // fallthrough 11091 } 11092 case CompatiblePointerDiscardsQualifiers: 11093 // If the qualifiers lost were because we were applying the 11094 // (deprecated) C++ conversion from a string literal to a char* 11095 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME: 11096 // Ideally, this check would be performed in 11097 // checkPointerTypesForAssignment. However, that would require a 11098 // bit of refactoring (so that the second argument is an 11099 // expression, rather than a type), which should be done as part 11100 // of a larger effort to fix checkPointerTypesForAssignment for 11101 // C++ semantics. 11102 if (getLangOpts().CPlusPlus && 11103 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType)) 11104 return false; 11105 DiagKind = diag::ext_typecheck_convert_discards_qualifiers; 11106 break; 11107 case IncompatibleNestedPointerQualifiers: 11108 DiagKind = diag::ext_nested_pointer_qualifier_mismatch; 11109 break; 11110 case IntToBlockPointer: 11111 DiagKind = diag::err_int_to_block_pointer; 11112 break; 11113 case IncompatibleBlockPointer: 11114 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer; 11115 break; 11116 case IncompatibleObjCQualifiedId: { 11117 if (SrcType->isObjCQualifiedIdType()) { 11118 const ObjCObjectPointerType *srcOPT = 11119 SrcType->getAs<ObjCObjectPointerType>(); 11120 for (auto *srcProto : srcOPT->quals()) { 11121 PDecl = srcProto; 11122 break; 11123 } 11124 if (const ObjCInterfaceType *IFaceT = 11125 DstType->getAs<ObjCObjectPointerType>()->getInterfaceType()) 11126 IFace = IFaceT->getDecl(); 11127 } 11128 else if (DstType->isObjCQualifiedIdType()) { 11129 const ObjCObjectPointerType *dstOPT = 11130 DstType->getAs<ObjCObjectPointerType>(); 11131 for (auto *dstProto : dstOPT->quals()) { 11132 PDecl = dstProto; 11133 break; 11134 } 11135 if (const ObjCInterfaceType *IFaceT = 11136 SrcType->getAs<ObjCObjectPointerType>()->getInterfaceType()) 11137 IFace = IFaceT->getDecl(); 11138 } 11139 DiagKind = diag::warn_incompatible_qualified_id; 11140 break; 11141 } 11142 case IncompatibleVectors: 11143 DiagKind = diag::warn_incompatible_vectors; 11144 break; 11145 case IncompatibleObjCWeakRef: 11146 DiagKind = diag::err_arc_weak_unavailable_assign; 11147 break; 11148 case Incompatible: 11149 DiagKind = diag::err_typecheck_convert_incompatible; 11150 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 11151 MayHaveConvFixit = true; 11152 isInvalid = true; 11153 MayHaveFunctionDiff = true; 11154 break; 11155 } 11156 11157 QualType FirstType, SecondType; 11158 switch (Action) { 11159 case AA_Assigning: 11160 case AA_Initializing: 11161 // The destination type comes first. 11162 FirstType = DstType; 11163 SecondType = SrcType; 11164 break; 11165 11166 case AA_Returning: 11167 case AA_Passing: 11168 case AA_Passing_CFAudited: 11169 case AA_Converting: 11170 case AA_Sending: 11171 case AA_Casting: 11172 // The source type comes first. 11173 FirstType = SrcType; 11174 SecondType = DstType; 11175 break; 11176 } 11177 11178 PartialDiagnostic FDiag = PDiag(DiagKind); 11179 if (Action == AA_Passing_CFAudited) 11180 FDiag << FirstType << SecondType << AA_Passing << SrcExpr->getSourceRange(); 11181 else 11182 FDiag << FirstType << SecondType << Action << SrcExpr->getSourceRange(); 11183 11184 // If we can fix the conversion, suggest the FixIts. 11185 assert(ConvHints.isNull() || Hint.isNull()); 11186 if (!ConvHints.isNull()) { 11187 for (std::vector<FixItHint>::iterator HI = ConvHints.Hints.begin(), 11188 HE = ConvHints.Hints.end(); HI != HE; ++HI) 11189 FDiag << *HI; 11190 } else { 11191 FDiag << Hint; 11192 } 11193 if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); } 11194 11195 if (MayHaveFunctionDiff) 11196 HandleFunctionTypeMismatch(FDiag, SecondType, FirstType); 11197 11198 Diag(Loc, FDiag); 11199 if (DiagKind == diag::warn_incompatible_qualified_id && 11200 PDecl && IFace && !IFace->hasDefinition()) 11201 Diag(IFace->getLocation(), diag::not_incomplete_class_and_qualified_id) 11202 << IFace->getName() << PDecl->getName(); 11203 11204 if (SecondType == Context.OverloadTy) 11205 NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression, 11206 FirstType); 11207 11208 if (CheckInferredResultType) 11209 EmitRelatedResultTypeNote(SrcExpr); 11210 11211 if (Action == AA_Returning && ConvTy == IncompatiblePointer) 11212 EmitRelatedResultTypeNoteForReturn(DstType); 11213 11214 if (Complained) 11215 *Complained = true; 11216 return isInvalid; 11217} 11218 11219ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, 11220 llvm::APSInt *Result) { 11221 class SimpleICEDiagnoser : public VerifyICEDiagnoser { 11222 public: 11223 void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override { 11224 S.Diag(Loc, diag::err_expr_not_ice) << S.LangOpts.CPlusPlus << SR; 11225 } 11226 } Diagnoser; 11227 11228 return VerifyIntegerConstantExpression(E, Result, Diagnoser); 11229} 11230 11231ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, 11232 llvm::APSInt *Result, 11233 unsigned DiagID, 11234 bool AllowFold) { 11235 class IDDiagnoser : public VerifyICEDiagnoser { 11236 unsigned DiagID; 11237 11238 public: 11239 IDDiagnoser(unsigned DiagID) 11240 : VerifyICEDiagnoser(DiagID == 0), DiagID(DiagID) { } 11241 11242 void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override { 11243 S.Diag(Loc, DiagID) << SR; 11244 } 11245 } Diagnoser(DiagID); 11246 11247 return VerifyIntegerConstantExpression(E, Result, Diagnoser, AllowFold); 11248} 11249 11250void Sema::VerifyICEDiagnoser::diagnoseFold(Sema &S, SourceLocation Loc, 11251 SourceRange SR) { 11252 S.Diag(Loc, diag::ext_expr_not_ice) << SR << S.LangOpts.CPlusPlus; 11253} 11254 11255ExprResult 11256Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, 11257 VerifyICEDiagnoser &Diagnoser, 11258 bool AllowFold) { 11259 SourceLocation DiagLoc = E->getLocStart(); 11260 11261 if (getLangOpts().CPlusPlus11) { 11262 // C++11 [expr.const]p5: 11263 // If an expression of literal class type is used in a context where an 11264 // integral constant expression is required, then that class type shall 11265 // have a single non-explicit conversion function to an integral or 11266 // unscoped enumeration type 11267 ExprResult Converted; 11268 class CXX11ConvertDiagnoser : public ICEConvertDiagnoser { 11269 public: 11270 CXX11ConvertDiagnoser(bool Silent) 11271 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/false, 11272 Silent, true) {} 11273 11274 SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc, 11275 QualType T) override { 11276 return S.Diag(Loc, diag::err_ice_not_integral) << T; 11277 } 11278 11279 SemaDiagnosticBuilder diagnoseIncomplete( 11280 Sema &S, SourceLocation Loc, QualType T) override { 11281 return S.Diag(Loc, diag::err_ice_incomplete_type) << T; 11282 } 11283 11284 SemaDiagnosticBuilder diagnoseExplicitConv( 11285 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override { 11286 return S.Diag(Loc, diag::err_ice_explicit_conversion) << T << ConvTy; 11287 } 11288 11289 SemaDiagnosticBuilder noteExplicitConv( 11290 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override { 11291 return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here) 11292 << ConvTy->isEnumeralType() << ConvTy; 11293 } 11294 11295 SemaDiagnosticBuilder diagnoseAmbiguous( 11296 Sema &S, SourceLocation Loc, QualType T) override { 11297 return S.Diag(Loc, diag::err_ice_ambiguous_conversion) << T; 11298 } 11299 11300 SemaDiagnosticBuilder noteAmbiguous( 11301 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override { 11302 return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here) 11303 << ConvTy->isEnumeralType() << ConvTy; 11304 } 11305 11306 SemaDiagnosticBuilder diagnoseConversion( 11307 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override { 11308 llvm_unreachable("conversion functions are permitted"); 11309 } 11310 } ConvertDiagnoser(Diagnoser.Suppress); 11311 11312 Converted = PerformContextualImplicitConversion(DiagLoc, E, 11313 ConvertDiagnoser); 11314 if (Converted.isInvalid()) 11315 return Converted; 11316 E = Converted.get(); 11317 if (!E->getType()->isIntegralOrUnscopedEnumerationType()) 11318 return ExprError(); 11319 } else if (!E->getType()->isIntegralOrUnscopedEnumerationType()) { 11320 // An ICE must be of integral or unscoped enumeration type. 11321 if (!Diagnoser.Suppress) 11322 Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange()); 11323 return ExprError(); 11324 } 11325 11326 // Circumvent ICE checking in C++11 to avoid evaluating the expression twice 11327 // in the non-ICE case. 11328 if (!getLangOpts().CPlusPlus11 && E->isIntegerConstantExpr(Context)) { 11329 if (Result) 11330 *Result = E->EvaluateKnownConstInt(Context); 11331 return E; 11332 } 11333 11334 Expr::EvalResult EvalResult; 11335 SmallVector<PartialDiagnosticAt, 8> Notes; 11336 EvalResult.Diag = &Notes; 11337 11338 // Try to evaluate the expression, and produce diagnostics explaining why it's 11339 // not a constant expression as a side-effect. 11340 bool Folded = E->EvaluateAsRValue(EvalResult, Context) && 11341 EvalResult.Val.isInt() && !EvalResult.HasSideEffects; 11342 11343 // In C++11, we can rely on diagnostics being produced for any expression 11344 // which is not a constant expression. If no diagnostics were produced, then 11345 // this is a constant expression. 11346 if (Folded && getLangOpts().CPlusPlus11 && Notes.empty()) { 11347 if (Result) 11348 *Result = EvalResult.Val.getInt(); 11349 return E; 11350 } 11351 11352 // If our only note is the usual "invalid subexpression" note, just point 11353 // the caret at its location rather than producing an essentially 11354 // redundant note. 11355 if (Notes.size() == 1 && Notes[0].second.getDiagID() == 11356 diag::note_invalid_subexpr_in_const_expr) { 11357 DiagLoc = Notes[0].first; 11358 Notes.clear(); 11359 } 11360 11361 if (!Folded || !AllowFold) { 11362 if (!Diagnoser.Suppress) { 11363 Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange()); 11364 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 11365 Diag(Notes[I].first, Notes[I].second); 11366 } 11367 11368 return ExprError(); 11369 } 11370 11371 Diagnoser.diagnoseFold(*this, DiagLoc, E->getSourceRange()); 11372 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 11373 Diag(Notes[I].first, Notes[I].second); 11374 11375 if (Result) 11376 *Result = EvalResult.Val.getInt(); 11377 return E; 11378} 11379 11380namespace { 11381 // Handle the case where we conclude a expression which we speculatively 11382 // considered to be unevaluated is actually evaluated. 11383 class TransformToPE : public TreeTransform<TransformToPE> { 11384 typedef TreeTransform<TransformToPE> BaseTransform; 11385 11386 public: 11387 TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) { } 11388 11389 // Make sure we redo semantic analysis 11390 bool AlwaysRebuild() { return true; } 11391 11392 // Make sure we handle LabelStmts correctly. 11393 // FIXME: This does the right thing, but maybe we need a more general 11394 // fix to TreeTransform? 11395 StmtResult TransformLabelStmt(LabelStmt *S) { 11396 S->getDecl()->setStmt(nullptr); 11397 return BaseTransform::TransformLabelStmt(S); 11398 } 11399 11400 // We need to special-case DeclRefExprs referring to FieldDecls which 11401 // are not part of a member pointer formation; normal TreeTransforming 11402 // doesn't catch this case because of the way we represent them in the AST. 11403 // FIXME: This is a bit ugly; is it really the best way to handle this 11404 // case? 11405 // 11406 // Error on DeclRefExprs referring to FieldDecls. 11407 ExprResult TransformDeclRefExpr(DeclRefExpr *E) { 11408 if (isa<FieldDecl>(E->getDecl()) && 11409 !SemaRef.isUnevaluatedContext()) 11410 return SemaRef.Diag(E->getLocation(), 11411 diag::err_invalid_non_static_member_use) 11412 << E->getDecl() << E->getSourceRange(); 11413 11414 return BaseTransform::TransformDeclRefExpr(E); 11415 } 11416 11417 // Exception: filter out member pointer formation 11418 ExprResult TransformUnaryOperator(UnaryOperator *E) { 11419 if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType()) 11420 return E; 11421 11422 return BaseTransform::TransformUnaryOperator(E); 11423 } 11424 11425 ExprResult TransformLambdaExpr(LambdaExpr *E) { 11426 // Lambdas never need to be transformed. 11427 return E; 11428 } 11429 }; 11430} 11431 11432ExprResult Sema::TransformToPotentiallyEvaluated(Expr *E) { 11433 assert(isUnevaluatedContext() && 11434 "Should only transform unevaluated expressions"); 11435 ExprEvalContexts.back().Context = 11436 ExprEvalContexts[ExprEvalContexts.size()-2].Context; 11437 if (isUnevaluatedContext()) 11438 return E; 11439 return TransformToPE(*this).TransformExpr(E); 11440} 11441 11442void 11443Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, 11444 Decl *LambdaContextDecl, 11445 bool IsDecltype) { 11446 ExprEvalContexts.push_back( 11447 ExpressionEvaluationContextRecord(NewContext, 11448 ExprCleanupObjects.size(), 11449 ExprNeedsCleanups, 11450 LambdaContextDecl, 11451 IsDecltype)); 11452 ExprNeedsCleanups = false; 11453 if (!MaybeODRUseExprs.empty()) 11454 std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs); 11455} 11456 11457void 11458Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, 11459 ReuseLambdaContextDecl_t, 11460 bool IsDecltype) { 11461 Decl *ClosureContextDecl = ExprEvalContexts.back().ManglingContextDecl; 11462 PushExpressionEvaluationContext(NewContext, ClosureContextDecl, IsDecltype); 11463} 11464 11465void Sema::PopExpressionEvaluationContext() { 11466 ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back(); 11467 unsigned NumTypos = Rec.NumTypos; 11468 11469 if (!Rec.Lambdas.empty()) { 11470 if (Rec.isUnevaluated() || Rec.Context == ConstantEvaluated) { 11471 unsigned D; 11472 if (Rec.isUnevaluated()) { 11473 // C++11 [expr.prim.lambda]p2: 11474 // A lambda-expression shall not appear in an unevaluated operand 11475 // (Clause 5). 11476 D = diag::err_lambda_unevaluated_operand; 11477 } else { 11478 // C++1y [expr.const]p2: 11479 // A conditional-expression e is a core constant expression unless the 11480 // evaluation of e, following the rules of the abstract machine, would 11481 // evaluate [...] a lambda-expression. 11482 D = diag::err_lambda_in_constant_expression; 11483 } 11484 for (const auto *L : Rec.Lambdas) 11485 Diag(L->getLocStart(), D); 11486 } else { 11487 // Mark the capture expressions odr-used. This was deferred 11488 // during lambda expression creation. 11489 for (auto *Lambda : Rec.Lambdas) { 11490 for (auto *C : Lambda->capture_inits()) 11491 MarkDeclarationsReferencedInExpr(C); 11492 } 11493 } 11494 } 11495 11496 // When are coming out of an unevaluated context, clear out any 11497 // temporaries that we may have created as part of the evaluation of 11498 // the expression in that context: they aren't relevant because they 11499 // will never be constructed. 11500 if (Rec.isUnevaluated() || Rec.Context == ConstantEvaluated) { 11501 ExprCleanupObjects.erase(ExprCleanupObjects.begin() + Rec.NumCleanupObjects, 11502 ExprCleanupObjects.end()); 11503 ExprNeedsCleanups = Rec.ParentNeedsCleanups; 11504 CleanupVarDeclMarking(); 11505 std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs); 11506 // Otherwise, merge the contexts together. 11507 } else { 11508 ExprNeedsCleanups |= Rec.ParentNeedsCleanups; 11509 MaybeODRUseExprs.insert(Rec.SavedMaybeODRUseExprs.begin(), 11510 Rec.SavedMaybeODRUseExprs.end()); 11511 } 11512 11513 // Pop the current expression evaluation context off the stack. 11514 ExprEvalContexts.pop_back(); 11515 11516 if (!ExprEvalContexts.empty()) 11517 ExprEvalContexts.back().NumTypos += NumTypos; 11518 else 11519 assert(NumTypos == 0 && "There are outstanding typos after popping the " 11520 "last ExpressionEvaluationContextRecord"); 11521} 11522 11523void Sema::DiscardCleanupsInEvaluationContext() { 11524 ExprCleanupObjects.erase( 11525 ExprCleanupObjects.begin() + ExprEvalContexts.back().NumCleanupObjects, 11526 ExprCleanupObjects.end()); 11527 ExprNeedsCleanups = false; 11528 MaybeODRUseExprs.clear(); 11529} 11530 11531ExprResult Sema::HandleExprEvaluationContextForTypeof(Expr *E) { 11532 if (!E->getType()->isVariablyModifiedType()) 11533 return E; 11534 return TransformToPotentiallyEvaluated(E); 11535} 11536 11537static bool IsPotentiallyEvaluatedContext(Sema &SemaRef) { 11538 // Do not mark anything as "used" within a dependent context; wait for 11539 // an instantiation. 11540 if (SemaRef.CurContext->isDependentContext()) 11541 return false; 11542 11543 switch (SemaRef.ExprEvalContexts.back().Context) { 11544 case Sema::Unevaluated: 11545 case Sema::UnevaluatedAbstract: 11546 // We are in an expression that is not potentially evaluated; do nothing. 11547 // (Depending on how you read the standard, we actually do need to do 11548 // something here for null pointer constants, but the standard's 11549 // definition of a null pointer constant is completely crazy.) 11550 return false; 11551 11552 case Sema::ConstantEvaluated: 11553 case Sema::PotentiallyEvaluated: 11554 // We are in a potentially evaluated expression (or a constant-expression 11555 // in C++03); we need to do implicit template instantiation, implicitly 11556 // define class members, and mark most declarations as used. 11557 return true; 11558 11559 case Sema::PotentiallyEvaluatedIfUsed: 11560 // Referenced declarations will only be used if the construct in the 11561 // containing expression is used. 11562 return false; 11563 } 11564 llvm_unreachable("Invalid context"); 11565} 11566 11567/// \brief Mark a function referenced, and check whether it is odr-used 11568/// (C++ [basic.def.odr]p2, C99 6.9p3) 11569void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, 11570 bool OdrUse) { 11571 assert(Func && "No function?"); 11572 11573 Func->setReferenced(); 11574 11575 // C++11 [basic.def.odr]p3: 11576 // A function whose name appears as a potentially-evaluated expression is 11577 // odr-used if it is the unique lookup result or the selected member of a 11578 // set of overloaded functions [...]. 11579 // 11580 // We (incorrectly) mark overload resolution as an unevaluated context, so we 11581 // can just check that here. Skip the rest of this function if we've already 11582 // marked the function as used. 11583 if (Func->isUsed(false) || !IsPotentiallyEvaluatedContext(*this)) { 11584 // C++11 [temp.inst]p3: 11585 // Unless a function template specialization has been explicitly 11586 // instantiated or explicitly specialized, the function template 11587 // specialization is implicitly instantiated when the specialization is 11588 // referenced in a context that requires a function definition to exist. 11589 // 11590 // We consider constexpr function templates to be referenced in a context 11591 // that requires a definition to exist whenever they are referenced. 11592 // 11593 // FIXME: This instantiates constexpr functions too frequently. If this is 11594 // really an unevaluated context (and we're not just in the definition of a 11595 // function template or overload resolution or other cases which we 11596 // incorrectly consider to be unevaluated contexts), and we're not in a 11597 // subexpression which we actually need to evaluate (for instance, a 11598 // template argument, array bound or an expression in a braced-init-list), 11599 // we are not permitted to instantiate this constexpr function definition. 11600 // 11601 // FIXME: This also implicitly defines special members too frequently. They 11602 // are only supposed to be implicitly defined if they are odr-used, but they 11603 // are not odr-used from constant expressions in unevaluated contexts. 11604 // However, they cannot be referenced if they are deleted, and they are 11605 // deleted whenever the implicit definition of the special member would 11606 // fail. 11607 if (!Func->isConstexpr() || Func->getBody()) 11608 return; 11609 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Func); 11610 if (!Func->isImplicitlyInstantiable() && (!MD || MD->isUserProvided())) 11611 return; 11612 } 11613 11614 // Note that this declaration has been used. 11615 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Func)) { 11616 Constructor = cast<CXXConstructorDecl>(Constructor->getFirstDecl()); 11617 if (Constructor->isDefaulted() && !Constructor->isDeleted()) { 11618 if (Constructor->isDefaultConstructor()) { 11619 if (Constructor->isTrivial() && !Constructor->hasAttr<DLLExportAttr>()) 11620 return; 11621 DefineImplicitDefaultConstructor(Loc, Constructor); 11622 } else if (Constructor->isCopyConstructor()) { 11623 DefineImplicitCopyConstructor(Loc, Constructor); 11624 } else if (Constructor->isMoveConstructor()) { 11625 DefineImplicitMoveConstructor(Loc, Constructor); 11626 } 11627 } else if (Constructor->getInheritedConstructor()) { 11628 DefineInheritingConstructor(Loc, Constructor); 11629 } 11630 } else if (CXXDestructorDecl *Destructor = 11631 dyn_cast<CXXDestructorDecl>(Func)) { 11632 Destructor = cast<CXXDestructorDecl>(Destructor->getFirstDecl());
|