SemaExpr.cpp revision adb1d4c18ee83249d4cffc99ef902f98e846092a
1//===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements semantic analysis for expressions. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Sema/SemaInternal.h" 15#include "clang/Sema/DelayedDiagnostic.h" 16#include "clang/Sema/Initialization.h" 17#include "clang/Sema/Lookup.h" 18#include "clang/Sema/ScopeInfo.h" 19#include "clang/Sema/AnalysisBasedWarnings.h" 20#include "clang/AST/ASTContext.h" 21#include "clang/AST/ASTConsumer.h" 22#include "clang/AST/ASTMutationListener.h" 23#include "clang/AST/CXXInheritance.h" 24#include "clang/AST/DeclObjC.h" 25#include "clang/AST/DeclTemplate.h" 26#include "clang/AST/EvaluatedExprVisitor.h" 27#include "clang/AST/Expr.h" 28#include "clang/AST/ExprCXX.h" 29#include "clang/AST/ExprObjC.h" 30#include "clang/AST/RecursiveASTVisitor.h" 31#include "clang/AST/TypeLoc.h" 32#include "clang/Basic/PartialDiagnostic.h" 33#include "clang/Basic/SourceManager.h" 34#include "clang/Basic/TargetInfo.h" 35#include "clang/Lex/LiteralSupport.h" 36#include "clang/Lex/Preprocessor.h" 37#include "clang/Sema/DeclSpec.h" 38#include "clang/Sema/Designator.h" 39#include "clang/Sema/Scope.h" 40#include "clang/Sema/ScopeInfo.h" 41#include "clang/Sema/ParsedTemplate.h" 42#include "clang/Sema/SemaFixItUtils.h" 43#include "clang/Sema/Template.h" 44#include "TreeTransform.h" 45using namespace clang; 46using namespace sema; 47 48/// \brief Determine whether the use of this declaration is valid, without 49/// emitting diagnostics. 50bool Sema::CanUseDecl(NamedDecl *D) { 51 // See if this is an auto-typed variable whose initializer we are parsing. 52 if (ParsingInitForAutoVars.count(D)) 53 return false; 54 55 // See if this is a deleted function. 56 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 57 if (FD->isDeleted()) 58 return false; 59 } 60 61 // See if this function is unavailable. 62 if (D->getAvailability() == AR_Unavailable && 63 cast<Decl>(CurContext)->getAvailability() != AR_Unavailable) 64 return false; 65 66 return true; 67} 68 69static AvailabilityResult DiagnoseAvailabilityOfDecl(Sema &S, 70 NamedDecl *D, SourceLocation Loc, 71 const ObjCInterfaceDecl *UnknownObjCClass) { 72 // See if this declaration is unavailable or deprecated. 73 std::string Message; 74 AvailabilityResult Result = D->getAvailability(&Message); 75 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) 76 if (Result == AR_Available) { 77 const DeclContext *DC = ECD->getDeclContext(); 78 if (const EnumDecl *TheEnumDecl = dyn_cast<EnumDecl>(DC)) 79 Result = TheEnumDecl->getAvailability(&Message); 80 } 81 82 switch (Result) { 83 case AR_Available: 84 case AR_NotYetIntroduced: 85 break; 86 87 case AR_Deprecated: 88 S.EmitDeprecationWarning(D, Message, Loc, UnknownObjCClass); 89 break; 90 91 case AR_Unavailable: 92 if (S.getCurContextAvailability() != AR_Unavailable) { 93 if (Message.empty()) { 94 if (!UnknownObjCClass) 95 S.Diag(Loc, diag::err_unavailable) << D->getDeclName(); 96 else 97 S.Diag(Loc, diag::warn_unavailable_fwdclass_message) 98 << D->getDeclName(); 99 } 100 else 101 S.Diag(Loc, diag::err_unavailable_message) 102 << D->getDeclName() << Message; 103 S.Diag(D->getLocation(), diag::note_unavailable_here) 104 << isa<FunctionDecl>(D) << false; 105 } 106 break; 107 } 108 return Result; 109} 110 111/// \brief Emit a note explaining that this function is deleted or unavailable. 112void Sema::NoteDeletedFunction(FunctionDecl *Decl) { 113 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Decl); 114 115 if (Method && Method->isDeleted() && !Method->isDeletedAsWritten()) { 116 // If the method was explicitly defaulted, point at that declaration. 117 if (!Method->isImplicit()) 118 Diag(Decl->getLocation(), diag::note_implicitly_deleted); 119 120 // Try to diagnose why this special member function was implicitly 121 // deleted. This might fail, if that reason no longer applies. 122 CXXSpecialMember CSM = getSpecialMember(Method); 123 if (CSM != CXXInvalid) 124 ShouldDeleteSpecialMember(Method, CSM, /*Diagnose=*/true); 125 126 return; 127 } 128 129 Diag(Decl->getLocation(), diag::note_unavailable_here) 130 << 1 << Decl->isDeleted(); 131} 132 133/// \brief Determine whether a FunctionDecl was ever declared with an 134/// explicit storage class. 135static bool hasAnyExplicitStorageClass(const FunctionDecl *D) { 136 for (FunctionDecl::redecl_iterator I = D->redecls_begin(), 137 E = D->redecls_end(); 138 I != E; ++I) { 139 if (I->getStorageClassAsWritten() != SC_None) 140 return true; 141 } 142 return false; 143} 144 145/// \brief Check whether we're in an extern inline function and referring to a 146/// variable or function with internal linkage (C11 6.7.4p3). 147/// 148/// This is only a warning because we used to silently accept this code, but 149/// in many cases it will not behave correctly. This is not enabled in C++ mode 150/// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6) 151/// and so while there may still be user mistakes, most of the time we can't 152/// prove that there are errors. 153static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S, 154 const NamedDecl *D, 155 SourceLocation Loc) { 156 // This is disabled under C++; there are too many ways for this to fire in 157 // contexts where the warning is a false positive, or where it is technically 158 // correct but benign. 159 if (S.getLangOpts().CPlusPlus) 160 return; 161 162 // Check if this is an inlined function or method. 163 FunctionDecl *Current = S.getCurFunctionDecl(); 164 if (!Current) 165 return; 166 if (!Current->isInlined()) 167 return; 168 if (Current->getLinkage() != ExternalLinkage) 169 return; 170 171 // Check if the decl has internal linkage. 172 if (D->getLinkage() != InternalLinkage) 173 return; 174 175 // Downgrade from ExtWarn to Extension if 176 // (1) the supposedly external inline function is in the main file, 177 // and probably won't be included anywhere else. 178 // (2) the thing we're referencing is a pure function. 179 // (3) the thing we're referencing is another inline function. 180 // This last can give us false negatives, but it's better than warning on 181 // wrappers for simple C library functions. 182 const FunctionDecl *UsedFn = dyn_cast<FunctionDecl>(D); 183 bool DowngradeWarning = S.getSourceManager().isFromMainFile(Loc); 184 if (!DowngradeWarning && UsedFn) 185 DowngradeWarning = UsedFn->isInlined() || UsedFn->hasAttr<ConstAttr>(); 186 187 S.Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline 188 : diag::warn_internal_in_extern_inline) 189 << /*IsVar=*/!UsedFn << D; 190 191 // Suggest "static" on the inline function, if possible. 192 if (!hasAnyExplicitStorageClass(Current)) { 193 const FunctionDecl *FirstDecl = Current->getCanonicalDecl(); 194 SourceLocation DeclBegin = FirstDecl->getSourceRange().getBegin(); 195 S.Diag(DeclBegin, diag::note_convert_inline_to_static) 196 << Current << FixItHint::CreateInsertion(DeclBegin, "static "); 197 } 198 199 S.Diag(D->getCanonicalDecl()->getLocation(), 200 diag::note_internal_decl_declared_here) 201 << D; 202} 203 204/// \brief Determine whether the use of this declaration is valid, and 205/// emit any corresponding diagnostics. 206/// 207/// This routine diagnoses various problems with referencing 208/// declarations that can occur when using a declaration. For example, 209/// it might warn if a deprecated or unavailable declaration is being 210/// used, or produce an error (and return true) if a C++0x deleted 211/// function is being used. 212/// 213/// \returns true if there was an error (this declaration cannot be 214/// referenced), false otherwise. 215/// 216bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, 217 const ObjCInterfaceDecl *UnknownObjCClass) { 218 if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) { 219 // If there were any diagnostics suppressed by template argument deduction, 220 // emit them now. 221 llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >::iterator 222 Pos = SuppressedDiagnostics.find(D->getCanonicalDecl()); 223 if (Pos != SuppressedDiagnostics.end()) { 224 SmallVectorImpl<PartialDiagnosticAt> &Suppressed = Pos->second; 225 for (unsigned I = 0, N = Suppressed.size(); I != N; ++I) 226 Diag(Suppressed[I].first, Suppressed[I].second); 227 228 // Clear out the list of suppressed diagnostics, so that we don't emit 229 // them again for this specialization. However, we don't obsolete this 230 // entry from the table, because we want to avoid ever emitting these 231 // diagnostics again. 232 Suppressed.clear(); 233 } 234 } 235 236 // See if this is an auto-typed variable whose initializer we are parsing. 237 if (ParsingInitForAutoVars.count(D)) { 238 Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer) 239 << D->getDeclName(); 240 return true; 241 } 242 243 // See if this is a deleted function. 244 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 245 if (FD->isDeleted()) { 246 Diag(Loc, diag::err_deleted_function_use); 247 NoteDeletedFunction(FD); 248 return true; 249 } 250 } 251 DiagnoseAvailabilityOfDecl(*this, D, Loc, UnknownObjCClass); 252 253 // Warn if this is used but marked unused. 254 if (D->hasAttr<UnusedAttr>()) 255 Diag(Loc, diag::warn_used_but_marked_unused) << D->getDeclName(); 256 257 diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc); 258 259 return false; 260} 261 262/// \brief Retrieve the message suffix that should be added to a 263/// diagnostic complaining about the given function being deleted or 264/// unavailable. 265std::string Sema::getDeletedOrUnavailableSuffix(const FunctionDecl *FD) { 266 // FIXME: C++0x implicitly-deleted special member functions could be 267 // detected here so that we could improve diagnostics to say, e.g., 268 // "base class 'A' had a deleted copy constructor". 269 if (FD->isDeleted()) 270 return std::string(); 271 272 std::string Message; 273 if (FD->getAvailability(&Message)) 274 return ": " + Message; 275 276 return std::string(); 277} 278 279/// DiagnoseSentinelCalls - This routine checks whether a call or 280/// message-send is to a declaration with the sentinel attribute, and 281/// if so, it checks that the requirements of the sentinel are 282/// satisfied. 283void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, 284 Expr **args, unsigned numArgs) { 285 const SentinelAttr *attr = D->getAttr<SentinelAttr>(); 286 if (!attr) 287 return; 288 289 // The number of formal parameters of the declaration. 290 unsigned numFormalParams; 291 292 // The kind of declaration. This is also an index into a %select in 293 // the diagnostic. 294 enum CalleeType { CT_Function, CT_Method, CT_Block } calleeType; 295 296 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 297 numFormalParams = MD->param_size(); 298 calleeType = CT_Method; 299 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 300 numFormalParams = FD->param_size(); 301 calleeType = CT_Function; 302 } else if (isa<VarDecl>(D)) { 303 QualType type = cast<ValueDecl>(D)->getType(); 304 const FunctionType *fn = 0; 305 if (const PointerType *ptr = type->getAs<PointerType>()) { 306 fn = ptr->getPointeeType()->getAs<FunctionType>(); 307 if (!fn) return; 308 calleeType = CT_Function; 309 } else if (const BlockPointerType *ptr = type->getAs<BlockPointerType>()) { 310 fn = ptr->getPointeeType()->castAs<FunctionType>(); 311 calleeType = CT_Block; 312 } else { 313 return; 314 } 315 316 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fn)) { 317 numFormalParams = proto->getNumArgs(); 318 } else { 319 numFormalParams = 0; 320 } 321 } else { 322 return; 323 } 324 325 // "nullPos" is the number of formal parameters at the end which 326 // effectively count as part of the variadic arguments. This is 327 // useful if you would prefer to not have *any* formal parameters, 328 // but the language forces you to have at least one. 329 unsigned nullPos = attr->getNullPos(); 330 assert((nullPos == 0 || nullPos == 1) && "invalid null position on sentinel"); 331 numFormalParams = (nullPos > numFormalParams ? 0 : numFormalParams - nullPos); 332 333 // The number of arguments which should follow the sentinel. 334 unsigned numArgsAfterSentinel = attr->getSentinel(); 335 336 // If there aren't enough arguments for all the formal parameters, 337 // the sentinel, and the args after the sentinel, complain. 338 if (numArgs < numFormalParams + numArgsAfterSentinel + 1) { 339 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName(); 340 Diag(D->getLocation(), diag::note_sentinel_here) << calleeType; 341 return; 342 } 343 344 // Otherwise, find the sentinel expression. 345 Expr *sentinelExpr = args[numArgs - numArgsAfterSentinel - 1]; 346 if (!sentinelExpr) return; 347 if (sentinelExpr->isValueDependent()) return; 348 if (Context.isSentinelNullExpr(sentinelExpr)) return; 349 350 // Pick a reasonable string to insert. Optimistically use 'nil' or 351 // 'NULL' if those are actually defined in the context. Only use 352 // 'nil' for ObjC methods, where it's much more likely that the 353 // variadic arguments form a list of object pointers. 354 SourceLocation MissingNilLoc 355 = PP.getLocForEndOfToken(sentinelExpr->getLocEnd()); 356 std::string NullValue; 357 if (calleeType == CT_Method && 358 PP.getIdentifierInfo("nil")->hasMacroDefinition()) 359 NullValue = "nil"; 360 else if (PP.getIdentifierInfo("NULL")->hasMacroDefinition()) 361 NullValue = "NULL"; 362 else 363 NullValue = "(void*) 0"; 364 365 if (MissingNilLoc.isInvalid()) 366 Diag(Loc, diag::warn_missing_sentinel) << calleeType; 367 else 368 Diag(MissingNilLoc, diag::warn_missing_sentinel) 369 << calleeType 370 << FixItHint::CreateInsertion(MissingNilLoc, ", " + NullValue); 371 Diag(D->getLocation(), diag::note_sentinel_here) << calleeType; 372} 373 374SourceRange Sema::getExprRange(Expr *E) const { 375 return E ? E->getSourceRange() : SourceRange(); 376} 377 378//===----------------------------------------------------------------------===// 379// Standard Promotions and Conversions 380//===----------------------------------------------------------------------===// 381 382/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4). 383ExprResult Sema::DefaultFunctionArrayConversion(Expr *E) { 384 // Handle any placeholder expressions which made it here. 385 if (E->getType()->isPlaceholderType()) { 386 ExprResult result = CheckPlaceholderExpr(E); 387 if (result.isInvalid()) return ExprError(); 388 E = result.take(); 389 } 390 391 QualType Ty = E->getType(); 392 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type"); 393 394 if (Ty->isFunctionType()) 395 E = ImpCastExprToType(E, Context.getPointerType(Ty), 396 CK_FunctionToPointerDecay).take(); 397 else if (Ty->isArrayType()) { 398 // In C90 mode, arrays only promote to pointers if the array expression is 399 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has 400 // type 'array of type' is converted to an expression that has type 'pointer 401 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression 402 // that has type 'array of type' ...". The relevant change is "an lvalue" 403 // (C90) to "an expression" (C99). 404 // 405 // C++ 4.2p1: 406 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of 407 // T" can be converted to an rvalue of type "pointer to T". 408 // 409 if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue()) 410 E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty), 411 CK_ArrayToPointerDecay).take(); 412 } 413 return Owned(E); 414} 415 416static void CheckForNullPointerDereference(Sema &S, Expr *E) { 417 // Check to see if we are dereferencing a null pointer. If so, 418 // and if not volatile-qualified, this is undefined behavior that the 419 // optimizer will delete, so warn about it. People sometimes try to use this 420 // to get a deterministic trap and are surprised by clang's behavior. This 421 // only handles the pattern "*null", which is a very syntactic check. 422 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts())) 423 if (UO->getOpcode() == UO_Deref && 424 UO->getSubExpr()->IgnoreParenCasts()-> 425 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) && 426 !UO->getType().isVolatileQualified()) { 427 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 428 S.PDiag(diag::warn_indirection_through_null) 429 << UO->getSubExpr()->getSourceRange()); 430 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 431 S.PDiag(diag::note_indirection_through_null)); 432 } 433} 434 435ExprResult Sema::DefaultLvalueConversion(Expr *E) { 436 // Handle any placeholder expressions which made it here. 437 if (E->getType()->isPlaceholderType()) { 438 ExprResult result = CheckPlaceholderExpr(E); 439 if (result.isInvalid()) return ExprError(); 440 E = result.take(); 441 } 442 443 // C++ [conv.lval]p1: 444 // A glvalue of a non-function, non-array type T can be 445 // converted to a prvalue. 446 if (!E->isGLValue()) return Owned(E); 447 448 QualType T = E->getType(); 449 assert(!T.isNull() && "r-value conversion on typeless expression?"); 450 451 // We don't want to throw lvalue-to-rvalue casts on top of 452 // expressions of certain types in C++. 453 if (getLangOpts().CPlusPlus && 454 (E->getType() == Context.OverloadTy || 455 T->isDependentType() || 456 T->isRecordType())) 457 return Owned(E); 458 459 // The C standard is actually really unclear on this point, and 460 // DR106 tells us what the result should be but not why. It's 461 // generally best to say that void types just doesn't undergo 462 // lvalue-to-rvalue at all. Note that expressions of unqualified 463 // 'void' type are never l-values, but qualified void can be. 464 if (T->isVoidType()) 465 return Owned(E); 466 467 CheckForNullPointerDereference(*this, E); 468 469 // C++ [conv.lval]p1: 470 // [...] If T is a non-class type, the type of the prvalue is the 471 // cv-unqualified version of T. Otherwise, the type of the 472 // rvalue is T. 473 // 474 // C99 6.3.2.1p2: 475 // If the lvalue has qualified type, the value has the unqualified 476 // version of the type of the lvalue; otherwise, the value has the 477 // type of the lvalue. 478 if (T.hasQualifiers()) 479 T = T.getUnqualifiedType(); 480 481 UpdateMarkingForLValueToRValue(E); 482 483 ExprResult Res = Owned(ImplicitCastExpr::Create(Context, T, CK_LValueToRValue, 484 E, 0, VK_RValue)); 485 486 // C11 6.3.2.1p2: 487 // ... if the lvalue has atomic type, the value has the non-atomic version 488 // of the type of the lvalue ... 489 if (const AtomicType *Atomic = T->getAs<AtomicType>()) { 490 T = Atomic->getValueType().getUnqualifiedType(); 491 Res = Owned(ImplicitCastExpr::Create(Context, T, CK_AtomicToNonAtomic, 492 Res.get(), 0, VK_RValue)); 493 } 494 495 return Res; 496} 497 498ExprResult Sema::DefaultFunctionArrayLvalueConversion(Expr *E) { 499 ExprResult Res = DefaultFunctionArrayConversion(E); 500 if (Res.isInvalid()) 501 return ExprError(); 502 Res = DefaultLvalueConversion(Res.take()); 503 if (Res.isInvalid()) 504 return ExprError(); 505 return move(Res); 506} 507 508 509/// UsualUnaryConversions - Performs various conversions that are common to most 510/// operators (C99 6.3). The conversions of array and function types are 511/// sometimes suppressed. For example, the array->pointer conversion doesn't 512/// apply if the array is an argument to the sizeof or address (&) operators. 513/// In these instances, this routine should *not* be called. 514ExprResult Sema::UsualUnaryConversions(Expr *E) { 515 // First, convert to an r-value. 516 ExprResult Res = DefaultFunctionArrayLvalueConversion(E); 517 if (Res.isInvalid()) 518 return Owned(E); 519 E = Res.take(); 520 521 QualType Ty = E->getType(); 522 assert(!Ty.isNull() && "UsualUnaryConversions - missing type"); 523 524 // Half FP is a bit different: it's a storage-only type, meaning that any 525 // "use" of it should be promoted to float. 526 if (Ty->isHalfType()) 527 return ImpCastExprToType(Res.take(), Context.FloatTy, CK_FloatingCast); 528 529 // Try to perform integral promotions if the object has a theoretically 530 // promotable type. 531 if (Ty->isIntegralOrUnscopedEnumerationType()) { 532 // C99 6.3.1.1p2: 533 // 534 // The following may be used in an expression wherever an int or 535 // unsigned int may be used: 536 // - an object or expression with an integer type whose integer 537 // conversion rank is less than or equal to the rank of int 538 // and unsigned int. 539 // - A bit-field of type _Bool, int, signed int, or unsigned int. 540 // 541 // If an int can represent all values of the original type, the 542 // value is converted to an int; otherwise, it is converted to an 543 // unsigned int. These are called the integer promotions. All 544 // other types are unchanged by the integer promotions. 545 546 QualType PTy = Context.isPromotableBitField(E); 547 if (!PTy.isNull()) { 548 E = ImpCastExprToType(E, PTy, CK_IntegralCast).take(); 549 return Owned(E); 550 } 551 if (Ty->isPromotableIntegerType()) { 552 QualType PT = Context.getPromotedIntegerType(Ty); 553 E = ImpCastExprToType(E, PT, CK_IntegralCast).take(); 554 return Owned(E); 555 } 556 } 557 return Owned(E); 558} 559 560/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that 561/// do not have a prototype. Arguments that have type float are promoted to 562/// double. All other argument types are converted by UsualUnaryConversions(). 563ExprResult Sema::DefaultArgumentPromotion(Expr *E) { 564 QualType Ty = E->getType(); 565 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type"); 566 567 ExprResult Res = UsualUnaryConversions(E); 568 if (Res.isInvalid()) 569 return Owned(E); 570 E = Res.take(); 571 572 // If this is a 'float' (CVR qualified or typedef) promote to double. 573 if (Ty->isSpecificBuiltinType(BuiltinType::Float)) 574 E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).take(); 575 576 // C++ performs lvalue-to-rvalue conversion as a default argument 577 // promotion, even on class types, but note: 578 // C++11 [conv.lval]p2: 579 // When an lvalue-to-rvalue conversion occurs in an unevaluated 580 // operand or a subexpression thereof the value contained in the 581 // referenced object is not accessed. Otherwise, if the glvalue 582 // has a class type, the conversion copy-initializes a temporary 583 // of type T from the glvalue and the result of the conversion 584 // is a prvalue for the temporary. 585 // FIXME: add some way to gate this entire thing for correctness in 586 // potentially potentially evaluated contexts. 587 if (getLangOpts().CPlusPlus && E->isGLValue() && 588 ExprEvalContexts.back().Context != Unevaluated) { 589 ExprResult Temp = PerformCopyInitialization( 590 InitializedEntity::InitializeTemporary(E->getType()), 591 E->getExprLoc(), 592 Owned(E)); 593 if (Temp.isInvalid()) 594 return ExprError(); 595 E = Temp.get(); 596 } 597 598 return Owned(E); 599} 600 601/// Determine the degree of POD-ness for an expression. 602/// Incomplete types are considered POD, since this check can be performed 603/// when we're in an unevaluated context. 604Sema::VarArgKind Sema::isValidVarArgType(const QualType &Ty) { 605 if (Ty->isIncompleteType()) { 606 if (Ty->isObjCObjectType()) 607 return VAK_Invalid; 608 return VAK_Valid; 609 } 610 611 if (Ty.isCXX98PODType(Context)) 612 return VAK_Valid; 613 614 // C++0x [expr.call]p7: 615 // Passing a potentially-evaluated argument of class type (Clause 9) 616 // having a non-trivial copy constructor, a non-trivial move constructor, 617 // or a non-trivial destructor, with no corresponding parameter, 618 // is conditionally-supported with implementation-defined semantics. 619 if (getLangOpts().CPlusPlus0x && !Ty->isDependentType()) 620 if (CXXRecordDecl *Record = Ty->getAsCXXRecordDecl()) 621 if (Record->hasTrivialCopyConstructor() && 622 Record->hasTrivialMoveConstructor() && 623 Record->hasTrivialDestructor()) 624 return VAK_ValidInCXX11; 625 626 if (getLangOpts().ObjCAutoRefCount && Ty->isObjCLifetimeType()) 627 return VAK_Valid; 628 return VAK_Invalid; 629} 630 631bool Sema::variadicArgumentPODCheck(const Expr *E, VariadicCallType CT) { 632 // Don't allow one to pass an Objective-C interface to a vararg. 633 const QualType & Ty = E->getType(); 634 635 // Complain about passing non-POD types through varargs. 636 switch (isValidVarArgType(Ty)) { 637 case VAK_Valid: 638 break; 639 case VAK_ValidInCXX11: 640 DiagRuntimeBehavior(E->getLocStart(), 0, 641 PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) 642 << E->getType() << CT); 643 break; 644 case VAK_Invalid: { 645 if (Ty->isObjCObjectType()) 646 return DiagRuntimeBehavior(E->getLocStart(), 0, 647 PDiag(diag::err_cannot_pass_objc_interface_to_vararg) 648 << Ty << CT); 649 650 return DiagRuntimeBehavior(E->getLocStart(), 0, 651 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg) 652 << getLangOpts().CPlusPlus0x << Ty << CT); 653 } 654 } 655 // c++ rules are enforced elsewhere. 656 return false; 657} 658 659/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but 660/// will create a trap if the resulting type is not a POD type. 661ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, 662 FunctionDecl *FDecl) { 663 if (const BuiltinType *PlaceholderTy = E->getType()->getAsPlaceholderType()) { 664 // Strip the unbridged-cast placeholder expression off, if applicable. 665 if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast && 666 (CT == VariadicMethod || 667 (FDecl && FDecl->hasAttr<CFAuditedTransferAttr>()))) { 668 E = stripARCUnbridgedCast(E); 669 670 // Otherwise, do normal placeholder checking. 671 } else { 672 ExprResult ExprRes = CheckPlaceholderExpr(E); 673 if (ExprRes.isInvalid()) 674 return ExprError(); 675 E = ExprRes.take(); 676 } 677 } 678 679 ExprResult ExprRes = DefaultArgumentPromotion(E); 680 if (ExprRes.isInvalid()) 681 return ExprError(); 682 E = ExprRes.take(); 683 684 // Diagnostics regarding non-POD argument types are 685 // emitted along with format string checking in Sema::CheckFunctionCall(). 686 if (isValidVarArgType(E->getType()) == VAK_Invalid) { 687 // Turn this into a trap. 688 CXXScopeSpec SS; 689 SourceLocation TemplateKWLoc; 690 UnqualifiedId Name; 691 Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"), 692 E->getLocStart()); 693 ExprResult TrapFn = ActOnIdExpression(TUScope, SS, TemplateKWLoc, 694 Name, true, false); 695 if (TrapFn.isInvalid()) 696 return ExprError(); 697 698 ExprResult Call = ActOnCallExpr(TUScope, TrapFn.get(), 699 E->getLocStart(), MultiExprArg(), 700 E->getLocEnd()); 701 if (Call.isInvalid()) 702 return ExprError(); 703 704 ExprResult Comma = ActOnBinOp(TUScope, E->getLocStart(), tok::comma, 705 Call.get(), E); 706 if (Comma.isInvalid()) 707 return ExprError(); 708 return Comma.get(); 709 } 710 711 if (!getLangOpts().CPlusPlus && 712 RequireCompleteType(E->getExprLoc(), E->getType(), 713 diag::err_call_incomplete_argument)) 714 return ExprError(); 715 716 return Owned(E); 717} 718 719/// \brief Converts an integer to complex float type. Helper function of 720/// UsualArithmeticConversions() 721/// 722/// \return false if the integer expression is an integer type and is 723/// successfully converted to the complex type. 724static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &IntExpr, 725 ExprResult &ComplexExpr, 726 QualType IntTy, 727 QualType ComplexTy, 728 bool SkipCast) { 729 if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true; 730 if (SkipCast) return false; 731 if (IntTy->isIntegerType()) { 732 QualType fpTy = cast<ComplexType>(ComplexTy)->getElementType(); 733 IntExpr = S.ImpCastExprToType(IntExpr.take(), fpTy, CK_IntegralToFloating); 734 IntExpr = S.ImpCastExprToType(IntExpr.take(), ComplexTy, 735 CK_FloatingRealToComplex); 736 } else { 737 assert(IntTy->isComplexIntegerType()); 738 IntExpr = S.ImpCastExprToType(IntExpr.take(), ComplexTy, 739 CK_IntegralComplexToFloatingComplex); 740 } 741 return false; 742} 743 744/// \brief Takes two complex float types and converts them to the same type. 745/// Helper function of UsualArithmeticConversions() 746static QualType 747handleComplexFloatToComplexFloatConverstion(Sema &S, ExprResult &LHS, 748 ExprResult &RHS, QualType LHSType, 749 QualType RHSType, 750 bool IsCompAssign) { 751 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 752 753 if (order < 0) { 754 // _Complex float -> _Complex double 755 if (!IsCompAssign) 756 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingComplexCast); 757 return RHSType; 758 } 759 if (order > 0) 760 // _Complex float -> _Complex double 761 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingComplexCast); 762 return LHSType; 763} 764 765/// \brief Converts otherExpr to complex float and promotes complexExpr if 766/// necessary. Helper function of UsualArithmeticConversions() 767static QualType handleOtherComplexFloatConversion(Sema &S, 768 ExprResult &ComplexExpr, 769 ExprResult &OtherExpr, 770 QualType ComplexTy, 771 QualType OtherTy, 772 bool ConvertComplexExpr, 773 bool ConvertOtherExpr) { 774 int order = S.Context.getFloatingTypeOrder(ComplexTy, OtherTy); 775 776 // If just the complexExpr is complex, the otherExpr needs to be converted, 777 // and the complexExpr might need to be promoted. 778 if (order > 0) { // complexExpr is wider 779 // float -> _Complex double 780 if (ConvertOtherExpr) { 781 QualType fp = cast<ComplexType>(ComplexTy)->getElementType(); 782 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), fp, CK_FloatingCast); 783 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), ComplexTy, 784 CK_FloatingRealToComplex); 785 } 786 return ComplexTy; 787 } 788 789 // otherTy is at least as wide. Find its corresponding complex type. 790 QualType result = (order == 0 ? ComplexTy : 791 S.Context.getComplexType(OtherTy)); 792 793 // double -> _Complex double 794 if (ConvertOtherExpr) 795 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), result, 796 CK_FloatingRealToComplex); 797 798 // _Complex float -> _Complex double 799 if (ConvertComplexExpr && order < 0) 800 ComplexExpr = S.ImpCastExprToType(ComplexExpr.take(), result, 801 CK_FloatingComplexCast); 802 803 return result; 804} 805 806/// \brief Handle arithmetic conversion with complex types. Helper function of 807/// UsualArithmeticConversions() 808static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS, 809 ExprResult &RHS, QualType LHSType, 810 QualType RHSType, 811 bool IsCompAssign) { 812 // if we have an integer operand, the result is the complex type. 813 if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType, 814 /*skipCast*/false)) 815 return LHSType; 816 if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType, 817 /*skipCast*/IsCompAssign)) 818 return RHSType; 819 820 // This handles complex/complex, complex/float, or float/complex. 821 // When both operands are complex, the shorter operand is converted to the 822 // type of the longer, and that is the type of the result. This corresponds 823 // to what is done when combining two real floating-point operands. 824 // The fun begins when size promotion occur across type domains. 825 // From H&S 6.3.4: When one operand is complex and the other is a real 826 // floating-point type, the less precise type is converted, within it's 827 // real or complex domain, to the precision of the other type. For example, 828 // when combining a "long double" with a "double _Complex", the 829 // "double _Complex" is promoted to "long double _Complex". 830 831 bool LHSComplexFloat = LHSType->isComplexType(); 832 bool RHSComplexFloat = RHSType->isComplexType(); 833 834 // If both are complex, just cast to the more precise type. 835 if (LHSComplexFloat && RHSComplexFloat) 836 return handleComplexFloatToComplexFloatConverstion(S, LHS, RHS, 837 LHSType, RHSType, 838 IsCompAssign); 839 840 // If only one operand is complex, promote it if necessary and convert the 841 // other operand to complex. 842 if (LHSComplexFloat) 843 return handleOtherComplexFloatConversion( 844 S, LHS, RHS, LHSType, RHSType, /*convertComplexExpr*/!IsCompAssign, 845 /*convertOtherExpr*/ true); 846 847 assert(RHSComplexFloat); 848 return handleOtherComplexFloatConversion( 849 S, RHS, LHS, RHSType, LHSType, /*convertComplexExpr*/true, 850 /*convertOtherExpr*/ !IsCompAssign); 851} 852 853/// \brief Hande arithmetic conversion from integer to float. Helper function 854/// of UsualArithmeticConversions() 855static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, 856 ExprResult &IntExpr, 857 QualType FloatTy, QualType IntTy, 858 bool ConvertFloat, bool ConvertInt) { 859 if (IntTy->isIntegerType()) { 860 if (ConvertInt) 861 // Convert intExpr to the lhs floating point type. 862 IntExpr = S.ImpCastExprToType(IntExpr.take(), FloatTy, 863 CK_IntegralToFloating); 864 return FloatTy; 865 } 866 867 // Convert both sides to the appropriate complex float. 868 assert(IntTy->isComplexIntegerType()); 869 QualType result = S.Context.getComplexType(FloatTy); 870 871 // _Complex int -> _Complex float 872 if (ConvertInt) 873 IntExpr = S.ImpCastExprToType(IntExpr.take(), result, 874 CK_IntegralComplexToFloatingComplex); 875 876 // float -> _Complex float 877 if (ConvertFloat) 878 FloatExpr = S.ImpCastExprToType(FloatExpr.take(), result, 879 CK_FloatingRealToComplex); 880 881 return result; 882} 883 884/// \brief Handle arithmethic conversion with floating point types. Helper 885/// function of UsualArithmeticConversions() 886static QualType handleFloatConversion(Sema &S, ExprResult &LHS, 887 ExprResult &RHS, QualType LHSType, 888 QualType RHSType, bool IsCompAssign) { 889 bool LHSFloat = LHSType->isRealFloatingType(); 890 bool RHSFloat = RHSType->isRealFloatingType(); 891 892 // If we have two real floating types, convert the smaller operand 893 // to the bigger result. 894 if (LHSFloat && RHSFloat) { 895 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 896 if (order > 0) { 897 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingCast); 898 return LHSType; 899 } 900 901 assert(order < 0 && "illegal float comparison"); 902 if (!IsCompAssign) 903 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingCast); 904 return RHSType; 905 } 906 907 if (LHSFloat) 908 return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType, 909 /*convertFloat=*/!IsCompAssign, 910 /*convertInt=*/ true); 911 assert(RHSFloat); 912 return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType, 913 /*convertInt=*/ true, 914 /*convertFloat=*/!IsCompAssign); 915} 916 917/// \brief Handle conversions with GCC complex int extension. Helper function 918/// of UsualArithmeticConversions() 919// FIXME: if the operands are (int, _Complex long), we currently 920// don't promote the complex. Also, signedness? 921static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS, 922 ExprResult &RHS, QualType LHSType, 923 QualType RHSType, 924 bool IsCompAssign) { 925 const ComplexType *LHSComplexInt = LHSType->getAsComplexIntegerType(); 926 const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType(); 927 928 if (LHSComplexInt && RHSComplexInt) { 929 int order = S.Context.getIntegerTypeOrder(LHSComplexInt->getElementType(), 930 RHSComplexInt->getElementType()); 931 assert(order && "inequal types with equal element ordering"); 932 if (order > 0) { 933 // _Complex int -> _Complex long 934 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralComplexCast); 935 return LHSType; 936 } 937 938 if (!IsCompAssign) 939 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralComplexCast); 940 return RHSType; 941 } 942 943 if (LHSComplexInt) { 944 // int -> _Complex int 945 // FIXME: This needs to take integer ranks into account 946 RHS = S.ImpCastExprToType(RHS.take(), LHSComplexInt->getElementType(), 947 CK_IntegralCast); 948 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralRealToComplex); 949 return LHSType; 950 } 951 952 assert(RHSComplexInt); 953 // int -> _Complex int 954 // FIXME: This needs to take integer ranks into account 955 if (!IsCompAssign) { 956 LHS = S.ImpCastExprToType(LHS.take(), RHSComplexInt->getElementType(), 957 CK_IntegralCast); 958 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralRealToComplex); 959 } 960 return RHSType; 961} 962 963/// \brief Handle integer arithmetic conversions. Helper function of 964/// UsualArithmeticConversions() 965static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, 966 ExprResult &RHS, QualType LHSType, 967 QualType RHSType, bool IsCompAssign) { 968 // The rules for this case are in C99 6.3.1.8 969 int order = S.Context.getIntegerTypeOrder(LHSType, RHSType); 970 bool LHSSigned = LHSType->hasSignedIntegerRepresentation(); 971 bool RHSSigned = RHSType->hasSignedIntegerRepresentation(); 972 if (LHSSigned == RHSSigned) { 973 // Same signedness; use the higher-ranked type 974 if (order >= 0) { 975 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 976 return LHSType; 977 } else if (!IsCompAssign) 978 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 979 return RHSType; 980 } else if (order != (LHSSigned ? 1 : -1)) { 981 // The unsigned type has greater than or equal rank to the 982 // signed type, so use the unsigned type 983 if (RHSSigned) { 984 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 985 return LHSType; 986 } else if (!IsCompAssign) 987 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 988 return RHSType; 989 } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) { 990 // The two types are different widths; if we are here, that 991 // means the signed type is larger than the unsigned type, so 992 // use the signed type. 993 if (LHSSigned) { 994 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 995 return LHSType; 996 } else if (!IsCompAssign) 997 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 998 return RHSType; 999 } else { 1000 // The signed type is higher-ranked than the unsigned type, 1001 // but isn't actually any bigger (like unsigned int and long 1002 // on most 32-bit systems). Use the unsigned type corresponding 1003 // to the signed type. 1004 QualType result = 1005 S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType); 1006 RHS = S.ImpCastExprToType(RHS.take(), result, CK_IntegralCast); 1007 if (!IsCompAssign) 1008 LHS = S.ImpCastExprToType(LHS.take(), result, CK_IntegralCast); 1009 return result; 1010 } 1011} 1012 1013/// UsualArithmeticConversions - Performs various conversions that are common to 1014/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this 1015/// routine returns the first non-arithmetic type found. The client is 1016/// responsible for emitting appropriate error diagnostics. 1017/// FIXME: verify the conversion rules for "complex int" are consistent with 1018/// GCC. 1019QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, 1020 bool IsCompAssign) { 1021 if (!IsCompAssign) { 1022 LHS = UsualUnaryConversions(LHS.take()); 1023 if (LHS.isInvalid()) 1024 return QualType(); 1025 } 1026 1027 RHS = UsualUnaryConversions(RHS.take()); 1028 if (RHS.isInvalid()) 1029 return QualType(); 1030 1031 // For conversion purposes, we ignore any qualifiers. 1032 // For example, "const float" and "float" are equivalent. 1033 QualType LHSType = 1034 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType(); 1035 QualType RHSType = 1036 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType(); 1037 1038 // For conversion purposes, we ignore any atomic qualifier on the LHS. 1039 if (const AtomicType *AtomicLHS = LHSType->getAs<AtomicType>()) 1040 LHSType = AtomicLHS->getValueType(); 1041 1042 // If both types are identical, no conversion is needed. 1043 if (LHSType == RHSType) 1044 return LHSType; 1045 1046 // If either side is a non-arithmetic type (e.g. a pointer), we are done. 1047 // The caller can deal with this (e.g. pointer + int). 1048 if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType()) 1049 return QualType(); 1050 1051 // Apply unary and bitfield promotions to the LHS's type. 1052 QualType LHSUnpromotedType = LHSType; 1053 if (LHSType->isPromotableIntegerType()) 1054 LHSType = Context.getPromotedIntegerType(LHSType); 1055 QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get()); 1056 if (!LHSBitfieldPromoteTy.isNull()) 1057 LHSType = LHSBitfieldPromoteTy; 1058 if (LHSType != LHSUnpromotedType && !IsCompAssign) 1059 LHS = ImpCastExprToType(LHS.take(), LHSType, CK_IntegralCast); 1060 1061 // If both types are identical, no conversion is needed. 1062 if (LHSType == RHSType) 1063 return LHSType; 1064 1065 // At this point, we have two different arithmetic types. 1066 1067 // Handle complex types first (C99 6.3.1.8p1). 1068 if (LHSType->isComplexType() || RHSType->isComplexType()) 1069 return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType, 1070 IsCompAssign); 1071 1072 // Now handle "real" floating types (i.e. float, double, long double). 1073 if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType()) 1074 return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType, 1075 IsCompAssign); 1076 1077 // Handle GCC complex int extension. 1078 if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType()) 1079 return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType, 1080 IsCompAssign); 1081 1082 // Finally, we have two differing integer types. 1083 return handleIntegerConversion(*this, LHS, RHS, LHSType, RHSType, 1084 IsCompAssign); 1085} 1086 1087//===----------------------------------------------------------------------===// 1088// Semantic Analysis for various Expression Types 1089//===----------------------------------------------------------------------===// 1090 1091 1092ExprResult 1093Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc, 1094 SourceLocation DefaultLoc, 1095 SourceLocation RParenLoc, 1096 Expr *ControllingExpr, 1097 MultiTypeArg ArgTypes, 1098 MultiExprArg ArgExprs) { 1099 unsigned NumAssocs = ArgTypes.size(); 1100 assert(NumAssocs == ArgExprs.size()); 1101 1102 ParsedType *ParsedTypes = ArgTypes.release(); 1103 Expr **Exprs = ArgExprs.release(); 1104 1105 TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs]; 1106 for (unsigned i = 0; i < NumAssocs; ++i) { 1107 if (ParsedTypes[i]) 1108 (void) GetTypeFromParser(ParsedTypes[i], &Types[i]); 1109 else 1110 Types[i] = 0; 1111 } 1112 1113 ExprResult ER = CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, 1114 ControllingExpr, Types, Exprs, 1115 NumAssocs); 1116 delete [] Types; 1117 return ER; 1118} 1119 1120ExprResult 1121Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc, 1122 SourceLocation DefaultLoc, 1123 SourceLocation RParenLoc, 1124 Expr *ControllingExpr, 1125 TypeSourceInfo **Types, 1126 Expr **Exprs, 1127 unsigned NumAssocs) { 1128 bool TypeErrorFound = false, 1129 IsResultDependent = ControllingExpr->isTypeDependent(), 1130 ContainsUnexpandedParameterPack 1131 = ControllingExpr->containsUnexpandedParameterPack(); 1132 1133 for (unsigned i = 0; i < NumAssocs; ++i) { 1134 if (Exprs[i]->containsUnexpandedParameterPack()) 1135 ContainsUnexpandedParameterPack = true; 1136 1137 if (Types[i]) { 1138 if (Types[i]->getType()->containsUnexpandedParameterPack()) 1139 ContainsUnexpandedParameterPack = true; 1140 1141 if (Types[i]->getType()->isDependentType()) { 1142 IsResultDependent = true; 1143 } else { 1144 // C11 6.5.1.1p2 "The type name in a generic association shall specify a 1145 // complete object type other than a variably modified type." 1146 unsigned D = 0; 1147 if (Types[i]->getType()->isIncompleteType()) 1148 D = diag::err_assoc_type_incomplete; 1149 else if (!Types[i]->getType()->isObjectType()) 1150 D = diag::err_assoc_type_nonobject; 1151 else if (Types[i]->getType()->isVariablyModifiedType()) 1152 D = diag::err_assoc_type_variably_modified; 1153 1154 if (D != 0) { 1155 Diag(Types[i]->getTypeLoc().getBeginLoc(), D) 1156 << Types[i]->getTypeLoc().getSourceRange() 1157 << Types[i]->getType(); 1158 TypeErrorFound = true; 1159 } 1160 1161 // C11 6.5.1.1p2 "No two generic associations in the same generic 1162 // selection shall specify compatible types." 1163 for (unsigned j = i+1; j < NumAssocs; ++j) 1164 if (Types[j] && !Types[j]->getType()->isDependentType() && 1165 Context.typesAreCompatible(Types[i]->getType(), 1166 Types[j]->getType())) { 1167 Diag(Types[j]->getTypeLoc().getBeginLoc(), 1168 diag::err_assoc_compatible_types) 1169 << Types[j]->getTypeLoc().getSourceRange() 1170 << Types[j]->getType() 1171 << Types[i]->getType(); 1172 Diag(Types[i]->getTypeLoc().getBeginLoc(), 1173 diag::note_compat_assoc) 1174 << Types[i]->getTypeLoc().getSourceRange() 1175 << Types[i]->getType(); 1176 TypeErrorFound = true; 1177 } 1178 } 1179 } 1180 } 1181 if (TypeErrorFound) 1182 return ExprError(); 1183 1184 // If we determined that the generic selection is result-dependent, don't 1185 // try to compute the result expression. 1186 if (IsResultDependent) 1187 return Owned(new (Context) GenericSelectionExpr( 1188 Context, KeyLoc, ControllingExpr, 1189 Types, Exprs, NumAssocs, DefaultLoc, 1190 RParenLoc, ContainsUnexpandedParameterPack)); 1191 1192 SmallVector<unsigned, 1> CompatIndices; 1193 unsigned DefaultIndex = -1U; 1194 for (unsigned i = 0; i < NumAssocs; ++i) { 1195 if (!Types[i]) 1196 DefaultIndex = i; 1197 else if (Context.typesAreCompatible(ControllingExpr->getType(), 1198 Types[i]->getType())) 1199 CompatIndices.push_back(i); 1200 } 1201 1202 // C11 6.5.1.1p2 "The controlling expression of a generic selection shall have 1203 // type compatible with at most one of the types named in its generic 1204 // association list." 1205 if (CompatIndices.size() > 1) { 1206 // We strip parens here because the controlling expression is typically 1207 // parenthesized in macro definitions. 1208 ControllingExpr = ControllingExpr->IgnoreParens(); 1209 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_multi_match) 1210 << ControllingExpr->getSourceRange() << ControllingExpr->getType() 1211 << (unsigned) CompatIndices.size(); 1212 for (SmallVector<unsigned, 1>::iterator I = CompatIndices.begin(), 1213 E = CompatIndices.end(); I != E; ++I) { 1214 Diag(Types[*I]->getTypeLoc().getBeginLoc(), 1215 diag::note_compat_assoc) 1216 << Types[*I]->getTypeLoc().getSourceRange() 1217 << Types[*I]->getType(); 1218 } 1219 return ExprError(); 1220 } 1221 1222 // C11 6.5.1.1p2 "If a generic selection has no default generic association, 1223 // its controlling expression shall have type compatible with exactly one of 1224 // the types named in its generic association list." 1225 if (DefaultIndex == -1U && CompatIndices.size() == 0) { 1226 // We strip parens here because the controlling expression is typically 1227 // parenthesized in macro definitions. 1228 ControllingExpr = ControllingExpr->IgnoreParens(); 1229 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_no_match) 1230 << ControllingExpr->getSourceRange() << ControllingExpr->getType(); 1231 return ExprError(); 1232 } 1233 1234 // C11 6.5.1.1p3 "If a generic selection has a generic association with a 1235 // type name that is compatible with the type of the controlling expression, 1236 // then the result expression of the generic selection is the expression 1237 // in that generic association. Otherwise, the result expression of the 1238 // generic selection is the expression in the default generic association." 1239 unsigned ResultIndex = 1240 CompatIndices.size() ? CompatIndices[0] : DefaultIndex; 1241 1242 return Owned(new (Context) GenericSelectionExpr( 1243 Context, KeyLoc, ControllingExpr, 1244 Types, Exprs, NumAssocs, DefaultLoc, 1245 RParenLoc, ContainsUnexpandedParameterPack, 1246 ResultIndex)); 1247} 1248 1249/// getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the 1250/// location of the token and the offset of the ud-suffix within it. 1251static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc, 1252 unsigned Offset) { 1253 return Lexer::AdvanceToTokenCharacter(TokLoc, Offset, S.getSourceManager(), 1254 S.getLangOpts()); 1255} 1256 1257/// BuildCookedLiteralOperatorCall - A user-defined literal was found. Look up 1258/// the corresponding cooked (non-raw) literal operator, and build a call to it. 1259static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope, 1260 IdentifierInfo *UDSuffix, 1261 SourceLocation UDSuffixLoc, 1262 ArrayRef<Expr*> Args, 1263 SourceLocation LitEndLoc) { 1264 assert(Args.size() <= 2 && "too many arguments for literal operator"); 1265 1266 QualType ArgTy[2]; 1267 for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) { 1268 ArgTy[ArgIdx] = Args[ArgIdx]->getType(); 1269 if (ArgTy[ArgIdx]->isArrayType()) 1270 ArgTy[ArgIdx] = S.Context.getArrayDecayedType(ArgTy[ArgIdx]); 1271 } 1272 1273 DeclarationName OpName = 1274 S.Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 1275 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 1276 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 1277 1278 LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName); 1279 if (S.LookupLiteralOperator(Scope, R, llvm::makeArrayRef(ArgTy, Args.size()), 1280 /*AllowRawAndTemplate*/false) == Sema::LOLR_Error) 1281 return ExprError(); 1282 1283 return S.BuildLiteralOperatorCall(R, OpNameInfo, Args, LitEndLoc); 1284} 1285 1286/// ActOnStringLiteral - The specified tokens were lexed as pasted string 1287/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string 1288/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from 1289/// multiple tokens. However, the common case is that StringToks points to one 1290/// string. 1291/// 1292ExprResult 1293Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks, 1294 Scope *UDLScope) { 1295 assert(NumStringToks && "Must have at least one string!"); 1296 1297 StringLiteralParser Literal(StringToks, NumStringToks, PP); 1298 if (Literal.hadError) 1299 return ExprError(); 1300 1301 SmallVector<SourceLocation, 4> StringTokLocs; 1302 for (unsigned i = 0; i != NumStringToks; ++i) 1303 StringTokLocs.push_back(StringToks[i].getLocation()); 1304 1305 QualType StrTy = Context.CharTy; 1306 if (Literal.isWide()) 1307 StrTy = Context.getWCharType(); 1308 else if (Literal.isUTF16()) 1309 StrTy = Context.Char16Ty; 1310 else if (Literal.isUTF32()) 1311 StrTy = Context.Char32Ty; 1312 else if (Literal.isPascal()) 1313 StrTy = Context.UnsignedCharTy; 1314 1315 StringLiteral::StringKind Kind = StringLiteral::Ascii; 1316 if (Literal.isWide()) 1317 Kind = StringLiteral::Wide; 1318 else if (Literal.isUTF8()) 1319 Kind = StringLiteral::UTF8; 1320 else if (Literal.isUTF16()) 1321 Kind = StringLiteral::UTF16; 1322 else if (Literal.isUTF32()) 1323 Kind = StringLiteral::UTF32; 1324 1325 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1). 1326 if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings) 1327 StrTy.addConst(); 1328 1329 // Get an array type for the string, according to C99 6.4.5. This includes 1330 // the nul terminator character as well as the string length for pascal 1331 // strings. 1332 StrTy = Context.getConstantArrayType(StrTy, 1333 llvm::APInt(32, Literal.GetNumStringChars()+1), 1334 ArrayType::Normal, 0); 1335 1336 // Pass &StringTokLocs[0], StringTokLocs.size() to factory! 1337 StringLiteral *Lit = StringLiteral::Create(Context, Literal.GetString(), 1338 Kind, Literal.Pascal, StrTy, 1339 &StringTokLocs[0], 1340 StringTokLocs.size()); 1341 if (Literal.getUDSuffix().empty()) 1342 return Owned(Lit); 1343 1344 // We're building a user-defined literal. 1345 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 1346 SourceLocation UDSuffixLoc = 1347 getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()], 1348 Literal.getUDSuffixOffset()); 1349 1350 // Make sure we're allowed user-defined literals here. 1351 if (!UDLScope) 1352 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_string_udl)); 1353 1354 // C++11 [lex.ext]p5: The literal L is treated as a call of the form 1355 // operator "" X (str, len) 1356 QualType SizeType = Context.getSizeType(); 1357 llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars()); 1358 IntegerLiteral *LenArg = IntegerLiteral::Create(Context, Len, SizeType, 1359 StringTokLocs[0]); 1360 Expr *Args[] = { Lit, LenArg }; 1361 return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc, 1362 Args, StringTokLocs.back()); 1363} 1364 1365ExprResult 1366Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1367 SourceLocation Loc, 1368 const CXXScopeSpec *SS) { 1369 DeclarationNameInfo NameInfo(D->getDeclName(), Loc); 1370 return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS); 1371} 1372 1373/// BuildDeclRefExpr - Build an expression that references a 1374/// declaration that does not require a closure capture. 1375ExprResult 1376Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1377 const DeclarationNameInfo &NameInfo, 1378 const CXXScopeSpec *SS) { 1379 if (getLangOpts().CUDA) 1380 if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext)) 1381 if (const FunctionDecl *Callee = dyn_cast<FunctionDecl>(D)) { 1382 CUDAFunctionTarget CallerTarget = IdentifyCUDATarget(Caller), 1383 CalleeTarget = IdentifyCUDATarget(Callee); 1384 if (CheckCUDATarget(CallerTarget, CalleeTarget)) { 1385 Diag(NameInfo.getLoc(), diag::err_ref_bad_target) 1386 << CalleeTarget << D->getIdentifier() << CallerTarget; 1387 Diag(D->getLocation(), diag::note_previous_decl) 1388 << D->getIdentifier(); 1389 return ExprError(); 1390 } 1391 } 1392 1393 bool refersToEnclosingScope = 1394 (CurContext != D->getDeclContext() && 1395 D->getDeclContext()->isFunctionOrMethod()); 1396 1397 DeclRefExpr *E = DeclRefExpr::Create(Context, 1398 SS ? SS->getWithLocInContext(Context) 1399 : NestedNameSpecifierLoc(), 1400 SourceLocation(), 1401 D, refersToEnclosingScope, 1402 NameInfo, Ty, VK); 1403 1404 MarkDeclRefReferenced(E); 1405 1406 // Just in case we're building an illegal pointer-to-member. 1407 FieldDecl *FD = dyn_cast<FieldDecl>(D); 1408 if (FD && FD->isBitField()) 1409 E->setObjectKind(OK_BitField); 1410 1411 return Owned(E); 1412} 1413 1414/// Decomposes the given name into a DeclarationNameInfo, its location, and 1415/// possibly a list of template arguments. 1416/// 1417/// If this produces template arguments, it is permitted to call 1418/// DecomposeTemplateName. 1419/// 1420/// This actually loses a lot of source location information for 1421/// non-standard name kinds; we should consider preserving that in 1422/// some way. 1423void 1424Sema::DecomposeUnqualifiedId(const UnqualifiedId &Id, 1425 TemplateArgumentListInfo &Buffer, 1426 DeclarationNameInfo &NameInfo, 1427 const TemplateArgumentListInfo *&TemplateArgs) { 1428 if (Id.getKind() == UnqualifiedId::IK_TemplateId) { 1429 Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc); 1430 Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc); 1431 1432 ASTTemplateArgsPtr TemplateArgsPtr(*this, 1433 Id.TemplateId->getTemplateArgs(), 1434 Id.TemplateId->NumArgs); 1435 translateTemplateArguments(TemplateArgsPtr, Buffer); 1436 TemplateArgsPtr.release(); 1437 1438 TemplateName TName = Id.TemplateId->Template.get(); 1439 SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc; 1440 NameInfo = Context.getNameForTemplate(TName, TNameLoc); 1441 TemplateArgs = &Buffer; 1442 } else { 1443 NameInfo = GetNameFromUnqualifiedId(Id); 1444 TemplateArgs = 0; 1445 } 1446} 1447 1448/// Diagnose an empty lookup. 1449/// 1450/// \return false if new lookup candidates were found 1451bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, 1452 CorrectionCandidateCallback &CCC, 1453 TemplateArgumentListInfo *ExplicitTemplateArgs, 1454 llvm::ArrayRef<Expr *> Args) { 1455 DeclarationName Name = R.getLookupName(); 1456 1457 unsigned diagnostic = diag::err_undeclared_var_use; 1458 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest; 1459 if (Name.getNameKind() == DeclarationName::CXXOperatorName || 1460 Name.getNameKind() == DeclarationName::CXXLiteralOperatorName || 1461 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 1462 diagnostic = diag::err_undeclared_use; 1463 diagnostic_suggest = diag::err_undeclared_use_suggest; 1464 } 1465 1466 // If the original lookup was an unqualified lookup, fake an 1467 // unqualified lookup. This is useful when (for example) the 1468 // original lookup would not have found something because it was a 1469 // dependent name. 1470 DeclContext *DC = (SS.isEmpty() && !CallsUndergoingInstantiation.empty()) 1471 ? CurContext : 0; 1472 while (DC) { 1473 if (isa<CXXRecordDecl>(DC)) { 1474 LookupQualifiedName(R, DC); 1475 1476 if (!R.empty()) { 1477 // Don't give errors about ambiguities in this lookup. 1478 R.suppressDiagnostics(); 1479 1480 // During a default argument instantiation the CurContext points 1481 // to a CXXMethodDecl; but we can't apply a this-> fixit inside a 1482 // function parameter list, hence add an explicit check. 1483 bool isDefaultArgument = !ActiveTemplateInstantiations.empty() && 1484 ActiveTemplateInstantiations.back().Kind == 1485 ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation; 1486 CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext); 1487 bool isInstance = CurMethod && 1488 CurMethod->isInstance() && 1489 DC == CurMethod->getParent() && !isDefaultArgument; 1490 1491 1492 // Give a code modification hint to insert 'this->'. 1493 // TODO: fixit for inserting 'Base<T>::' in the other cases. 1494 // Actually quite difficult! 1495 if (getLangOpts().MicrosoftMode) 1496 diagnostic = diag::warn_found_via_dependent_bases_lookup; 1497 if (isInstance) { 1498 Diag(R.getNameLoc(), diagnostic) << Name 1499 << FixItHint::CreateInsertion(R.getNameLoc(), "this->"); 1500 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>( 1501 CallsUndergoingInstantiation.back()->getCallee()); 1502 1503 1504 CXXMethodDecl *DepMethod; 1505 if (CurMethod->getTemplatedKind() == 1506 FunctionDecl::TK_FunctionTemplateSpecialization) 1507 DepMethod = cast<CXXMethodDecl>(CurMethod->getPrimaryTemplate()-> 1508 getInstantiatedFromMemberTemplate()->getTemplatedDecl()); 1509 else 1510 DepMethod = cast<CXXMethodDecl>( 1511 CurMethod->getInstantiatedFromMemberFunction()); 1512 assert(DepMethod && "No template pattern found"); 1513 1514 QualType DepThisType = DepMethod->getThisType(Context); 1515 CheckCXXThisCapture(R.getNameLoc()); 1516 CXXThisExpr *DepThis = new (Context) CXXThisExpr( 1517 R.getNameLoc(), DepThisType, false); 1518 TemplateArgumentListInfo TList; 1519 if (ULE->hasExplicitTemplateArgs()) 1520 ULE->copyTemplateArgumentsInto(TList); 1521 1522 CXXScopeSpec SS; 1523 SS.Adopt(ULE->getQualifierLoc()); 1524 CXXDependentScopeMemberExpr *DepExpr = 1525 CXXDependentScopeMemberExpr::Create( 1526 Context, DepThis, DepThisType, true, SourceLocation(), 1527 SS.getWithLocInContext(Context), 1528 ULE->getTemplateKeywordLoc(), 0, 1529 R.getLookupNameInfo(), 1530 ULE->hasExplicitTemplateArgs() ? &TList : 0); 1531 CallsUndergoingInstantiation.back()->setCallee(DepExpr); 1532 } else { 1533 Diag(R.getNameLoc(), diagnostic) << Name; 1534 } 1535 1536 // Do we really want to note all of these? 1537 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) 1538 Diag((*I)->getLocation(), diag::note_dependent_var_use); 1539 1540 // Return true if we are inside a default argument instantiation 1541 // and the found name refers to an instance member function, otherwise 1542 // the function calling DiagnoseEmptyLookup will try to create an 1543 // implicit member call and this is wrong for default argument. 1544 if (isDefaultArgument && ((*R.begin())->isCXXInstanceMember())) { 1545 Diag(R.getNameLoc(), diag::err_member_call_without_object); 1546 return true; 1547 } 1548 1549 // Tell the callee to try to recover. 1550 return false; 1551 } 1552 1553 R.clear(); 1554 } 1555 1556 // In Microsoft mode, if we are performing lookup from within a friend 1557 // function definition declared at class scope then we must set 1558 // DC to the lexical parent to be able to search into the parent 1559 // class. 1560 if (getLangOpts().MicrosoftMode && isa<FunctionDecl>(DC) && 1561 cast<FunctionDecl>(DC)->getFriendObjectKind() && 1562 DC->getLexicalParent()->isRecord()) 1563 DC = DC->getLexicalParent(); 1564 else 1565 DC = DC->getParent(); 1566 } 1567 1568 // We didn't find anything, so try to correct for a typo. 1569 TypoCorrection Corrected; 1570 if (S && (Corrected = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), 1571 S, &SS, CCC))) { 1572 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 1573 std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOpts())); 1574 R.setLookupName(Corrected.getCorrection()); 1575 1576 if (NamedDecl *ND = Corrected.getCorrectionDecl()) { 1577 if (Corrected.isOverloaded()) { 1578 OverloadCandidateSet OCS(R.getNameLoc()); 1579 OverloadCandidateSet::iterator Best; 1580 for (TypoCorrection::decl_iterator CD = Corrected.begin(), 1581 CDEnd = Corrected.end(); 1582 CD != CDEnd; ++CD) { 1583 if (FunctionTemplateDecl *FTD = 1584 dyn_cast<FunctionTemplateDecl>(*CD)) 1585 AddTemplateOverloadCandidate( 1586 FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs, 1587 Args, OCS); 1588 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD)) 1589 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0) 1590 AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), 1591 Args, OCS); 1592 } 1593 switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) { 1594 case OR_Success: 1595 ND = Best->Function; 1596 break; 1597 default: 1598 break; 1599 } 1600 } 1601 R.addDecl(ND); 1602 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) { 1603 if (SS.isEmpty()) 1604 Diag(R.getNameLoc(), diagnostic_suggest) << Name << CorrectedQuotedStr 1605 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr); 1606 else 1607 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1608 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1609 << SS.getRange() 1610 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr); 1611 if (ND) 1612 Diag(ND->getLocation(), diag::note_previous_decl) 1613 << CorrectedQuotedStr; 1614 1615 // Tell the callee to try to recover. 1616 return false; 1617 } 1618 1619 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) { 1620 // FIXME: If we ended up with a typo for a type name or 1621 // Objective-C class name, we're in trouble because the parser 1622 // is in the wrong place to recover. Suggest the typo 1623 // correction, but don't make it a fix-it since we're not going 1624 // to recover well anyway. 1625 if (SS.isEmpty()) 1626 Diag(R.getNameLoc(), diagnostic_suggest) 1627 << Name << CorrectedQuotedStr; 1628 else 1629 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1630 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1631 << SS.getRange(); 1632 1633 // Don't try to recover; it won't work. 1634 return true; 1635 } 1636 } else { 1637 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it 1638 // because we aren't able to recover. 1639 if (SS.isEmpty()) 1640 Diag(R.getNameLoc(), diagnostic_suggest) << Name << CorrectedQuotedStr; 1641 else 1642 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1643 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1644 << SS.getRange(); 1645 return true; 1646 } 1647 } 1648 R.clear(); 1649 1650 // Emit a special diagnostic for failed member lookups. 1651 // FIXME: computing the declaration context might fail here (?) 1652 if (!SS.isEmpty()) { 1653 Diag(R.getNameLoc(), diag::err_no_member) 1654 << Name << computeDeclContext(SS, false) 1655 << SS.getRange(); 1656 return true; 1657 } 1658 1659 // Give up, we can't recover. 1660 Diag(R.getNameLoc(), diagnostic) << Name; 1661 return true; 1662} 1663 1664ExprResult Sema::ActOnIdExpression(Scope *S, 1665 CXXScopeSpec &SS, 1666 SourceLocation TemplateKWLoc, 1667 UnqualifiedId &Id, 1668 bool HasTrailingLParen, 1669 bool IsAddressOfOperand, 1670 CorrectionCandidateCallback *CCC) { 1671 assert(!(IsAddressOfOperand && HasTrailingLParen) && 1672 "cannot be direct & operand and have a trailing lparen"); 1673 1674 if (SS.isInvalid()) 1675 return ExprError(); 1676 1677 TemplateArgumentListInfo TemplateArgsBuffer; 1678 1679 // Decompose the UnqualifiedId into the following data. 1680 DeclarationNameInfo NameInfo; 1681 const TemplateArgumentListInfo *TemplateArgs; 1682 DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs); 1683 1684 DeclarationName Name = NameInfo.getName(); 1685 IdentifierInfo *II = Name.getAsIdentifierInfo(); 1686 SourceLocation NameLoc = NameInfo.getLoc(); 1687 1688 // C++ [temp.dep.expr]p3: 1689 // An id-expression is type-dependent if it contains: 1690 // -- an identifier that was declared with a dependent type, 1691 // (note: handled after lookup) 1692 // -- a template-id that is dependent, 1693 // (note: handled in BuildTemplateIdExpr) 1694 // -- a conversion-function-id that specifies a dependent type, 1695 // -- a nested-name-specifier that contains a class-name that 1696 // names a dependent type. 1697 // Determine whether this is a member of an unknown specialization; 1698 // we need to handle these differently. 1699 bool DependentID = false; 1700 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName && 1701 Name.getCXXNameType()->isDependentType()) { 1702 DependentID = true; 1703 } else if (SS.isSet()) { 1704 if (DeclContext *DC = computeDeclContext(SS, false)) { 1705 if (RequireCompleteDeclContext(SS, DC)) 1706 return ExprError(); 1707 } else { 1708 DependentID = true; 1709 } 1710 } 1711 1712 if (DependentID) 1713 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1714 IsAddressOfOperand, TemplateArgs); 1715 1716 // Perform the required lookup. 1717 LookupResult R(*this, NameInfo, 1718 (Id.getKind() == UnqualifiedId::IK_ImplicitSelfParam) 1719 ? LookupObjCImplicitSelfParam : LookupOrdinaryName); 1720 if (TemplateArgs) { 1721 // Lookup the template name again to correctly establish the context in 1722 // which it was found. This is really unfortunate as we already did the 1723 // lookup to determine that it was a template name in the first place. If 1724 // this becomes a performance hit, we can work harder to preserve those 1725 // results until we get here but it's likely not worth it. 1726 bool MemberOfUnknownSpecialization; 1727 LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false, 1728 MemberOfUnknownSpecialization); 1729 1730 if (MemberOfUnknownSpecialization || 1731 (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)) 1732 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1733 IsAddressOfOperand, TemplateArgs); 1734 } else { 1735 bool IvarLookupFollowUp = II && !SS.isSet() && getCurMethodDecl(); 1736 LookupParsedName(R, S, &SS, !IvarLookupFollowUp); 1737 1738 // If the result might be in a dependent base class, this is a dependent 1739 // id-expression. 1740 if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation) 1741 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1742 IsAddressOfOperand, TemplateArgs); 1743 1744 // If this reference is in an Objective-C method, then we need to do 1745 // some special Objective-C lookup, too. 1746 if (IvarLookupFollowUp) { 1747 ExprResult E(LookupInObjCMethod(R, S, II, true)); 1748 if (E.isInvalid()) 1749 return ExprError(); 1750 1751 if (Expr *Ex = E.takeAs<Expr>()) 1752 return Owned(Ex); 1753 } 1754 } 1755 1756 if (R.isAmbiguous()) 1757 return ExprError(); 1758 1759 // Determine whether this name might be a candidate for 1760 // argument-dependent lookup. 1761 bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen); 1762 1763 if (R.empty() && !ADL) { 1764 // Otherwise, this could be an implicitly declared function reference (legal 1765 // in C90, extension in C99, forbidden in C++). 1766 if (HasTrailingLParen && II && !getLangOpts().CPlusPlus) { 1767 NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S); 1768 if (D) R.addDecl(D); 1769 } 1770 1771 // If this name wasn't predeclared and if this is not a function 1772 // call, diagnose the problem. 1773 if (R.empty()) { 1774 1775 // In Microsoft mode, if we are inside a template class member function 1776 // and we can't resolve an identifier then assume the identifier is type 1777 // dependent. The goal is to postpone name lookup to instantiation time 1778 // to be able to search into type dependent base classes. 1779 if (getLangOpts().MicrosoftMode && CurContext->isDependentContext() && 1780 isa<CXXMethodDecl>(CurContext)) 1781 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1782 IsAddressOfOperand, TemplateArgs); 1783 1784 CorrectionCandidateCallback DefaultValidator; 1785 if (DiagnoseEmptyLookup(S, SS, R, CCC ? *CCC : DefaultValidator)) 1786 return ExprError(); 1787 1788 assert(!R.empty() && 1789 "DiagnoseEmptyLookup returned false but added no results"); 1790 1791 // If we found an Objective-C instance variable, let 1792 // LookupInObjCMethod build the appropriate expression to 1793 // reference the ivar. 1794 if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) { 1795 R.clear(); 1796 ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier())); 1797 // In a hopelessly buggy code, Objective-C instance variable 1798 // lookup fails and no expression will be built to reference it. 1799 if (!E.isInvalid() && !E.get()) 1800 return ExprError(); 1801 return move(E); 1802 } 1803 } 1804 } 1805 1806 // This is guaranteed from this point on. 1807 assert(!R.empty() || ADL); 1808 1809 // Check whether this might be a C++ implicit instance member access. 1810 // C++ [class.mfct.non-static]p3: 1811 // When an id-expression that is not part of a class member access 1812 // syntax and not used to form a pointer to member is used in the 1813 // body of a non-static member function of class X, if name lookup 1814 // resolves the name in the id-expression to a non-static non-type 1815 // member of some class C, the id-expression is transformed into a 1816 // class member access expression using (*this) as the 1817 // postfix-expression to the left of the . operator. 1818 // 1819 // But we don't actually need to do this for '&' operands if R 1820 // resolved to a function or overloaded function set, because the 1821 // expression is ill-formed if it actually works out to be a 1822 // non-static member function: 1823 // 1824 // C++ [expr.ref]p4: 1825 // Otherwise, if E1.E2 refers to a non-static member function. . . 1826 // [t]he expression can be used only as the left-hand operand of a 1827 // member function call. 1828 // 1829 // There are other safeguards against such uses, but it's important 1830 // to get this right here so that we don't end up making a 1831 // spuriously dependent expression if we're inside a dependent 1832 // instance method. 1833 if (!R.empty() && (*R.begin())->isCXXClassMember()) { 1834 bool MightBeImplicitMember; 1835 if (!IsAddressOfOperand) 1836 MightBeImplicitMember = true; 1837 else if (!SS.isEmpty()) 1838 MightBeImplicitMember = false; 1839 else if (R.isOverloadedResult()) 1840 MightBeImplicitMember = false; 1841 else if (R.isUnresolvableResult()) 1842 MightBeImplicitMember = true; 1843 else 1844 MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) || 1845 isa<IndirectFieldDecl>(R.getFoundDecl()); 1846 1847 if (MightBeImplicitMember) 1848 return BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, 1849 R, TemplateArgs); 1850 } 1851 1852 if (TemplateArgs || TemplateKWLoc.isValid()) 1853 return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs); 1854 1855 return BuildDeclarationNameExpr(SS, R, ADL); 1856} 1857 1858/// BuildQualifiedDeclarationNameExpr - Build a C++ qualified 1859/// declaration name, generally during template instantiation. 1860/// There's a large number of things which don't need to be done along 1861/// this path. 1862ExprResult 1863Sema::BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, 1864 const DeclarationNameInfo &NameInfo) { 1865 DeclContext *DC; 1866 if (!(DC = computeDeclContext(SS, false)) || DC->isDependentContext()) 1867 return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(), 1868 NameInfo, /*TemplateArgs=*/0); 1869 1870 if (RequireCompleteDeclContext(SS, DC)) 1871 return ExprError(); 1872 1873 LookupResult R(*this, NameInfo, LookupOrdinaryName); 1874 LookupQualifiedName(R, DC); 1875 1876 if (R.isAmbiguous()) 1877 return ExprError(); 1878 1879 if (R.empty()) { 1880 Diag(NameInfo.getLoc(), diag::err_no_member) 1881 << NameInfo.getName() << DC << SS.getRange(); 1882 return ExprError(); 1883 } 1884 1885 return BuildDeclarationNameExpr(SS, R, /*ADL*/ false); 1886} 1887 1888/// LookupInObjCMethod - The parser has read a name in, and Sema has 1889/// detected that we're currently inside an ObjC method. Perform some 1890/// additional lookup. 1891/// 1892/// Ideally, most of this would be done by lookup, but there's 1893/// actually quite a lot of extra work involved. 1894/// 1895/// Returns a null sentinel to indicate trivial success. 1896ExprResult 1897Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S, 1898 IdentifierInfo *II, bool AllowBuiltinCreation) { 1899 SourceLocation Loc = Lookup.getNameLoc(); 1900 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 1901 1902 // There are two cases to handle here. 1) scoped lookup could have failed, 1903 // in which case we should look for an ivar. 2) scoped lookup could have 1904 // found a decl, but that decl is outside the current instance method (i.e. 1905 // a global variable). In these two cases, we do a lookup for an ivar with 1906 // this name, if the lookup sucedes, we replace it our current decl. 1907 1908 // If we're in a class method, we don't normally want to look for 1909 // ivars. But if we don't find anything else, and there's an 1910 // ivar, that's an error. 1911 bool IsClassMethod = CurMethod->isClassMethod(); 1912 1913 bool LookForIvars; 1914 if (Lookup.empty()) 1915 LookForIvars = true; 1916 else if (IsClassMethod) 1917 LookForIvars = false; 1918 else 1919 LookForIvars = (Lookup.isSingleResult() && 1920 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()); 1921 ObjCInterfaceDecl *IFace = 0; 1922 if (LookForIvars) { 1923 IFace = CurMethod->getClassInterface(); 1924 ObjCInterfaceDecl *ClassDeclared; 1925 ObjCIvarDecl *IV = 0; 1926 if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) { 1927 // Diagnose using an ivar in a class method. 1928 if (IsClassMethod) 1929 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 1930 << IV->getDeclName()); 1931 1932 // If we're referencing an invalid decl, just return this as a silent 1933 // error node. The error diagnostic was already emitted on the decl. 1934 if (IV->isInvalidDecl()) 1935 return ExprError(); 1936 1937 // Check if referencing a field with __attribute__((deprecated)). 1938 if (DiagnoseUseOfDecl(IV, Loc)) 1939 return ExprError(); 1940 1941 // Diagnose the use of an ivar outside of the declaring class. 1942 if (IV->getAccessControl() == ObjCIvarDecl::Private && 1943 !declaresSameEntity(ClassDeclared, IFace) && 1944 !getLangOpts().DebuggerSupport) 1945 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName(); 1946 1947 // FIXME: This should use a new expr for a direct reference, don't 1948 // turn this into Self->ivar, just return a BareIVarExpr or something. 1949 IdentifierInfo &II = Context.Idents.get("self"); 1950 UnqualifiedId SelfName; 1951 SelfName.setIdentifier(&II, SourceLocation()); 1952 SelfName.setKind(UnqualifiedId::IK_ImplicitSelfParam); 1953 CXXScopeSpec SelfScopeSpec; 1954 SourceLocation TemplateKWLoc; 1955 ExprResult SelfExpr = ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc, 1956 SelfName, false, false); 1957 if (SelfExpr.isInvalid()) 1958 return ExprError(); 1959 1960 SelfExpr = DefaultLvalueConversion(SelfExpr.take()); 1961 if (SelfExpr.isInvalid()) 1962 return ExprError(); 1963 1964 MarkAnyDeclReferenced(Loc, IV); 1965 return Owned(new (Context) 1966 ObjCIvarRefExpr(IV, IV->getType(), Loc, 1967 SelfExpr.take(), true, true)); 1968 } 1969 } else if (CurMethod->isInstanceMethod()) { 1970 // We should warn if a local variable hides an ivar. 1971 if (ObjCInterfaceDecl *IFace = CurMethod->getClassInterface()) { 1972 ObjCInterfaceDecl *ClassDeclared; 1973 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) { 1974 if (IV->getAccessControl() != ObjCIvarDecl::Private || 1975 declaresSameEntity(IFace, ClassDeclared)) 1976 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName(); 1977 } 1978 } 1979 } else if (Lookup.isSingleResult() && 1980 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()) { 1981 // If accessing a stand-alone ivar in a class method, this is an error. 1982 if (const ObjCIvarDecl *IV = dyn_cast<ObjCIvarDecl>(Lookup.getFoundDecl())) 1983 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 1984 << IV->getDeclName()); 1985 } 1986 1987 if (Lookup.empty() && II && AllowBuiltinCreation) { 1988 // FIXME. Consolidate this with similar code in LookupName. 1989 if (unsigned BuiltinID = II->getBuiltinID()) { 1990 if (!(getLangOpts().CPlusPlus && 1991 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) { 1992 NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID, 1993 S, Lookup.isForRedeclaration(), 1994 Lookup.getNameLoc()); 1995 if (D) Lookup.addDecl(D); 1996 } 1997 } 1998 } 1999 // Sentinel value saying that we didn't do anything special. 2000 return Owned((Expr*) 0); 2001} 2002 2003/// \brief Cast a base object to a member's actual type. 2004/// 2005/// Logically this happens in three phases: 2006/// 2007/// * First we cast from the base type to the naming class. 2008/// The naming class is the class into which we were looking 2009/// when we found the member; it's the qualifier type if a 2010/// qualifier was provided, and otherwise it's the base type. 2011/// 2012/// * Next we cast from the naming class to the declaring class. 2013/// If the member we found was brought into a class's scope by 2014/// a using declaration, this is that class; otherwise it's 2015/// the class declaring the member. 2016/// 2017/// * Finally we cast from the declaring class to the "true" 2018/// declaring class of the member. This conversion does not 2019/// obey access control. 2020ExprResult 2021Sema::PerformObjectMemberConversion(Expr *From, 2022 NestedNameSpecifier *Qualifier, 2023 NamedDecl *FoundDecl, 2024 NamedDecl *Member) { 2025 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext()); 2026 if (!RD) 2027 return Owned(From); 2028 2029 QualType DestRecordType; 2030 QualType DestType; 2031 QualType FromRecordType; 2032 QualType FromType = From->getType(); 2033 bool PointerConversions = false; 2034 if (isa<FieldDecl>(Member)) { 2035 DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD)); 2036 2037 if (FromType->getAs<PointerType>()) { 2038 DestType = Context.getPointerType(DestRecordType); 2039 FromRecordType = FromType->getPointeeType(); 2040 PointerConversions = true; 2041 } else { 2042 DestType = DestRecordType; 2043 FromRecordType = FromType; 2044 } 2045 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) { 2046 if (Method->isStatic()) 2047 return Owned(From); 2048 2049 DestType = Method->getThisType(Context); 2050 DestRecordType = DestType->getPointeeType(); 2051 2052 if (FromType->getAs<PointerType>()) { 2053 FromRecordType = FromType->getPointeeType(); 2054 PointerConversions = true; 2055 } else { 2056 FromRecordType = FromType; 2057 DestType = DestRecordType; 2058 } 2059 } else { 2060 // No conversion necessary. 2061 return Owned(From); 2062 } 2063 2064 if (DestType->isDependentType() || FromType->isDependentType()) 2065 return Owned(From); 2066 2067 // If the unqualified types are the same, no conversion is necessary. 2068 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 2069 return Owned(From); 2070 2071 SourceRange FromRange = From->getSourceRange(); 2072 SourceLocation FromLoc = FromRange.getBegin(); 2073 2074 ExprValueKind VK = From->getValueKind(); 2075 2076 // C++ [class.member.lookup]p8: 2077 // [...] Ambiguities can often be resolved by qualifying a name with its 2078 // class name. 2079 // 2080 // If the member was a qualified name and the qualified referred to a 2081 // specific base subobject type, we'll cast to that intermediate type 2082 // first and then to the object in which the member is declared. That allows 2083 // one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as: 2084 // 2085 // class Base { public: int x; }; 2086 // class Derived1 : public Base { }; 2087 // class Derived2 : public Base { }; 2088 // class VeryDerived : public Derived1, public Derived2 { void f(); }; 2089 // 2090 // void VeryDerived::f() { 2091 // x = 17; // error: ambiguous base subobjects 2092 // Derived1::x = 17; // okay, pick the Base subobject of Derived1 2093 // } 2094 if (Qualifier) { 2095 QualType QType = QualType(Qualifier->getAsType(), 0); 2096 assert(!QType.isNull() && "lookup done with dependent qualifier?"); 2097 assert(QType->isRecordType() && "lookup done with non-record type"); 2098 2099 QualType QRecordType = QualType(QType->getAs<RecordType>(), 0); 2100 2101 // In C++98, the qualifier type doesn't actually have to be a base 2102 // type of the object type, in which case we just ignore it. 2103 // Otherwise build the appropriate casts. 2104 if (IsDerivedFrom(FromRecordType, QRecordType)) { 2105 CXXCastPath BasePath; 2106 if (CheckDerivedToBaseConversion(FromRecordType, QRecordType, 2107 FromLoc, FromRange, &BasePath)) 2108 return ExprError(); 2109 2110 if (PointerConversions) 2111 QType = Context.getPointerType(QType); 2112 From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase, 2113 VK, &BasePath).take(); 2114 2115 FromType = QType; 2116 FromRecordType = QRecordType; 2117 2118 // If the qualifier type was the same as the destination type, 2119 // we're done. 2120 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 2121 return Owned(From); 2122 } 2123 } 2124 2125 bool IgnoreAccess = false; 2126 2127 // If we actually found the member through a using declaration, cast 2128 // down to the using declaration's type. 2129 // 2130 // Pointer equality is fine here because only one declaration of a 2131 // class ever has member declarations. 2132 if (FoundDecl->getDeclContext() != Member->getDeclContext()) { 2133 assert(isa<UsingShadowDecl>(FoundDecl)); 2134 QualType URecordType = Context.getTypeDeclType( 2135 cast<CXXRecordDecl>(FoundDecl->getDeclContext())); 2136 2137 // We only need to do this if the naming-class to declaring-class 2138 // conversion is non-trivial. 2139 if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) { 2140 assert(IsDerivedFrom(FromRecordType, URecordType)); 2141 CXXCastPath BasePath; 2142 if (CheckDerivedToBaseConversion(FromRecordType, URecordType, 2143 FromLoc, FromRange, &BasePath)) 2144 return ExprError(); 2145 2146 QualType UType = URecordType; 2147 if (PointerConversions) 2148 UType = Context.getPointerType(UType); 2149 From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase, 2150 VK, &BasePath).take(); 2151 FromType = UType; 2152 FromRecordType = URecordType; 2153 } 2154 2155 // We don't do access control for the conversion from the 2156 // declaring class to the true declaring class. 2157 IgnoreAccess = true; 2158 } 2159 2160 CXXCastPath BasePath; 2161 if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType, 2162 FromLoc, FromRange, &BasePath, 2163 IgnoreAccess)) 2164 return ExprError(); 2165 2166 return ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase, 2167 VK, &BasePath); 2168} 2169 2170bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS, 2171 const LookupResult &R, 2172 bool HasTrailingLParen) { 2173 // Only when used directly as the postfix-expression of a call. 2174 if (!HasTrailingLParen) 2175 return false; 2176 2177 // Never if a scope specifier was provided. 2178 if (SS.isSet()) 2179 return false; 2180 2181 // Only in C++ or ObjC++. 2182 if (!getLangOpts().CPlusPlus) 2183 return false; 2184 2185 // Turn off ADL when we find certain kinds of declarations during 2186 // normal lookup: 2187 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { 2188 NamedDecl *D = *I; 2189 2190 // C++0x [basic.lookup.argdep]p3: 2191 // -- a declaration of a class member 2192 // Since using decls preserve this property, we check this on the 2193 // original decl. 2194 if (D->isCXXClassMember()) 2195 return false; 2196 2197 // C++0x [basic.lookup.argdep]p3: 2198 // -- a block-scope function declaration that is not a 2199 // using-declaration 2200 // NOTE: we also trigger this for function templates (in fact, we 2201 // don't check the decl type at all, since all other decl types 2202 // turn off ADL anyway). 2203 if (isa<UsingShadowDecl>(D)) 2204 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 2205 else if (D->getDeclContext()->isFunctionOrMethod()) 2206 return false; 2207 2208 // C++0x [basic.lookup.argdep]p3: 2209 // -- a declaration that is neither a function or a function 2210 // template 2211 // And also for builtin functions. 2212 if (isa<FunctionDecl>(D)) { 2213 FunctionDecl *FDecl = cast<FunctionDecl>(D); 2214 2215 // But also builtin functions. 2216 if (FDecl->getBuiltinID() && FDecl->isImplicit()) 2217 return false; 2218 } else if (!isa<FunctionTemplateDecl>(D)) 2219 return false; 2220 } 2221 2222 return true; 2223} 2224 2225 2226/// Diagnoses obvious problems with the use of the given declaration 2227/// as an expression. This is only actually called for lookups that 2228/// were not overloaded, and it doesn't promise that the declaration 2229/// will in fact be used. 2230static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) { 2231 if (isa<TypedefNameDecl>(D)) { 2232 S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName(); 2233 return true; 2234 } 2235 2236 if (isa<ObjCInterfaceDecl>(D)) { 2237 S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName(); 2238 return true; 2239 } 2240 2241 if (isa<NamespaceDecl>(D)) { 2242 S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName(); 2243 return true; 2244 } 2245 2246 return false; 2247} 2248 2249ExprResult 2250Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2251 LookupResult &R, 2252 bool NeedsADL) { 2253 // If this is a single, fully-resolved result and we don't need ADL, 2254 // just build an ordinary singleton decl ref. 2255 if (!NeedsADL && R.isSingleResult() && !R.getAsSingle<FunctionTemplateDecl>()) 2256 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), 2257 R.getFoundDecl()); 2258 2259 // We only need to check the declaration if there's exactly one 2260 // result, because in the overloaded case the results can only be 2261 // functions and function templates. 2262 if (R.isSingleResult() && 2263 CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl())) 2264 return ExprError(); 2265 2266 // Otherwise, just build an unresolved lookup expression. Suppress 2267 // any lookup-related diagnostics; we'll hash these out later, when 2268 // we've picked a target. 2269 R.suppressDiagnostics(); 2270 2271 UnresolvedLookupExpr *ULE 2272 = UnresolvedLookupExpr::Create(Context, R.getNamingClass(), 2273 SS.getWithLocInContext(Context), 2274 R.getLookupNameInfo(), 2275 NeedsADL, R.isOverloadedResult(), 2276 R.begin(), R.end()); 2277 2278 return Owned(ULE); 2279} 2280 2281/// \brief Complete semantic analysis for a reference to the given declaration. 2282ExprResult 2283Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2284 const DeclarationNameInfo &NameInfo, 2285 NamedDecl *D) { 2286 assert(D && "Cannot refer to a NULL declaration"); 2287 assert(!isa<FunctionTemplateDecl>(D) && 2288 "Cannot refer unambiguously to a function template"); 2289 2290 SourceLocation Loc = NameInfo.getLoc(); 2291 if (CheckDeclInExpr(*this, Loc, D)) 2292 return ExprError(); 2293 2294 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) { 2295 // Specifically diagnose references to class templates that are missing 2296 // a template argument list. 2297 Diag(Loc, diag::err_template_decl_ref) 2298 << Template << SS.getRange(); 2299 Diag(Template->getLocation(), diag::note_template_decl_here); 2300 return ExprError(); 2301 } 2302 2303 // Make sure that we're referring to a value. 2304 ValueDecl *VD = dyn_cast<ValueDecl>(D); 2305 if (!VD) { 2306 Diag(Loc, diag::err_ref_non_value) 2307 << D << SS.getRange(); 2308 Diag(D->getLocation(), diag::note_declared_at); 2309 return ExprError(); 2310 } 2311 2312 // Check whether this declaration can be used. Note that we suppress 2313 // this check when we're going to perform argument-dependent lookup 2314 // on this function name, because this might not be the function 2315 // that overload resolution actually selects. 2316 if (DiagnoseUseOfDecl(VD, Loc)) 2317 return ExprError(); 2318 2319 // Only create DeclRefExpr's for valid Decl's. 2320 if (VD->isInvalidDecl()) 2321 return ExprError(); 2322 2323 // Handle members of anonymous structs and unions. If we got here, 2324 // and the reference is to a class member indirect field, then this 2325 // must be the subject of a pointer-to-member expression. 2326 if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD)) 2327 if (!indirectField->isCXXClassMember()) 2328 return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(), 2329 indirectField); 2330 2331 { 2332 QualType type = VD->getType(); 2333 ExprValueKind valueKind = VK_RValue; 2334 2335 switch (D->getKind()) { 2336 // Ignore all the non-ValueDecl kinds. 2337#define ABSTRACT_DECL(kind) 2338#define VALUE(type, base) 2339#define DECL(type, base) \ 2340 case Decl::type: 2341#include "clang/AST/DeclNodes.inc" 2342 llvm_unreachable("invalid value decl kind"); 2343 2344 // These shouldn't make it here. 2345 case Decl::ObjCAtDefsField: 2346 case Decl::ObjCIvar: 2347 llvm_unreachable("forming non-member reference to ivar?"); 2348 2349 // Enum constants are always r-values and never references. 2350 // Unresolved using declarations are dependent. 2351 case Decl::EnumConstant: 2352 case Decl::UnresolvedUsingValue: 2353 valueKind = VK_RValue; 2354 break; 2355 2356 // Fields and indirect fields that got here must be for 2357 // pointer-to-member expressions; we just call them l-values for 2358 // internal consistency, because this subexpression doesn't really 2359 // exist in the high-level semantics. 2360 case Decl::Field: 2361 case Decl::IndirectField: 2362 assert(getLangOpts().CPlusPlus && 2363 "building reference to field in C?"); 2364 2365 // These can't have reference type in well-formed programs, but 2366 // for internal consistency we do this anyway. 2367 type = type.getNonReferenceType(); 2368 valueKind = VK_LValue; 2369 break; 2370 2371 // Non-type template parameters are either l-values or r-values 2372 // depending on the type. 2373 case Decl::NonTypeTemplateParm: { 2374 if (const ReferenceType *reftype = type->getAs<ReferenceType>()) { 2375 type = reftype->getPointeeType(); 2376 valueKind = VK_LValue; // even if the parameter is an r-value reference 2377 break; 2378 } 2379 2380 // For non-references, we need to strip qualifiers just in case 2381 // the template parameter was declared as 'const int' or whatever. 2382 valueKind = VK_RValue; 2383 type = type.getUnqualifiedType(); 2384 break; 2385 } 2386 2387 case Decl::Var: 2388 // In C, "extern void blah;" is valid and is an r-value. 2389 if (!getLangOpts().CPlusPlus && 2390 !type.hasQualifiers() && 2391 type->isVoidType()) { 2392 valueKind = VK_RValue; 2393 break; 2394 } 2395 // fallthrough 2396 2397 case Decl::ImplicitParam: 2398 case Decl::ParmVar: { 2399 // These are always l-values. 2400 valueKind = VK_LValue; 2401 type = type.getNonReferenceType(); 2402 2403 // FIXME: Does the addition of const really only apply in 2404 // potentially-evaluated contexts? Since the variable isn't actually 2405 // captured in an unevaluated context, it seems that the answer is no. 2406 if (ExprEvalContexts.back().Context != Sema::Unevaluated) { 2407 QualType CapturedType = getCapturedDeclRefType(cast<VarDecl>(VD), Loc); 2408 if (!CapturedType.isNull()) 2409 type = CapturedType; 2410 } 2411 2412 break; 2413 } 2414 2415 case Decl::Function: { 2416 const FunctionType *fty = type->castAs<FunctionType>(); 2417 2418 // If we're referring to a function with an __unknown_anytype 2419 // result type, make the entire expression __unknown_anytype. 2420 if (fty->getResultType() == Context.UnknownAnyTy) { 2421 type = Context.UnknownAnyTy; 2422 valueKind = VK_RValue; 2423 break; 2424 } 2425 2426 // Functions are l-values in C++. 2427 if (getLangOpts().CPlusPlus) { 2428 valueKind = VK_LValue; 2429 break; 2430 } 2431 2432 // C99 DR 316 says that, if a function type comes from a 2433 // function definition (without a prototype), that type is only 2434 // used for checking compatibility. Therefore, when referencing 2435 // the function, we pretend that we don't have the full function 2436 // type. 2437 if (!cast<FunctionDecl>(VD)->hasPrototype() && 2438 isa<FunctionProtoType>(fty)) 2439 type = Context.getFunctionNoProtoType(fty->getResultType(), 2440 fty->getExtInfo()); 2441 2442 // Functions are r-values in C. 2443 valueKind = VK_RValue; 2444 break; 2445 } 2446 2447 case Decl::CXXMethod: 2448 // If we're referring to a method with an __unknown_anytype 2449 // result type, make the entire expression __unknown_anytype. 2450 // This should only be possible with a type written directly. 2451 if (const FunctionProtoType *proto 2452 = dyn_cast<FunctionProtoType>(VD->getType())) 2453 if (proto->getResultType() == Context.UnknownAnyTy) { 2454 type = Context.UnknownAnyTy; 2455 valueKind = VK_RValue; 2456 break; 2457 } 2458 2459 // C++ methods are l-values if static, r-values if non-static. 2460 if (cast<CXXMethodDecl>(VD)->isStatic()) { 2461 valueKind = VK_LValue; 2462 break; 2463 } 2464 // fallthrough 2465 2466 case Decl::CXXConversion: 2467 case Decl::CXXDestructor: 2468 case Decl::CXXConstructor: 2469 valueKind = VK_RValue; 2470 break; 2471 } 2472 2473 return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS); 2474 } 2475} 2476 2477ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) { 2478 PredefinedExpr::IdentType IT; 2479 2480 switch (Kind) { 2481 default: llvm_unreachable("Unknown simple primary expr!"); 2482 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2] 2483 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break; 2484 case tok::kw_L__FUNCTION__: IT = PredefinedExpr::LFunction; break; 2485 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break; 2486 } 2487 2488 // Pre-defined identifiers are of type char[x], where x is the length of the 2489 // string. 2490 2491 Decl *currentDecl = getCurFunctionOrMethodDecl(); 2492 if (!currentDecl && getCurBlock()) 2493 currentDecl = getCurBlock()->TheDecl; 2494 if (!currentDecl) { 2495 Diag(Loc, diag::ext_predef_outside_function); 2496 currentDecl = Context.getTranslationUnitDecl(); 2497 } 2498 2499 QualType ResTy; 2500 if (cast<DeclContext>(currentDecl)->isDependentContext()) { 2501 ResTy = Context.DependentTy; 2502 } else { 2503 unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length(); 2504 2505 llvm::APInt LengthI(32, Length + 1); 2506 if (IT == PredefinedExpr::LFunction) 2507 ResTy = Context.WCharTy.withConst(); 2508 else 2509 ResTy = Context.CharTy.withConst(); 2510 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0); 2511 } 2512 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT)); 2513} 2514 2515ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) { 2516 SmallString<16> CharBuffer; 2517 bool Invalid = false; 2518 StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid); 2519 if (Invalid) 2520 return ExprError(); 2521 2522 CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(), 2523 PP, Tok.getKind()); 2524 if (Literal.hadError()) 2525 return ExprError(); 2526 2527 QualType Ty; 2528 if (Literal.isWide()) 2529 Ty = Context.WCharTy; // L'x' -> wchar_t in C and C++. 2530 else if (Literal.isUTF16()) 2531 Ty = Context.Char16Ty; // u'x' -> char16_t in C11 and C++11. 2532 else if (Literal.isUTF32()) 2533 Ty = Context.Char32Ty; // U'x' -> char32_t in C11 and C++11. 2534 else if (!getLangOpts().CPlusPlus || Literal.isMultiChar()) 2535 Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++. 2536 else 2537 Ty = Context.CharTy; // 'x' -> char in C++ 2538 2539 CharacterLiteral::CharacterKind Kind = CharacterLiteral::Ascii; 2540 if (Literal.isWide()) 2541 Kind = CharacterLiteral::Wide; 2542 else if (Literal.isUTF16()) 2543 Kind = CharacterLiteral::UTF16; 2544 else if (Literal.isUTF32()) 2545 Kind = CharacterLiteral::UTF32; 2546 2547 Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty, 2548 Tok.getLocation()); 2549 2550 if (Literal.getUDSuffix().empty()) 2551 return Owned(Lit); 2552 2553 // We're building a user-defined literal. 2554 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 2555 SourceLocation UDSuffixLoc = 2556 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset()); 2557 2558 // Make sure we're allowed user-defined literals here. 2559 if (!UDLScope) 2560 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_character_udl)); 2561 2562 // C++11 [lex.ext]p6: The literal L is treated as a call of the form 2563 // operator "" X (ch) 2564 return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc, 2565 llvm::makeArrayRef(&Lit, 1), 2566 Tok.getLocation()); 2567} 2568 2569ExprResult Sema::ActOnIntegerConstant(SourceLocation Loc, uint64_t Val) { 2570 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 2571 return Owned(IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val), 2572 Context.IntTy, Loc)); 2573} 2574 2575static Expr *BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal, 2576 QualType Ty, SourceLocation Loc) { 2577 const llvm::fltSemantics &Format = S.Context.getFloatTypeSemantics(Ty); 2578 2579 using llvm::APFloat; 2580 APFloat Val(Format); 2581 2582 APFloat::opStatus result = Literal.GetFloatValue(Val); 2583 2584 // Overflow is always an error, but underflow is only an error if 2585 // we underflowed to zero (APFloat reports denormals as underflow). 2586 if ((result & APFloat::opOverflow) || 2587 ((result & APFloat::opUnderflow) && Val.isZero())) { 2588 unsigned diagnostic; 2589 SmallString<20> buffer; 2590 if (result & APFloat::opOverflow) { 2591 diagnostic = diag::warn_float_overflow; 2592 APFloat::getLargest(Format).toString(buffer); 2593 } else { 2594 diagnostic = diag::warn_float_underflow; 2595 APFloat::getSmallest(Format).toString(buffer); 2596 } 2597 2598 S.Diag(Loc, diagnostic) 2599 << Ty 2600 << StringRef(buffer.data(), buffer.size()); 2601 } 2602 2603 bool isExact = (result == APFloat::opOK); 2604 return FloatingLiteral::Create(S.Context, Val, isExact, Ty, Loc); 2605} 2606 2607ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) { 2608 // Fast path for a single digit (which is quite common). A single digit 2609 // cannot have a trigraph, escaped newline, radix prefix, or suffix. 2610 if (Tok.getLength() == 1) { 2611 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok); 2612 return ActOnIntegerConstant(Tok.getLocation(), Val-'0'); 2613 } 2614 2615 SmallString<512> IntegerBuffer; 2616 // Add padding so that NumericLiteralParser can overread by one character. 2617 IntegerBuffer.resize(Tok.getLength()+1); 2618 const char *ThisTokBegin = &IntegerBuffer[0]; 2619 2620 // Get the spelling of the token, which eliminates trigraphs, etc. 2621 bool Invalid = false; 2622 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid); 2623 if (Invalid) 2624 return ExprError(); 2625 2626 NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength, 2627 Tok.getLocation(), PP); 2628 if (Literal.hadError) 2629 return ExprError(); 2630 2631 if (Literal.hasUDSuffix()) { 2632 // We're building a user-defined literal. 2633 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 2634 SourceLocation UDSuffixLoc = 2635 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset()); 2636 2637 // Make sure we're allowed user-defined literals here. 2638 if (!UDLScope) 2639 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_numeric_udl)); 2640 2641 QualType CookedTy; 2642 if (Literal.isFloatingLiteral()) { 2643 // C++11 [lex.ext]p4: If S contains a literal operator with parameter type 2644 // long double, the literal is treated as a call of the form 2645 // operator "" X (f L) 2646 CookedTy = Context.LongDoubleTy; 2647 } else { 2648 // C++11 [lex.ext]p3: If S contains a literal operator with parameter type 2649 // unsigned long long, the literal is treated as a call of the form 2650 // operator "" X (n ULL) 2651 CookedTy = Context.UnsignedLongLongTy; 2652 } 2653 2654 DeclarationName OpName = 2655 Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 2656 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 2657 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 2658 2659 // Perform literal operator lookup to determine if we're building a raw 2660 // literal or a cooked one. 2661 LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName); 2662 switch (LookupLiteralOperator(UDLScope, R, llvm::makeArrayRef(&CookedTy, 1), 2663 /*AllowRawAndTemplate*/true)) { 2664 case LOLR_Error: 2665 return ExprError(); 2666 2667 case LOLR_Cooked: { 2668 Expr *Lit; 2669 if (Literal.isFloatingLiteral()) { 2670 Lit = BuildFloatingLiteral(*this, Literal, CookedTy, Tok.getLocation()); 2671 } else { 2672 llvm::APInt ResultVal(Context.getTargetInfo().getLongLongWidth(), 0); 2673 if (Literal.GetIntegerValue(ResultVal)) 2674 Diag(Tok.getLocation(), diag::warn_integer_too_large); 2675 Lit = IntegerLiteral::Create(Context, ResultVal, CookedTy, 2676 Tok.getLocation()); 2677 } 2678 return BuildLiteralOperatorCall(R, OpNameInfo, 2679 llvm::makeArrayRef(&Lit, 1), 2680 Tok.getLocation()); 2681 } 2682 2683 case LOLR_Raw: { 2684 // C++11 [lit.ext]p3, p4: If S contains a raw literal operator, the 2685 // literal is treated as a call of the form 2686 // operator "" X ("n") 2687 SourceLocation TokLoc = Tok.getLocation(); 2688 unsigned Length = Literal.getUDSuffixOffset(); 2689 QualType StrTy = Context.getConstantArrayType( 2690 Context.CharTy, llvm::APInt(32, Length + 1), 2691 ArrayType::Normal, 0); 2692 Expr *Lit = StringLiteral::Create( 2693 Context, StringRef(ThisTokBegin, Length), StringLiteral::Ascii, 2694 /*Pascal*/false, StrTy, &TokLoc, 1); 2695 return BuildLiteralOperatorCall(R, OpNameInfo, 2696 llvm::makeArrayRef(&Lit, 1), TokLoc); 2697 } 2698 2699 case LOLR_Template: 2700 // C++11 [lit.ext]p3, p4: Otherwise (S contains a literal operator 2701 // template), L is treated as a call fo the form 2702 // operator "" X <'c1', 'c2', ... 'ck'>() 2703 // where n is the source character sequence c1 c2 ... ck. 2704 TemplateArgumentListInfo ExplicitArgs; 2705 unsigned CharBits = Context.getIntWidth(Context.CharTy); 2706 bool CharIsUnsigned = Context.CharTy->isUnsignedIntegerType(); 2707 llvm::APSInt Value(CharBits, CharIsUnsigned); 2708 for (unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) { 2709 Value = ThisTokBegin[I]; 2710 TemplateArgument Arg(Context, Value, Context.CharTy); 2711 TemplateArgumentLocInfo ArgInfo; 2712 ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo)); 2713 } 2714 return BuildLiteralOperatorCall(R, OpNameInfo, ArrayRef<Expr*>(), 2715 Tok.getLocation(), &ExplicitArgs); 2716 } 2717 2718 llvm_unreachable("unexpected literal operator lookup result"); 2719 } 2720 2721 Expr *Res; 2722 2723 if (Literal.isFloatingLiteral()) { 2724 QualType Ty; 2725 if (Literal.isFloat) 2726 Ty = Context.FloatTy; 2727 else if (!Literal.isLong) 2728 Ty = Context.DoubleTy; 2729 else 2730 Ty = Context.LongDoubleTy; 2731 2732 Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation()); 2733 2734 if (Ty == Context.DoubleTy) { 2735 if (getLangOpts().SinglePrecisionConstants) { 2736 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); 2737 } else if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp64) { 2738 Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64); 2739 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); 2740 } 2741 } 2742 } else if (!Literal.isIntegerLiteral()) { 2743 return ExprError(); 2744 } else { 2745 QualType Ty; 2746 2747 // long long is a C99 feature. 2748 if (!getLangOpts().C99 && Literal.isLongLong) 2749 Diag(Tok.getLocation(), 2750 getLangOpts().CPlusPlus0x ? 2751 diag::warn_cxx98_compat_longlong : diag::ext_longlong); 2752 2753 // Get the value in the widest-possible width. 2754 unsigned MaxWidth = Context.getTargetInfo().getIntMaxTWidth(); 2755 // The microsoft literal suffix extensions support 128-bit literals, which 2756 // may be wider than [u]intmax_t. 2757 if (Literal.isMicrosoftInteger && MaxWidth < 128) 2758 MaxWidth = 128; 2759 llvm::APInt ResultVal(MaxWidth, 0); 2760 2761 if (Literal.GetIntegerValue(ResultVal)) { 2762 // If this value didn't fit into uintmax_t, warn and force to ull. 2763 Diag(Tok.getLocation(), diag::warn_integer_too_large); 2764 Ty = Context.UnsignedLongLongTy; 2765 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() && 2766 "long long is not intmax_t?"); 2767 } else { 2768 // If this value fits into a ULL, try to figure out what else it fits into 2769 // according to the rules of C99 6.4.4.1p5. 2770 2771 // Octal, Hexadecimal, and integers with a U suffix are allowed to 2772 // be an unsigned int. 2773 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10; 2774 2775 // Check from smallest to largest, picking the smallest type we can. 2776 unsigned Width = 0; 2777 if (!Literal.isLong && !Literal.isLongLong) { 2778 // Are int/unsigned possibilities? 2779 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 2780 2781 // Does it fit in a unsigned int? 2782 if (ResultVal.isIntN(IntSize)) { 2783 // Does it fit in a signed int? 2784 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0) 2785 Ty = Context.IntTy; 2786 else if (AllowUnsigned) 2787 Ty = Context.UnsignedIntTy; 2788 Width = IntSize; 2789 } 2790 } 2791 2792 // Are long/unsigned long possibilities? 2793 if (Ty.isNull() && !Literal.isLongLong) { 2794 unsigned LongSize = Context.getTargetInfo().getLongWidth(); 2795 2796 // Does it fit in a unsigned long? 2797 if (ResultVal.isIntN(LongSize)) { 2798 // Does it fit in a signed long? 2799 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0) 2800 Ty = Context.LongTy; 2801 else if (AllowUnsigned) 2802 Ty = Context.UnsignedLongTy; 2803 Width = LongSize; 2804 } 2805 } 2806 2807 // Check long long if needed. 2808 if (Ty.isNull()) { 2809 unsigned LongLongSize = Context.getTargetInfo().getLongLongWidth(); 2810 2811 // Does it fit in a unsigned long long? 2812 if (ResultVal.isIntN(LongLongSize)) { 2813 // Does it fit in a signed long long? 2814 // To be compatible with MSVC, hex integer literals ending with the 2815 // LL or i64 suffix are always signed in Microsoft mode. 2816 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 || 2817 (getLangOpts().MicrosoftExt && Literal.isLongLong))) 2818 Ty = Context.LongLongTy; 2819 else if (AllowUnsigned) 2820 Ty = Context.UnsignedLongLongTy; 2821 Width = LongLongSize; 2822 } 2823 } 2824 2825 // If it doesn't fit in unsigned long long, and we're using Microsoft 2826 // extensions, then its a 128-bit integer literal. 2827 if (Ty.isNull() && Literal.isMicrosoftInteger) { 2828 if (Literal.isUnsigned) 2829 Ty = Context.UnsignedInt128Ty; 2830 else 2831 Ty = Context.Int128Ty; 2832 Width = 128; 2833 } 2834 2835 // If we still couldn't decide a type, we probably have something that 2836 // does not fit in a signed long long, but has no U suffix. 2837 if (Ty.isNull()) { 2838 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed); 2839 Ty = Context.UnsignedLongLongTy; 2840 Width = Context.getTargetInfo().getLongLongWidth(); 2841 } 2842 2843 if (ResultVal.getBitWidth() != Width) 2844 ResultVal = ResultVal.trunc(Width); 2845 } 2846 Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation()); 2847 } 2848 2849 // If this is an imaginary literal, create the ImaginaryLiteral wrapper. 2850 if (Literal.isImaginary) 2851 Res = new (Context) ImaginaryLiteral(Res, 2852 Context.getComplexType(Res->getType())); 2853 2854 return Owned(Res); 2855} 2856 2857ExprResult Sema::ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E) { 2858 assert((E != 0) && "ActOnParenExpr() missing expr"); 2859 return Owned(new (Context) ParenExpr(L, R, E)); 2860} 2861 2862static bool CheckVecStepTraitOperandType(Sema &S, QualType T, 2863 SourceLocation Loc, 2864 SourceRange ArgRange) { 2865 // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in 2866 // scalar or vector data type argument..." 2867 // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic 2868 // type (C99 6.2.5p18) or void. 2869 if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) { 2870 S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type) 2871 << T << ArgRange; 2872 return true; 2873 } 2874 2875 assert((T->isVoidType() || !T->isIncompleteType()) && 2876 "Scalar types should always be complete"); 2877 return false; 2878} 2879 2880static bool CheckExtensionTraitOperandType(Sema &S, QualType T, 2881 SourceLocation Loc, 2882 SourceRange ArgRange, 2883 UnaryExprOrTypeTrait TraitKind) { 2884 // C99 6.5.3.4p1: 2885 if (T->isFunctionType()) { 2886 // alignof(function) is allowed as an extension. 2887 if (TraitKind == UETT_SizeOf) 2888 S.Diag(Loc, diag::ext_sizeof_function_type) << ArgRange; 2889 return false; 2890 } 2891 2892 // Allow sizeof(void)/alignof(void) as an extension. 2893 if (T->isVoidType()) { 2894 S.Diag(Loc, diag::ext_sizeof_void_type) << TraitKind << ArgRange; 2895 return false; 2896 } 2897 2898 return true; 2899} 2900 2901static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, 2902 SourceLocation Loc, 2903 SourceRange ArgRange, 2904 UnaryExprOrTypeTrait TraitKind) { 2905 // Reject sizeof(interface) and sizeof(interface<proto>) in 64-bit mode. 2906 if (S.LangOpts.ObjCRuntime.isNonFragile() && T->isObjCObjectType()) { 2907 S.Diag(Loc, diag::err_sizeof_nonfragile_interface) 2908 << T << (TraitKind == UETT_SizeOf) 2909 << ArgRange; 2910 return true; 2911 } 2912 2913 return false; 2914} 2915 2916/// \brief Check the constrains on expression operands to unary type expression 2917/// and type traits. 2918/// 2919/// Completes any types necessary and validates the constraints on the operand 2920/// expression. The logic mostly mirrors the type-based overload, but may modify 2921/// the expression as it completes the type for that expression through template 2922/// instantiation, etc. 2923bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E, 2924 UnaryExprOrTypeTrait ExprKind) { 2925 QualType ExprTy = E->getType(); 2926 2927 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 2928 // the result is the size of the referenced type." 2929 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the 2930 // result shall be the alignment of the referenced type." 2931 if (const ReferenceType *Ref = ExprTy->getAs<ReferenceType>()) 2932 ExprTy = Ref->getPointeeType(); 2933 2934 if (ExprKind == UETT_VecStep) 2935 return CheckVecStepTraitOperandType(*this, ExprTy, E->getExprLoc(), 2936 E->getSourceRange()); 2937 2938 // Whitelist some types as extensions 2939 if (!CheckExtensionTraitOperandType(*this, ExprTy, E->getExprLoc(), 2940 E->getSourceRange(), ExprKind)) 2941 return false; 2942 2943 if (RequireCompleteExprType(E, 2944 diag::err_sizeof_alignof_incomplete_type, 2945 ExprKind, E->getSourceRange())) 2946 return true; 2947 2948 // Completeing the expression's type may have changed it. 2949 ExprTy = E->getType(); 2950 if (const ReferenceType *Ref = ExprTy->getAs<ReferenceType>()) 2951 ExprTy = Ref->getPointeeType(); 2952 2953 if (CheckObjCTraitOperandConstraints(*this, ExprTy, E->getExprLoc(), 2954 E->getSourceRange(), ExprKind)) 2955 return true; 2956 2957 if (ExprKind == UETT_SizeOf) { 2958 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E->IgnoreParens())) { 2959 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) { 2960 QualType OType = PVD->getOriginalType(); 2961 QualType Type = PVD->getType(); 2962 if (Type->isPointerType() && OType->isArrayType()) { 2963 Diag(E->getExprLoc(), diag::warn_sizeof_array_param) 2964 << Type << OType; 2965 Diag(PVD->getLocation(), diag::note_declared_at); 2966 } 2967 } 2968 } 2969 } 2970 2971 return false; 2972} 2973 2974/// \brief Check the constraints on operands to unary expression and type 2975/// traits. 2976/// 2977/// This will complete any types necessary, and validate the various constraints 2978/// on those operands. 2979/// 2980/// The UsualUnaryConversions() function is *not* called by this routine. 2981/// C99 6.3.2.1p[2-4] all state: 2982/// Except when it is the operand of the sizeof operator ... 2983/// 2984/// C++ [expr.sizeof]p4 2985/// The lvalue-to-rvalue, array-to-pointer, and function-to-pointer 2986/// standard conversions are not applied to the operand of sizeof. 2987/// 2988/// This policy is followed for all of the unary trait expressions. 2989bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType, 2990 SourceLocation OpLoc, 2991 SourceRange ExprRange, 2992 UnaryExprOrTypeTrait ExprKind) { 2993 if (ExprType->isDependentType()) 2994 return false; 2995 2996 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 2997 // the result is the size of the referenced type." 2998 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the 2999 // result shall be the alignment of the referenced type." 3000 if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>()) 3001 ExprType = Ref->getPointeeType(); 3002 3003 if (ExprKind == UETT_VecStep) 3004 return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange); 3005 3006 // Whitelist some types as extensions 3007 if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange, 3008 ExprKind)) 3009 return false; 3010 3011 if (RequireCompleteType(OpLoc, ExprType, 3012 diag::err_sizeof_alignof_incomplete_type, 3013 ExprKind, ExprRange)) 3014 return true; 3015 3016 if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange, 3017 ExprKind)) 3018 return true; 3019 3020 return false; 3021} 3022 3023static bool CheckAlignOfExpr(Sema &S, Expr *E) { 3024 E = E->IgnoreParens(); 3025 3026 // alignof decl is always ok. 3027 if (isa<DeclRefExpr>(E)) 3028 return false; 3029 3030 // Cannot know anything else if the expression is dependent. 3031 if (E->isTypeDependent()) 3032 return false; 3033 3034 if (E->getBitField()) { 3035 S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) 3036 << 1 << E->getSourceRange(); 3037 return true; 3038 } 3039 3040 // Alignment of a field access is always okay, so long as it isn't a 3041 // bit-field. 3042 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) 3043 if (isa<FieldDecl>(ME->getMemberDecl())) 3044 return false; 3045 3046 return S.CheckUnaryExprOrTypeTraitOperand(E, UETT_AlignOf); 3047} 3048 3049bool Sema::CheckVecStepExpr(Expr *E) { 3050 E = E->IgnoreParens(); 3051 3052 // Cannot know anything else if the expression is dependent. 3053 if (E->isTypeDependent()) 3054 return false; 3055 3056 return CheckUnaryExprOrTypeTraitOperand(E, UETT_VecStep); 3057} 3058 3059/// \brief Build a sizeof or alignof expression given a type operand. 3060ExprResult 3061Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, 3062 SourceLocation OpLoc, 3063 UnaryExprOrTypeTrait ExprKind, 3064 SourceRange R) { 3065 if (!TInfo) 3066 return ExprError(); 3067 3068 QualType T = TInfo->getType(); 3069 3070 if (!T->isDependentType() && 3071 CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind)) 3072 return ExprError(); 3073 3074 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 3075 return Owned(new (Context) UnaryExprOrTypeTraitExpr(ExprKind, TInfo, 3076 Context.getSizeType(), 3077 OpLoc, R.getEnd())); 3078} 3079 3080/// \brief Build a sizeof or alignof expression given an expression 3081/// operand. 3082ExprResult 3083Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc, 3084 UnaryExprOrTypeTrait ExprKind) { 3085 ExprResult PE = CheckPlaceholderExpr(E); 3086 if (PE.isInvalid()) 3087 return ExprError(); 3088 3089 E = PE.get(); 3090 3091 // Verify that the operand is valid. 3092 bool isInvalid = false; 3093 if (E->isTypeDependent()) { 3094 // Delay type-checking for type-dependent expressions. 3095 } else if (ExprKind == UETT_AlignOf) { 3096 isInvalid = CheckAlignOfExpr(*this, E); 3097 } else if (ExprKind == UETT_VecStep) { 3098 isInvalid = CheckVecStepExpr(E); 3099 } else if (E->getBitField()) { // C99 6.5.3.4p1. 3100 Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) << 0; 3101 isInvalid = true; 3102 } else { 3103 isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf); 3104 } 3105 3106 if (isInvalid) 3107 return ExprError(); 3108 3109 if (ExprKind == UETT_SizeOf && E->getType()->isVariableArrayType()) { 3110 PE = TranformToPotentiallyEvaluated(E); 3111 if (PE.isInvalid()) return ExprError(); 3112 E = PE.take(); 3113 } 3114 3115 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 3116 return Owned(new (Context) UnaryExprOrTypeTraitExpr( 3117 ExprKind, E, Context.getSizeType(), OpLoc, 3118 E->getSourceRange().getEnd())); 3119} 3120 3121/// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c 3122/// expr and the same for @c alignof and @c __alignof 3123/// Note that the ArgRange is invalid if isType is false. 3124ExprResult 3125Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, 3126 UnaryExprOrTypeTrait ExprKind, bool IsType, 3127 void *TyOrEx, const SourceRange &ArgRange) { 3128 // If error parsing type, ignore. 3129 if (TyOrEx == 0) return ExprError(); 3130 3131 if (IsType) { 3132 TypeSourceInfo *TInfo; 3133 (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo); 3134 return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange); 3135 } 3136 3137 Expr *ArgEx = (Expr *)TyOrEx; 3138 ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind); 3139 return move(Result); 3140} 3141 3142static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, 3143 bool IsReal) { 3144 if (V.get()->isTypeDependent()) 3145 return S.Context.DependentTy; 3146 3147 // _Real and _Imag are only l-values for normal l-values. 3148 if (V.get()->getObjectKind() != OK_Ordinary) { 3149 V = S.DefaultLvalueConversion(V.take()); 3150 if (V.isInvalid()) 3151 return QualType(); 3152 } 3153 3154 // These operators return the element type of a complex type. 3155 if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>()) 3156 return CT->getElementType(); 3157 3158 // Otherwise they pass through real integer and floating point types here. 3159 if (V.get()->getType()->isArithmeticType()) 3160 return V.get()->getType(); 3161 3162 // Test for placeholders. 3163 ExprResult PR = S.CheckPlaceholderExpr(V.get()); 3164 if (PR.isInvalid()) return QualType(); 3165 if (PR.get() != V.get()) { 3166 V = move(PR); 3167 return CheckRealImagOperand(S, V, Loc, IsReal); 3168 } 3169 3170 // Reject anything else. 3171 S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType() 3172 << (IsReal ? "__real" : "__imag"); 3173 return QualType(); 3174} 3175 3176 3177 3178ExprResult 3179Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, 3180 tok::TokenKind Kind, Expr *Input) { 3181 UnaryOperatorKind Opc; 3182 switch (Kind) { 3183 default: llvm_unreachable("Unknown unary op!"); 3184 case tok::plusplus: Opc = UO_PostInc; break; 3185 case tok::minusminus: Opc = UO_PostDec; break; 3186 } 3187 3188 // Since this might is a postfix expression, get rid of ParenListExprs. 3189 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input); 3190 if (Result.isInvalid()) return ExprError(); 3191 Input = Result.take(); 3192 3193 return BuildUnaryOp(S, OpLoc, Opc, Input); 3194} 3195 3196ExprResult 3197Sema::ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, 3198 Expr *Idx, SourceLocation RLoc) { 3199 // Since this might be a postfix expression, get rid of ParenListExprs. 3200 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); 3201 if (Result.isInvalid()) return ExprError(); 3202 Base = Result.take(); 3203 3204 Expr *LHSExp = Base, *RHSExp = Idx; 3205 3206 if (getLangOpts().CPlusPlus && 3207 (LHSExp->isTypeDependent() || RHSExp->isTypeDependent())) { 3208 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 3209 Context.DependentTy, 3210 VK_LValue, OK_Ordinary, 3211 RLoc)); 3212 } 3213 3214 if (getLangOpts().CPlusPlus && 3215 (LHSExp->getType()->isRecordType() || 3216 LHSExp->getType()->isEnumeralType() || 3217 RHSExp->getType()->isRecordType() || 3218 RHSExp->getType()->isEnumeralType()) && 3219 !LHSExp->getType()->isObjCObjectPointerType()) { 3220 return CreateOverloadedArraySubscriptExpr(LLoc, RLoc, Base, Idx); 3221 } 3222 3223 return CreateBuiltinArraySubscriptExpr(Base, LLoc, Idx, RLoc); 3224} 3225 3226 3227ExprResult 3228Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, 3229 Expr *Idx, SourceLocation RLoc) { 3230 Expr *LHSExp = Base; 3231 Expr *RHSExp = Idx; 3232 3233 // Perform default conversions. 3234 if (!LHSExp->getType()->getAs<VectorType>()) { 3235 ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp); 3236 if (Result.isInvalid()) 3237 return ExprError(); 3238 LHSExp = Result.take(); 3239 } 3240 ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp); 3241 if (Result.isInvalid()) 3242 return ExprError(); 3243 RHSExp = Result.take(); 3244 3245 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType(); 3246 ExprValueKind VK = VK_LValue; 3247 ExprObjectKind OK = OK_Ordinary; 3248 3249 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent 3250 // to the expression *((e1)+(e2)). This means the array "Base" may actually be 3251 // in the subscript position. As a result, we need to derive the array base 3252 // and index from the expression types. 3253 Expr *BaseExpr, *IndexExpr; 3254 QualType ResultType; 3255 if (LHSTy->isDependentType() || RHSTy->isDependentType()) { 3256 BaseExpr = LHSExp; 3257 IndexExpr = RHSExp; 3258 ResultType = Context.DependentTy; 3259 } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) { 3260 BaseExpr = LHSExp; 3261 IndexExpr = RHSExp; 3262 ResultType = PTy->getPointeeType(); 3263 } else if (const ObjCObjectPointerType *PTy = 3264 LHSTy->getAs<ObjCObjectPointerType>()) { 3265 BaseExpr = LHSExp; 3266 IndexExpr = RHSExp; 3267 Result = BuildObjCSubscriptExpression(RLoc, BaseExpr, IndexExpr, 0, 0); 3268 if (!Result.isInvalid()) 3269 return Owned(Result.take()); 3270 ResultType = PTy->getPointeeType(); 3271 } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) { 3272 // Handle the uncommon case of "123[Ptr]". 3273 BaseExpr = RHSExp; 3274 IndexExpr = LHSExp; 3275 ResultType = PTy->getPointeeType(); 3276 } else if (const ObjCObjectPointerType *PTy = 3277 RHSTy->getAs<ObjCObjectPointerType>()) { 3278 // Handle the uncommon case of "123[Ptr]". 3279 BaseExpr = RHSExp; 3280 IndexExpr = LHSExp; 3281 ResultType = PTy->getPointeeType(); 3282 } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) { 3283 BaseExpr = LHSExp; // vectors: V[123] 3284 IndexExpr = RHSExp; 3285 VK = LHSExp->getValueKind(); 3286 if (VK != VK_RValue) 3287 OK = OK_VectorComponent; 3288 3289 // FIXME: need to deal with const... 3290 ResultType = VTy->getElementType(); 3291 } else if (LHSTy->isArrayType()) { 3292 // If we see an array that wasn't promoted by 3293 // DefaultFunctionArrayLvalueConversion, it must be an array that 3294 // wasn't promoted because of the C90 rule that doesn't 3295 // allow promoting non-lvalue arrays. Warn, then 3296 // force the promotion here. 3297 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3298 LHSExp->getSourceRange(); 3299 LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy), 3300 CK_ArrayToPointerDecay).take(); 3301 LHSTy = LHSExp->getType(); 3302 3303 BaseExpr = LHSExp; 3304 IndexExpr = RHSExp; 3305 ResultType = LHSTy->getAs<PointerType>()->getPointeeType(); 3306 } else if (RHSTy->isArrayType()) { 3307 // Same as previous, except for 123[f().a] case 3308 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3309 RHSExp->getSourceRange(); 3310 RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy), 3311 CK_ArrayToPointerDecay).take(); 3312 RHSTy = RHSExp->getType(); 3313 3314 BaseExpr = RHSExp; 3315 IndexExpr = LHSExp; 3316 ResultType = RHSTy->getAs<PointerType>()->getPointeeType(); 3317 } else { 3318 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value) 3319 << LHSExp->getSourceRange() << RHSExp->getSourceRange()); 3320 } 3321 // C99 6.5.2.1p1 3322 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent()) 3323 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer) 3324 << IndexExpr->getSourceRange()); 3325 3326 if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) || 3327 IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U)) 3328 && !IndexExpr->isTypeDependent()) 3329 Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange(); 3330 3331 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly, 3332 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object 3333 // type. Note that Functions are not objects, and that (in C99 parlance) 3334 // incomplete types are not object types. 3335 if (ResultType->isFunctionType()) { 3336 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type) 3337 << ResultType << BaseExpr->getSourceRange(); 3338 return ExprError(); 3339 } 3340 3341 if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) { 3342 // GNU extension: subscripting on pointer to void 3343 Diag(LLoc, diag::ext_gnu_subscript_void_type) 3344 << BaseExpr->getSourceRange(); 3345 3346 // C forbids expressions of unqualified void type from being l-values. 3347 // See IsCForbiddenLValueType. 3348 if (!ResultType.hasQualifiers()) VK = VK_RValue; 3349 } else if (!ResultType->isDependentType() && 3350 RequireCompleteType(LLoc, ResultType, 3351 diag::err_subscript_incomplete_type, BaseExpr)) 3352 return ExprError(); 3353 3354 // Diagnose bad cases where we step over interface counts. 3355 if (ResultType->isObjCObjectType() && LangOpts.ObjCRuntime.isNonFragile()) { 3356 Diag(LLoc, diag::err_subscript_nonfragile_interface) 3357 << ResultType << BaseExpr->getSourceRange(); 3358 return ExprError(); 3359 } 3360 3361 assert(VK == VK_RValue || LangOpts.CPlusPlus || 3362 !ResultType.isCForbiddenLValueType()); 3363 3364 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 3365 ResultType, VK, OK, RLoc)); 3366} 3367 3368ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc, 3369 FunctionDecl *FD, 3370 ParmVarDecl *Param) { 3371 if (Param->hasUnparsedDefaultArg()) { 3372 Diag(CallLoc, 3373 diag::err_use_of_default_argument_to_function_declared_later) << 3374 FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName(); 3375 Diag(UnparsedDefaultArgLocs[Param], 3376 diag::note_default_argument_declared_here); 3377 return ExprError(); 3378 } 3379 3380 if (Param->hasUninstantiatedDefaultArg()) { 3381 Expr *UninstExpr = Param->getUninstantiatedDefaultArg(); 3382 3383 EnterExpressionEvaluationContext EvalContext(*this, PotentiallyEvaluated, 3384 Param); 3385 3386 // Instantiate the expression. 3387 MultiLevelTemplateArgumentList ArgList 3388 = getTemplateInstantiationArgs(FD, 0, /*RelativeToPrimary=*/true); 3389 3390 std::pair<const TemplateArgument *, unsigned> Innermost 3391 = ArgList.getInnermost(); 3392 InstantiatingTemplate Inst(*this, CallLoc, Param, 3393 ArrayRef<TemplateArgument>(Innermost.first, 3394 Innermost.second)); 3395 if (Inst) 3396 return ExprError(); 3397 3398 ExprResult Result; 3399 { 3400 // C++ [dcl.fct.default]p5: 3401 // The names in the [default argument] expression are bound, and 3402 // the semantic constraints are checked, at the point where the 3403 // default argument expression appears. 3404 ContextRAII SavedContext(*this, FD); 3405 LocalInstantiationScope Local(*this); 3406 Result = SubstExpr(UninstExpr, ArgList); 3407 } 3408 if (Result.isInvalid()) 3409 return ExprError(); 3410 3411 // Check the expression as an initializer for the parameter. 3412 InitializedEntity Entity 3413 = InitializedEntity::InitializeParameter(Context, Param); 3414 InitializationKind Kind 3415 = InitializationKind::CreateCopy(Param->getLocation(), 3416 /*FIXME:EqualLoc*/UninstExpr->getLocStart()); 3417 Expr *ResultE = Result.takeAs<Expr>(); 3418 3419 InitializationSequence InitSeq(*this, Entity, Kind, &ResultE, 1); 3420 Result = InitSeq.Perform(*this, Entity, Kind, 3421 MultiExprArg(*this, &ResultE, 1)); 3422 if (Result.isInvalid()) 3423 return ExprError(); 3424 3425 Expr *Arg = Result.takeAs<Expr>(); 3426 CheckImplicitConversions(Arg, Param->getOuterLocStart()); 3427 // Build the default argument expression. 3428 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param, Arg)); 3429 } 3430 3431 // If the default expression creates temporaries, we need to 3432 // push them to the current stack of expression temporaries so they'll 3433 // be properly destroyed. 3434 // FIXME: We should really be rebuilding the default argument with new 3435 // bound temporaries; see the comment in PR5810. 3436 // We don't need to do that with block decls, though, because 3437 // blocks in default argument expression can never capture anything. 3438 if (isa<ExprWithCleanups>(Param->getInit())) { 3439 // Set the "needs cleanups" bit regardless of whether there are 3440 // any explicit objects. 3441 ExprNeedsCleanups = true; 3442 3443 // Append all the objects to the cleanup list. Right now, this 3444 // should always be a no-op, because blocks in default argument 3445 // expressions should never be able to capture anything. 3446 assert(!cast<ExprWithCleanups>(Param->getInit())->getNumObjects() && 3447 "default argument expression has capturing blocks?"); 3448 } 3449 3450 // We already type-checked the argument, so we know it works. 3451 // Just mark all of the declarations in this potentially-evaluated expression 3452 // as being "referenced". 3453 MarkDeclarationsReferencedInExpr(Param->getDefaultArg(), 3454 /*SkipLocalVariables=*/true); 3455 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param)); 3456} 3457 3458 3459Sema::VariadicCallType 3460Sema::getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto, 3461 Expr *Fn) { 3462 if (Proto && Proto->isVariadic()) { 3463 if (dyn_cast_or_null<CXXConstructorDecl>(FDecl)) 3464 return VariadicConstructor; 3465 else if (Fn && Fn->getType()->isBlockPointerType()) 3466 return VariadicBlock; 3467 else if (FDecl) { 3468 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl)) 3469 if (Method->isInstance()) 3470 return VariadicMethod; 3471 } 3472 return VariadicFunction; 3473 } 3474 return VariadicDoesNotApply; 3475} 3476 3477/// ConvertArgumentsForCall - Converts the arguments specified in 3478/// Args/NumArgs to the parameter types of the function FDecl with 3479/// function prototype Proto. Call is the call expression itself, and 3480/// Fn is the function expression. For a C++ member function, this 3481/// routine does not attempt to convert the object argument. Returns 3482/// true if the call is ill-formed. 3483bool 3484Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, 3485 FunctionDecl *FDecl, 3486 const FunctionProtoType *Proto, 3487 Expr **Args, unsigned NumArgs, 3488 SourceLocation RParenLoc, 3489 bool IsExecConfig) { 3490 // Bail out early if calling a builtin with custom typechecking. 3491 // We don't need to do this in the 3492 if (FDecl) 3493 if (unsigned ID = FDecl->getBuiltinID()) 3494 if (Context.BuiltinInfo.hasCustomTypechecking(ID)) 3495 return false; 3496 3497 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by 3498 // assignment, to the types of the corresponding parameter, ... 3499 unsigned NumArgsInProto = Proto->getNumArgs(); 3500 bool Invalid = false; 3501 unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumArgsInProto; 3502 unsigned FnKind = Fn->getType()->isBlockPointerType() 3503 ? 1 /* block */ 3504 : (IsExecConfig ? 3 /* kernel function (exec config) */ 3505 : 0 /* function */); 3506 3507 // If too few arguments are available (and we don't have default 3508 // arguments for the remaining parameters), don't make the call. 3509 if (NumArgs < NumArgsInProto) { 3510 if (NumArgs < MinArgs) { 3511 if (MinArgs == 1 && FDecl && FDecl->getParamDecl(0)->getDeclName()) 3512 Diag(RParenLoc, MinArgs == NumArgsInProto && !Proto->isVariadic() 3513 ? diag::err_typecheck_call_too_few_args_one 3514 : diag::err_typecheck_call_too_few_args_at_least_one) 3515 << FnKind 3516 << FDecl->getParamDecl(0) << Fn->getSourceRange(); 3517 else 3518 Diag(RParenLoc, MinArgs == NumArgsInProto && !Proto->isVariadic() 3519 ? diag::err_typecheck_call_too_few_args 3520 : diag::err_typecheck_call_too_few_args_at_least) 3521 << FnKind 3522 << MinArgs << NumArgs << Fn->getSourceRange(); 3523 3524 // Emit the location of the prototype. 3525 if (FDecl && !FDecl->getBuiltinID() && !IsExecConfig) 3526 Diag(FDecl->getLocStart(), diag::note_callee_decl) 3527 << FDecl; 3528 3529 return true; 3530 } 3531 Call->setNumArgs(Context, NumArgsInProto); 3532 } 3533 3534 // If too many are passed and not variadic, error on the extras and drop 3535 // them. 3536 if (NumArgs > NumArgsInProto) { 3537 if (!Proto->isVariadic()) { 3538 if (NumArgsInProto == 1 && FDecl && FDecl->getParamDecl(0)->getDeclName()) 3539 Diag(Args[NumArgsInProto]->getLocStart(), 3540 MinArgs == NumArgsInProto 3541 ? diag::err_typecheck_call_too_many_args_one 3542 : diag::err_typecheck_call_too_many_args_at_most_one) 3543 << FnKind 3544 << FDecl->getParamDecl(0) << NumArgs << Fn->getSourceRange() 3545 << SourceRange(Args[NumArgsInProto]->getLocStart(), 3546 Args[NumArgs-1]->getLocEnd()); 3547 else 3548 Diag(Args[NumArgsInProto]->getLocStart(), 3549 MinArgs == NumArgsInProto 3550 ? diag::err_typecheck_call_too_many_args 3551 : diag::err_typecheck_call_too_many_args_at_most) 3552 << FnKind 3553 << NumArgsInProto << NumArgs << Fn->getSourceRange() 3554 << SourceRange(Args[NumArgsInProto]->getLocStart(), 3555 Args[NumArgs-1]->getLocEnd()); 3556 3557 // Emit the location of the prototype. 3558 if (FDecl && !FDecl->getBuiltinID() && !IsExecConfig) 3559 Diag(FDecl->getLocStart(), diag::note_callee_decl) 3560 << FDecl; 3561 3562 // This deletes the extra arguments. 3563 Call->setNumArgs(Context, NumArgsInProto); 3564 return true; 3565 } 3566 } 3567 SmallVector<Expr *, 8> AllArgs; 3568 VariadicCallType CallType = getVariadicCallType(FDecl, Proto, Fn); 3569 3570 Invalid = GatherArgumentsForCall(Call->getLocStart(), FDecl, 3571 Proto, 0, Args, NumArgs, AllArgs, CallType); 3572 if (Invalid) 3573 return true; 3574 unsigned TotalNumArgs = AllArgs.size(); 3575 for (unsigned i = 0; i < TotalNumArgs; ++i) 3576 Call->setArg(i, AllArgs[i]); 3577 3578 return false; 3579} 3580 3581bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, 3582 FunctionDecl *FDecl, 3583 const FunctionProtoType *Proto, 3584 unsigned FirstProtoArg, 3585 Expr **Args, unsigned NumArgs, 3586 SmallVector<Expr *, 8> &AllArgs, 3587 VariadicCallType CallType, 3588 bool AllowExplicit) { 3589 unsigned NumArgsInProto = Proto->getNumArgs(); 3590 unsigned NumArgsToCheck = NumArgs; 3591 bool Invalid = false; 3592 if (NumArgs != NumArgsInProto) 3593 // Use default arguments for missing arguments 3594 NumArgsToCheck = NumArgsInProto; 3595 unsigned ArgIx = 0; 3596 // Continue to check argument types (even if we have too few/many args). 3597 for (unsigned i = FirstProtoArg; i != NumArgsToCheck; i++) { 3598 QualType ProtoArgType = Proto->getArgType(i); 3599 3600 Expr *Arg; 3601 ParmVarDecl *Param; 3602 if (ArgIx < NumArgs) { 3603 Arg = Args[ArgIx++]; 3604 3605 if (RequireCompleteType(Arg->getLocStart(), 3606 ProtoArgType, 3607 diag::err_call_incomplete_argument, Arg)) 3608 return true; 3609 3610 // Pass the argument 3611 Param = 0; 3612 if (FDecl && i < FDecl->getNumParams()) 3613 Param = FDecl->getParamDecl(i); 3614 3615 // Strip the unbridged-cast placeholder expression off, if applicable. 3616 if (Arg->getType() == Context.ARCUnbridgedCastTy && 3617 FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() && 3618 (!Param || !Param->hasAttr<CFConsumedAttr>())) 3619 Arg = stripARCUnbridgedCast(Arg); 3620 3621 InitializedEntity Entity = 3622 Param? InitializedEntity::InitializeParameter(Context, Param) 3623 : InitializedEntity::InitializeParameter(Context, ProtoArgType, 3624 Proto->isArgConsumed(i)); 3625 ExprResult ArgE = PerformCopyInitialization(Entity, 3626 SourceLocation(), 3627 Owned(Arg), 3628 /*TopLevelOfInitList=*/false, 3629 AllowExplicit); 3630 if (ArgE.isInvalid()) 3631 return true; 3632 3633 Arg = ArgE.takeAs<Expr>(); 3634 } else { 3635 Param = FDecl->getParamDecl(i); 3636 3637 ExprResult ArgExpr = 3638 BuildCXXDefaultArgExpr(CallLoc, FDecl, Param); 3639 if (ArgExpr.isInvalid()) 3640 return true; 3641 3642 Arg = ArgExpr.takeAs<Expr>(); 3643 } 3644 3645 // Check for array bounds violations for each argument to the call. This 3646 // check only triggers warnings when the argument isn't a more complex Expr 3647 // with its own checking, such as a BinaryOperator. 3648 CheckArrayAccess(Arg); 3649 3650 // Check for violations of C99 static array rules (C99 6.7.5.3p7). 3651 CheckStaticArrayArgument(CallLoc, Param, Arg); 3652 3653 AllArgs.push_back(Arg); 3654 } 3655 3656 // If this is a variadic call, handle args passed through "...". 3657 if (CallType != VariadicDoesNotApply) { 3658 // Assume that extern "C" functions with variadic arguments that 3659 // return __unknown_anytype aren't *really* variadic. 3660 if (Proto->getResultType() == Context.UnknownAnyTy && 3661 FDecl && FDecl->isExternC()) { 3662 for (unsigned i = ArgIx; i != NumArgs; ++i) { 3663 ExprResult arg; 3664 if (isa<ExplicitCastExpr>(Args[i]->IgnoreParens())) 3665 arg = DefaultFunctionArrayLvalueConversion(Args[i]); 3666 else 3667 arg = DefaultVariadicArgumentPromotion(Args[i], CallType, FDecl); 3668 Invalid |= arg.isInvalid(); 3669 AllArgs.push_back(arg.take()); 3670 } 3671 3672 // Otherwise do argument promotion, (C99 6.5.2.2p7). 3673 } else { 3674 for (unsigned i = ArgIx; i != NumArgs; ++i) { 3675 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], CallType, 3676 FDecl); 3677 Invalid |= Arg.isInvalid(); 3678 AllArgs.push_back(Arg.take()); 3679 } 3680 } 3681 3682 // Check for array bounds violations. 3683 for (unsigned i = ArgIx; i != NumArgs; ++i) 3684 CheckArrayAccess(Args[i]); 3685 } 3686 return Invalid; 3687} 3688 3689static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD) { 3690 TypeLoc TL = PVD->getTypeSourceInfo()->getTypeLoc(); 3691 if (ArrayTypeLoc *ATL = dyn_cast<ArrayTypeLoc>(&TL)) 3692 S.Diag(PVD->getLocation(), diag::note_callee_static_array) 3693 << ATL->getLocalSourceRange(); 3694} 3695 3696/// CheckStaticArrayArgument - If the given argument corresponds to a static 3697/// array parameter, check that it is non-null, and that if it is formed by 3698/// array-to-pointer decay, the underlying array is sufficiently large. 3699/// 3700/// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the 3701/// array type derivation, then for each call to the function, the value of the 3702/// corresponding actual argument shall provide access to the first element of 3703/// an array with at least as many elements as specified by the size expression. 3704void 3705Sema::CheckStaticArrayArgument(SourceLocation CallLoc, 3706 ParmVarDecl *Param, 3707 const Expr *ArgExpr) { 3708 // Static array parameters are not supported in C++. 3709 if (!Param || getLangOpts().CPlusPlus) 3710 return; 3711 3712 QualType OrigTy = Param->getOriginalType(); 3713 3714 const ArrayType *AT = Context.getAsArrayType(OrigTy); 3715 if (!AT || AT->getSizeModifier() != ArrayType::Static) 3716 return; 3717 3718 if (ArgExpr->isNullPointerConstant(Context, 3719 Expr::NPC_NeverValueDependent)) { 3720 Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange(); 3721 DiagnoseCalleeStaticArrayParam(*this, Param); 3722 return; 3723 } 3724 3725 const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT); 3726 if (!CAT) 3727 return; 3728 3729 const ConstantArrayType *ArgCAT = 3730 Context.getAsConstantArrayType(ArgExpr->IgnoreParenImpCasts()->getType()); 3731 if (!ArgCAT) 3732 return; 3733 3734 if (ArgCAT->getSize().ult(CAT->getSize())) { 3735 Diag(CallLoc, diag::warn_static_array_too_small) 3736 << ArgExpr->getSourceRange() 3737 << (unsigned) ArgCAT->getSize().getZExtValue() 3738 << (unsigned) CAT->getSize().getZExtValue(); 3739 DiagnoseCalleeStaticArrayParam(*this, Param); 3740 } 3741} 3742 3743/// Given a function expression of unknown-any type, try to rebuild it 3744/// to have a function type. 3745static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn); 3746 3747/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments. 3748/// This provides the location of the left/right parens and a list of comma 3749/// locations. 3750ExprResult 3751Sema::ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, 3752 MultiExprArg ArgExprs, SourceLocation RParenLoc, 3753 Expr *ExecConfig, bool IsExecConfig) { 3754 unsigned NumArgs = ArgExprs.size(); 3755 3756 // Since this might be a postfix expression, get rid of ParenListExprs. 3757 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn); 3758 if (Result.isInvalid()) return ExprError(); 3759 Fn = Result.take(); 3760 3761 Expr **Args = ArgExprs.release(); 3762 3763 if (getLangOpts().CPlusPlus) { 3764 // If this is a pseudo-destructor expression, build the call immediately. 3765 if (isa<CXXPseudoDestructorExpr>(Fn)) { 3766 if (NumArgs > 0) { 3767 // Pseudo-destructor calls should not have any arguments. 3768 Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args) 3769 << FixItHint::CreateRemoval( 3770 SourceRange(Args[0]->getLocStart(), 3771 Args[NumArgs-1]->getLocEnd())); 3772 } 3773 3774 return Owned(new (Context) CallExpr(Context, Fn, 0, 0, Context.VoidTy, 3775 VK_RValue, RParenLoc)); 3776 } 3777 3778 // Determine whether this is a dependent call inside a C++ template, 3779 // in which case we won't do any semantic analysis now. 3780 // FIXME: Will need to cache the results of name lookup (including ADL) in 3781 // Fn. 3782 bool Dependent = false; 3783 if (Fn->isTypeDependent()) 3784 Dependent = true; 3785 else if (Expr::hasAnyTypeDependentArguments( 3786 llvm::makeArrayRef(Args, NumArgs))) 3787 Dependent = true; 3788 3789 if (Dependent) { 3790 if (ExecConfig) { 3791 return Owned(new (Context) CUDAKernelCallExpr( 3792 Context, Fn, cast<CallExpr>(ExecConfig), Args, NumArgs, 3793 Context.DependentTy, VK_RValue, RParenLoc)); 3794 } else { 3795 return Owned(new (Context) CallExpr(Context, Fn, Args, NumArgs, 3796 Context.DependentTy, VK_RValue, 3797 RParenLoc)); 3798 } 3799 } 3800 3801 // Determine whether this is a call to an object (C++ [over.call.object]). 3802 if (Fn->getType()->isRecordType()) 3803 return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc, Args, NumArgs, 3804 RParenLoc)); 3805 3806 if (Fn->getType() == Context.UnknownAnyTy) { 3807 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 3808 if (result.isInvalid()) return ExprError(); 3809 Fn = result.take(); 3810 } 3811 3812 if (Fn->getType() == Context.BoundMemberTy) { 3813 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs, 3814 RParenLoc); 3815 } 3816 } 3817 3818 // Check for overloaded calls. This can happen even in C due to extensions. 3819 if (Fn->getType() == Context.OverloadTy) { 3820 OverloadExpr::FindResult find = OverloadExpr::find(Fn); 3821 3822 // We aren't supposed to apply this logic for if there's an '&' involved. 3823 if (!find.HasFormOfMemberPointer) { 3824 OverloadExpr *ovl = find.Expression; 3825 if (isa<UnresolvedLookupExpr>(ovl)) { 3826 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(ovl); 3827 return BuildOverloadedCallExpr(S, Fn, ULE, LParenLoc, Args, NumArgs, 3828 RParenLoc, ExecConfig); 3829 } else { 3830 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs, 3831 RParenLoc); 3832 } 3833 } 3834 } 3835 3836 // If we're directly calling a function, get the appropriate declaration. 3837 if (Fn->getType() == Context.UnknownAnyTy) { 3838 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 3839 if (result.isInvalid()) return ExprError(); 3840 Fn = result.take(); 3841 } 3842 3843 Expr *NakedFn = Fn->IgnoreParens(); 3844 3845 NamedDecl *NDecl = 0; 3846 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) 3847 if (UnOp->getOpcode() == UO_AddrOf) 3848 NakedFn = UnOp->getSubExpr()->IgnoreParens(); 3849 3850 if (isa<DeclRefExpr>(NakedFn)) 3851 NDecl = cast<DeclRefExpr>(NakedFn)->getDecl(); 3852 else if (isa<MemberExpr>(NakedFn)) 3853 NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl(); 3854 3855 return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, Args, NumArgs, RParenLoc, 3856 ExecConfig, IsExecConfig); 3857} 3858 3859ExprResult 3860Sema::ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc, 3861 MultiExprArg ExecConfig, SourceLocation GGGLoc) { 3862 FunctionDecl *ConfigDecl = Context.getcudaConfigureCallDecl(); 3863 if (!ConfigDecl) 3864 return ExprError(Diag(LLLLoc, diag::err_undeclared_var_use) 3865 << "cudaConfigureCall"); 3866 QualType ConfigQTy = ConfigDecl->getType(); 3867 3868 DeclRefExpr *ConfigDR = new (Context) DeclRefExpr( 3869 ConfigDecl, false, ConfigQTy, VK_LValue, LLLLoc); 3870 MarkFunctionReferenced(LLLLoc, ConfigDecl); 3871 3872 return ActOnCallExpr(S, ConfigDR, LLLLoc, ExecConfig, GGGLoc, 0, 3873 /*IsExecConfig=*/true); 3874} 3875 3876/// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments. 3877/// 3878/// __builtin_astype( value, dst type ) 3879/// 3880ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, 3881 SourceLocation BuiltinLoc, 3882 SourceLocation RParenLoc) { 3883 ExprValueKind VK = VK_RValue; 3884 ExprObjectKind OK = OK_Ordinary; 3885 QualType DstTy = GetTypeFromParser(ParsedDestTy); 3886 QualType SrcTy = E->getType(); 3887 if (Context.getTypeSize(DstTy) != Context.getTypeSize(SrcTy)) 3888 return ExprError(Diag(BuiltinLoc, 3889 diag::err_invalid_astype_of_different_size) 3890 << DstTy 3891 << SrcTy 3892 << E->getSourceRange()); 3893 return Owned(new (Context) AsTypeExpr(E, DstTy, VK, OK, BuiltinLoc, 3894 RParenLoc)); 3895} 3896 3897/// BuildResolvedCallExpr - Build a call to a resolved expression, 3898/// i.e. an expression not of \p OverloadTy. The expression should 3899/// unary-convert to an expression of function-pointer or 3900/// block-pointer type. 3901/// 3902/// \param NDecl the declaration being called, if available 3903ExprResult 3904Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, 3905 SourceLocation LParenLoc, 3906 Expr **Args, unsigned NumArgs, 3907 SourceLocation RParenLoc, 3908 Expr *Config, bool IsExecConfig) { 3909 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl); 3910 3911 // Promote the function operand. 3912 ExprResult Result = UsualUnaryConversions(Fn); 3913 if (Result.isInvalid()) 3914 return ExprError(); 3915 Fn = Result.take(); 3916 3917 // Make the call expr early, before semantic checks. This guarantees cleanup 3918 // of arguments and function on error. 3919 CallExpr *TheCall; 3920 if (Config) 3921 TheCall = new (Context) CUDAKernelCallExpr(Context, Fn, 3922 cast<CallExpr>(Config), 3923 Args, NumArgs, 3924 Context.BoolTy, 3925 VK_RValue, 3926 RParenLoc); 3927 else 3928 TheCall = new (Context) CallExpr(Context, Fn, 3929 Args, NumArgs, 3930 Context.BoolTy, 3931 VK_RValue, 3932 RParenLoc); 3933 3934 unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0); 3935 3936 // Bail out early if calling a builtin with custom typechecking. 3937 if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID)) 3938 return CheckBuiltinFunctionCall(BuiltinID, TheCall); 3939 3940 retry: 3941 const FunctionType *FuncT; 3942 if (const PointerType *PT = Fn->getType()->getAs<PointerType>()) { 3943 // C99 6.5.2.2p1 - "The expression that denotes the called function shall 3944 // have type pointer to function". 3945 FuncT = PT->getPointeeType()->getAs<FunctionType>(); 3946 if (FuncT == 0) 3947 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 3948 << Fn->getType() << Fn->getSourceRange()); 3949 } else if (const BlockPointerType *BPT = 3950 Fn->getType()->getAs<BlockPointerType>()) { 3951 FuncT = BPT->getPointeeType()->castAs<FunctionType>(); 3952 } else { 3953 // Handle calls to expressions of unknown-any type. 3954 if (Fn->getType() == Context.UnknownAnyTy) { 3955 ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn); 3956 if (rewrite.isInvalid()) return ExprError(); 3957 Fn = rewrite.take(); 3958 TheCall->setCallee(Fn); 3959 goto retry; 3960 } 3961 3962 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 3963 << Fn->getType() << Fn->getSourceRange()); 3964 } 3965 3966 if (getLangOpts().CUDA) { 3967 if (Config) { 3968 // CUDA: Kernel calls must be to global functions 3969 if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>()) 3970 return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function) 3971 << FDecl->getName() << Fn->getSourceRange()); 3972 3973 // CUDA: Kernel function must have 'void' return type 3974 if (!FuncT->getResultType()->isVoidType()) 3975 return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return) 3976 << Fn->getType() << Fn->getSourceRange()); 3977 } else { 3978 // CUDA: Calls to global functions must be configured 3979 if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>()) 3980 return ExprError(Diag(LParenLoc, diag::err_global_call_not_config) 3981 << FDecl->getName() << Fn->getSourceRange()); 3982 } 3983 } 3984 3985 // Check for a valid return type 3986 if (CheckCallReturnType(FuncT->getResultType(), 3987 Fn->getLocStart(), TheCall, 3988 FDecl)) 3989 return ExprError(); 3990 3991 // We know the result type of the call, set it. 3992 TheCall->setType(FuncT->getCallResultType(Context)); 3993 TheCall->setValueKind(Expr::getValueKindForType(FuncT->getResultType())); 3994 3995 const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT); 3996 if (Proto) { 3997 if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, NumArgs, 3998 RParenLoc, IsExecConfig)) 3999 return ExprError(); 4000 } else { 4001 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!"); 4002 4003 if (FDecl) { 4004 // Check if we have too few/too many template arguments, based 4005 // on our knowledge of the function definition. 4006 const FunctionDecl *Def = 0; 4007 if (FDecl->hasBody(Def) && NumArgs != Def->param_size()) { 4008 Proto = Def->getType()->getAs<FunctionProtoType>(); 4009 if (!Proto || !(Proto->isVariadic() && NumArgs >= Def->param_size())) 4010 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments) 4011 << (NumArgs > Def->param_size()) << FDecl << Fn->getSourceRange(); 4012 } 4013 4014 // If the function we're calling isn't a function prototype, but we have 4015 // a function prototype from a prior declaratiom, use that prototype. 4016 if (!FDecl->hasPrototype()) 4017 Proto = FDecl->getType()->getAs<FunctionProtoType>(); 4018 } 4019 4020 // Promote the arguments (C99 6.5.2.2p6). 4021 for (unsigned i = 0; i != NumArgs; i++) { 4022 Expr *Arg = Args[i]; 4023 4024 if (Proto && i < Proto->getNumArgs()) { 4025 InitializedEntity Entity 4026 = InitializedEntity::InitializeParameter(Context, 4027 Proto->getArgType(i), 4028 Proto->isArgConsumed(i)); 4029 ExprResult ArgE = PerformCopyInitialization(Entity, 4030 SourceLocation(), 4031 Owned(Arg)); 4032 if (ArgE.isInvalid()) 4033 return true; 4034 4035 Arg = ArgE.takeAs<Expr>(); 4036 4037 } else { 4038 ExprResult ArgE = DefaultArgumentPromotion(Arg); 4039 4040 if (ArgE.isInvalid()) 4041 return true; 4042 4043 Arg = ArgE.takeAs<Expr>(); 4044 } 4045 4046 if (RequireCompleteType(Arg->getLocStart(), 4047 Arg->getType(), 4048 diag::err_call_incomplete_argument, Arg)) 4049 return ExprError(); 4050 4051 TheCall->setArg(i, Arg); 4052 } 4053 } 4054 4055 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl)) 4056 if (!Method->isStatic()) 4057 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object) 4058 << Fn->getSourceRange()); 4059 4060 // Check for sentinels 4061 if (NDecl) 4062 DiagnoseSentinelCalls(NDecl, LParenLoc, Args, NumArgs); 4063 4064 // Do special checking on direct calls to functions. 4065 if (FDecl) { 4066 if (CheckFunctionCall(FDecl, TheCall, Proto)) 4067 return ExprError(); 4068 4069 if (BuiltinID) 4070 return CheckBuiltinFunctionCall(BuiltinID, TheCall); 4071 } else if (NDecl) { 4072 if (CheckBlockCall(NDecl, TheCall, Proto)) 4073 return ExprError(); 4074 } 4075 4076 return MaybeBindToTemporary(TheCall); 4077} 4078 4079ExprResult 4080Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, 4081 SourceLocation RParenLoc, Expr *InitExpr) { 4082 assert((Ty != 0) && "ActOnCompoundLiteral(): missing type"); 4083 // FIXME: put back this assert when initializers are worked out. 4084 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression"); 4085 4086 TypeSourceInfo *TInfo; 4087 QualType literalType = GetTypeFromParser(Ty, &TInfo); 4088 if (!TInfo) 4089 TInfo = Context.getTrivialTypeSourceInfo(literalType); 4090 4091 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr); 4092} 4093 4094ExprResult 4095Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, 4096 SourceLocation RParenLoc, Expr *LiteralExpr) { 4097 QualType literalType = TInfo->getType(); 4098 4099 if (literalType->isArrayType()) { 4100 if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType), 4101 diag::err_illegal_decl_array_incomplete_type, 4102 SourceRange(LParenLoc, 4103 LiteralExpr->getSourceRange().getEnd()))) 4104 return ExprError(); 4105 if (literalType->isVariableArrayType()) 4106 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init) 4107 << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())); 4108 } else if (!literalType->isDependentType() && 4109 RequireCompleteType(LParenLoc, literalType, 4110 diag::err_typecheck_decl_incomplete_type, 4111 SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd()))) 4112 return ExprError(); 4113 4114 InitializedEntity Entity 4115 = InitializedEntity::InitializeTemporary(literalType); 4116 InitializationKind Kind 4117 = InitializationKind::CreateCStyleCast(LParenLoc, 4118 SourceRange(LParenLoc, RParenLoc), 4119 /*InitList=*/true); 4120 InitializationSequence InitSeq(*this, Entity, Kind, &LiteralExpr, 1); 4121 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, 4122 MultiExprArg(*this, &LiteralExpr, 1), 4123 &literalType); 4124 if (Result.isInvalid()) 4125 return ExprError(); 4126 LiteralExpr = Result.get(); 4127 4128 bool isFileScope = getCurFunctionOrMethodDecl() == 0; 4129 if (isFileScope) { // 6.5.2.5p3 4130 if (CheckForConstantInitializer(LiteralExpr, literalType)) 4131 return ExprError(); 4132 } 4133 4134 // In C, compound literals are l-values for some reason. 4135 ExprValueKind VK = getLangOpts().CPlusPlus ? VK_RValue : VK_LValue; 4136 4137 return MaybeBindToTemporary( 4138 new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType, 4139 VK, LiteralExpr, isFileScope)); 4140} 4141 4142ExprResult 4143Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, 4144 SourceLocation RBraceLoc) { 4145 unsigned NumInit = InitArgList.size(); 4146 Expr **InitList = InitArgList.release(); 4147 4148 // Immediately handle non-overload placeholders. Overloads can be 4149 // resolved contextually, but everything else here can't. 4150 for (unsigned I = 0; I != NumInit; ++I) { 4151 if (InitList[I]->getType()->isNonOverloadPlaceholderType()) { 4152 ExprResult result = CheckPlaceholderExpr(InitList[I]); 4153 4154 // Ignore failures; dropping the entire initializer list because 4155 // of one failure would be terrible for indexing/etc. 4156 if (result.isInvalid()) continue; 4157 4158 InitList[I] = result.take(); 4159 } 4160 } 4161 4162 // Semantic analysis for initializers is done by ActOnDeclarator() and 4163 // CheckInitializer() - it requires knowledge of the object being intialized. 4164 4165 InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitList, 4166 NumInit, RBraceLoc); 4167 E->setType(Context.VoidTy); // FIXME: just a place holder for now. 4168 return Owned(E); 4169} 4170 4171/// Do an explicit extend of the given block pointer if we're in ARC. 4172static void maybeExtendBlockObject(Sema &S, ExprResult &E) { 4173 assert(E.get()->getType()->isBlockPointerType()); 4174 assert(E.get()->isRValue()); 4175 4176 // Only do this in an r-value context. 4177 if (!S.getLangOpts().ObjCAutoRefCount) return; 4178 4179 E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), 4180 CK_ARCExtendBlockObject, E.get(), 4181 /*base path*/ 0, VK_RValue); 4182 S.ExprNeedsCleanups = true; 4183} 4184 4185/// Prepare a conversion of the given expression to an ObjC object 4186/// pointer type. 4187CastKind Sema::PrepareCastToObjCObjectPointer(ExprResult &E) { 4188 QualType type = E.get()->getType(); 4189 if (type->isObjCObjectPointerType()) { 4190 return CK_BitCast; 4191 } else if (type->isBlockPointerType()) { 4192 maybeExtendBlockObject(*this, E); 4193 return CK_BlockPointerToObjCPointerCast; 4194 } else { 4195 assert(type->isPointerType()); 4196 return CK_CPointerToObjCPointerCast; 4197 } 4198} 4199 4200/// Prepares for a scalar cast, performing all the necessary stages 4201/// except the final cast and returning the kind required. 4202CastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) { 4203 // Both Src and Dest are scalar types, i.e. arithmetic or pointer. 4204 // Also, callers should have filtered out the invalid cases with 4205 // pointers. Everything else should be possible. 4206 4207 QualType SrcTy = Src.get()->getType(); 4208 if (Context.hasSameUnqualifiedType(SrcTy, DestTy)) 4209 return CK_NoOp; 4210 4211 switch (Type::ScalarTypeKind SrcKind = SrcTy->getScalarTypeKind()) { 4212 case Type::STK_MemberPointer: 4213 llvm_unreachable("member pointer type in C"); 4214 4215 case Type::STK_CPointer: 4216 case Type::STK_BlockPointer: 4217 case Type::STK_ObjCObjectPointer: 4218 switch (DestTy->getScalarTypeKind()) { 4219 case Type::STK_CPointer: 4220 return CK_BitCast; 4221 case Type::STK_BlockPointer: 4222 return (SrcKind == Type::STK_BlockPointer 4223 ? CK_BitCast : CK_AnyPointerToBlockPointerCast); 4224 case Type::STK_ObjCObjectPointer: 4225 if (SrcKind == Type::STK_ObjCObjectPointer) 4226 return CK_BitCast; 4227 if (SrcKind == Type::STK_CPointer) 4228 return CK_CPointerToObjCPointerCast; 4229 maybeExtendBlockObject(*this, Src); 4230 return CK_BlockPointerToObjCPointerCast; 4231 case Type::STK_Bool: 4232 return CK_PointerToBoolean; 4233 case Type::STK_Integral: 4234 return CK_PointerToIntegral; 4235 case Type::STK_Floating: 4236 case Type::STK_FloatingComplex: 4237 case Type::STK_IntegralComplex: 4238 case Type::STK_MemberPointer: 4239 llvm_unreachable("illegal cast from pointer"); 4240 } 4241 llvm_unreachable("Should have returned before this"); 4242 4243 case Type::STK_Bool: // casting from bool is like casting from an integer 4244 case Type::STK_Integral: 4245 switch (DestTy->getScalarTypeKind()) { 4246 case Type::STK_CPointer: 4247 case Type::STK_ObjCObjectPointer: 4248 case Type::STK_BlockPointer: 4249 if (Src.get()->isNullPointerConstant(Context, 4250 Expr::NPC_ValueDependentIsNull)) 4251 return CK_NullToPointer; 4252 return CK_IntegralToPointer; 4253 case Type::STK_Bool: 4254 return CK_IntegralToBoolean; 4255 case Type::STK_Integral: 4256 return CK_IntegralCast; 4257 case Type::STK_Floating: 4258 return CK_IntegralToFloating; 4259 case Type::STK_IntegralComplex: 4260 Src = ImpCastExprToType(Src.take(), 4261 DestTy->castAs<ComplexType>()->getElementType(), 4262 CK_IntegralCast); 4263 return CK_IntegralRealToComplex; 4264 case Type::STK_FloatingComplex: 4265 Src = ImpCastExprToType(Src.take(), 4266 DestTy->castAs<ComplexType>()->getElementType(), 4267 CK_IntegralToFloating); 4268 return CK_FloatingRealToComplex; 4269 case Type::STK_MemberPointer: 4270 llvm_unreachable("member pointer type in C"); 4271 } 4272 llvm_unreachable("Should have returned before this"); 4273 4274 case Type::STK_Floating: 4275 switch (DestTy->getScalarTypeKind()) { 4276 case Type::STK_Floating: 4277 return CK_FloatingCast; 4278 case Type::STK_Bool: 4279 return CK_FloatingToBoolean; 4280 case Type::STK_Integral: 4281 return CK_FloatingToIntegral; 4282 case Type::STK_FloatingComplex: 4283 Src = ImpCastExprToType(Src.take(), 4284 DestTy->castAs<ComplexType>()->getElementType(), 4285 CK_FloatingCast); 4286 return CK_FloatingRealToComplex; 4287 case Type::STK_IntegralComplex: 4288 Src = ImpCastExprToType(Src.take(), 4289 DestTy->castAs<ComplexType>()->getElementType(), 4290 CK_FloatingToIntegral); 4291 return CK_IntegralRealToComplex; 4292 case Type::STK_CPointer: 4293 case Type::STK_ObjCObjectPointer: 4294 case Type::STK_BlockPointer: 4295 llvm_unreachable("valid float->pointer cast?"); 4296 case Type::STK_MemberPointer: 4297 llvm_unreachable("member pointer type in C"); 4298 } 4299 llvm_unreachable("Should have returned before this"); 4300 4301 case Type::STK_FloatingComplex: 4302 switch (DestTy->getScalarTypeKind()) { 4303 case Type::STK_FloatingComplex: 4304 return CK_FloatingComplexCast; 4305 case Type::STK_IntegralComplex: 4306 return CK_FloatingComplexToIntegralComplex; 4307 case Type::STK_Floating: { 4308 QualType ET = SrcTy->castAs<ComplexType>()->getElementType(); 4309 if (Context.hasSameType(ET, DestTy)) 4310 return CK_FloatingComplexToReal; 4311 Src = ImpCastExprToType(Src.take(), ET, CK_FloatingComplexToReal); 4312 return CK_FloatingCast; 4313 } 4314 case Type::STK_Bool: 4315 return CK_FloatingComplexToBoolean; 4316 case Type::STK_Integral: 4317 Src = ImpCastExprToType(Src.take(), 4318 SrcTy->castAs<ComplexType>()->getElementType(), 4319 CK_FloatingComplexToReal); 4320 return CK_FloatingToIntegral; 4321 case Type::STK_CPointer: 4322 case Type::STK_ObjCObjectPointer: 4323 case Type::STK_BlockPointer: 4324 llvm_unreachable("valid complex float->pointer cast?"); 4325 case Type::STK_MemberPointer: 4326 llvm_unreachable("member pointer type in C"); 4327 } 4328 llvm_unreachable("Should have returned before this"); 4329 4330 case Type::STK_IntegralComplex: 4331 switch (DestTy->getScalarTypeKind()) { 4332 case Type::STK_FloatingComplex: 4333 return CK_IntegralComplexToFloatingComplex; 4334 case Type::STK_IntegralComplex: 4335 return CK_IntegralComplexCast; 4336 case Type::STK_Integral: { 4337 QualType ET = SrcTy->castAs<ComplexType>()->getElementType(); 4338 if (Context.hasSameType(ET, DestTy)) 4339 return CK_IntegralComplexToReal; 4340 Src = ImpCastExprToType(Src.take(), ET, CK_IntegralComplexToReal); 4341 return CK_IntegralCast; 4342 } 4343 case Type::STK_Bool: 4344 return CK_IntegralComplexToBoolean; 4345 case Type::STK_Floating: 4346 Src = ImpCastExprToType(Src.take(), 4347 SrcTy->castAs<ComplexType>()->getElementType(), 4348 CK_IntegralComplexToReal); 4349 return CK_IntegralToFloating; 4350 case Type::STK_CPointer: 4351 case Type::STK_ObjCObjectPointer: 4352 case Type::STK_BlockPointer: 4353 llvm_unreachable("valid complex int->pointer cast?"); 4354 case Type::STK_MemberPointer: 4355 llvm_unreachable("member pointer type in C"); 4356 } 4357 llvm_unreachable("Should have returned before this"); 4358 } 4359 4360 llvm_unreachable("Unhandled scalar cast"); 4361} 4362 4363bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, 4364 CastKind &Kind) { 4365 assert(VectorTy->isVectorType() && "Not a vector type!"); 4366 4367 if (Ty->isVectorType() || Ty->isIntegerType()) { 4368 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty)) 4369 return Diag(R.getBegin(), 4370 Ty->isVectorType() ? 4371 diag::err_invalid_conversion_between_vectors : 4372 diag::err_invalid_conversion_between_vector_and_integer) 4373 << VectorTy << Ty << R; 4374 } else 4375 return Diag(R.getBegin(), 4376 diag::err_invalid_conversion_between_vector_and_scalar) 4377 << VectorTy << Ty << R; 4378 4379 Kind = CK_BitCast; 4380 return false; 4381} 4382 4383ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy, 4384 Expr *CastExpr, CastKind &Kind) { 4385 assert(DestTy->isExtVectorType() && "Not an extended vector type!"); 4386 4387 QualType SrcTy = CastExpr->getType(); 4388 4389 // If SrcTy is a VectorType, the total size must match to explicitly cast to 4390 // an ExtVectorType. 4391 // In OpenCL, casts between vectors of different types are not allowed. 4392 // (See OpenCL 6.2). 4393 if (SrcTy->isVectorType()) { 4394 if (Context.getTypeSize(DestTy) != Context.getTypeSize(SrcTy) 4395 || (getLangOpts().OpenCL && 4396 (DestTy.getCanonicalType() != SrcTy.getCanonicalType()))) { 4397 Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors) 4398 << DestTy << SrcTy << R; 4399 return ExprError(); 4400 } 4401 Kind = CK_BitCast; 4402 return Owned(CastExpr); 4403 } 4404 4405 // All non-pointer scalars can be cast to ExtVector type. The appropriate 4406 // conversion will take place first from scalar to elt type, and then 4407 // splat from elt type to vector. 4408 if (SrcTy->isPointerType()) 4409 return Diag(R.getBegin(), 4410 diag::err_invalid_conversion_between_vector_and_scalar) 4411 << DestTy << SrcTy << R; 4412 4413 QualType DestElemTy = DestTy->getAs<ExtVectorType>()->getElementType(); 4414 ExprResult CastExprRes = Owned(CastExpr); 4415 CastKind CK = PrepareScalarCast(CastExprRes, DestElemTy); 4416 if (CastExprRes.isInvalid()) 4417 return ExprError(); 4418 CastExpr = ImpCastExprToType(CastExprRes.take(), DestElemTy, CK).take(); 4419 4420 Kind = CK_VectorSplat; 4421 return Owned(CastExpr); 4422} 4423 4424ExprResult 4425Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, 4426 Declarator &D, ParsedType &Ty, 4427 SourceLocation RParenLoc, Expr *CastExpr) { 4428 assert(!D.isInvalidType() && (CastExpr != 0) && 4429 "ActOnCastExpr(): missing type or expr"); 4430 4431 TypeSourceInfo *castTInfo = GetTypeForDeclaratorCast(D, CastExpr->getType()); 4432 if (D.isInvalidType()) 4433 return ExprError(); 4434 4435 if (getLangOpts().CPlusPlus) { 4436 // Check that there are no default arguments (C++ only). 4437 CheckExtraCXXDefaultArguments(D); 4438 } 4439 4440 checkUnusedDeclAttributes(D); 4441 4442 QualType castType = castTInfo->getType(); 4443 Ty = CreateParsedType(castType, castTInfo); 4444 4445 bool isVectorLiteral = false; 4446 4447 // Check for an altivec or OpenCL literal, 4448 // i.e. all the elements are integer constants. 4449 ParenExpr *PE = dyn_cast<ParenExpr>(CastExpr); 4450 ParenListExpr *PLE = dyn_cast<ParenListExpr>(CastExpr); 4451 if ((getLangOpts().AltiVec || getLangOpts().OpenCL) 4452 && castType->isVectorType() && (PE || PLE)) { 4453 if (PLE && PLE->getNumExprs() == 0) { 4454 Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer); 4455 return ExprError(); 4456 } 4457 if (PE || PLE->getNumExprs() == 1) { 4458 Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0)); 4459 if (!E->getType()->isVectorType()) 4460 isVectorLiteral = true; 4461 } 4462 else 4463 isVectorLiteral = true; 4464 } 4465 4466 // If this is a vector initializer, '(' type ')' '(' init, ..., init ')' 4467 // then handle it as such. 4468 if (isVectorLiteral) 4469 return BuildVectorLiteral(LParenLoc, RParenLoc, CastExpr, castTInfo); 4470 4471 // If the Expr being casted is a ParenListExpr, handle it specially. 4472 // This is not an AltiVec-style cast, so turn the ParenListExpr into a 4473 // sequence of BinOp comma operators. 4474 if (isa<ParenListExpr>(CastExpr)) { 4475 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr); 4476 if (Result.isInvalid()) return ExprError(); 4477 CastExpr = Result.take(); 4478 } 4479 4480 return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, CastExpr); 4481} 4482 4483ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc, 4484 SourceLocation RParenLoc, Expr *E, 4485 TypeSourceInfo *TInfo) { 4486 assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) && 4487 "Expected paren or paren list expression"); 4488 4489 Expr **exprs; 4490 unsigned numExprs; 4491 Expr *subExpr; 4492 if (ParenListExpr *PE = dyn_cast<ParenListExpr>(E)) { 4493 exprs = PE->getExprs(); 4494 numExprs = PE->getNumExprs(); 4495 } else { 4496 subExpr = cast<ParenExpr>(E)->getSubExpr(); 4497 exprs = &subExpr; 4498 numExprs = 1; 4499 } 4500 4501 QualType Ty = TInfo->getType(); 4502 assert(Ty->isVectorType() && "Expected vector type"); 4503 4504 SmallVector<Expr *, 8> initExprs; 4505 const VectorType *VTy = Ty->getAs<VectorType>(); 4506 unsigned numElems = Ty->getAs<VectorType>()->getNumElements(); 4507 4508 // '(...)' form of vector initialization in AltiVec: the number of 4509 // initializers must be one or must match the size of the vector. 4510 // If a single value is specified in the initializer then it will be 4511 // replicated to all the components of the vector 4512 if (VTy->getVectorKind() == VectorType::AltiVecVector) { 4513 // The number of initializers must be one or must match the size of the 4514 // vector. If a single value is specified in the initializer then it will 4515 // be replicated to all the components of the vector 4516 if (numExprs == 1) { 4517 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 4518 ExprResult Literal = DefaultLvalueConversion(exprs[0]); 4519 if (Literal.isInvalid()) 4520 return ExprError(); 4521 Literal = ImpCastExprToType(Literal.take(), ElemTy, 4522 PrepareScalarCast(Literal, ElemTy)); 4523 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take()); 4524 } 4525 else if (numExprs < numElems) { 4526 Diag(E->getExprLoc(), 4527 diag::err_incorrect_number_of_vector_initializers); 4528 return ExprError(); 4529 } 4530 else 4531 initExprs.append(exprs, exprs + numExprs); 4532 } 4533 else { 4534 // For OpenCL, when the number of initializers is a single value, 4535 // it will be replicated to all components of the vector. 4536 if (getLangOpts().OpenCL && 4537 VTy->getVectorKind() == VectorType::GenericVector && 4538 numExprs == 1) { 4539 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 4540 ExprResult Literal = DefaultLvalueConversion(exprs[0]); 4541 if (Literal.isInvalid()) 4542 return ExprError(); 4543 Literal = ImpCastExprToType(Literal.take(), ElemTy, 4544 PrepareScalarCast(Literal, ElemTy)); 4545 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take()); 4546 } 4547 4548 initExprs.append(exprs, exprs + numExprs); 4549 } 4550 // FIXME: This means that pretty-printing the final AST will produce curly 4551 // braces instead of the original commas. 4552 InitListExpr *initE = new (Context) InitListExpr(Context, LParenLoc, 4553 &initExprs[0], 4554 initExprs.size(), RParenLoc); 4555 initE->setType(Ty); 4556 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE); 4557} 4558 4559/// This is not an AltiVec-style cast or or C++ direct-initialization, so turn 4560/// the ParenListExpr into a sequence of comma binary operators. 4561ExprResult 4562Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *OrigExpr) { 4563 ParenListExpr *E = dyn_cast<ParenListExpr>(OrigExpr); 4564 if (!E) 4565 return Owned(OrigExpr); 4566 4567 ExprResult Result(E->getExpr(0)); 4568 4569 for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i) 4570 Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(), 4571 E->getExpr(i)); 4572 4573 if (Result.isInvalid()) return ExprError(); 4574 4575 return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get()); 4576} 4577 4578ExprResult Sema::ActOnParenListExpr(SourceLocation L, 4579 SourceLocation R, 4580 MultiExprArg Val) { 4581 unsigned nexprs = Val.size(); 4582 Expr **exprs = reinterpret_cast<Expr**>(Val.release()); 4583 assert((exprs != 0) && "ActOnParenOrParenListExpr() missing expr list"); 4584 Expr *expr = new (Context) ParenListExpr(Context, L, exprs, nexprs, R); 4585 return Owned(expr); 4586} 4587 4588/// \brief Emit a specialized diagnostic when one expression is a null pointer 4589/// constant and the other is not a pointer. Returns true if a diagnostic is 4590/// emitted. 4591bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, 4592 SourceLocation QuestionLoc) { 4593 Expr *NullExpr = LHSExpr; 4594 Expr *NonPointerExpr = RHSExpr; 4595 Expr::NullPointerConstantKind NullKind = 4596 NullExpr->isNullPointerConstant(Context, 4597 Expr::NPC_ValueDependentIsNotNull); 4598 4599 if (NullKind == Expr::NPCK_NotNull) { 4600 NullExpr = RHSExpr; 4601 NonPointerExpr = LHSExpr; 4602 NullKind = 4603 NullExpr->isNullPointerConstant(Context, 4604 Expr::NPC_ValueDependentIsNotNull); 4605 } 4606 4607 if (NullKind == Expr::NPCK_NotNull) 4608 return false; 4609 4610 if (NullKind == Expr::NPCK_ZeroInteger) { 4611 // In this case, check to make sure that we got here from a "NULL" 4612 // string in the source code. 4613 NullExpr = NullExpr->IgnoreParenImpCasts(); 4614 SourceLocation loc = NullExpr->getExprLoc(); 4615 if (!findMacroSpelling(loc, "NULL")) 4616 return false; 4617 } 4618 4619 int DiagType = (NullKind == Expr::NPCK_CXX0X_nullptr); 4620 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null) 4621 << NonPointerExpr->getType() << DiagType 4622 << NonPointerExpr->getSourceRange(); 4623 return true; 4624} 4625 4626/// \brief Return false if the condition expression is valid, true otherwise. 4627static bool checkCondition(Sema &S, Expr *Cond) { 4628 QualType CondTy = Cond->getType(); 4629 4630 // C99 6.5.15p2 4631 if (CondTy->isScalarType()) return false; 4632 4633 // OpenCL: Sec 6.3.i says the condition is allowed to be a vector or scalar. 4634 if (S.getLangOpts().OpenCL && CondTy->isVectorType()) 4635 return false; 4636 4637 // Emit the proper error message. 4638 S.Diag(Cond->getLocStart(), S.getLangOpts().OpenCL ? 4639 diag::err_typecheck_cond_expect_scalar : 4640 diag::err_typecheck_cond_expect_scalar_or_vector) 4641 << CondTy; 4642 return true; 4643} 4644 4645/// \brief Return false if the two expressions can be converted to a vector, 4646/// true otherwise 4647static bool checkConditionalConvertScalarsToVectors(Sema &S, ExprResult &LHS, 4648 ExprResult &RHS, 4649 QualType CondTy) { 4650 // Both operands should be of scalar type. 4651 if (!LHS.get()->getType()->isScalarType()) { 4652 S.Diag(LHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 4653 << CondTy; 4654 return true; 4655 } 4656 if (!RHS.get()->getType()->isScalarType()) { 4657 S.Diag(RHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 4658 << CondTy; 4659 return true; 4660 } 4661 4662 // Implicity convert these scalars to the type of the condition. 4663 LHS = S.ImpCastExprToType(LHS.take(), CondTy, CK_IntegralCast); 4664 RHS = S.ImpCastExprToType(RHS.take(), CondTy, CK_IntegralCast); 4665 return false; 4666} 4667 4668/// \brief Handle when one or both operands are void type. 4669static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS, 4670 ExprResult &RHS) { 4671 Expr *LHSExpr = LHS.get(); 4672 Expr *RHSExpr = RHS.get(); 4673 4674 if (!LHSExpr->getType()->isVoidType()) 4675 S.Diag(RHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 4676 << RHSExpr->getSourceRange(); 4677 if (!RHSExpr->getType()->isVoidType()) 4678 S.Diag(LHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 4679 << LHSExpr->getSourceRange(); 4680 LHS = S.ImpCastExprToType(LHS.take(), S.Context.VoidTy, CK_ToVoid); 4681 RHS = S.ImpCastExprToType(RHS.take(), S.Context.VoidTy, CK_ToVoid); 4682 return S.Context.VoidTy; 4683} 4684 4685/// \brief Return false if the NullExpr can be promoted to PointerTy, 4686/// true otherwise. 4687static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, 4688 QualType PointerTy) { 4689 if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) || 4690 !NullExpr.get()->isNullPointerConstant(S.Context, 4691 Expr::NPC_ValueDependentIsNull)) 4692 return true; 4693 4694 NullExpr = S.ImpCastExprToType(NullExpr.take(), PointerTy, CK_NullToPointer); 4695 return false; 4696} 4697 4698/// \brief Checks compatibility between two pointers and return the resulting 4699/// type. 4700static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, 4701 ExprResult &RHS, 4702 SourceLocation Loc) { 4703 QualType LHSTy = LHS.get()->getType(); 4704 QualType RHSTy = RHS.get()->getType(); 4705 4706 if (S.Context.hasSameType(LHSTy, RHSTy)) { 4707 // Two identical pointers types are always compatible. 4708 return LHSTy; 4709 } 4710 4711 QualType lhptee, rhptee; 4712 4713 // Get the pointee types. 4714 if (const BlockPointerType *LHSBTy = LHSTy->getAs<BlockPointerType>()) { 4715 lhptee = LHSBTy->getPointeeType(); 4716 rhptee = RHSTy->castAs<BlockPointerType>()->getPointeeType(); 4717 } else { 4718 lhptee = LHSTy->castAs<PointerType>()->getPointeeType(); 4719 rhptee = RHSTy->castAs<PointerType>()->getPointeeType(); 4720 } 4721 4722 // C99 6.5.15p6: If both operands are pointers to compatible types or to 4723 // differently qualified versions of compatible types, the result type is 4724 // a pointer to an appropriately qualified version of the composite 4725 // type. 4726 4727 // Only CVR-qualifiers exist in the standard, and the differently-qualified 4728 // clause doesn't make sense for our extensions. E.g. address space 2 should 4729 // be incompatible with address space 3: they may live on different devices or 4730 // anything. 4731 Qualifiers lhQual = lhptee.getQualifiers(); 4732 Qualifiers rhQual = rhptee.getQualifiers(); 4733 4734 unsigned MergedCVRQual = lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers(); 4735 lhQual.removeCVRQualifiers(); 4736 rhQual.removeCVRQualifiers(); 4737 4738 lhptee = S.Context.getQualifiedType(lhptee.getUnqualifiedType(), lhQual); 4739 rhptee = S.Context.getQualifiedType(rhptee.getUnqualifiedType(), rhQual); 4740 4741 QualType CompositeTy = S.Context.mergeTypes(lhptee, rhptee); 4742 4743 if (CompositeTy.isNull()) { 4744 S.Diag(Loc, diag::warn_typecheck_cond_incompatible_pointers) 4745 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4746 << RHS.get()->getSourceRange(); 4747 // In this situation, we assume void* type. No especially good 4748 // reason, but this is what gcc does, and we do have to pick 4749 // to get a consistent AST. 4750 QualType incompatTy = S.Context.getPointerType(S.Context.VoidTy); 4751 LHS = S.ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); 4752 RHS = S.ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); 4753 return incompatTy; 4754 } 4755 4756 // The pointer types are compatible. 4757 QualType ResultTy = CompositeTy.withCVRQualifiers(MergedCVRQual); 4758 ResultTy = S.Context.getPointerType(ResultTy); 4759 4760 LHS = S.ImpCastExprToType(LHS.take(), ResultTy, CK_BitCast); 4761 RHS = S.ImpCastExprToType(RHS.take(), ResultTy, CK_BitCast); 4762 return ResultTy; 4763} 4764 4765/// \brief Return the resulting type when the operands are both block pointers. 4766static QualType checkConditionalBlockPointerCompatibility(Sema &S, 4767 ExprResult &LHS, 4768 ExprResult &RHS, 4769 SourceLocation Loc) { 4770 QualType LHSTy = LHS.get()->getType(); 4771 QualType RHSTy = RHS.get()->getType(); 4772 4773 if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) { 4774 if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) { 4775 QualType destType = S.Context.getPointerType(S.Context.VoidTy); 4776 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast); 4777 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast); 4778 return destType; 4779 } 4780 S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 4781 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4782 << RHS.get()->getSourceRange(); 4783 return QualType(); 4784 } 4785 4786 // We have 2 block pointer types. 4787 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 4788} 4789 4790/// \brief Return the resulting type when the operands are both pointers. 4791static QualType 4792checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, 4793 ExprResult &RHS, 4794 SourceLocation Loc) { 4795 // get the pointer types 4796 QualType LHSTy = LHS.get()->getType(); 4797 QualType RHSTy = RHS.get()->getType(); 4798 4799 // get the "pointed to" types 4800 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 4801 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 4802 4803 // ignore qualifiers on void (C99 6.5.15p3, clause 6) 4804 if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) { 4805 // Figure out necessary qualifiers (C99 6.5.15p6) 4806 QualType destPointee 4807 = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 4808 QualType destType = S.Context.getPointerType(destPointee); 4809 // Add qualifiers if necessary. 4810 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_NoOp); 4811 // Promote to void*. 4812 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast); 4813 return destType; 4814 } 4815 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) { 4816 QualType destPointee 4817 = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 4818 QualType destType = S.Context.getPointerType(destPointee); 4819 // Add qualifiers if necessary. 4820 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_NoOp); 4821 // Promote to void*. 4822 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast); 4823 return destType; 4824 } 4825 4826 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 4827} 4828 4829/// \brief Return false if the first expression is not an integer and the second 4830/// expression is not a pointer, true otherwise. 4831static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, 4832 Expr* PointerExpr, SourceLocation Loc, 4833 bool IsIntFirstExpr) { 4834 if (!PointerExpr->getType()->isPointerType() || 4835 !Int.get()->getType()->isIntegerType()) 4836 return false; 4837 4838 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr; 4839 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get(); 4840 4841 S.Diag(Loc, diag::warn_typecheck_cond_pointer_integer_mismatch) 4842 << Expr1->getType() << Expr2->getType() 4843 << Expr1->getSourceRange() << Expr2->getSourceRange(); 4844 Int = S.ImpCastExprToType(Int.take(), PointerExpr->getType(), 4845 CK_IntegralToPointer); 4846 return true; 4847} 4848 4849/// Note that LHS is not null here, even if this is the gnu "x ?: y" extension. 4850/// In that case, LHS = cond. 4851/// C99 6.5.15 4852QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, 4853 ExprResult &RHS, ExprValueKind &VK, 4854 ExprObjectKind &OK, 4855 SourceLocation QuestionLoc) { 4856 4857 ExprResult LHSResult = CheckPlaceholderExpr(LHS.get()); 4858 if (!LHSResult.isUsable()) return QualType(); 4859 LHS = move(LHSResult); 4860 4861 ExprResult RHSResult = CheckPlaceholderExpr(RHS.get()); 4862 if (!RHSResult.isUsable()) return QualType(); 4863 RHS = move(RHSResult); 4864 4865 // C++ is sufficiently different to merit its own checker. 4866 if (getLangOpts().CPlusPlus) 4867 return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc); 4868 4869 VK = VK_RValue; 4870 OK = OK_Ordinary; 4871 4872 Cond = UsualUnaryConversions(Cond.take()); 4873 if (Cond.isInvalid()) 4874 return QualType(); 4875 LHS = UsualUnaryConversions(LHS.take()); 4876 if (LHS.isInvalid()) 4877 return QualType(); 4878 RHS = UsualUnaryConversions(RHS.take()); 4879 if (RHS.isInvalid()) 4880 return QualType(); 4881 4882 QualType CondTy = Cond.get()->getType(); 4883 QualType LHSTy = LHS.get()->getType(); 4884 QualType RHSTy = RHS.get()->getType(); 4885 4886 // first, check the condition. 4887 if (checkCondition(*this, Cond.get())) 4888 return QualType(); 4889 4890 // Now check the two expressions. 4891 if (LHSTy->isVectorType() || RHSTy->isVectorType()) 4892 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false); 4893 4894 // OpenCL: If the condition is a vector, and both operands are scalar, 4895 // attempt to implicity convert them to the vector type to act like the 4896 // built in select. 4897 if (getLangOpts().OpenCL && CondTy->isVectorType()) 4898 if (checkConditionalConvertScalarsToVectors(*this, LHS, RHS, CondTy)) 4899 return QualType(); 4900 4901 // If both operands have arithmetic type, do the usual arithmetic conversions 4902 // to find a common type: C99 6.5.15p3,5. 4903 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) { 4904 UsualArithmeticConversions(LHS, RHS); 4905 if (LHS.isInvalid() || RHS.isInvalid()) 4906 return QualType(); 4907 return LHS.get()->getType(); 4908 } 4909 4910 // If both operands are the same structure or union type, the result is that 4911 // type. 4912 if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3 4913 if (const RecordType *RHSRT = RHSTy->getAs<RecordType>()) 4914 if (LHSRT->getDecl() == RHSRT->getDecl()) 4915 // "If both the operands have structure or union type, the result has 4916 // that type." This implies that CV qualifiers are dropped. 4917 return LHSTy.getUnqualifiedType(); 4918 // FIXME: Type of conditional expression must be complete in C mode. 4919 } 4920 4921 // C99 6.5.15p5: "If both operands have void type, the result has void type." 4922 // The following || allows only one side to be void (a GCC-ism). 4923 if (LHSTy->isVoidType() || RHSTy->isVoidType()) { 4924 return checkConditionalVoidType(*this, LHS, RHS); 4925 } 4926 4927 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has 4928 // the type of the other operand." 4929 if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy; 4930 if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy; 4931 4932 // All objective-c pointer type analysis is done here. 4933 QualType compositeType = FindCompositeObjCPointerType(LHS, RHS, 4934 QuestionLoc); 4935 if (LHS.isInvalid() || RHS.isInvalid()) 4936 return QualType(); 4937 if (!compositeType.isNull()) 4938 return compositeType; 4939 4940 4941 // Handle block pointer types. 4942 if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) 4943 return checkConditionalBlockPointerCompatibility(*this, LHS, RHS, 4944 QuestionLoc); 4945 4946 // Check constraints for C object pointers types (C99 6.5.15p3,6). 4947 if (LHSTy->isPointerType() && RHSTy->isPointerType()) 4948 return checkConditionalObjectPointersCompatibility(*this, LHS, RHS, 4949 QuestionLoc); 4950 4951 // GCC compatibility: soften pointer/integer mismatch. Note that 4952 // null pointers have been filtered out by this point. 4953 if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc, 4954 /*isIntFirstExpr=*/true)) 4955 return RHSTy; 4956 if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc, 4957 /*isIntFirstExpr=*/false)) 4958 return LHSTy; 4959 4960 // Emit a better diagnostic if one of the expressions is a null pointer 4961 // constant and the other is not a pointer type. In this case, the user most 4962 // likely forgot to take the address of the other expression. 4963 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc)) 4964 return QualType(); 4965 4966 // Otherwise, the operands are not compatible. 4967 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 4968 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4969 << RHS.get()->getSourceRange(); 4970 return QualType(); 4971} 4972 4973/// FindCompositeObjCPointerType - Helper method to find composite type of 4974/// two objective-c pointer types of the two input expressions. 4975QualType Sema::FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, 4976 SourceLocation QuestionLoc) { 4977 QualType LHSTy = LHS.get()->getType(); 4978 QualType RHSTy = RHS.get()->getType(); 4979 4980 // Handle things like Class and struct objc_class*. Here we case the result 4981 // to the pseudo-builtin, because that will be implicitly cast back to the 4982 // redefinition type if an attempt is made to access its fields. 4983 if (LHSTy->isObjCClassType() && 4984 (Context.hasSameType(RHSTy, Context.getObjCClassRedefinitionType()))) { 4985 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_CPointerToObjCPointerCast); 4986 return LHSTy; 4987 } 4988 if (RHSTy->isObjCClassType() && 4989 (Context.hasSameType(LHSTy, Context.getObjCClassRedefinitionType()))) { 4990 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_CPointerToObjCPointerCast); 4991 return RHSTy; 4992 } 4993 // And the same for struct objc_object* / id 4994 if (LHSTy->isObjCIdType() && 4995 (Context.hasSameType(RHSTy, Context.getObjCIdRedefinitionType()))) { 4996 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_CPointerToObjCPointerCast); 4997 return LHSTy; 4998 } 4999 if (RHSTy->isObjCIdType() && 5000 (Context.hasSameType(LHSTy, Context.getObjCIdRedefinitionType()))) { 5001 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_CPointerToObjCPointerCast); 5002 return RHSTy; 5003 } 5004 // And the same for struct objc_selector* / SEL 5005 if (Context.isObjCSelType(LHSTy) && 5006 (Context.hasSameType(RHSTy, Context.getObjCSelRedefinitionType()))) { 5007 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 5008 return LHSTy; 5009 } 5010 if (Context.isObjCSelType(RHSTy) && 5011 (Context.hasSameType(LHSTy, Context.getObjCSelRedefinitionType()))) { 5012 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_BitCast); 5013 return RHSTy; 5014 } 5015 // Check constraints for Objective-C object pointers types. 5016 if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) { 5017 5018 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) { 5019 // Two identical object pointer types are always compatible. 5020 return LHSTy; 5021 } 5022 const ObjCObjectPointerType *LHSOPT = LHSTy->castAs<ObjCObjectPointerType>(); 5023 const ObjCObjectPointerType *RHSOPT = RHSTy->castAs<ObjCObjectPointerType>(); 5024 QualType compositeType = LHSTy; 5025 5026 // If both operands are interfaces and either operand can be 5027 // assigned to the other, use that type as the composite 5028 // type. This allows 5029 // xxx ? (A*) a : (B*) b 5030 // where B is a subclass of A. 5031 // 5032 // Additionally, as for assignment, if either type is 'id' 5033 // allow silent coercion. Finally, if the types are 5034 // incompatible then make sure to use 'id' as the composite 5035 // type so the result is acceptable for sending messages to. 5036 5037 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'. 5038 // It could return the composite type. 5039 if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) { 5040 compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy; 5041 } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) { 5042 compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy; 5043 } else if ((LHSTy->isObjCQualifiedIdType() || 5044 RHSTy->isObjCQualifiedIdType()) && 5045 Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) { 5046 // Need to handle "id<xx>" explicitly. 5047 // GCC allows qualified id and any Objective-C type to devolve to 5048 // id. Currently localizing to here until clear this should be 5049 // part of ObjCQualifiedIdTypesAreCompatible. 5050 compositeType = Context.getObjCIdType(); 5051 } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) { 5052 compositeType = Context.getObjCIdType(); 5053 } else if (!(compositeType = 5054 Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull()) 5055 ; 5056 else { 5057 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands) 5058 << LHSTy << RHSTy 5059 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5060 QualType incompatTy = Context.getObjCIdType(); 5061 LHS = ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); 5062 RHS = ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); 5063 return incompatTy; 5064 } 5065 // The object pointer types are compatible. 5066 LHS = ImpCastExprToType(LHS.take(), compositeType, CK_BitCast); 5067 RHS = ImpCastExprToType(RHS.take(), compositeType, CK_BitCast); 5068 return compositeType; 5069 } 5070 // Check Objective-C object pointer types and 'void *' 5071 if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) { 5072 if (getLangOpts().ObjCAutoRefCount) { 5073 // ARC forbids the implicit conversion of object pointers to 'void *', 5074 // so these types are not compatible. 5075 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy 5076 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5077 LHS = RHS = true; 5078 return QualType(); 5079 } 5080 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 5081 QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 5082 QualType destPointee 5083 = Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 5084 QualType destType = Context.getPointerType(destPointee); 5085 // Add qualifiers if necessary. 5086 LHS = ImpCastExprToType(LHS.take(), destType, CK_NoOp); 5087 // Promote to void*. 5088 RHS = ImpCastExprToType(RHS.take(), destType, CK_BitCast); 5089 return destType; 5090 } 5091 if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) { 5092 if (getLangOpts().ObjCAutoRefCount) { 5093 // ARC forbids the implicit conversion of object pointers to 'void *', 5094 // so these types are not compatible. 5095 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy 5096 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5097 LHS = RHS = true; 5098 return QualType(); 5099 } 5100 QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 5101 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 5102 QualType destPointee 5103 = Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 5104 QualType destType = Context.getPointerType(destPointee); 5105 // Add qualifiers if necessary. 5106 RHS = ImpCastExprToType(RHS.take(), destType, CK_NoOp); 5107 // Promote to void*. 5108 LHS = ImpCastExprToType(LHS.take(), destType, CK_BitCast); 5109 return destType; 5110 } 5111 return QualType(); 5112} 5113 5114/// SuggestParentheses - Emit a note with a fixit hint that wraps 5115/// ParenRange in parentheses. 5116static void SuggestParentheses(Sema &Self, SourceLocation Loc, 5117 const PartialDiagnostic &Note, 5118 SourceRange ParenRange) { 5119 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(ParenRange.getEnd()); 5120 if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() && 5121 EndLoc.isValid()) { 5122 Self.Diag(Loc, Note) 5123 << FixItHint::CreateInsertion(ParenRange.getBegin(), "(") 5124 << FixItHint::CreateInsertion(EndLoc, ")"); 5125 } else { 5126 // We can't display the parentheses, so just show the bare note. 5127 Self.Diag(Loc, Note) << ParenRange; 5128 } 5129} 5130 5131static bool IsArithmeticOp(BinaryOperatorKind Opc) { 5132 return Opc >= BO_Mul && Opc <= BO_Shr; 5133} 5134 5135/// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary 5136/// expression, either using a built-in or overloaded operator, 5137/// and sets *OpCode to the opcode and *RHSExprs to the right-hand side 5138/// expression. 5139static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode, 5140 Expr **RHSExprs) { 5141 // Don't strip parenthesis: we should not warn if E is in parenthesis. 5142 E = E->IgnoreImpCasts(); 5143 E = E->IgnoreConversionOperator(); 5144 E = E->IgnoreImpCasts(); 5145 5146 // Built-in binary operator. 5147 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) { 5148 if (IsArithmeticOp(OP->getOpcode())) { 5149 *Opcode = OP->getOpcode(); 5150 *RHSExprs = OP->getRHS(); 5151 return true; 5152 } 5153 } 5154 5155 // Overloaded operator. 5156 if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(E)) { 5157 if (Call->getNumArgs() != 2) 5158 return false; 5159 5160 // Make sure this is really a binary operator that is safe to pass into 5161 // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op. 5162 OverloadedOperatorKind OO = Call->getOperator(); 5163 if (OO < OO_Plus || OO > OO_Arrow) 5164 return false; 5165 5166 BinaryOperatorKind OpKind = BinaryOperator::getOverloadedOpcode(OO); 5167 if (IsArithmeticOp(OpKind)) { 5168 *Opcode = OpKind; 5169 *RHSExprs = Call->getArg(1); 5170 return true; 5171 } 5172 } 5173 5174 return false; 5175} 5176 5177static bool IsLogicOp(BinaryOperatorKind Opc) { 5178 return (Opc >= BO_LT && Opc <= BO_NE) || (Opc >= BO_LAnd && Opc <= BO_LOr); 5179} 5180 5181/// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type 5182/// or is a logical expression such as (x==y) which has int type, but is 5183/// commonly interpreted as boolean. 5184static bool ExprLooksBoolean(Expr *E) { 5185 E = E->IgnoreParenImpCasts(); 5186 5187 if (E->getType()->isBooleanType()) 5188 return true; 5189 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) 5190 return IsLogicOp(OP->getOpcode()); 5191 if (UnaryOperator *OP = dyn_cast<UnaryOperator>(E)) 5192 return OP->getOpcode() == UO_LNot; 5193 5194 return false; 5195} 5196 5197/// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator 5198/// and binary operator are mixed in a way that suggests the programmer assumed 5199/// the conditional operator has higher precedence, for example: 5200/// "int x = a + someBinaryCondition ? 1 : 2". 5201static void DiagnoseConditionalPrecedence(Sema &Self, 5202 SourceLocation OpLoc, 5203 Expr *Condition, 5204 Expr *LHSExpr, 5205 Expr *RHSExpr) { 5206 BinaryOperatorKind CondOpcode; 5207 Expr *CondRHS; 5208 5209 if (!IsArithmeticBinaryExpr(Condition, &CondOpcode, &CondRHS)) 5210 return; 5211 if (!ExprLooksBoolean(CondRHS)) 5212 return; 5213 5214 // The condition is an arithmetic binary expression, with a right- 5215 // hand side that looks boolean, so warn. 5216 5217 Self.Diag(OpLoc, diag::warn_precedence_conditional) 5218 << Condition->getSourceRange() 5219 << BinaryOperator::getOpcodeStr(CondOpcode); 5220 5221 SuggestParentheses(Self, OpLoc, 5222 Self.PDiag(diag::note_precedence_conditional_silence) 5223 << BinaryOperator::getOpcodeStr(CondOpcode), 5224 SourceRange(Condition->getLocStart(), Condition->getLocEnd())); 5225 5226 SuggestParentheses(Self, OpLoc, 5227 Self.PDiag(diag::note_precedence_conditional_first), 5228 SourceRange(CondRHS->getLocStart(), RHSExpr->getLocEnd())); 5229} 5230 5231/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null 5232/// in the case of a the GNU conditional expr extension. 5233ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc, 5234 SourceLocation ColonLoc, 5235 Expr *CondExpr, Expr *LHSExpr, 5236 Expr *RHSExpr) { 5237 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS 5238 // was the condition. 5239 OpaqueValueExpr *opaqueValue = 0; 5240 Expr *commonExpr = 0; 5241 if (LHSExpr == 0) { 5242 commonExpr = CondExpr; 5243 5244 // We usually want to apply unary conversions *before* saving, except 5245 // in the special case of a C++ l-value conditional. 5246 if (!(getLangOpts().CPlusPlus 5247 && !commonExpr->isTypeDependent() 5248 && commonExpr->getValueKind() == RHSExpr->getValueKind() 5249 && commonExpr->isGLValue() 5250 && commonExpr->isOrdinaryOrBitFieldObject() 5251 && RHSExpr->isOrdinaryOrBitFieldObject() 5252 && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) { 5253 ExprResult commonRes = UsualUnaryConversions(commonExpr); 5254 if (commonRes.isInvalid()) 5255 return ExprError(); 5256 commonExpr = commonRes.take(); 5257 } 5258 5259 opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(), 5260 commonExpr->getType(), 5261 commonExpr->getValueKind(), 5262 commonExpr->getObjectKind(), 5263 commonExpr); 5264 LHSExpr = CondExpr = opaqueValue; 5265 } 5266 5267 ExprValueKind VK = VK_RValue; 5268 ExprObjectKind OK = OK_Ordinary; 5269 ExprResult Cond = Owned(CondExpr), LHS = Owned(LHSExpr), RHS = Owned(RHSExpr); 5270 QualType result = CheckConditionalOperands(Cond, LHS, RHS, 5271 VK, OK, QuestionLoc); 5272 if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() || 5273 RHS.isInvalid()) 5274 return ExprError(); 5275 5276 DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(), 5277 RHS.get()); 5278 5279 if (!commonExpr) 5280 return Owned(new (Context) ConditionalOperator(Cond.take(), QuestionLoc, 5281 LHS.take(), ColonLoc, 5282 RHS.take(), result, VK, OK)); 5283 5284 return Owned(new (Context) 5285 BinaryConditionalOperator(commonExpr, opaqueValue, Cond.take(), LHS.take(), 5286 RHS.take(), QuestionLoc, ColonLoc, result, VK, 5287 OK)); 5288} 5289 5290// checkPointerTypesForAssignment - This is a very tricky routine (despite 5291// being closely modeled after the C99 spec:-). The odd characteristic of this 5292// routine is it effectively iqnores the qualifiers on the top level pointee. 5293// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3]. 5294// FIXME: add a couple examples in this comment. 5295static Sema::AssignConvertType 5296checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) { 5297 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 5298 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 5299 5300 // get the "pointed to" type (ignoring qualifiers at the top level) 5301 const Type *lhptee, *rhptee; 5302 Qualifiers lhq, rhq; 5303 llvm::tie(lhptee, lhq) = cast<PointerType>(LHSType)->getPointeeType().split(); 5304 llvm::tie(rhptee, rhq) = cast<PointerType>(RHSType)->getPointeeType().split(); 5305 5306 Sema::AssignConvertType ConvTy = Sema::Compatible; 5307 5308 // C99 6.5.16.1p1: This following citation is common to constraints 5309 // 3 & 4 (below). ...and the type *pointed to* by the left has all the 5310 // qualifiers of the type *pointed to* by the right; 5311 Qualifiers lq; 5312 5313 // As a special case, 'non-__weak A *' -> 'non-__weak const *' is okay. 5314 if (lhq.getObjCLifetime() != rhq.getObjCLifetime() && 5315 lhq.compatiblyIncludesObjCLifetime(rhq)) { 5316 // Ignore lifetime for further calculation. 5317 lhq.removeObjCLifetime(); 5318 rhq.removeObjCLifetime(); 5319 } 5320 5321 if (!lhq.compatiblyIncludes(rhq)) { 5322 // Treat address-space mismatches as fatal. TODO: address subspaces 5323 if (lhq.getAddressSpace() != rhq.getAddressSpace()) 5324 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 5325 5326 // It's okay to add or remove GC or lifetime qualifiers when converting to 5327 // and from void*. 5328 else if (lhq.withoutObjCGCAttr().withoutObjCLifetime() 5329 .compatiblyIncludes( 5330 rhq.withoutObjCGCAttr().withoutObjCLifetime()) 5331 && (lhptee->isVoidType() || rhptee->isVoidType())) 5332 ; // keep old 5333 5334 // Treat lifetime mismatches as fatal. 5335 else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) 5336 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 5337 5338 // For GCC compatibility, other qualifier mismatches are treated 5339 // as still compatible in C. 5340 else ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 5341 } 5342 5343 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or 5344 // incomplete type and the other is a pointer to a qualified or unqualified 5345 // version of void... 5346 if (lhptee->isVoidType()) { 5347 if (rhptee->isIncompleteOrObjectType()) 5348 return ConvTy; 5349 5350 // As an extension, we allow cast to/from void* to function pointer. 5351 assert(rhptee->isFunctionType()); 5352 return Sema::FunctionVoidPointer; 5353 } 5354 5355 if (rhptee->isVoidType()) { 5356 if (lhptee->isIncompleteOrObjectType()) 5357 return ConvTy; 5358 5359 // As an extension, we allow cast to/from void* to function pointer. 5360 assert(lhptee->isFunctionType()); 5361 return Sema::FunctionVoidPointer; 5362 } 5363 5364 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or 5365 // unqualified versions of compatible types, ... 5366 QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0); 5367 if (!S.Context.typesAreCompatible(ltrans, rtrans)) { 5368 // Check if the pointee types are compatible ignoring the sign. 5369 // We explicitly check for char so that we catch "char" vs 5370 // "unsigned char" on systems where "char" is unsigned. 5371 if (lhptee->isCharType()) 5372 ltrans = S.Context.UnsignedCharTy; 5373 else if (lhptee->hasSignedIntegerRepresentation()) 5374 ltrans = S.Context.getCorrespondingUnsignedType(ltrans); 5375 5376 if (rhptee->isCharType()) 5377 rtrans = S.Context.UnsignedCharTy; 5378 else if (rhptee->hasSignedIntegerRepresentation()) 5379 rtrans = S.Context.getCorrespondingUnsignedType(rtrans); 5380 5381 if (ltrans == rtrans) { 5382 // Types are compatible ignoring the sign. Qualifier incompatibility 5383 // takes priority over sign incompatibility because the sign 5384 // warning can be disabled. 5385 if (ConvTy != Sema::Compatible) 5386 return ConvTy; 5387 5388 return Sema::IncompatiblePointerSign; 5389 } 5390 5391 // If we are a multi-level pointer, it's possible that our issue is simply 5392 // one of qualification - e.g. char ** -> const char ** is not allowed. If 5393 // the eventual target type is the same and the pointers have the same 5394 // level of indirection, this must be the issue. 5395 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) { 5396 do { 5397 lhptee = cast<PointerType>(lhptee)->getPointeeType().getTypePtr(); 5398 rhptee = cast<PointerType>(rhptee)->getPointeeType().getTypePtr(); 5399 } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)); 5400 5401 if (lhptee == rhptee) 5402 return Sema::IncompatibleNestedPointerQualifiers; 5403 } 5404 5405 // General pointer incompatibility takes priority over qualifiers. 5406 return Sema::IncompatiblePointer; 5407 } 5408 if (!S.getLangOpts().CPlusPlus && 5409 S.IsNoReturnConversion(ltrans, rtrans, ltrans)) 5410 return Sema::IncompatiblePointer; 5411 return ConvTy; 5412} 5413 5414/// checkBlockPointerTypesForAssignment - This routine determines whether two 5415/// block pointer types are compatible or whether a block and normal pointer 5416/// are compatible. It is more restrict than comparing two function pointer 5417// types. 5418static Sema::AssignConvertType 5419checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType, 5420 QualType RHSType) { 5421 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 5422 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 5423 5424 QualType lhptee, rhptee; 5425 5426 // get the "pointed to" type (ignoring qualifiers at the top level) 5427 lhptee = cast<BlockPointerType>(LHSType)->getPointeeType(); 5428 rhptee = cast<BlockPointerType>(RHSType)->getPointeeType(); 5429 5430 // In C++, the types have to match exactly. 5431 if (S.getLangOpts().CPlusPlus) 5432 return Sema::IncompatibleBlockPointer; 5433 5434 Sema::AssignConvertType ConvTy = Sema::Compatible; 5435 5436 // For blocks we enforce that qualifiers are identical. 5437 if (lhptee.getLocalQualifiers() != rhptee.getLocalQualifiers()) 5438 ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 5439 5440 if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType)) 5441 return Sema::IncompatibleBlockPointer; 5442 5443 return ConvTy; 5444} 5445 5446/// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types 5447/// for assignment compatibility. 5448static Sema::AssignConvertType 5449checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType, 5450 QualType RHSType) { 5451 assert(LHSType.isCanonical() && "LHS was not canonicalized!"); 5452 assert(RHSType.isCanonical() && "RHS was not canonicalized!"); 5453 5454 if (LHSType->isObjCBuiltinType()) { 5455 // Class is not compatible with ObjC object pointers. 5456 if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() && 5457 !RHSType->isObjCQualifiedClassType()) 5458 return Sema::IncompatiblePointer; 5459 return Sema::Compatible; 5460 } 5461 if (RHSType->isObjCBuiltinType()) { 5462 if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() && 5463 !LHSType->isObjCQualifiedClassType()) 5464 return Sema::IncompatiblePointer; 5465 return Sema::Compatible; 5466 } 5467 QualType lhptee = LHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 5468 QualType rhptee = RHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 5469 5470 if (!lhptee.isAtLeastAsQualifiedAs(rhptee) && 5471 // make an exception for id<P> 5472 !LHSType->isObjCQualifiedIdType()) 5473 return Sema::CompatiblePointerDiscardsQualifiers; 5474 5475 if (S.Context.typesAreCompatible(LHSType, RHSType)) 5476 return Sema::Compatible; 5477 if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType()) 5478 return Sema::IncompatibleObjCQualifiedId; 5479 return Sema::IncompatiblePointer; 5480} 5481 5482Sema::AssignConvertType 5483Sema::CheckAssignmentConstraints(SourceLocation Loc, 5484 QualType LHSType, QualType RHSType) { 5485 // Fake up an opaque expression. We don't actually care about what 5486 // cast operations are required, so if CheckAssignmentConstraints 5487 // adds casts to this they'll be wasted, but fortunately that doesn't 5488 // usually happen on valid code. 5489 OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue); 5490 ExprResult RHSPtr = &RHSExpr; 5491 CastKind K = CK_Invalid; 5492 5493 return CheckAssignmentConstraints(LHSType, RHSPtr, K); 5494} 5495 5496/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently 5497/// has code to accommodate several GCC extensions when type checking 5498/// pointers. Here are some objectionable examples that GCC considers warnings: 5499/// 5500/// int a, *pint; 5501/// short *pshort; 5502/// struct foo *pfoo; 5503/// 5504/// pint = pshort; // warning: assignment from incompatible pointer type 5505/// a = pint; // warning: assignment makes integer from pointer without a cast 5506/// pint = a; // warning: assignment makes pointer from integer without a cast 5507/// pint = pfoo; // warning: assignment from incompatible pointer type 5508/// 5509/// As a result, the code for dealing with pointers is more complex than the 5510/// C99 spec dictates. 5511/// 5512/// Sets 'Kind' for any result kind except Incompatible. 5513Sema::AssignConvertType 5514Sema::CheckAssignmentConstraints(QualType LHSType, ExprResult &RHS, 5515 CastKind &Kind) { 5516 QualType RHSType = RHS.get()->getType(); 5517 QualType OrigLHSType = LHSType; 5518 5519 // Get canonical types. We're not formatting these types, just comparing 5520 // them. 5521 LHSType = Context.getCanonicalType(LHSType).getUnqualifiedType(); 5522 RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType(); 5523 5524 5525 // Common case: no conversion required. 5526 if (LHSType == RHSType) { 5527 Kind = CK_NoOp; 5528 return Compatible; 5529 } 5530 5531 // If we have an atomic type, try a non-atomic assignment, then just add an 5532 // atomic qualification step. 5533 if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) { 5534 Sema::AssignConvertType result = 5535 CheckAssignmentConstraints(AtomicTy->getValueType(), RHS, Kind); 5536 if (result != Compatible) 5537 return result; 5538 if (Kind != CK_NoOp) 5539 RHS = ImpCastExprToType(RHS.take(), AtomicTy->getValueType(), Kind); 5540 Kind = CK_NonAtomicToAtomic; 5541 return Compatible; 5542 } 5543 5544 // If the left-hand side is a reference type, then we are in a 5545 // (rare!) case where we've allowed the use of references in C, 5546 // e.g., as a parameter type in a built-in function. In this case, 5547 // just make sure that the type referenced is compatible with the 5548 // right-hand side type. The caller is responsible for adjusting 5549 // LHSType so that the resulting expression does not have reference 5550 // type. 5551 if (const ReferenceType *LHSTypeRef = LHSType->getAs<ReferenceType>()) { 5552 if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) { 5553 Kind = CK_LValueBitCast; 5554 return Compatible; 5555 } 5556 return Incompatible; 5557 } 5558 5559 // Allow scalar to ExtVector assignments, and assignments of an ExtVector type 5560 // to the same ExtVector type. 5561 if (LHSType->isExtVectorType()) { 5562 if (RHSType->isExtVectorType()) 5563 return Incompatible; 5564 if (RHSType->isArithmeticType()) { 5565 // CK_VectorSplat does T -> vector T, so first cast to the 5566 // element type. 5567 QualType elType = cast<ExtVectorType>(LHSType)->getElementType(); 5568 if (elType != RHSType) { 5569 Kind = PrepareScalarCast(RHS, elType); 5570 RHS = ImpCastExprToType(RHS.take(), elType, Kind); 5571 } 5572 Kind = CK_VectorSplat; 5573 return Compatible; 5574 } 5575 } 5576 5577 // Conversions to or from vector type. 5578 if (LHSType->isVectorType() || RHSType->isVectorType()) { 5579 if (LHSType->isVectorType() && RHSType->isVectorType()) { 5580 // Allow assignments of an AltiVec vector type to an equivalent GCC 5581 // vector type and vice versa 5582 if (Context.areCompatibleVectorTypes(LHSType, RHSType)) { 5583 Kind = CK_BitCast; 5584 return Compatible; 5585 } 5586 5587 // If we are allowing lax vector conversions, and LHS and RHS are both 5588 // vectors, the total size only needs to be the same. This is a bitcast; 5589 // no bits are changed but the result type is different. 5590 if (getLangOpts().LaxVectorConversions && 5591 (Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType))) { 5592 Kind = CK_BitCast; 5593 return IncompatibleVectors; 5594 } 5595 } 5596 return Incompatible; 5597 } 5598 5599 // Arithmetic conversions. 5600 if (LHSType->isArithmeticType() && RHSType->isArithmeticType() && 5601 !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) { 5602 Kind = PrepareScalarCast(RHS, LHSType); 5603 return Compatible; 5604 } 5605 5606 // Conversions to normal pointers. 5607 if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) { 5608 // U* -> T* 5609 if (isa<PointerType>(RHSType)) { 5610 Kind = CK_BitCast; 5611 return checkPointerTypesForAssignment(*this, LHSType, RHSType); 5612 } 5613 5614 // int -> T* 5615 if (RHSType->isIntegerType()) { 5616 Kind = CK_IntegralToPointer; // FIXME: null? 5617 return IntToPointer; 5618 } 5619 5620 // C pointers are not compatible with ObjC object pointers, 5621 // with two exceptions: 5622 if (isa<ObjCObjectPointerType>(RHSType)) { 5623 // - conversions to void* 5624 if (LHSPointer->getPointeeType()->isVoidType()) { 5625 Kind = CK_BitCast; 5626 return Compatible; 5627 } 5628 5629 // - conversions from 'Class' to the redefinition type 5630 if (RHSType->isObjCClassType() && 5631 Context.hasSameType(LHSType, 5632 Context.getObjCClassRedefinitionType())) { 5633 Kind = CK_BitCast; 5634 return Compatible; 5635 } 5636 5637 Kind = CK_BitCast; 5638 return IncompatiblePointer; 5639 } 5640 5641 // U^ -> void* 5642 if (RHSType->getAs<BlockPointerType>()) { 5643 if (LHSPointer->getPointeeType()->isVoidType()) { 5644 Kind = CK_BitCast; 5645 return Compatible; 5646 } 5647 } 5648 5649 return Incompatible; 5650 } 5651 5652 // Conversions to block pointers. 5653 if (isa<BlockPointerType>(LHSType)) { 5654 // U^ -> T^ 5655 if (RHSType->isBlockPointerType()) { 5656 Kind = CK_BitCast; 5657 return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType); 5658 } 5659 5660 // int or null -> T^ 5661 if (RHSType->isIntegerType()) { 5662 Kind = CK_IntegralToPointer; // FIXME: null 5663 return IntToBlockPointer; 5664 } 5665 5666 // id -> T^ 5667 if (getLangOpts().ObjC1 && RHSType->isObjCIdType()) { 5668 Kind = CK_AnyPointerToBlockPointerCast; 5669 return Compatible; 5670 } 5671 5672 // void* -> T^ 5673 if (const PointerType *RHSPT = RHSType->getAs<PointerType>()) 5674 if (RHSPT->getPointeeType()->isVoidType()) { 5675 Kind = CK_AnyPointerToBlockPointerCast; 5676 return Compatible; 5677 } 5678 5679 return Incompatible; 5680 } 5681 5682 // Conversions to Objective-C pointers. 5683 if (isa<ObjCObjectPointerType>(LHSType)) { 5684 // A* -> B* 5685 if (RHSType->isObjCObjectPointerType()) { 5686 Kind = CK_BitCast; 5687 Sema::AssignConvertType result = 5688 checkObjCPointerTypesForAssignment(*this, LHSType, RHSType); 5689 if (getLangOpts().ObjCAutoRefCount && 5690 result == Compatible && 5691 !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType)) 5692 result = IncompatibleObjCWeakRef; 5693 return result; 5694 } 5695 5696 // int or null -> A* 5697 if (RHSType->isIntegerType()) { 5698 Kind = CK_IntegralToPointer; // FIXME: null 5699 return IntToPointer; 5700 } 5701 5702 // In general, C pointers are not compatible with ObjC object pointers, 5703 // with two exceptions: 5704 if (isa<PointerType>(RHSType)) { 5705 Kind = CK_CPointerToObjCPointerCast; 5706 5707 // - conversions from 'void*' 5708 if (RHSType->isVoidPointerType()) { 5709 return Compatible; 5710 } 5711 5712 // - conversions to 'Class' from its redefinition type 5713 if (LHSType->isObjCClassType() && 5714 Context.hasSameType(RHSType, 5715 Context.getObjCClassRedefinitionType())) { 5716 return Compatible; 5717 } 5718 5719 return IncompatiblePointer; 5720 } 5721 5722 // T^ -> A* 5723 if (RHSType->isBlockPointerType()) { 5724 maybeExtendBlockObject(*this, RHS); 5725 Kind = CK_BlockPointerToObjCPointerCast; 5726 return Compatible; 5727 } 5728 5729 return Incompatible; 5730 } 5731 5732 // Conversions from pointers that are not covered by the above. 5733 if (isa<PointerType>(RHSType)) { 5734 // T* -> _Bool 5735 if (LHSType == Context.BoolTy) { 5736 Kind = CK_PointerToBoolean; 5737 return Compatible; 5738 } 5739 5740 // T* -> int 5741 if (LHSType->isIntegerType()) { 5742 Kind = CK_PointerToIntegral; 5743 return PointerToInt; 5744 } 5745 5746 return Incompatible; 5747 } 5748 5749 // Conversions from Objective-C pointers that are not covered by the above. 5750 if (isa<ObjCObjectPointerType>(RHSType)) { 5751 // T* -> _Bool 5752 if (LHSType == Context.BoolTy) { 5753 Kind = CK_PointerToBoolean; 5754 return Compatible; 5755 } 5756 5757 // T* -> int 5758 if (LHSType->isIntegerType()) { 5759 Kind = CK_PointerToIntegral; 5760 return PointerToInt; 5761 } 5762 5763 return Incompatible; 5764 } 5765 5766 // struct A -> struct B 5767 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) { 5768 if (Context.typesAreCompatible(LHSType, RHSType)) { 5769 Kind = CK_NoOp; 5770 return Compatible; 5771 } 5772 } 5773 5774 return Incompatible; 5775} 5776 5777/// \brief Constructs a transparent union from an expression that is 5778/// used to initialize the transparent union. 5779static void ConstructTransparentUnion(Sema &S, ASTContext &C, 5780 ExprResult &EResult, QualType UnionType, 5781 FieldDecl *Field) { 5782 // Build an initializer list that designates the appropriate member 5783 // of the transparent union. 5784 Expr *E = EResult.take(); 5785 InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(), 5786 &E, 1, 5787 SourceLocation()); 5788 Initializer->setType(UnionType); 5789 Initializer->setInitializedFieldInUnion(Field); 5790 5791 // Build a compound literal constructing a value of the transparent 5792 // union type from this initializer list. 5793 TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType); 5794 EResult = S.Owned( 5795 new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType, 5796 VK_RValue, Initializer, false)); 5797} 5798 5799Sema::AssignConvertType 5800Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, 5801 ExprResult &RHS) { 5802 QualType RHSType = RHS.get()->getType(); 5803 5804 // If the ArgType is a Union type, we want to handle a potential 5805 // transparent_union GCC extension. 5806 const RecordType *UT = ArgType->getAsUnionType(); 5807 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>()) 5808 return Incompatible; 5809 5810 // The field to initialize within the transparent union. 5811 RecordDecl *UD = UT->getDecl(); 5812 FieldDecl *InitField = 0; 5813 // It's compatible if the expression matches any of the fields. 5814 for (RecordDecl::field_iterator it = UD->field_begin(), 5815 itend = UD->field_end(); 5816 it != itend; ++it) { 5817 if (it->getType()->isPointerType()) { 5818 // If the transparent union contains a pointer type, we allow: 5819 // 1) void pointer 5820 // 2) null pointer constant 5821 if (RHSType->isPointerType()) 5822 if (RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) { 5823 RHS = ImpCastExprToType(RHS.take(), it->getType(), CK_BitCast); 5824 InitField = *it; 5825 break; 5826 } 5827 5828 if (RHS.get()->isNullPointerConstant(Context, 5829 Expr::NPC_ValueDependentIsNull)) { 5830 RHS = ImpCastExprToType(RHS.take(), it->getType(), 5831 CK_NullToPointer); 5832 InitField = *it; 5833 break; 5834 } 5835 } 5836 5837 CastKind Kind = CK_Invalid; 5838 if (CheckAssignmentConstraints(it->getType(), RHS, Kind) 5839 == Compatible) { 5840 RHS = ImpCastExprToType(RHS.take(), it->getType(), Kind); 5841 InitField = *it; 5842 break; 5843 } 5844 } 5845 5846 if (!InitField) 5847 return Incompatible; 5848 5849 ConstructTransparentUnion(*this, Context, RHS, ArgType, InitField); 5850 return Compatible; 5851} 5852 5853Sema::AssignConvertType 5854Sema::CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, 5855 bool Diagnose) { 5856 if (getLangOpts().CPlusPlus) { 5857 if (!LHSType->isRecordType() && !LHSType->isAtomicType()) { 5858 // C++ 5.17p3: If the left operand is not of class type, the 5859 // expression is implicitly converted (C++ 4) to the 5860 // cv-unqualified type of the left operand. 5861 ExprResult Res; 5862 if (Diagnose) { 5863 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 5864 AA_Assigning); 5865 } else { 5866 ImplicitConversionSequence ICS = 5867 TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 5868 /*SuppressUserConversions=*/false, 5869 /*AllowExplicit=*/false, 5870 /*InOverloadResolution=*/false, 5871 /*CStyle=*/false, 5872 /*AllowObjCWritebackConversion=*/false); 5873 if (ICS.isFailure()) 5874 return Incompatible; 5875 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 5876 ICS, AA_Assigning); 5877 } 5878 if (Res.isInvalid()) 5879 return Incompatible; 5880 Sema::AssignConvertType result = Compatible; 5881 if (getLangOpts().ObjCAutoRefCount && 5882 !CheckObjCARCUnavailableWeakConversion(LHSType, 5883 RHS.get()->getType())) 5884 result = IncompatibleObjCWeakRef; 5885 RHS = move(Res); 5886 return result; 5887 } 5888 5889 // FIXME: Currently, we fall through and treat C++ classes like C 5890 // structures. 5891 // FIXME: We also fall through for atomics; not sure what should 5892 // happen there, though. 5893 } 5894 5895 // C99 6.5.16.1p1: the left operand is a pointer and the right is 5896 // a null pointer constant. 5897 if ((LHSType->isPointerType() || 5898 LHSType->isObjCObjectPointerType() || 5899 LHSType->isBlockPointerType()) 5900 && RHS.get()->isNullPointerConstant(Context, 5901 Expr::NPC_ValueDependentIsNull)) { 5902 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_NullToPointer); 5903 return Compatible; 5904 } 5905 5906 // This check seems unnatural, however it is necessary to ensure the proper 5907 // conversion of functions/arrays. If the conversion were done for all 5908 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary 5909 // expressions that suppress this implicit conversion (&, sizeof). 5910 // 5911 // Suppress this for references: C++ 8.5.3p5. 5912 if (!LHSType->isReferenceType()) { 5913 RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); 5914 if (RHS.isInvalid()) 5915 return Incompatible; 5916 } 5917 5918 CastKind Kind = CK_Invalid; 5919 Sema::AssignConvertType result = 5920 CheckAssignmentConstraints(LHSType, RHS, Kind); 5921 5922 // C99 6.5.16.1p2: The value of the right operand is converted to the 5923 // type of the assignment expression. 5924 // CheckAssignmentConstraints allows the left-hand side to be a reference, 5925 // so that we can use references in built-in functions even in C. 5926 // The getNonReferenceType() call makes sure that the resulting expression 5927 // does not have reference type. 5928 if (result != Incompatible && RHS.get()->getType() != LHSType) 5929 RHS = ImpCastExprToType(RHS.take(), 5930 LHSType.getNonLValueExprType(Context), Kind); 5931 return result; 5932} 5933 5934QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &LHS, 5935 ExprResult &RHS) { 5936 Diag(Loc, diag::err_typecheck_invalid_operands) 5937 << LHS.get()->getType() << RHS.get()->getType() 5938 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5939 return QualType(); 5940} 5941 5942QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, 5943 SourceLocation Loc, bool IsCompAssign) { 5944 if (!IsCompAssign) { 5945 LHS = DefaultFunctionArrayLvalueConversion(LHS.take()); 5946 if (LHS.isInvalid()) 5947 return QualType(); 5948 } 5949 RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); 5950 if (RHS.isInvalid()) 5951 return QualType(); 5952 5953 // For conversion purposes, we ignore any qualifiers. 5954 // For example, "const float" and "float" are equivalent. 5955 QualType LHSType = 5956 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType(); 5957 QualType RHSType = 5958 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType(); 5959 5960 // If the vector types are identical, return. 5961 if (LHSType == RHSType) 5962 return LHSType; 5963 5964 // Handle the case of equivalent AltiVec and GCC vector types 5965 if (LHSType->isVectorType() && RHSType->isVectorType() && 5966 Context.areCompatibleVectorTypes(LHSType, RHSType)) { 5967 if (LHSType->isExtVectorType()) { 5968 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 5969 return LHSType; 5970 } 5971 5972 if (!IsCompAssign) 5973 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); 5974 return RHSType; 5975 } 5976 5977 if (getLangOpts().LaxVectorConversions && 5978 Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType)) { 5979 // If we are allowing lax vector conversions, and LHS and RHS are both 5980 // vectors, the total size only needs to be the same. This is a 5981 // bitcast; no bits are changed but the result type is different. 5982 // FIXME: Should we really be allowing this? 5983 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 5984 return LHSType; 5985 } 5986 5987 // Canonicalize the ExtVector to the LHS, remember if we swapped so we can 5988 // swap back (so that we don't reverse the inputs to a subtract, for instance. 5989 bool swapped = false; 5990 if (RHSType->isExtVectorType() && !IsCompAssign) { 5991 swapped = true; 5992 std::swap(RHS, LHS); 5993 std::swap(RHSType, LHSType); 5994 } 5995 5996 // Handle the case of an ext vector and scalar. 5997 if (const ExtVectorType *LV = LHSType->getAs<ExtVectorType>()) { 5998 QualType EltTy = LV->getElementType(); 5999 if (EltTy->isIntegralType(Context) && RHSType->isIntegralType(Context)) { 6000 int order = Context.getIntegerTypeOrder(EltTy, RHSType); 6001 if (order > 0) 6002 RHS = ImpCastExprToType(RHS.take(), EltTy, CK_IntegralCast); 6003 if (order >= 0) { 6004 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_VectorSplat); 6005 if (swapped) std::swap(RHS, LHS); 6006 return LHSType; 6007 } 6008 } 6009 if (EltTy->isRealFloatingType() && RHSType->isScalarType() && 6010 RHSType->isRealFloatingType()) { 6011 int order = Context.getFloatingTypeOrder(EltTy, RHSType); 6012 if (order > 0) 6013 RHS = ImpCastExprToType(RHS.take(), EltTy, CK_FloatingCast); 6014 if (order >= 0) { 6015 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_VectorSplat); 6016 if (swapped) std::swap(RHS, LHS); 6017 return LHSType; 6018 } 6019 } 6020 } 6021 6022 // Vectors of different size or scalar and non-ext-vector are errors. 6023 if (swapped) std::swap(RHS, LHS); 6024 Diag(Loc, diag::err_typecheck_vector_not_convertable) 6025 << LHS.get()->getType() << RHS.get()->getType() 6026 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6027 return QualType(); 6028} 6029 6030// checkArithmeticNull - Detect when a NULL constant is used improperly in an 6031// expression. These are mainly cases where the null pointer is used as an 6032// integer instead of a pointer. 6033static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, 6034 SourceLocation Loc, bool IsCompare) { 6035 // The canonical way to check for a GNU null is with isNullPointerConstant, 6036 // but we use a bit of a hack here for speed; this is a relatively 6037 // hot path, and isNullPointerConstant is slow. 6038 bool LHSNull = isa<GNUNullExpr>(LHS.get()->IgnoreParenImpCasts()); 6039 bool RHSNull = isa<GNUNullExpr>(RHS.get()->IgnoreParenImpCasts()); 6040 6041 QualType NonNullType = LHSNull ? RHS.get()->getType() : LHS.get()->getType(); 6042 6043 // Avoid analyzing cases where the result will either be invalid (and 6044 // diagnosed as such) or entirely valid and not something to warn about. 6045 if ((!LHSNull && !RHSNull) || NonNullType->isBlockPointerType() || 6046 NonNullType->isMemberPointerType() || NonNullType->isFunctionType()) 6047 return; 6048 6049 // Comparison operations would not make sense with a null pointer no matter 6050 // what the other expression is. 6051 if (!IsCompare) { 6052 S.Diag(Loc, diag::warn_null_in_arithmetic_operation) 6053 << (LHSNull ? LHS.get()->getSourceRange() : SourceRange()) 6054 << (RHSNull ? RHS.get()->getSourceRange() : SourceRange()); 6055 return; 6056 } 6057 6058 // The rest of the operations only make sense with a null pointer 6059 // if the other expression is a pointer. 6060 if (LHSNull == RHSNull || NonNullType->isAnyPointerType() || 6061 NonNullType->canDecayToPointerType()) 6062 return; 6063 6064 S.Diag(Loc, diag::warn_null_in_comparison_operation) 6065 << LHSNull /* LHS is NULL */ << NonNullType 6066 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6067} 6068 6069QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS, 6070 SourceLocation Loc, 6071 bool IsCompAssign, bool IsDiv) { 6072 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 6073 6074 if (LHS.get()->getType()->isVectorType() || 6075 RHS.get()->getType()->isVectorType()) 6076 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 6077 6078 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign); 6079 if (LHS.isInvalid() || RHS.isInvalid()) 6080 return QualType(); 6081 6082 6083 if (compType.isNull() || !compType->isArithmeticType()) 6084 return InvalidOperands(Loc, LHS, RHS); 6085 6086 // Check for division by zero. 6087 if (IsDiv && 6088 RHS.get()->isNullPointerConstant(Context, 6089 Expr::NPC_ValueDependentIsNotNull)) 6090 DiagRuntimeBehavior(Loc, RHS.get(), PDiag(diag::warn_division_by_zero) 6091 << RHS.get()->getSourceRange()); 6092 6093 return compType; 6094} 6095 6096QualType Sema::CheckRemainderOperands( 6097 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { 6098 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 6099 6100 if (LHS.get()->getType()->isVectorType() || 6101 RHS.get()->getType()->isVectorType()) { 6102 if (LHS.get()->getType()->hasIntegerRepresentation() && 6103 RHS.get()->getType()->hasIntegerRepresentation()) 6104 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 6105 return InvalidOperands(Loc, LHS, RHS); 6106 } 6107 6108 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign); 6109 if (LHS.isInvalid() || RHS.isInvalid()) 6110 return QualType(); 6111 6112 if (compType.isNull() || !compType->isIntegerType()) 6113 return InvalidOperands(Loc, LHS, RHS); 6114 6115 // Check for remainder by zero. 6116 if (RHS.get()->isNullPointerConstant(Context, 6117 Expr::NPC_ValueDependentIsNotNull)) 6118 DiagRuntimeBehavior(Loc, RHS.get(), PDiag(diag::warn_remainder_by_zero) 6119 << RHS.get()->getSourceRange()); 6120 6121 return compType; 6122} 6123 6124/// \brief Diagnose invalid arithmetic on two void pointers. 6125static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, 6126 Expr *LHSExpr, Expr *RHSExpr) { 6127 S.Diag(Loc, S.getLangOpts().CPlusPlus 6128 ? diag::err_typecheck_pointer_arith_void_type 6129 : diag::ext_gnu_void_ptr) 6130 << 1 /* two pointers */ << LHSExpr->getSourceRange() 6131 << RHSExpr->getSourceRange(); 6132} 6133 6134/// \brief Diagnose invalid arithmetic on a void pointer. 6135static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, 6136 Expr *Pointer) { 6137 S.Diag(Loc, S.getLangOpts().CPlusPlus 6138 ? diag::err_typecheck_pointer_arith_void_type 6139 : diag::ext_gnu_void_ptr) 6140 << 0 /* one pointer */ << Pointer->getSourceRange(); 6141} 6142 6143/// \brief Diagnose invalid arithmetic on two function pointers. 6144static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, 6145 Expr *LHS, Expr *RHS) { 6146 assert(LHS->getType()->isAnyPointerType()); 6147 assert(RHS->getType()->isAnyPointerType()); 6148 S.Diag(Loc, S.getLangOpts().CPlusPlus 6149 ? diag::err_typecheck_pointer_arith_function_type 6150 : diag::ext_gnu_ptr_func_arith) 6151 << 1 /* two pointers */ << LHS->getType()->getPointeeType() 6152 // We only show the second type if it differs from the first. 6153 << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(), 6154 RHS->getType()) 6155 << RHS->getType()->getPointeeType() 6156 << LHS->getSourceRange() << RHS->getSourceRange(); 6157} 6158 6159/// \brief Diagnose invalid arithmetic on a function pointer. 6160static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, 6161 Expr *Pointer) { 6162 assert(Pointer->getType()->isAnyPointerType()); 6163 S.Diag(Loc, S.getLangOpts().CPlusPlus 6164 ? diag::err_typecheck_pointer_arith_function_type 6165 : diag::ext_gnu_ptr_func_arith) 6166 << 0 /* one pointer */ << Pointer->getType()->getPointeeType() 6167 << 0 /* one pointer, so only one type */ 6168 << Pointer->getSourceRange(); 6169} 6170 6171/// \brief Emit error if Operand is incomplete pointer type 6172/// 6173/// \returns True if pointer has incomplete type 6174static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, 6175 Expr *Operand) { 6176 if ((Operand->getType()->isPointerType() && 6177 !Operand->getType()->isDependentType()) || 6178 Operand->getType()->isObjCObjectPointerType()) { 6179 QualType PointeeTy = Operand->getType()->getPointeeType(); 6180 if (S.RequireCompleteType( 6181 Loc, PointeeTy, 6182 diag::err_typecheck_arithmetic_incomplete_type, 6183 PointeeTy, Operand->getSourceRange())) 6184 return true; 6185 } 6186 return false; 6187} 6188 6189/// \brief Check the validity of an arithmetic pointer operand. 6190/// 6191/// If the operand has pointer type, this code will check for pointer types 6192/// which are invalid in arithmetic operations. These will be diagnosed 6193/// appropriately, including whether or not the use is supported as an 6194/// extension. 6195/// 6196/// \returns True when the operand is valid to use (even if as an extension). 6197static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc, 6198 Expr *Operand) { 6199 if (!Operand->getType()->isAnyPointerType()) return true; 6200 6201 QualType PointeeTy = Operand->getType()->getPointeeType(); 6202 if (PointeeTy->isVoidType()) { 6203 diagnoseArithmeticOnVoidPointer(S, Loc, Operand); 6204 return !S.getLangOpts().CPlusPlus; 6205 } 6206 if (PointeeTy->isFunctionType()) { 6207 diagnoseArithmeticOnFunctionPointer(S, Loc, Operand); 6208 return !S.getLangOpts().CPlusPlus; 6209 } 6210 6211 if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false; 6212 6213 return true; 6214} 6215 6216/// \brief Check the validity of a binary arithmetic operation w.r.t. pointer 6217/// operands. 6218/// 6219/// This routine will diagnose any invalid arithmetic on pointer operands much 6220/// like \see checkArithmeticOpPointerOperand. However, it has special logic 6221/// for emitting a single diagnostic even for operations where both LHS and RHS 6222/// are (potentially problematic) pointers. 6223/// 6224/// \returns True when the operand is valid to use (even if as an extension). 6225static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc, 6226 Expr *LHSExpr, Expr *RHSExpr) { 6227 bool isLHSPointer = LHSExpr->getType()->isAnyPointerType(); 6228 bool isRHSPointer = RHSExpr->getType()->isAnyPointerType(); 6229 if (!isLHSPointer && !isRHSPointer) return true; 6230 6231 QualType LHSPointeeTy, RHSPointeeTy; 6232 if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType(); 6233 if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType(); 6234 6235 // Check for arithmetic on pointers to incomplete types. 6236 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType(); 6237 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType(); 6238 if (isLHSVoidPtr || isRHSVoidPtr) { 6239 if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr); 6240 else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr); 6241 else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr); 6242 6243 return !S.getLangOpts().CPlusPlus; 6244 } 6245 6246 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType(); 6247 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType(); 6248 if (isLHSFuncPtr || isRHSFuncPtr) { 6249 if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr); 6250 else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, 6251 RHSExpr); 6252 else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr); 6253 6254 return !S.getLangOpts().CPlusPlus; 6255 } 6256 6257 if (checkArithmeticIncompletePointerType(S, Loc, LHSExpr)) return false; 6258 if (checkArithmeticIncompletePointerType(S, Loc, RHSExpr)) return false; 6259 6260 return true; 6261} 6262 6263/// \brief Check bad cases where we step over interface counts. 6264static bool checkArithmethicPointerOnNonFragileABI(Sema &S, 6265 SourceLocation OpLoc, 6266 Expr *Op) { 6267 assert(Op->getType()->isAnyPointerType()); 6268 QualType PointeeTy = Op->getType()->getPointeeType(); 6269 if (!PointeeTy->isObjCObjectType() || S.LangOpts.ObjCRuntime.isFragile()) 6270 return true; 6271 6272 S.Diag(OpLoc, diag::err_arithmetic_nonfragile_interface) 6273 << PointeeTy << Op->getSourceRange(); 6274 return false; 6275} 6276 6277/// diagnoseStringPlusInt - Emit a warning when adding an integer to a string 6278/// literal. 6279static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc, 6280 Expr *LHSExpr, Expr *RHSExpr) { 6281 StringLiteral* StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts()); 6282 Expr* IndexExpr = RHSExpr; 6283 if (!StrExpr) { 6284 StrExpr = dyn_cast<StringLiteral>(RHSExpr->IgnoreImpCasts()); 6285 IndexExpr = LHSExpr; 6286 } 6287 6288 bool IsStringPlusInt = StrExpr && 6289 IndexExpr->getType()->isIntegralOrUnscopedEnumerationType(); 6290 if (!IsStringPlusInt) 6291 return; 6292 6293 llvm::APSInt index; 6294 if (IndexExpr->EvaluateAsInt(index, Self.getASTContext())) { 6295 unsigned StrLenWithNull = StrExpr->getLength() + 1; 6296 if (index.isNonNegative() && 6297 index <= llvm::APSInt(llvm::APInt(index.getBitWidth(), StrLenWithNull), 6298 index.isUnsigned())) 6299 return; 6300 } 6301 6302 SourceRange DiagRange(LHSExpr->getLocStart(), RHSExpr->getLocEnd()); 6303 Self.Diag(OpLoc, diag::warn_string_plus_int) 6304 << DiagRange << IndexExpr->IgnoreImpCasts()->getType(); 6305 6306 // Only print a fixit for "str" + int, not for int + "str". 6307 if (IndexExpr == RHSExpr) { 6308 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(RHSExpr->getLocEnd()); 6309 Self.Diag(OpLoc, diag::note_string_plus_int_silence) 6310 << FixItHint::CreateInsertion(LHSExpr->getLocStart(), "&") 6311 << FixItHint::CreateReplacement(SourceRange(OpLoc), "[") 6312 << FixItHint::CreateInsertion(EndLoc, "]"); 6313 } else 6314 Self.Diag(OpLoc, diag::note_string_plus_int_silence); 6315} 6316 6317/// \brief Emit error when two pointers are incompatible. 6318static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, 6319 Expr *LHSExpr, Expr *RHSExpr) { 6320 assert(LHSExpr->getType()->isAnyPointerType()); 6321 assert(RHSExpr->getType()->isAnyPointerType()); 6322 S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible) 6323 << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange() 6324 << RHSExpr->getSourceRange(); 6325} 6326 6327QualType Sema::CheckAdditionOperands( // C99 6.5.6 6328 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc, 6329 QualType* CompLHSTy) { 6330 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 6331 6332 if (LHS.get()->getType()->isVectorType() || 6333 RHS.get()->getType()->isVectorType()) { 6334 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy); 6335 if (CompLHSTy) *CompLHSTy = compType; 6336 return compType; 6337 } 6338 6339 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy); 6340 if (LHS.isInvalid() || RHS.isInvalid()) 6341 return QualType(); 6342 6343 // Diagnose "string literal" '+' int. 6344 if (Opc == BO_Add) 6345 diagnoseStringPlusInt(*this, Loc, LHS.get(), RHS.get()); 6346 6347 // handle the common case first (both operands are arithmetic). 6348 if (!compType.isNull() && compType->isArithmeticType()) { 6349 if (CompLHSTy) *CompLHSTy = compType; 6350 return compType; 6351 } 6352 6353 // Put any potential pointer into PExp 6354 Expr* PExp = LHS.get(), *IExp = RHS.get(); 6355 if (IExp->getType()->isAnyPointerType()) 6356 std::swap(PExp, IExp); 6357 6358 if (!PExp->getType()->isAnyPointerType()) 6359 return InvalidOperands(Loc, LHS, RHS); 6360 6361 if (!IExp->getType()->isIntegerType()) 6362 return InvalidOperands(Loc, LHS, RHS); 6363 6364 if (!checkArithmeticOpPointerOperand(*this, Loc, PExp)) 6365 return QualType(); 6366 6367 // Diagnose bad cases where we step over interface counts. 6368 if (!checkArithmethicPointerOnNonFragileABI(*this, Loc, PExp)) 6369 return QualType(); 6370 6371 // Check array bounds for pointer arithemtic 6372 CheckArrayAccess(PExp, IExp); 6373 6374 if (CompLHSTy) { 6375 QualType LHSTy = Context.isPromotableBitField(LHS.get()); 6376 if (LHSTy.isNull()) { 6377 LHSTy = LHS.get()->getType(); 6378 if (LHSTy->isPromotableIntegerType()) 6379 LHSTy = Context.getPromotedIntegerType(LHSTy); 6380 } 6381 *CompLHSTy = LHSTy; 6382 } 6383 6384 return PExp->getType(); 6385} 6386 6387// C99 6.5.6 6388QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS, 6389 SourceLocation Loc, 6390 QualType* CompLHSTy) { 6391 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 6392 6393 if (LHS.get()->getType()->isVectorType() || 6394 RHS.get()->getType()->isVectorType()) { 6395 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy); 6396 if (CompLHSTy) *CompLHSTy = compType; 6397 return compType; 6398 } 6399 6400 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy); 6401 if (LHS.isInvalid() || RHS.isInvalid()) 6402 return QualType(); 6403 6404 // Enforce type constraints: C99 6.5.6p3. 6405 6406 // Handle the common case first (both operands are arithmetic). 6407 if (!compType.isNull() && compType->isArithmeticType()) { 6408 if (CompLHSTy) *CompLHSTy = compType; 6409 return compType; 6410 } 6411 6412 // Either ptr - int or ptr - ptr. 6413 if (LHS.get()->getType()->isAnyPointerType()) { 6414 QualType lpointee = LHS.get()->getType()->getPointeeType(); 6415 6416 // Diagnose bad cases where we step over interface counts. 6417 if (!checkArithmethicPointerOnNonFragileABI(*this, Loc, LHS.get())) 6418 return QualType(); 6419 6420 // The result type of a pointer-int computation is the pointer type. 6421 if (RHS.get()->getType()->isIntegerType()) { 6422 if (!checkArithmeticOpPointerOperand(*this, Loc, LHS.get())) 6423 return QualType(); 6424 6425 // Check array bounds for pointer arithemtic 6426 CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/0, 6427 /*AllowOnePastEnd*/true, /*IndexNegated*/true); 6428 6429 if (CompLHSTy) *CompLHSTy = LHS.get()->getType(); 6430 return LHS.get()->getType(); 6431 } 6432 6433 // Handle pointer-pointer subtractions. 6434 if (const PointerType *RHSPTy 6435 = RHS.get()->getType()->getAs<PointerType>()) { 6436 QualType rpointee = RHSPTy->getPointeeType(); 6437 6438 if (getLangOpts().CPlusPlus) { 6439 // Pointee types must be the same: C++ [expr.add] 6440 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) { 6441 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get()); 6442 } 6443 } else { 6444 // Pointee types must be compatible C99 6.5.6p3 6445 if (!Context.typesAreCompatible( 6446 Context.getCanonicalType(lpointee).getUnqualifiedType(), 6447 Context.getCanonicalType(rpointee).getUnqualifiedType())) { 6448 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get()); 6449 return QualType(); 6450 } 6451 } 6452 6453 if (!checkArithmeticBinOpPointerOperands(*this, Loc, 6454 LHS.get(), RHS.get())) 6455 return QualType(); 6456 6457 if (CompLHSTy) *CompLHSTy = LHS.get()->getType(); 6458 return Context.getPointerDiffType(); 6459 } 6460 } 6461 6462 return InvalidOperands(Loc, LHS, RHS); 6463} 6464 6465static bool isScopedEnumerationType(QualType T) { 6466 if (const EnumType *ET = dyn_cast<EnumType>(T)) 6467 return ET->getDecl()->isScoped(); 6468 return false; 6469} 6470 6471static void DiagnoseBadShiftValues(Sema& S, ExprResult &LHS, ExprResult &RHS, 6472 SourceLocation Loc, unsigned Opc, 6473 QualType LHSType) { 6474 llvm::APSInt Right; 6475 // Check right/shifter operand 6476 if (RHS.get()->isValueDependent() || 6477 !RHS.get()->isIntegerConstantExpr(Right, S.Context)) 6478 return; 6479 6480 if (Right.isNegative()) { 6481 S.DiagRuntimeBehavior(Loc, RHS.get(), 6482 S.PDiag(diag::warn_shift_negative) 6483 << RHS.get()->getSourceRange()); 6484 return; 6485 } 6486 llvm::APInt LeftBits(Right.getBitWidth(), 6487 S.Context.getTypeSize(LHS.get()->getType())); 6488 if (Right.uge(LeftBits)) { 6489 S.DiagRuntimeBehavior(Loc, RHS.get(), 6490 S.PDiag(diag::warn_shift_gt_typewidth) 6491 << RHS.get()->getSourceRange()); 6492 return; 6493 } 6494 if (Opc != BO_Shl) 6495 return; 6496 6497 // When left shifting an ICE which is signed, we can check for overflow which 6498 // according to C++ has undefined behavior ([expr.shift] 5.8/2). Unsigned 6499 // integers have defined behavior modulo one more than the maximum value 6500 // representable in the result type, so never warn for those. 6501 llvm::APSInt Left; 6502 if (LHS.get()->isValueDependent() || 6503 !LHS.get()->isIntegerConstantExpr(Left, S.Context) || 6504 LHSType->hasUnsignedIntegerRepresentation()) 6505 return; 6506 llvm::APInt ResultBits = 6507 static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits(); 6508 if (LeftBits.uge(ResultBits)) 6509 return; 6510 llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue()); 6511 Result = Result.shl(Right); 6512 6513 // Print the bit representation of the signed integer as an unsigned 6514 // hexadecimal number. 6515 SmallString<40> HexResult; 6516 Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true); 6517 6518 // If we are only missing a sign bit, this is less likely to result in actual 6519 // bugs -- if the result is cast back to an unsigned type, it will have the 6520 // expected value. Thus we place this behind a different warning that can be 6521 // turned off separately if needed. 6522 if (LeftBits == ResultBits - 1) { 6523 S.Diag(Loc, diag::warn_shift_result_sets_sign_bit) 6524 << HexResult.str() << LHSType 6525 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6526 return; 6527 } 6528 6529 S.Diag(Loc, diag::warn_shift_result_gt_typewidth) 6530 << HexResult.str() << Result.getMinSignedBits() << LHSType 6531 << Left.getBitWidth() << LHS.get()->getSourceRange() 6532 << RHS.get()->getSourceRange(); 6533} 6534 6535// C99 6.5.7 6536QualType Sema::CheckShiftOperands(ExprResult &LHS, ExprResult &RHS, 6537 SourceLocation Loc, unsigned Opc, 6538 bool IsCompAssign) { 6539 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 6540 6541 // C99 6.5.7p2: Each of the operands shall have integer type. 6542 if (!LHS.get()->getType()->hasIntegerRepresentation() || 6543 !RHS.get()->getType()->hasIntegerRepresentation()) 6544 return InvalidOperands(Loc, LHS, RHS); 6545 6546 // C++0x: Don't allow scoped enums. FIXME: Use something better than 6547 // hasIntegerRepresentation() above instead of this. 6548 if (isScopedEnumerationType(LHS.get()->getType()) || 6549 isScopedEnumerationType(RHS.get()->getType())) { 6550 return InvalidOperands(Loc, LHS, RHS); 6551 } 6552 6553 // Vector shifts promote their scalar inputs to vector type. 6554 if (LHS.get()->getType()->isVectorType() || 6555 RHS.get()->getType()->isVectorType()) 6556 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 6557 6558 // Shifts don't perform usual arithmetic conversions, they just do integer 6559 // promotions on each operand. C99 6.5.7p3 6560 6561 // For the LHS, do usual unary conversions, but then reset them away 6562 // if this is a compound assignment. 6563 ExprResult OldLHS = LHS; 6564 LHS = UsualUnaryConversions(LHS.take()); 6565 if (LHS.isInvalid()) 6566 return QualType(); 6567 QualType LHSType = LHS.get()->getType(); 6568 if (IsCompAssign) LHS = OldLHS; 6569 6570 // The RHS is simpler. 6571 RHS = UsualUnaryConversions(RHS.take()); 6572 if (RHS.isInvalid()) 6573 return QualType(); 6574 6575 // Sanity-check shift operands 6576 DiagnoseBadShiftValues(*this, LHS, RHS, Loc, Opc, LHSType); 6577 6578 // "The type of the result is that of the promoted left operand." 6579 return LHSType; 6580} 6581 6582static bool IsWithinTemplateSpecialization(Decl *D) { 6583 if (DeclContext *DC = D->getDeclContext()) { 6584 if (isa<ClassTemplateSpecializationDecl>(DC)) 6585 return true; 6586 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) 6587 return FD->isFunctionTemplateSpecialization(); 6588 } 6589 return false; 6590} 6591 6592/// If two different enums are compared, raise a warning. 6593static void checkEnumComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, 6594 ExprResult &RHS) { 6595 QualType LHSStrippedType = LHS.get()->IgnoreParenImpCasts()->getType(); 6596 QualType RHSStrippedType = RHS.get()->IgnoreParenImpCasts()->getType(); 6597 6598 const EnumType *LHSEnumType = LHSStrippedType->getAs<EnumType>(); 6599 if (!LHSEnumType) 6600 return; 6601 const EnumType *RHSEnumType = RHSStrippedType->getAs<EnumType>(); 6602 if (!RHSEnumType) 6603 return; 6604 6605 // Ignore anonymous enums. 6606 if (!LHSEnumType->getDecl()->getIdentifier()) 6607 return; 6608 if (!RHSEnumType->getDecl()->getIdentifier()) 6609 return; 6610 6611 if (S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType)) 6612 return; 6613 6614 S.Diag(Loc, diag::warn_comparison_of_mixed_enum_types) 6615 << LHSStrippedType << RHSStrippedType 6616 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6617} 6618 6619/// \brief Diagnose bad pointer comparisons. 6620static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, 6621 ExprResult &LHS, ExprResult &RHS, 6622 bool IsError) { 6623 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers 6624 : diag::ext_typecheck_comparison_of_distinct_pointers) 6625 << LHS.get()->getType() << RHS.get()->getType() 6626 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6627} 6628 6629/// \brief Returns false if the pointers are converted to a composite type, 6630/// true otherwise. 6631static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc, 6632 ExprResult &LHS, ExprResult &RHS) { 6633 // C++ [expr.rel]p2: 6634 // [...] Pointer conversions (4.10) and qualification 6635 // conversions (4.4) are performed on pointer operands (or on 6636 // a pointer operand and a null pointer constant) to bring 6637 // them to their composite pointer type. [...] 6638 // 6639 // C++ [expr.eq]p1 uses the same notion for (in)equality 6640 // comparisons of pointers. 6641 6642 // C++ [expr.eq]p2: 6643 // In addition, pointers to members can be compared, or a pointer to 6644 // member and a null pointer constant. Pointer to member conversions 6645 // (4.11) and qualification conversions (4.4) are performed to bring 6646 // them to a common type. If one operand is a null pointer constant, 6647 // the common type is the type of the other operand. Otherwise, the 6648 // common type is a pointer to member type similar (4.4) to the type 6649 // of one of the operands, with a cv-qualification signature (4.4) 6650 // that is the union of the cv-qualification signatures of the operand 6651 // types. 6652 6653 QualType LHSType = LHS.get()->getType(); 6654 QualType RHSType = RHS.get()->getType(); 6655 assert((LHSType->isPointerType() && RHSType->isPointerType()) || 6656 (LHSType->isMemberPointerType() && RHSType->isMemberPointerType())); 6657 6658 bool NonStandardCompositeType = false; 6659 bool *BoolPtr = S.isSFINAEContext() ? 0 : &NonStandardCompositeType; 6660 QualType T = S.FindCompositePointerType(Loc, LHS, RHS, BoolPtr); 6661 if (T.isNull()) { 6662 diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true); 6663 return true; 6664 } 6665 6666 if (NonStandardCompositeType) 6667 S.Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard) 6668 << LHSType << RHSType << T << LHS.get()->getSourceRange() 6669 << RHS.get()->getSourceRange(); 6670 6671 LHS = S.ImpCastExprToType(LHS.take(), T, CK_BitCast); 6672 RHS = S.ImpCastExprToType(RHS.take(), T, CK_BitCast); 6673 return false; 6674} 6675 6676static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc, 6677 ExprResult &LHS, 6678 ExprResult &RHS, 6679 bool IsError) { 6680 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void 6681 : diag::ext_typecheck_comparison_of_fptr_to_void) 6682 << LHS.get()->getType() << RHS.get()->getType() 6683 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6684} 6685 6686static bool isObjCObjectLiteral(ExprResult &E) { 6687 switch (E.get()->getStmtClass()) { 6688 case Stmt::ObjCArrayLiteralClass: 6689 case Stmt::ObjCDictionaryLiteralClass: 6690 case Stmt::ObjCStringLiteralClass: 6691 case Stmt::ObjCBoxedExprClass: 6692 return true; 6693 default: 6694 // Note that ObjCBoolLiteral is NOT an object literal! 6695 return false; 6696 } 6697} 6698 6699static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) { 6700 // Get the LHS object's interface type. 6701 QualType Type = LHS->getType(); 6702 QualType InterfaceType; 6703 if (const ObjCObjectPointerType *PTy = Type->getAs<ObjCObjectPointerType>()) { 6704 InterfaceType = PTy->getPointeeType(); 6705 if (const ObjCObjectType *iQFaceTy = 6706 InterfaceType->getAsObjCQualifiedInterfaceType()) 6707 InterfaceType = iQFaceTy->getBaseType(); 6708 } else { 6709 // If this is not actually an Objective-C object, bail out. 6710 return false; 6711 } 6712 6713 // If the RHS isn't an Objective-C object, bail out. 6714 if (!RHS->getType()->isObjCObjectPointerType()) 6715 return false; 6716 6717 // Try to find the -isEqual: method. 6718 Selector IsEqualSel = S.NSAPIObj->getIsEqualSelector(); 6719 ObjCMethodDecl *Method = S.LookupMethodInObjectType(IsEqualSel, 6720 InterfaceType, 6721 /*instance=*/true); 6722 if (!Method) { 6723 if (Type->isObjCIdType()) { 6724 // For 'id', just check the global pool. 6725 Method = S.LookupInstanceMethodInGlobalPool(IsEqualSel, SourceRange(), 6726 /*receiverId=*/true, 6727 /*warn=*/false); 6728 } else { 6729 // Check protocols. 6730 Method = S.LookupMethodInQualifiedType(IsEqualSel, 6731 cast<ObjCObjectPointerType>(Type), 6732 /*instance=*/true); 6733 } 6734 } 6735 6736 if (!Method) 6737 return false; 6738 6739 QualType T = Method->param_begin()[0]->getType(); 6740 if (!T->isObjCObjectPointerType()) 6741 return false; 6742 6743 QualType R = Method->getResultType(); 6744 if (!R->isScalarType()) 6745 return false; 6746 6747 return true; 6748} 6749 6750static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc, 6751 ExprResult &LHS, ExprResult &RHS, 6752 BinaryOperator::Opcode Opc){ 6753 Expr *Literal; 6754 Expr *Other; 6755 if (isObjCObjectLiteral(LHS)) { 6756 Literal = LHS.get(); 6757 Other = RHS.get(); 6758 } else { 6759 Literal = RHS.get(); 6760 Other = LHS.get(); 6761 } 6762 6763 // Don't warn on comparisons against nil. 6764 Other = Other->IgnoreParenCasts(); 6765 if (Other->isNullPointerConstant(S.getASTContext(), 6766 Expr::NPC_ValueDependentIsNotNull)) 6767 return; 6768 6769 // This should be kept in sync with warn_objc_literal_comparison. 6770 // LK_String should always be last, since it has its own warning flag. 6771 enum { 6772 LK_Array, 6773 LK_Dictionary, 6774 LK_Numeric, 6775 LK_Boxed, 6776 LK_String 6777 } LiteralKind; 6778 6779 switch (Literal->getStmtClass()) { 6780 case Stmt::ObjCStringLiteralClass: 6781 // "string literal" 6782 LiteralKind = LK_String; 6783 break; 6784 case Stmt::ObjCArrayLiteralClass: 6785 // "array literal" 6786 LiteralKind = LK_Array; 6787 break; 6788 case Stmt::ObjCDictionaryLiteralClass: 6789 // "dictionary literal" 6790 LiteralKind = LK_Dictionary; 6791 break; 6792 case Stmt::ObjCBoxedExprClass: { 6793 Expr *Inner = cast<ObjCBoxedExpr>(Literal)->getSubExpr(); 6794 switch (Inner->getStmtClass()) { 6795 case Stmt::IntegerLiteralClass: 6796 case Stmt::FloatingLiteralClass: 6797 case Stmt::CharacterLiteralClass: 6798 case Stmt::ObjCBoolLiteralExprClass: 6799 case Stmt::CXXBoolLiteralExprClass: 6800 // "numeric literal" 6801 LiteralKind = LK_Numeric; 6802 break; 6803 case Stmt::ImplicitCastExprClass: { 6804 CastKind CK = cast<CastExpr>(Inner)->getCastKind(); 6805 // Boolean literals can be represented by implicit casts. 6806 if (CK == CK_IntegralToBoolean || CK == CK_IntegralCast) { 6807 LiteralKind = LK_Numeric; 6808 break; 6809 } 6810 // FALLTHROUGH 6811 } 6812 default: 6813 // "boxed expression" 6814 LiteralKind = LK_Boxed; 6815 break; 6816 } 6817 break; 6818 } 6819 default: 6820 llvm_unreachable("Unknown Objective-C object literal kind"); 6821 } 6822 6823 if (LiteralKind == LK_String) 6824 S.Diag(Loc, diag::warn_objc_string_literal_comparison) 6825 << Literal->getSourceRange(); 6826 else 6827 S.Diag(Loc, diag::warn_objc_literal_comparison) 6828 << LiteralKind << Literal->getSourceRange(); 6829 6830 if (BinaryOperator::isEqualityOp(Opc) && 6831 hasIsEqualMethod(S, LHS.get(), RHS.get())) { 6832 SourceLocation Start = LHS.get()->getLocStart(); 6833 SourceLocation End = S.PP.getLocForEndOfToken(RHS.get()->getLocEnd()); 6834 SourceRange OpRange(Loc, S.PP.getLocForEndOfToken(Loc)); 6835 6836 S.Diag(Loc, diag::note_objc_literal_comparison_isequal) 6837 << FixItHint::CreateInsertion(Start, Opc == BO_EQ ? "[" : "![") 6838 << FixItHint::CreateReplacement(OpRange, "isEqual:") 6839 << FixItHint::CreateInsertion(End, "]"); 6840 } 6841} 6842 6843// C99 6.5.8, C++ [expr.rel] 6844QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS, 6845 SourceLocation Loc, unsigned OpaqueOpc, 6846 bool IsRelational) { 6847 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/true); 6848 6849 BinaryOperatorKind Opc = (BinaryOperatorKind) OpaqueOpc; 6850 6851 // Handle vector comparisons separately. 6852 if (LHS.get()->getType()->isVectorType() || 6853 RHS.get()->getType()->isVectorType()) 6854 return CheckVectorCompareOperands(LHS, RHS, Loc, IsRelational); 6855 6856 QualType LHSType = LHS.get()->getType(); 6857 QualType RHSType = RHS.get()->getType(); 6858 6859 Expr *LHSStripped = LHS.get()->IgnoreParenImpCasts(); 6860 Expr *RHSStripped = RHS.get()->IgnoreParenImpCasts(); 6861 6862 checkEnumComparison(*this, Loc, LHS, RHS); 6863 6864 if (!LHSType->hasFloatingRepresentation() && 6865 !(LHSType->isBlockPointerType() && IsRelational) && 6866 !LHS.get()->getLocStart().isMacroID() && 6867 !RHS.get()->getLocStart().isMacroID()) { 6868 // For non-floating point types, check for self-comparisons of the form 6869 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 6870 // often indicate logic errors in the program. 6871 // 6872 // NOTE: Don't warn about comparison expressions resulting from macro 6873 // expansion. Also don't warn about comparisons which are only self 6874 // comparisons within a template specialization. The warnings should catch 6875 // obvious cases in the definition of the template anyways. The idea is to 6876 // warn when the typed comparison operator will always evaluate to the same 6877 // result. 6878 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHSStripped)) { 6879 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHSStripped)) { 6880 if (DRL->getDecl() == DRR->getDecl() && 6881 !IsWithinTemplateSpecialization(DRL->getDecl())) { 6882 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always) 6883 << 0 // self- 6884 << (Opc == BO_EQ 6885 || Opc == BO_LE 6886 || Opc == BO_GE)); 6887 } else if (LHSType->isArrayType() && RHSType->isArrayType() && 6888 !DRL->getDecl()->getType()->isReferenceType() && 6889 !DRR->getDecl()->getType()->isReferenceType()) { 6890 // what is it always going to eval to? 6891 char always_evals_to; 6892 switch(Opc) { 6893 case BO_EQ: // e.g. array1 == array2 6894 always_evals_to = 0; // false 6895 break; 6896 case BO_NE: // e.g. array1 != array2 6897 always_evals_to = 1; // true 6898 break; 6899 default: 6900 // best we can say is 'a constant' 6901 always_evals_to = 2; // e.g. array1 <= array2 6902 break; 6903 } 6904 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always) 6905 << 1 // array 6906 << always_evals_to); 6907 } 6908 } 6909 } 6910 6911 if (isa<CastExpr>(LHSStripped)) 6912 LHSStripped = LHSStripped->IgnoreParenCasts(); 6913 if (isa<CastExpr>(RHSStripped)) 6914 RHSStripped = RHSStripped->IgnoreParenCasts(); 6915 6916 // Warn about comparisons against a string constant (unless the other 6917 // operand is null), the user probably wants strcmp. 6918 Expr *literalString = 0; 6919 Expr *literalStringStripped = 0; 6920 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) && 6921 !RHSStripped->isNullPointerConstant(Context, 6922 Expr::NPC_ValueDependentIsNull)) { 6923 literalString = LHS.get(); 6924 literalStringStripped = LHSStripped; 6925 } else if ((isa<StringLiteral>(RHSStripped) || 6926 isa<ObjCEncodeExpr>(RHSStripped)) && 6927 !LHSStripped->isNullPointerConstant(Context, 6928 Expr::NPC_ValueDependentIsNull)) { 6929 literalString = RHS.get(); 6930 literalStringStripped = RHSStripped; 6931 } 6932 6933 if (literalString) { 6934 std::string resultComparison; 6935 switch (Opc) { 6936 case BO_LT: resultComparison = ") < 0"; break; 6937 case BO_GT: resultComparison = ") > 0"; break; 6938 case BO_LE: resultComparison = ") <= 0"; break; 6939 case BO_GE: resultComparison = ") >= 0"; break; 6940 case BO_EQ: resultComparison = ") == 0"; break; 6941 case BO_NE: resultComparison = ") != 0"; break; 6942 default: llvm_unreachable("Invalid comparison operator"); 6943 } 6944 6945 DiagRuntimeBehavior(Loc, 0, 6946 PDiag(diag::warn_stringcompare) 6947 << isa<ObjCEncodeExpr>(literalStringStripped) 6948 << literalString->getSourceRange()); 6949 } 6950 } 6951 6952 // C99 6.5.8p3 / C99 6.5.9p4 6953 if (LHS.get()->getType()->isArithmeticType() && 6954 RHS.get()->getType()->isArithmeticType()) { 6955 UsualArithmeticConversions(LHS, RHS); 6956 if (LHS.isInvalid() || RHS.isInvalid()) 6957 return QualType(); 6958 } 6959 else { 6960 LHS = UsualUnaryConversions(LHS.take()); 6961 if (LHS.isInvalid()) 6962 return QualType(); 6963 6964 RHS = UsualUnaryConversions(RHS.take()); 6965 if (RHS.isInvalid()) 6966 return QualType(); 6967 } 6968 6969 LHSType = LHS.get()->getType(); 6970 RHSType = RHS.get()->getType(); 6971 6972 // The result of comparisons is 'bool' in C++, 'int' in C. 6973 QualType ResultTy = Context.getLogicalOperationType(); 6974 6975 if (IsRelational) { 6976 if (LHSType->isRealType() && RHSType->isRealType()) 6977 return ResultTy; 6978 } else { 6979 // Check for comparisons of floating point operands using != and ==. 6980 if (LHSType->hasFloatingRepresentation()) 6981 CheckFloatComparison(Loc, LHS.get(), RHS.get()); 6982 6983 if (LHSType->isArithmeticType() && RHSType->isArithmeticType()) 6984 return ResultTy; 6985 } 6986 6987 bool LHSIsNull = LHS.get()->isNullPointerConstant(Context, 6988 Expr::NPC_ValueDependentIsNull); 6989 bool RHSIsNull = RHS.get()->isNullPointerConstant(Context, 6990 Expr::NPC_ValueDependentIsNull); 6991 6992 // All of the following pointer-related warnings are GCC extensions, except 6993 // when handling null pointer constants. 6994 if (LHSType->isPointerType() && RHSType->isPointerType()) { // C99 6.5.8p2 6995 QualType LCanPointeeTy = 6996 LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType(); 6997 QualType RCanPointeeTy = 6998 RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType(); 6999 7000 if (getLangOpts().CPlusPlus) { 7001 if (LCanPointeeTy == RCanPointeeTy) 7002 return ResultTy; 7003 if (!IsRelational && 7004 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 7005 // Valid unless comparison between non-null pointer and function pointer 7006 // This is a gcc extension compatibility comparison. 7007 // In a SFINAE context, we treat this as a hard error to maintain 7008 // conformance with the C++ standard. 7009 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 7010 && !LHSIsNull && !RHSIsNull) { 7011 diagnoseFunctionPointerToVoidComparison( 7012 *this, Loc, LHS, RHS, /*isError*/ isSFINAEContext()); 7013 7014 if (isSFINAEContext()) 7015 return QualType(); 7016 7017 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 7018 return ResultTy; 7019 } 7020 } 7021 7022 if (convertPointersToCompositeType(*this, Loc, LHS, RHS)) 7023 return QualType(); 7024 else 7025 return ResultTy; 7026 } 7027 // C99 6.5.9p2 and C99 6.5.8p2 7028 if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(), 7029 RCanPointeeTy.getUnqualifiedType())) { 7030 // Valid unless a relational comparison of function pointers 7031 if (IsRelational && LCanPointeeTy->isFunctionType()) { 7032 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers) 7033 << LHSType << RHSType << LHS.get()->getSourceRange() 7034 << RHS.get()->getSourceRange(); 7035 } 7036 } else if (!IsRelational && 7037 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 7038 // Valid unless comparison between non-null pointer and function pointer 7039 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 7040 && !LHSIsNull && !RHSIsNull) 7041 diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS, 7042 /*isError*/false); 7043 } else { 7044 // Invalid 7045 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false); 7046 } 7047 if (LCanPointeeTy != RCanPointeeTy) { 7048 if (LHSIsNull && !RHSIsNull) 7049 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); 7050 else 7051 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 7052 } 7053 return ResultTy; 7054 } 7055 7056 if (getLangOpts().CPlusPlus) { 7057 // Comparison of nullptr_t with itself. 7058 if (LHSType->isNullPtrType() && RHSType->isNullPtrType()) 7059 return ResultTy; 7060 7061 // Comparison of pointers with null pointer constants and equality 7062 // comparisons of member pointers to null pointer constants. 7063 if (RHSIsNull && 7064 ((LHSType->isAnyPointerType() || LHSType->isNullPtrType()) || 7065 (!IsRelational && 7066 (LHSType->isMemberPointerType() || LHSType->isBlockPointerType())))) { 7067 RHS = ImpCastExprToType(RHS.take(), LHSType, 7068 LHSType->isMemberPointerType() 7069 ? CK_NullToMemberPointer 7070 : CK_NullToPointer); 7071 return ResultTy; 7072 } 7073 if (LHSIsNull && 7074 ((RHSType->isAnyPointerType() || RHSType->isNullPtrType()) || 7075 (!IsRelational && 7076 (RHSType->isMemberPointerType() || RHSType->isBlockPointerType())))) { 7077 LHS = ImpCastExprToType(LHS.take(), RHSType, 7078 RHSType->isMemberPointerType() 7079 ? CK_NullToMemberPointer 7080 : CK_NullToPointer); 7081 return ResultTy; 7082 } 7083 7084 // Comparison of member pointers. 7085 if (!IsRelational && 7086 LHSType->isMemberPointerType() && RHSType->isMemberPointerType()) { 7087 if (convertPointersToCompositeType(*this, Loc, LHS, RHS)) 7088 return QualType(); 7089 else 7090 return ResultTy; 7091 } 7092 7093 // Handle scoped enumeration types specifically, since they don't promote 7094 // to integers. 7095 if (LHS.get()->getType()->isEnumeralType() && 7096 Context.hasSameUnqualifiedType(LHS.get()->getType(), 7097 RHS.get()->getType())) 7098 return ResultTy; 7099 } 7100 7101 // Handle block pointer types. 7102 if (!IsRelational && LHSType->isBlockPointerType() && 7103 RHSType->isBlockPointerType()) { 7104 QualType lpointee = LHSType->castAs<BlockPointerType>()->getPointeeType(); 7105 QualType rpointee = RHSType->castAs<BlockPointerType>()->getPointeeType(); 7106 7107 if (!LHSIsNull && !RHSIsNull && 7108 !Context.typesAreCompatible(lpointee, rpointee)) { 7109 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 7110 << LHSType << RHSType << LHS.get()->getSourceRange() 7111 << RHS.get()->getSourceRange(); 7112 } 7113 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 7114 return ResultTy; 7115 } 7116 7117 // Allow block pointers to be compared with null pointer constants. 7118 if (!IsRelational 7119 && ((LHSType->isBlockPointerType() && RHSType->isPointerType()) 7120 || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) { 7121 if (!LHSIsNull && !RHSIsNull) { 7122 if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>() 7123 ->getPointeeType()->isVoidType()) 7124 || (LHSType->isPointerType() && LHSType->castAs<PointerType>() 7125 ->getPointeeType()->isVoidType()))) 7126 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 7127 << LHSType << RHSType << LHS.get()->getSourceRange() 7128 << RHS.get()->getSourceRange(); 7129 } 7130 if (LHSIsNull && !RHSIsNull) 7131 LHS = ImpCastExprToType(LHS.take(), RHSType, 7132 RHSType->isPointerType() ? CK_BitCast 7133 : CK_AnyPointerToBlockPointerCast); 7134 else 7135 RHS = ImpCastExprToType(RHS.take(), LHSType, 7136 LHSType->isPointerType() ? CK_BitCast 7137 : CK_AnyPointerToBlockPointerCast); 7138 return ResultTy; 7139 } 7140 7141 if (LHSType->isObjCObjectPointerType() || 7142 RHSType->isObjCObjectPointerType()) { 7143 const PointerType *LPT = LHSType->getAs<PointerType>(); 7144 const PointerType *RPT = RHSType->getAs<PointerType>(); 7145 if (LPT || RPT) { 7146 bool LPtrToVoid = LPT ? LPT->getPointeeType()->isVoidType() : false; 7147 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() : false; 7148 7149 if (!LPtrToVoid && !RPtrToVoid && 7150 !Context.typesAreCompatible(LHSType, RHSType)) { 7151 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, 7152 /*isError*/false); 7153 } 7154 if (LHSIsNull && !RHSIsNull) 7155 LHS = ImpCastExprToType(LHS.take(), RHSType, 7156 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast); 7157 else 7158 RHS = ImpCastExprToType(RHS.take(), LHSType, 7159 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast); 7160 return ResultTy; 7161 } 7162 if (LHSType->isObjCObjectPointerType() && 7163 RHSType->isObjCObjectPointerType()) { 7164 if (!Context.areComparableObjCPointerTypes(LHSType, RHSType)) 7165 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, 7166 /*isError*/false); 7167 if (isObjCObjectLiteral(LHS) || isObjCObjectLiteral(RHS)) 7168 diagnoseObjCLiteralComparison(*this, Loc, LHS, RHS, Opc); 7169 7170 if (LHSIsNull && !RHSIsNull) 7171 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); 7172 else 7173 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 7174 return ResultTy; 7175 } 7176 } 7177 if ((LHSType->isAnyPointerType() && RHSType->isIntegerType()) || 7178 (LHSType->isIntegerType() && RHSType->isAnyPointerType())) { 7179 unsigned DiagID = 0; 7180 bool isError = false; 7181 if ((LHSIsNull && LHSType->isIntegerType()) || 7182 (RHSIsNull && RHSType->isIntegerType())) { 7183 if (IsRelational && !getLangOpts().CPlusPlus) 7184 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero; 7185 } else if (IsRelational && !getLangOpts().CPlusPlus) 7186 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer; 7187 else if (getLangOpts().CPlusPlus) { 7188 DiagID = diag::err_typecheck_comparison_of_pointer_integer; 7189 isError = true; 7190 } else 7191 DiagID = diag::ext_typecheck_comparison_of_pointer_integer; 7192 7193 if (DiagID) { 7194 Diag(Loc, DiagID) 7195 << LHSType << RHSType << LHS.get()->getSourceRange() 7196 << RHS.get()->getSourceRange(); 7197 if (isError) 7198 return QualType(); 7199 } 7200 7201 if (LHSType->isIntegerType()) 7202 LHS = ImpCastExprToType(LHS.take(), RHSType, 7203 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 7204 else 7205 RHS = ImpCastExprToType(RHS.take(), LHSType, 7206 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 7207 return ResultTy; 7208 } 7209 7210 // Handle block pointers. 7211 if (!IsRelational && RHSIsNull 7212 && LHSType->isBlockPointerType() && RHSType->isIntegerType()) { 7213 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_NullToPointer); 7214 return ResultTy; 7215 } 7216 if (!IsRelational && LHSIsNull 7217 && LHSType->isIntegerType() && RHSType->isBlockPointerType()) { 7218 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_NullToPointer); 7219 return ResultTy; 7220 } 7221 7222 return InvalidOperands(Loc, LHS, RHS); 7223} 7224 7225 7226// Return a signed type that is of identical size and number of elements. 7227// For floating point vectors, return an integer type of identical size 7228// and number of elements. 7229QualType Sema::GetSignedVectorType(QualType V) { 7230 const VectorType *VTy = V->getAs<VectorType>(); 7231 unsigned TypeSize = Context.getTypeSize(VTy->getElementType()); 7232 if (TypeSize == Context.getTypeSize(Context.CharTy)) 7233 return Context.getExtVectorType(Context.CharTy, VTy->getNumElements()); 7234 else if (TypeSize == Context.getTypeSize(Context.ShortTy)) 7235 return Context.getExtVectorType(Context.ShortTy, VTy->getNumElements()); 7236 else if (TypeSize == Context.getTypeSize(Context.IntTy)) 7237 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements()); 7238 else if (TypeSize == Context.getTypeSize(Context.LongTy)) 7239 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements()); 7240 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) && 7241 "Unhandled vector element size in vector compare"); 7242 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements()); 7243} 7244 7245/// CheckVectorCompareOperands - vector comparisons are a clang extension that 7246/// operates on extended vector types. Instead of producing an IntTy result, 7247/// like a scalar comparison, a vector comparison produces a vector of integer 7248/// types. 7249QualType Sema::CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, 7250 SourceLocation Loc, 7251 bool IsRelational) { 7252 // Check to make sure we're operating on vectors of the same type and width, 7253 // Allowing one side to be a scalar of element type. 7254 QualType vType = CheckVectorOperands(LHS, RHS, Loc, /*isCompAssign*/false); 7255 if (vType.isNull()) 7256 return vType; 7257 7258 QualType LHSType = LHS.get()->getType(); 7259 7260 // If AltiVec, the comparison results in a numeric type, i.e. 7261 // bool for C++, int for C 7262 if (vType->getAs<VectorType>()->getVectorKind() == VectorType::AltiVecVector) 7263 return Context.getLogicalOperationType(); 7264 7265 // For non-floating point types, check for self-comparisons of the form 7266 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 7267 // often indicate logic errors in the program. 7268 if (!LHSType->hasFloatingRepresentation()) { 7269 if (DeclRefExpr* DRL 7270 = dyn_cast<DeclRefExpr>(LHS.get()->IgnoreParenImpCasts())) 7271 if (DeclRefExpr* DRR 7272 = dyn_cast<DeclRefExpr>(RHS.get()->IgnoreParenImpCasts())) 7273 if (DRL->getDecl() == DRR->getDecl()) 7274 DiagRuntimeBehavior(Loc, 0, 7275 PDiag(diag::warn_comparison_always) 7276 << 0 // self- 7277 << 2 // "a constant" 7278 ); 7279 } 7280 7281 // Check for comparisons of floating point operands using != and ==. 7282 if (!IsRelational && LHSType->hasFloatingRepresentation()) { 7283 assert (RHS.get()->getType()->hasFloatingRepresentation()); 7284 CheckFloatComparison(Loc, LHS.get(), RHS.get()); 7285 } 7286 7287 // Return a signed type for the vector. 7288 return GetSignedVectorType(LHSType); 7289} 7290 7291QualType Sema::CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, 7292 SourceLocation Loc) { 7293 // Ensure that either both operands are of the same vector type, or 7294 // one operand is of a vector type and the other is of its element type. 7295 QualType vType = CheckVectorOperands(LHS, RHS, Loc, false); 7296 if (vType.isNull() || vType->isFloatingType()) 7297 return InvalidOperands(Loc, LHS, RHS); 7298 7299 return GetSignedVectorType(LHS.get()->getType()); 7300} 7301 7302inline QualType Sema::CheckBitwiseOperands( 7303 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { 7304 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7305 7306 if (LHS.get()->getType()->isVectorType() || 7307 RHS.get()->getType()->isVectorType()) { 7308 if (LHS.get()->getType()->hasIntegerRepresentation() && 7309 RHS.get()->getType()->hasIntegerRepresentation()) 7310 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 7311 7312 return InvalidOperands(Loc, LHS, RHS); 7313 } 7314 7315 ExprResult LHSResult = Owned(LHS), RHSResult = Owned(RHS); 7316 QualType compType = UsualArithmeticConversions(LHSResult, RHSResult, 7317 IsCompAssign); 7318 if (LHSResult.isInvalid() || RHSResult.isInvalid()) 7319 return QualType(); 7320 LHS = LHSResult.take(); 7321 RHS = RHSResult.take(); 7322 7323 if (!compType.isNull() && compType->isIntegralOrUnscopedEnumerationType()) 7324 return compType; 7325 return InvalidOperands(Loc, LHS, RHS); 7326} 7327 7328inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14] 7329 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc) { 7330 7331 // Check vector operands differently. 7332 if (LHS.get()->getType()->isVectorType() || RHS.get()->getType()->isVectorType()) 7333 return CheckVectorLogicalOperands(LHS, RHS, Loc); 7334 7335 // Diagnose cases where the user write a logical and/or but probably meant a 7336 // bitwise one. We do this when the LHS is a non-bool integer and the RHS 7337 // is a constant. 7338 if (LHS.get()->getType()->isIntegerType() && 7339 !LHS.get()->getType()->isBooleanType() && 7340 RHS.get()->getType()->isIntegerType() && !RHS.get()->isValueDependent() && 7341 // Don't warn in macros or template instantiations. 7342 !Loc.isMacroID() && ActiveTemplateInstantiations.empty()) { 7343 // If the RHS can be constant folded, and if it constant folds to something 7344 // that isn't 0 or 1 (which indicate a potential logical operation that 7345 // happened to fold to true/false) then warn. 7346 // Parens on the RHS are ignored. 7347 llvm::APSInt Result; 7348 if (RHS.get()->EvaluateAsInt(Result, Context)) 7349 if ((getLangOpts().Bool && !RHS.get()->getType()->isBooleanType()) || 7350 (Result != 0 && Result != 1)) { 7351 Diag(Loc, diag::warn_logical_instead_of_bitwise) 7352 << RHS.get()->getSourceRange() 7353 << (Opc == BO_LAnd ? "&&" : "||"); 7354 // Suggest replacing the logical operator with the bitwise version 7355 Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator) 7356 << (Opc == BO_LAnd ? "&" : "|") 7357 << FixItHint::CreateReplacement(SourceRange( 7358 Loc, Lexer::getLocForEndOfToken(Loc, 0, getSourceManager(), 7359 getLangOpts())), 7360 Opc == BO_LAnd ? "&" : "|"); 7361 if (Opc == BO_LAnd) 7362 // Suggest replacing "Foo() && kNonZero" with "Foo()" 7363 Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant) 7364 << FixItHint::CreateRemoval( 7365 SourceRange( 7366 Lexer::getLocForEndOfToken(LHS.get()->getLocEnd(), 7367 0, getSourceManager(), 7368 getLangOpts()), 7369 RHS.get()->getLocEnd())); 7370 } 7371 } 7372 7373 if (!Context.getLangOpts().CPlusPlus) { 7374 LHS = UsualUnaryConversions(LHS.take()); 7375 if (LHS.isInvalid()) 7376 return QualType(); 7377 7378 RHS = UsualUnaryConversions(RHS.take()); 7379 if (RHS.isInvalid()) 7380 return QualType(); 7381 7382 if (!LHS.get()->getType()->isScalarType() || 7383 !RHS.get()->getType()->isScalarType()) 7384 return InvalidOperands(Loc, LHS, RHS); 7385 7386 return Context.IntTy; 7387 } 7388 7389 // The following is safe because we only use this method for 7390 // non-overloadable operands. 7391 7392 // C++ [expr.log.and]p1 7393 // C++ [expr.log.or]p1 7394 // The operands are both contextually converted to type bool. 7395 ExprResult LHSRes = PerformContextuallyConvertToBool(LHS.get()); 7396 if (LHSRes.isInvalid()) 7397 return InvalidOperands(Loc, LHS, RHS); 7398 LHS = move(LHSRes); 7399 7400 ExprResult RHSRes = PerformContextuallyConvertToBool(RHS.get()); 7401 if (RHSRes.isInvalid()) 7402 return InvalidOperands(Loc, LHS, RHS); 7403 RHS = move(RHSRes); 7404 7405 // C++ [expr.log.and]p2 7406 // C++ [expr.log.or]p2 7407 // The result is a bool. 7408 return Context.BoolTy; 7409} 7410 7411/// IsReadonlyProperty - Verify that otherwise a valid l-value expression 7412/// is a read-only property; return true if so. A readonly property expression 7413/// depends on various declarations and thus must be treated specially. 7414/// 7415static bool IsReadonlyProperty(Expr *E, Sema &S) { 7416 const ObjCPropertyRefExpr *PropExpr = dyn_cast<ObjCPropertyRefExpr>(E); 7417 if (!PropExpr) return false; 7418 if (PropExpr->isImplicitProperty()) return false; 7419 7420 ObjCPropertyDecl *PDecl = PropExpr->getExplicitProperty(); 7421 QualType BaseType = PropExpr->isSuperReceiver() ? 7422 PropExpr->getSuperReceiverType() : 7423 PropExpr->getBase()->getType(); 7424 7425 if (const ObjCObjectPointerType *OPT = 7426 BaseType->getAsObjCInterfacePointerType()) 7427 if (ObjCInterfaceDecl *IFace = OPT->getInterfaceDecl()) 7428 if (S.isPropertyReadonly(PDecl, IFace)) 7429 return true; 7430 return false; 7431} 7432 7433static bool IsReadonlyMessage(Expr *E, Sema &S) { 7434 const MemberExpr *ME = dyn_cast<MemberExpr>(E); 7435 if (!ME) return false; 7436 if (!isa<FieldDecl>(ME->getMemberDecl())) return false; 7437 ObjCMessageExpr *Base = 7438 dyn_cast<ObjCMessageExpr>(ME->getBase()->IgnoreParenImpCasts()); 7439 if (!Base) return false; 7440 return Base->getMethodDecl() != 0; 7441} 7442 7443/// Is the given expression (which must be 'const') a reference to a 7444/// variable which was originally non-const, but which has become 7445/// 'const' due to being captured within a block? 7446enum NonConstCaptureKind { NCCK_None, NCCK_Block, NCCK_Lambda }; 7447static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) { 7448 assert(E->isLValue() && E->getType().isConstQualified()); 7449 E = E->IgnoreParens(); 7450 7451 // Must be a reference to a declaration from an enclosing scope. 7452 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 7453 if (!DRE) return NCCK_None; 7454 if (!DRE->refersToEnclosingLocal()) return NCCK_None; 7455 7456 // The declaration must be a variable which is not declared 'const'. 7457 VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl()); 7458 if (!var) return NCCK_None; 7459 if (var->getType().isConstQualified()) return NCCK_None; 7460 assert(var->hasLocalStorage() && "capture added 'const' to non-local?"); 7461 7462 // Decide whether the first capture was for a block or a lambda. 7463 DeclContext *DC = S.CurContext; 7464 while (DC->getParent() != var->getDeclContext()) 7465 DC = DC->getParent(); 7466 return (isa<BlockDecl>(DC) ? NCCK_Block : NCCK_Lambda); 7467} 7468 7469/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not, 7470/// emit an error and return true. If so, return false. 7471static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) { 7472 assert(!E->hasPlaceholderType(BuiltinType::PseudoObject)); 7473 SourceLocation OrigLoc = Loc; 7474 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context, 7475 &Loc); 7476 if (IsLV == Expr::MLV_Valid && IsReadonlyProperty(E, S)) 7477 IsLV = Expr::MLV_ReadonlyProperty; 7478 else if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S)) 7479 IsLV = Expr::MLV_InvalidMessageExpression; 7480 if (IsLV == Expr::MLV_Valid) 7481 return false; 7482 7483 unsigned Diag = 0; 7484 bool NeedType = false; 7485 switch (IsLV) { // C99 6.5.16p2 7486 case Expr::MLV_ConstQualified: 7487 Diag = diag::err_typecheck_assign_const; 7488 7489 // Use a specialized diagnostic when we're assigning to an object 7490 // from an enclosing function or block. 7491 if (NonConstCaptureKind NCCK = isReferenceToNonConstCapture(S, E)) { 7492 if (NCCK == NCCK_Block) 7493 Diag = diag::err_block_decl_ref_not_modifiable_lvalue; 7494 else 7495 Diag = diag::err_lambda_decl_ref_not_modifiable_lvalue; 7496 break; 7497 } 7498 7499 // In ARC, use some specialized diagnostics for occasions where we 7500 // infer 'const'. These are always pseudo-strong variables. 7501 if (S.getLangOpts().ObjCAutoRefCount) { 7502 DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()); 7503 if (declRef && isa<VarDecl>(declRef->getDecl())) { 7504 VarDecl *var = cast<VarDecl>(declRef->getDecl()); 7505 7506 // Use the normal diagnostic if it's pseudo-__strong but the 7507 // user actually wrote 'const'. 7508 if (var->isARCPseudoStrong() && 7509 (!var->getTypeSourceInfo() || 7510 !var->getTypeSourceInfo()->getType().isConstQualified())) { 7511 // There are two pseudo-strong cases: 7512 // - self 7513 ObjCMethodDecl *method = S.getCurMethodDecl(); 7514 if (method && var == method->getSelfDecl()) 7515 Diag = method->isClassMethod() 7516 ? diag::err_typecheck_arc_assign_self_class_method 7517 : diag::err_typecheck_arc_assign_self; 7518 7519 // - fast enumeration variables 7520 else 7521 Diag = diag::err_typecheck_arr_assign_enumeration; 7522 7523 SourceRange Assign; 7524 if (Loc != OrigLoc) 7525 Assign = SourceRange(OrigLoc, OrigLoc); 7526 S.Diag(Loc, Diag) << E->getSourceRange() << Assign; 7527 // We need to preserve the AST regardless, so migration tool 7528 // can do its job. 7529 return false; 7530 } 7531 } 7532 } 7533 7534 break; 7535 case Expr::MLV_ArrayType: 7536 case Expr::MLV_ArrayTemporary: 7537 Diag = diag::err_typecheck_array_not_modifiable_lvalue; 7538 NeedType = true; 7539 break; 7540 case Expr::MLV_NotObjectType: 7541 Diag = diag::err_typecheck_non_object_not_modifiable_lvalue; 7542 NeedType = true; 7543 break; 7544 case Expr::MLV_LValueCast: 7545 Diag = diag::err_typecheck_lvalue_casts_not_supported; 7546 break; 7547 case Expr::MLV_Valid: 7548 llvm_unreachable("did not take early return for MLV_Valid"); 7549 case Expr::MLV_InvalidExpression: 7550 case Expr::MLV_MemberFunction: 7551 case Expr::MLV_ClassTemporary: 7552 Diag = diag::err_typecheck_expression_not_modifiable_lvalue; 7553 break; 7554 case Expr::MLV_IncompleteType: 7555 case Expr::MLV_IncompleteVoidType: 7556 return S.RequireCompleteType(Loc, E->getType(), 7557 diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E); 7558 case Expr::MLV_DuplicateVectorComponents: 7559 Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue; 7560 break; 7561 case Expr::MLV_ReadonlyProperty: 7562 case Expr::MLV_NoSetterProperty: 7563 llvm_unreachable("readonly properties should be processed differently"); 7564 case Expr::MLV_InvalidMessageExpression: 7565 Diag = diag::error_readonly_message_assignment; 7566 break; 7567 case Expr::MLV_SubObjCPropertySetting: 7568 Diag = diag::error_no_subobject_property_setting; 7569 break; 7570 } 7571 7572 SourceRange Assign; 7573 if (Loc != OrigLoc) 7574 Assign = SourceRange(OrigLoc, OrigLoc); 7575 if (NeedType) 7576 S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign; 7577 else 7578 S.Diag(Loc, Diag) << E->getSourceRange() << Assign; 7579 return true; 7580} 7581 7582static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr, 7583 SourceLocation Loc, 7584 Sema &Sema) { 7585 // C / C++ fields 7586 MemberExpr *ML = dyn_cast<MemberExpr>(LHSExpr); 7587 MemberExpr *MR = dyn_cast<MemberExpr>(RHSExpr); 7588 if (ML && MR && ML->getMemberDecl() == MR->getMemberDecl()) { 7589 if (isa<CXXThisExpr>(ML->getBase()) && isa<CXXThisExpr>(MR->getBase())) 7590 Sema.Diag(Loc, diag::warn_identity_field_assign) << 0; 7591 } 7592 7593 // Objective-C instance variables 7594 ObjCIvarRefExpr *OL = dyn_cast<ObjCIvarRefExpr>(LHSExpr); 7595 ObjCIvarRefExpr *OR = dyn_cast<ObjCIvarRefExpr>(RHSExpr); 7596 if (OL && OR && OL->getDecl() == OR->getDecl()) { 7597 DeclRefExpr *RL = dyn_cast<DeclRefExpr>(OL->getBase()->IgnoreImpCasts()); 7598 DeclRefExpr *RR = dyn_cast<DeclRefExpr>(OR->getBase()->IgnoreImpCasts()); 7599 if (RL && RR && RL->getDecl() == RR->getDecl()) 7600 Sema.Diag(Loc, diag::warn_identity_field_assign) << 1; 7601 } 7602} 7603 7604// C99 6.5.16.1 7605QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, 7606 SourceLocation Loc, 7607 QualType CompoundType) { 7608 assert(!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject)); 7609 7610 // Verify that LHS is a modifiable lvalue, and emit error if not. 7611 if (CheckForModifiableLvalue(LHSExpr, Loc, *this)) 7612 return QualType(); 7613 7614 QualType LHSType = LHSExpr->getType(); 7615 QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() : 7616 CompoundType; 7617 AssignConvertType ConvTy; 7618 if (CompoundType.isNull()) { 7619 Expr *RHSCheck = RHS.get(); 7620 7621 CheckIdentityFieldAssignment(LHSExpr, RHSCheck, Loc, *this); 7622 7623 QualType LHSTy(LHSType); 7624 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS); 7625 if (RHS.isInvalid()) 7626 return QualType(); 7627 // Special case of NSObject attributes on c-style pointer types. 7628 if (ConvTy == IncompatiblePointer && 7629 ((Context.isObjCNSObjectType(LHSType) && 7630 RHSType->isObjCObjectPointerType()) || 7631 (Context.isObjCNSObjectType(RHSType) && 7632 LHSType->isObjCObjectPointerType()))) 7633 ConvTy = Compatible; 7634 7635 if (ConvTy == Compatible && 7636 LHSType->isObjCObjectType()) 7637 Diag(Loc, diag::err_objc_object_assignment) 7638 << LHSType; 7639 7640 // If the RHS is a unary plus or minus, check to see if they = and + are 7641 // right next to each other. If so, the user may have typo'd "x =+ 4" 7642 // instead of "x += 4". 7643 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck)) 7644 RHSCheck = ICE->getSubExpr(); 7645 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) { 7646 if ((UO->getOpcode() == UO_Plus || 7647 UO->getOpcode() == UO_Minus) && 7648 Loc.isFileID() && UO->getOperatorLoc().isFileID() && 7649 // Only if the two operators are exactly adjacent. 7650 Loc.getLocWithOffset(1) == UO->getOperatorLoc() && 7651 // And there is a space or other character before the subexpr of the 7652 // unary +/-. We don't want to warn on "x=-1". 7653 Loc.getLocWithOffset(2) != UO->getSubExpr()->getLocStart() && 7654 UO->getSubExpr()->getLocStart().isFileID()) { 7655 Diag(Loc, diag::warn_not_compound_assign) 7656 << (UO->getOpcode() == UO_Plus ? "+" : "-") 7657 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc()); 7658 } 7659 } 7660 7661 if (ConvTy == Compatible) { 7662 if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong) 7663 checkRetainCycles(LHSExpr, RHS.get()); 7664 else if (getLangOpts().ObjCAutoRefCount) 7665 checkUnsafeExprAssigns(Loc, LHSExpr, RHS.get()); 7666 } 7667 } else { 7668 // Compound assignment "x += y" 7669 ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType); 7670 } 7671 7672 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType, 7673 RHS.get(), AA_Assigning)) 7674 return QualType(); 7675 7676 CheckForNullPointerDereference(*this, LHSExpr); 7677 7678 // C99 6.5.16p3: The type of an assignment expression is the type of the 7679 // left operand unless the left operand has qualified type, in which case 7680 // it is the unqualified version of the type of the left operand. 7681 // C99 6.5.16.1p2: In simple assignment, the value of the right operand 7682 // is converted to the type of the assignment expression (above). 7683 // C++ 5.17p1: the type of the assignment expression is that of its left 7684 // operand. 7685 return (getLangOpts().CPlusPlus 7686 ? LHSType : LHSType.getUnqualifiedType()); 7687} 7688 7689// C99 6.5.17 7690static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, 7691 SourceLocation Loc) { 7692 LHS = S.CheckPlaceholderExpr(LHS.take()); 7693 RHS = S.CheckPlaceholderExpr(RHS.take()); 7694 if (LHS.isInvalid() || RHS.isInvalid()) 7695 return QualType(); 7696 7697 // C's comma performs lvalue conversion (C99 6.3.2.1) on both its 7698 // operands, but not unary promotions. 7699 // C++'s comma does not do any conversions at all (C++ [expr.comma]p1). 7700 7701 // So we treat the LHS as a ignored value, and in C++ we allow the 7702 // containing site to determine what should be done with the RHS. 7703 LHS = S.IgnoredValueConversions(LHS.take()); 7704 if (LHS.isInvalid()) 7705 return QualType(); 7706 7707 S.DiagnoseUnusedExprResult(LHS.get()); 7708 7709 if (!S.getLangOpts().CPlusPlus) { 7710 RHS = S.DefaultFunctionArrayLvalueConversion(RHS.take()); 7711 if (RHS.isInvalid()) 7712 return QualType(); 7713 if (!RHS.get()->getType()->isVoidType()) 7714 S.RequireCompleteType(Loc, RHS.get()->getType(), 7715 diag::err_incomplete_type); 7716 } 7717 7718 return RHS.get()->getType(); 7719} 7720 7721/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine 7722/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions. 7723static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, 7724 ExprValueKind &VK, 7725 SourceLocation OpLoc, 7726 bool IsInc, bool IsPrefix) { 7727 if (Op->isTypeDependent()) 7728 return S.Context.DependentTy; 7729 7730 QualType ResType = Op->getType(); 7731 // Atomic types can be used for increment / decrement where the non-atomic 7732 // versions can, so ignore the _Atomic() specifier for the purpose of 7733 // checking. 7734 if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>()) 7735 ResType = ResAtomicType->getValueType(); 7736 7737 assert(!ResType.isNull() && "no type for increment/decrement expression"); 7738 7739 if (S.getLangOpts().CPlusPlus && ResType->isBooleanType()) { 7740 // Decrement of bool is not allowed. 7741 if (!IsInc) { 7742 S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange(); 7743 return QualType(); 7744 } 7745 // Increment of bool sets it to true, but is deprecated. 7746 S.Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange(); 7747 } else if (ResType->isRealType()) { 7748 // OK! 7749 } else if (ResType->isAnyPointerType()) { 7750 // C99 6.5.2.4p2, 6.5.6p2 7751 if (!checkArithmeticOpPointerOperand(S, OpLoc, Op)) 7752 return QualType(); 7753 7754 // Diagnose bad cases where we step over interface counts. 7755 else if (!checkArithmethicPointerOnNonFragileABI(S, OpLoc, Op)) 7756 return QualType(); 7757 } else if (ResType->isAnyComplexType()) { 7758 // C99 does not support ++/-- on complex types, we allow as an extension. 7759 S.Diag(OpLoc, diag::ext_integer_increment_complex) 7760 << ResType << Op->getSourceRange(); 7761 } else if (ResType->isPlaceholderType()) { 7762 ExprResult PR = S.CheckPlaceholderExpr(Op); 7763 if (PR.isInvalid()) return QualType(); 7764 return CheckIncrementDecrementOperand(S, PR.take(), VK, OpLoc, 7765 IsInc, IsPrefix); 7766 } else if (S.getLangOpts().AltiVec && ResType->isVectorType()) { 7767 // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 ) 7768 } else { 7769 S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement) 7770 << ResType << int(IsInc) << Op->getSourceRange(); 7771 return QualType(); 7772 } 7773 // At this point, we know we have a real, complex or pointer type. 7774 // Now make sure the operand is a modifiable lvalue. 7775 if (CheckForModifiableLvalue(Op, OpLoc, S)) 7776 return QualType(); 7777 // In C++, a prefix increment is the same type as the operand. Otherwise 7778 // (in C or with postfix), the increment is the unqualified type of the 7779 // operand. 7780 if (IsPrefix && S.getLangOpts().CPlusPlus) { 7781 VK = VK_LValue; 7782 return ResType; 7783 } else { 7784 VK = VK_RValue; 7785 return ResType.getUnqualifiedType(); 7786 } 7787} 7788 7789 7790/// getPrimaryDecl - Helper function for CheckAddressOfOperand(). 7791/// This routine allows us to typecheck complex/recursive expressions 7792/// where the declaration is needed for type checking. We only need to 7793/// handle cases when the expression references a function designator 7794/// or is an lvalue. Here are some examples: 7795/// - &(x) => x 7796/// - &*****f => f for f a function designator. 7797/// - &s.xx => s 7798/// - &s.zz[1].yy -> s, if zz is an array 7799/// - *(x + 1) -> x, if x is an array 7800/// - &"123"[2] -> 0 7801/// - & __real__ x -> x 7802static ValueDecl *getPrimaryDecl(Expr *E) { 7803 switch (E->getStmtClass()) { 7804 case Stmt::DeclRefExprClass: 7805 return cast<DeclRefExpr>(E)->getDecl(); 7806 case Stmt::MemberExprClass: 7807 // If this is an arrow operator, the address is an offset from 7808 // the base's value, so the object the base refers to is 7809 // irrelevant. 7810 if (cast<MemberExpr>(E)->isArrow()) 7811 return 0; 7812 // Otherwise, the expression refers to a part of the base 7813 return getPrimaryDecl(cast<MemberExpr>(E)->getBase()); 7814 case Stmt::ArraySubscriptExprClass: { 7815 // FIXME: This code shouldn't be necessary! We should catch the implicit 7816 // promotion of register arrays earlier. 7817 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase(); 7818 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) { 7819 if (ICE->getSubExpr()->getType()->isArrayType()) 7820 return getPrimaryDecl(ICE->getSubExpr()); 7821 } 7822 return 0; 7823 } 7824 case Stmt::UnaryOperatorClass: { 7825 UnaryOperator *UO = cast<UnaryOperator>(E); 7826 7827 switch(UO->getOpcode()) { 7828 case UO_Real: 7829 case UO_Imag: 7830 case UO_Extension: 7831 return getPrimaryDecl(UO->getSubExpr()); 7832 default: 7833 return 0; 7834 } 7835 } 7836 case Stmt::ParenExprClass: 7837 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr()); 7838 case Stmt::ImplicitCastExprClass: 7839 // If the result of an implicit cast is an l-value, we care about 7840 // the sub-expression; otherwise, the result here doesn't matter. 7841 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr()); 7842 default: 7843 return 0; 7844 } 7845} 7846 7847namespace { 7848 enum { 7849 AO_Bit_Field = 0, 7850 AO_Vector_Element = 1, 7851 AO_Property_Expansion = 2, 7852 AO_Register_Variable = 3, 7853 AO_No_Error = 4 7854 }; 7855} 7856/// \brief Diagnose invalid operand for address of operations. 7857/// 7858/// \param Type The type of operand which cannot have its address taken. 7859static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, 7860 Expr *E, unsigned Type) { 7861 S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange(); 7862} 7863 7864/// CheckAddressOfOperand - The operand of & must be either a function 7865/// designator or an lvalue designating an object. If it is an lvalue, the 7866/// object cannot be declared with storage class register or be a bit field. 7867/// Note: The usual conversions are *not* applied to the operand of the & 7868/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue. 7869/// In C++, the operand might be an overloaded function name, in which case 7870/// we allow the '&' but retain the overloaded-function type. 7871static QualType CheckAddressOfOperand(Sema &S, ExprResult &OrigOp, 7872 SourceLocation OpLoc) { 7873 if (const BuiltinType *PTy = OrigOp.get()->getType()->getAsPlaceholderType()){ 7874 if (PTy->getKind() == BuiltinType::Overload) { 7875 if (!isa<OverloadExpr>(OrigOp.get()->IgnoreParens())) { 7876 S.Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof) 7877 << OrigOp.get()->getSourceRange(); 7878 return QualType(); 7879 } 7880 7881 return S.Context.OverloadTy; 7882 } 7883 7884 if (PTy->getKind() == BuiltinType::UnknownAny) 7885 return S.Context.UnknownAnyTy; 7886 7887 if (PTy->getKind() == BuiltinType::BoundMember) { 7888 S.Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 7889 << OrigOp.get()->getSourceRange(); 7890 return QualType(); 7891 } 7892 7893 OrigOp = S.CheckPlaceholderExpr(OrigOp.take()); 7894 if (OrigOp.isInvalid()) return QualType(); 7895 } 7896 7897 if (OrigOp.get()->isTypeDependent()) 7898 return S.Context.DependentTy; 7899 7900 assert(!OrigOp.get()->getType()->isPlaceholderType()); 7901 7902 // Make sure to ignore parentheses in subsequent checks 7903 Expr *op = OrigOp.get()->IgnoreParens(); 7904 7905 if (S.getLangOpts().C99) { 7906 // Implement C99-only parts of addressof rules. 7907 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) { 7908 if (uOp->getOpcode() == UO_Deref) 7909 // Per C99 6.5.3.2, the address of a deref always returns a valid result 7910 // (assuming the deref expression is valid). 7911 return uOp->getSubExpr()->getType(); 7912 } 7913 // Technically, there should be a check for array subscript 7914 // expressions here, but the result of one is always an lvalue anyway. 7915 } 7916 ValueDecl *dcl = getPrimaryDecl(op); 7917 Expr::LValueClassification lval = op->ClassifyLValue(S.Context); 7918 unsigned AddressOfError = AO_No_Error; 7919 7920 if (lval == Expr::LV_ClassTemporary) { 7921 bool sfinae = S.isSFINAEContext(); 7922 S.Diag(OpLoc, sfinae ? diag::err_typecheck_addrof_class_temporary 7923 : diag::ext_typecheck_addrof_class_temporary) 7924 << op->getType() << op->getSourceRange(); 7925 if (sfinae) 7926 return QualType(); 7927 } else if (isa<ObjCSelectorExpr>(op)) { 7928 return S.Context.getPointerType(op->getType()); 7929 } else if (lval == Expr::LV_MemberFunction) { 7930 // If it's an instance method, make a member pointer. 7931 // The expression must have exactly the form &A::foo. 7932 7933 // If the underlying expression isn't a decl ref, give up. 7934 if (!isa<DeclRefExpr>(op)) { 7935 S.Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 7936 << OrigOp.get()->getSourceRange(); 7937 return QualType(); 7938 } 7939 DeclRefExpr *DRE = cast<DeclRefExpr>(op); 7940 CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl()); 7941 7942 // The id-expression was parenthesized. 7943 if (OrigOp.get() != DRE) { 7944 S.Diag(OpLoc, diag::err_parens_pointer_member_function) 7945 << OrigOp.get()->getSourceRange(); 7946 7947 // The method was named without a qualifier. 7948 } else if (!DRE->getQualifier()) { 7949 S.Diag(OpLoc, diag::err_unqualified_pointer_member_function) 7950 << op->getSourceRange(); 7951 } 7952 7953 return S.Context.getMemberPointerType(op->getType(), 7954 S.Context.getTypeDeclType(MD->getParent()).getTypePtr()); 7955 } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) { 7956 // C99 6.5.3.2p1 7957 // The operand must be either an l-value or a function designator 7958 if (!op->getType()->isFunctionType()) { 7959 // Use a special diagnostic for loads from property references. 7960 if (isa<PseudoObjectExpr>(op)) { 7961 AddressOfError = AO_Property_Expansion; 7962 } else { 7963 // FIXME: emit more specific diag... 7964 S.Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof) 7965 << op->getSourceRange(); 7966 return QualType(); 7967 } 7968 } 7969 } else if (op->getObjectKind() == OK_BitField) { // C99 6.5.3.2p1 7970 // The operand cannot be a bit-field 7971 AddressOfError = AO_Bit_Field; 7972 } else if (op->getObjectKind() == OK_VectorComponent) { 7973 // The operand cannot be an element of a vector 7974 AddressOfError = AO_Vector_Element; 7975 } else if (dcl) { // C99 6.5.3.2p1 7976 // We have an lvalue with a decl. Make sure the decl is not declared 7977 // with the register storage-class specifier. 7978 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) { 7979 // in C++ it is not error to take address of a register 7980 // variable (c++03 7.1.1P3) 7981 if (vd->getStorageClass() == SC_Register && 7982 !S.getLangOpts().CPlusPlus) { 7983 AddressOfError = AO_Register_Variable; 7984 } 7985 } else if (isa<FunctionTemplateDecl>(dcl)) { 7986 return S.Context.OverloadTy; 7987 } else if (isa<FieldDecl>(dcl) || isa<IndirectFieldDecl>(dcl)) { 7988 // Okay: we can take the address of a field. 7989 // Could be a pointer to member, though, if there is an explicit 7990 // scope qualifier for the class. 7991 if (isa<DeclRefExpr>(op) && cast<DeclRefExpr>(op)->getQualifier()) { 7992 DeclContext *Ctx = dcl->getDeclContext(); 7993 if (Ctx && Ctx->isRecord()) { 7994 if (dcl->getType()->isReferenceType()) { 7995 S.Diag(OpLoc, 7996 diag::err_cannot_form_pointer_to_member_of_reference_type) 7997 << dcl->getDeclName() << dcl->getType(); 7998 return QualType(); 7999 } 8000 8001 while (cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion()) 8002 Ctx = Ctx->getParent(); 8003 return S.Context.getMemberPointerType(op->getType(), 8004 S.Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr()); 8005 } 8006 } 8007 } else if (!isa<FunctionDecl>(dcl) && !isa<NonTypeTemplateParmDecl>(dcl)) 8008 llvm_unreachable("Unknown/unexpected decl type"); 8009 } 8010 8011 if (AddressOfError != AO_No_Error) { 8012 diagnoseAddressOfInvalidType(S, OpLoc, op, AddressOfError); 8013 return QualType(); 8014 } 8015 8016 if (lval == Expr::LV_IncompleteVoidType) { 8017 // Taking the address of a void variable is technically illegal, but we 8018 // allow it in cases which are otherwise valid. 8019 // Example: "extern void x; void* y = &x;". 8020 S.Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange(); 8021 } 8022 8023 // If the operand has type "type", the result has type "pointer to type". 8024 if (op->getType()->isObjCObjectType()) 8025 return S.Context.getObjCObjectPointerType(op->getType()); 8026 return S.Context.getPointerType(op->getType()); 8027} 8028 8029/// CheckIndirectionOperand - Type check unary indirection (prefix '*'). 8030static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK, 8031 SourceLocation OpLoc) { 8032 if (Op->isTypeDependent()) 8033 return S.Context.DependentTy; 8034 8035 ExprResult ConvResult = S.UsualUnaryConversions(Op); 8036 if (ConvResult.isInvalid()) 8037 return QualType(); 8038 Op = ConvResult.take(); 8039 QualType OpTy = Op->getType(); 8040 QualType Result; 8041 8042 if (isa<CXXReinterpretCastExpr>(Op)) { 8043 QualType OpOrigType = Op->IgnoreParenCasts()->getType(); 8044 S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true, 8045 Op->getSourceRange()); 8046 } 8047 8048 // Note that per both C89 and C99, indirection is always legal, even if OpTy 8049 // is an incomplete type or void. It would be possible to warn about 8050 // dereferencing a void pointer, but it's completely well-defined, and such a 8051 // warning is unlikely to catch any mistakes. 8052 if (const PointerType *PT = OpTy->getAs<PointerType>()) 8053 Result = PT->getPointeeType(); 8054 else if (const ObjCObjectPointerType *OPT = 8055 OpTy->getAs<ObjCObjectPointerType>()) 8056 Result = OPT->getPointeeType(); 8057 else { 8058 ExprResult PR = S.CheckPlaceholderExpr(Op); 8059 if (PR.isInvalid()) return QualType(); 8060 if (PR.take() != Op) 8061 return CheckIndirectionOperand(S, PR.take(), VK, OpLoc); 8062 } 8063 8064 if (Result.isNull()) { 8065 S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer) 8066 << OpTy << Op->getSourceRange(); 8067 return QualType(); 8068 } 8069 8070 // Dereferences are usually l-values... 8071 VK = VK_LValue; 8072 8073 // ...except that certain expressions are never l-values in C. 8074 if (!S.getLangOpts().CPlusPlus && Result.isCForbiddenLValueType()) 8075 VK = VK_RValue; 8076 8077 return Result; 8078} 8079 8080static inline BinaryOperatorKind ConvertTokenKindToBinaryOpcode( 8081 tok::TokenKind Kind) { 8082 BinaryOperatorKind Opc; 8083 switch (Kind) { 8084 default: llvm_unreachable("Unknown binop!"); 8085 case tok::periodstar: Opc = BO_PtrMemD; break; 8086 case tok::arrowstar: Opc = BO_PtrMemI; break; 8087 case tok::star: Opc = BO_Mul; break; 8088 case tok::slash: Opc = BO_Div; break; 8089 case tok::percent: Opc = BO_Rem; break; 8090 case tok::plus: Opc = BO_Add; break; 8091 case tok::minus: Opc = BO_Sub; break; 8092 case tok::lessless: Opc = BO_Shl; break; 8093 case tok::greatergreater: Opc = BO_Shr; break; 8094 case tok::lessequal: Opc = BO_LE; break; 8095 case tok::less: Opc = BO_LT; break; 8096 case tok::greaterequal: Opc = BO_GE; break; 8097 case tok::greater: Opc = BO_GT; break; 8098 case tok::exclaimequal: Opc = BO_NE; break; 8099 case tok::equalequal: Opc = BO_EQ; break; 8100 case tok::amp: Opc = BO_And; break; 8101 case tok::caret: Opc = BO_Xor; break; 8102 case tok::pipe: Opc = BO_Or; break; 8103 case tok::ampamp: Opc = BO_LAnd; break; 8104 case tok::pipepipe: Opc = BO_LOr; break; 8105 case tok::equal: Opc = BO_Assign; break; 8106 case tok::starequal: Opc = BO_MulAssign; break; 8107 case tok::slashequal: Opc = BO_DivAssign; break; 8108 case tok::percentequal: Opc = BO_RemAssign; break; 8109 case tok::plusequal: Opc = BO_AddAssign; break; 8110 case tok::minusequal: Opc = BO_SubAssign; break; 8111 case tok::lesslessequal: Opc = BO_ShlAssign; break; 8112 case tok::greatergreaterequal: Opc = BO_ShrAssign; break; 8113 case tok::ampequal: Opc = BO_AndAssign; break; 8114 case tok::caretequal: Opc = BO_XorAssign; break; 8115 case tok::pipeequal: Opc = BO_OrAssign; break; 8116 case tok::comma: Opc = BO_Comma; break; 8117 } 8118 return Opc; 8119} 8120 8121static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode( 8122 tok::TokenKind Kind) { 8123 UnaryOperatorKind Opc; 8124 switch (Kind) { 8125 default: llvm_unreachable("Unknown unary op!"); 8126 case tok::plusplus: Opc = UO_PreInc; break; 8127 case tok::minusminus: Opc = UO_PreDec; break; 8128 case tok::amp: Opc = UO_AddrOf; break; 8129 case tok::star: Opc = UO_Deref; break; 8130 case tok::plus: Opc = UO_Plus; break; 8131 case tok::minus: Opc = UO_Minus; break; 8132 case tok::tilde: Opc = UO_Not; break; 8133 case tok::exclaim: Opc = UO_LNot; break; 8134 case tok::kw___real: Opc = UO_Real; break; 8135 case tok::kw___imag: Opc = UO_Imag; break; 8136 case tok::kw___extension__: Opc = UO_Extension; break; 8137 } 8138 return Opc; 8139} 8140 8141/// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself. 8142/// This warning is only emitted for builtin assignment operations. It is also 8143/// suppressed in the event of macro expansions. 8144static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr, 8145 SourceLocation OpLoc) { 8146 if (!S.ActiveTemplateInstantiations.empty()) 8147 return; 8148 if (OpLoc.isInvalid() || OpLoc.isMacroID()) 8149 return; 8150 LHSExpr = LHSExpr->IgnoreParenImpCasts(); 8151 RHSExpr = RHSExpr->IgnoreParenImpCasts(); 8152 const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr); 8153 const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr); 8154 if (!LHSDeclRef || !RHSDeclRef || 8155 LHSDeclRef->getLocation().isMacroID() || 8156 RHSDeclRef->getLocation().isMacroID()) 8157 return; 8158 const ValueDecl *LHSDecl = 8159 cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl()); 8160 const ValueDecl *RHSDecl = 8161 cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl()); 8162 if (LHSDecl != RHSDecl) 8163 return; 8164 if (LHSDecl->getType().isVolatileQualified()) 8165 return; 8166 if (const ReferenceType *RefTy = LHSDecl->getType()->getAs<ReferenceType>()) 8167 if (RefTy->getPointeeType().isVolatileQualified()) 8168 return; 8169 8170 S.Diag(OpLoc, diag::warn_self_assignment) 8171 << LHSDeclRef->getType() 8172 << LHSExpr->getSourceRange() << RHSExpr->getSourceRange(); 8173} 8174 8175/// CreateBuiltinBinOp - Creates a new built-in binary operation with 8176/// operator @p Opc at location @c TokLoc. This routine only supports 8177/// built-in operations; ActOnBinOp handles overloaded operators. 8178ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc, 8179 BinaryOperatorKind Opc, 8180 Expr *LHSExpr, Expr *RHSExpr) { 8181 if (getLangOpts().CPlusPlus0x && isa<InitListExpr>(RHSExpr)) { 8182 // The syntax only allows initializer lists on the RHS of assignment, 8183 // so we don't need to worry about accepting invalid code for 8184 // non-assignment operators. 8185 // C++11 5.17p9: 8186 // The meaning of x = {v} [...] is that of x = T(v) [...]. The meaning 8187 // of x = {} is x = T(). 8188 InitializationKind Kind = 8189 InitializationKind::CreateDirectList(RHSExpr->getLocStart()); 8190 InitializedEntity Entity = 8191 InitializedEntity::InitializeTemporary(LHSExpr->getType()); 8192 InitializationSequence InitSeq(*this, Entity, Kind, &RHSExpr, 1); 8193 ExprResult Init = InitSeq.Perform(*this, Entity, Kind, 8194 MultiExprArg(&RHSExpr, 1)); 8195 if (Init.isInvalid()) 8196 return Init; 8197 RHSExpr = Init.take(); 8198 } 8199 8200 ExprResult LHS = Owned(LHSExpr), RHS = Owned(RHSExpr); 8201 QualType ResultTy; // Result type of the binary operator. 8202 // The following two variables are used for compound assignment operators 8203 QualType CompLHSTy; // Type of LHS after promotions for computation 8204 QualType CompResultTy; // Type of computation result 8205 ExprValueKind VK = VK_RValue; 8206 ExprObjectKind OK = OK_Ordinary; 8207 8208 switch (Opc) { 8209 case BO_Assign: 8210 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, QualType()); 8211 if (getLangOpts().CPlusPlus && 8212 LHS.get()->getObjectKind() != OK_ObjCProperty) { 8213 VK = LHS.get()->getValueKind(); 8214 OK = LHS.get()->getObjectKind(); 8215 } 8216 if (!ResultTy.isNull()) 8217 DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc); 8218 break; 8219 case BO_PtrMemD: 8220 case BO_PtrMemI: 8221 ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc, 8222 Opc == BO_PtrMemI); 8223 break; 8224 case BO_Mul: 8225 case BO_Div: 8226 ResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, false, 8227 Opc == BO_Div); 8228 break; 8229 case BO_Rem: 8230 ResultTy = CheckRemainderOperands(LHS, RHS, OpLoc); 8231 break; 8232 case BO_Add: 8233 ResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc); 8234 break; 8235 case BO_Sub: 8236 ResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc); 8237 break; 8238 case BO_Shl: 8239 case BO_Shr: 8240 ResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc); 8241 break; 8242 case BO_LE: 8243 case BO_LT: 8244 case BO_GE: 8245 case BO_GT: 8246 ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, true); 8247 break; 8248 case BO_EQ: 8249 case BO_NE: 8250 ResultTy = CheckCompareOperands(LHS, RHS, OpLoc, Opc, false); 8251 break; 8252 case BO_And: 8253 case BO_Xor: 8254 case BO_Or: 8255 ResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc); 8256 break; 8257 case BO_LAnd: 8258 case BO_LOr: 8259 ResultTy = CheckLogicalOperands(LHS, RHS, OpLoc, Opc); 8260 break; 8261 case BO_MulAssign: 8262 case BO_DivAssign: 8263 CompResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, true, 8264 Opc == BO_DivAssign); 8265 CompLHSTy = CompResultTy; 8266 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 8267 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 8268 break; 8269 case BO_RemAssign: 8270 CompResultTy = CheckRemainderOperands(LHS, RHS, OpLoc, true); 8271 CompLHSTy = CompResultTy; 8272 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 8273 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 8274 break; 8275 case BO_AddAssign: 8276 CompResultTy = CheckAdditionOperands(LHS, RHS, OpLoc, Opc, &CompLHSTy); 8277 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 8278 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 8279 break; 8280 case BO_SubAssign: 8281 CompResultTy = CheckSubtractionOperands(LHS, RHS, OpLoc, &CompLHSTy); 8282 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 8283 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 8284 break; 8285 case BO_ShlAssign: 8286 case BO_ShrAssign: 8287 CompResultTy = CheckShiftOperands(LHS, RHS, OpLoc, Opc, true); 8288 CompLHSTy = CompResultTy; 8289 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 8290 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 8291 break; 8292 case BO_AndAssign: 8293 case BO_XorAssign: 8294 case BO_OrAssign: 8295 CompResultTy = CheckBitwiseOperands(LHS, RHS, OpLoc, true); 8296 CompLHSTy = CompResultTy; 8297 if (!CompResultTy.isNull() && !LHS.isInvalid() && !RHS.isInvalid()) 8298 ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, CompResultTy); 8299 break; 8300 case BO_Comma: 8301 ResultTy = CheckCommaOperands(*this, LHS, RHS, OpLoc); 8302 if (getLangOpts().CPlusPlus && !RHS.isInvalid()) { 8303 VK = RHS.get()->getValueKind(); 8304 OK = RHS.get()->getObjectKind(); 8305 } 8306 break; 8307 } 8308 if (ResultTy.isNull() || LHS.isInvalid() || RHS.isInvalid()) 8309 return ExprError(); 8310 8311 // Check for array bounds violations for both sides of the BinaryOperator 8312 CheckArrayAccess(LHS.get()); 8313 CheckArrayAccess(RHS.get()); 8314 8315 if (CompResultTy.isNull()) 8316 return Owned(new (Context) BinaryOperator(LHS.take(), RHS.take(), Opc, 8317 ResultTy, VK, OK, OpLoc)); 8318 if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() != 8319 OK_ObjCProperty) { 8320 VK = VK_LValue; 8321 OK = LHS.get()->getObjectKind(); 8322 } 8323 return Owned(new (Context) CompoundAssignOperator(LHS.take(), RHS.take(), Opc, 8324 ResultTy, VK, OK, CompLHSTy, 8325 CompResultTy, OpLoc)); 8326} 8327 8328/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison 8329/// operators are mixed in a way that suggests that the programmer forgot that 8330/// comparison operators have higher precedence. The most typical example of 8331/// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1". 8332static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc, 8333 SourceLocation OpLoc, Expr *LHSExpr, 8334 Expr *RHSExpr) { 8335 typedef BinaryOperator BinOp; 8336 BinOp::Opcode LHSopc = static_cast<BinOp::Opcode>(-1), 8337 RHSopc = static_cast<BinOp::Opcode>(-1); 8338 if (BinOp *BO = dyn_cast<BinOp>(LHSExpr)) 8339 LHSopc = BO->getOpcode(); 8340 if (BinOp *BO = dyn_cast<BinOp>(RHSExpr)) 8341 RHSopc = BO->getOpcode(); 8342 8343 // Subs are not binary operators. 8344 if (LHSopc == -1 && RHSopc == -1) 8345 return; 8346 8347 // Bitwise operations are sometimes used as eager logical ops. 8348 // Don't diagnose this. 8349 if ((BinOp::isComparisonOp(LHSopc) || BinOp::isBitwiseOp(LHSopc)) && 8350 (BinOp::isComparisonOp(RHSopc) || BinOp::isBitwiseOp(RHSopc))) 8351 return; 8352 8353 bool isLeftComp = BinOp::isComparisonOp(LHSopc); 8354 bool isRightComp = BinOp::isComparisonOp(RHSopc); 8355 if (!isLeftComp && !isRightComp) return; 8356 8357 SourceRange DiagRange = isLeftComp ? SourceRange(LHSExpr->getLocStart(), 8358 OpLoc) 8359 : SourceRange(OpLoc, RHSExpr->getLocEnd()); 8360 std::string OpStr = isLeftComp ? BinOp::getOpcodeStr(LHSopc) 8361 : BinOp::getOpcodeStr(RHSopc); 8362 SourceRange ParensRange = isLeftComp ? 8363 SourceRange(cast<BinOp>(LHSExpr)->getRHS()->getLocStart(), 8364 RHSExpr->getLocEnd()) 8365 : SourceRange(LHSExpr->getLocStart(), 8366 cast<BinOp>(RHSExpr)->getLHS()->getLocStart()); 8367 8368 Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel) 8369 << DiagRange << BinOp::getOpcodeStr(Opc) << OpStr; 8370 SuggestParentheses(Self, OpLoc, 8371 Self.PDiag(diag::note_precedence_bitwise_silence) << OpStr, 8372 (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange()); 8373 SuggestParentheses(Self, OpLoc, 8374 Self.PDiag(diag::note_precedence_bitwise_first) << BinOp::getOpcodeStr(Opc), 8375 ParensRange); 8376} 8377 8378/// \brief It accepts a '&' expr that is inside a '|' one. 8379/// Emit a diagnostic together with a fixit hint that wraps the '&' expression 8380/// in parentheses. 8381static void 8382EmitDiagnosticForBitwiseAndInBitwiseOr(Sema &Self, SourceLocation OpLoc, 8383 BinaryOperator *Bop) { 8384 assert(Bop->getOpcode() == BO_And); 8385 Self.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_and_in_bitwise_or) 8386 << Bop->getSourceRange() << OpLoc; 8387 SuggestParentheses(Self, Bop->getOperatorLoc(), 8388 Self.PDiag(diag::note_bitwise_and_in_bitwise_or_silence), 8389 Bop->getSourceRange()); 8390} 8391 8392/// \brief It accepts a '&&' expr that is inside a '||' one. 8393/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression 8394/// in parentheses. 8395static void 8396EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc, 8397 BinaryOperator *Bop) { 8398 assert(Bop->getOpcode() == BO_LAnd); 8399 Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or) 8400 << Bop->getSourceRange() << OpLoc; 8401 SuggestParentheses(Self, Bop->getOperatorLoc(), 8402 Self.PDiag(diag::note_logical_and_in_logical_or_silence), 8403 Bop->getSourceRange()); 8404} 8405 8406/// \brief Returns true if the given expression can be evaluated as a constant 8407/// 'true'. 8408static bool EvaluatesAsTrue(Sema &S, Expr *E) { 8409 bool Res; 8410 return E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res; 8411} 8412 8413/// \brief Returns true if the given expression can be evaluated as a constant 8414/// 'false'. 8415static bool EvaluatesAsFalse(Sema &S, Expr *E) { 8416 bool Res; 8417 return E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res; 8418} 8419 8420/// \brief Look for '&&' in the left hand of a '||' expr. 8421static void DiagnoseLogicalAndInLogicalOrLHS(Sema &S, SourceLocation OpLoc, 8422 Expr *LHSExpr, Expr *RHSExpr) { 8423 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(LHSExpr)) { 8424 if (Bop->getOpcode() == BO_LAnd) { 8425 // If it's "a && b || 0" don't warn since the precedence doesn't matter. 8426 if (EvaluatesAsFalse(S, RHSExpr)) 8427 return; 8428 // If it's "1 && a || b" don't warn since the precedence doesn't matter. 8429 if (!EvaluatesAsTrue(S, Bop->getLHS())) 8430 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 8431 } else if (Bop->getOpcode() == BO_LOr) { 8432 if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) { 8433 // If it's "a || b && 1 || c" we didn't warn earlier for 8434 // "a || b && 1", but warn now. 8435 if (RBop->getOpcode() == BO_LAnd && EvaluatesAsTrue(S, RBop->getRHS())) 8436 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop); 8437 } 8438 } 8439 } 8440} 8441 8442/// \brief Look for '&&' in the right hand of a '||' expr. 8443static void DiagnoseLogicalAndInLogicalOrRHS(Sema &S, SourceLocation OpLoc, 8444 Expr *LHSExpr, Expr *RHSExpr) { 8445 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(RHSExpr)) { 8446 if (Bop->getOpcode() == BO_LAnd) { 8447 // If it's "0 || a && b" don't warn since the precedence doesn't matter. 8448 if (EvaluatesAsFalse(S, LHSExpr)) 8449 return; 8450 // If it's "a || b && 1" don't warn since the precedence doesn't matter. 8451 if (!EvaluatesAsTrue(S, Bop->getRHS())) 8452 return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop); 8453 } 8454 } 8455} 8456 8457/// \brief Look for '&' in the left or right hand of a '|' expr. 8458static void DiagnoseBitwiseAndInBitwiseOr(Sema &S, SourceLocation OpLoc, 8459 Expr *OrArg) { 8460 if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(OrArg)) { 8461 if (Bop->getOpcode() == BO_And) 8462 return EmitDiagnosticForBitwiseAndInBitwiseOr(S, OpLoc, Bop); 8463 } 8464} 8465 8466/// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky 8467/// precedence. 8468static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc, 8469 SourceLocation OpLoc, Expr *LHSExpr, 8470 Expr *RHSExpr){ 8471 // Diagnose "arg1 'bitwise' arg2 'eq' arg3". 8472 if (BinaryOperator::isBitwiseOp(Opc)) 8473 DiagnoseBitwisePrecedence(Self, Opc, OpLoc, LHSExpr, RHSExpr); 8474 8475 // Diagnose "arg1 & arg2 | arg3" 8476 if (Opc == BO_Or && !OpLoc.isMacroID()/* Don't warn in macros. */) { 8477 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, LHSExpr); 8478 DiagnoseBitwiseAndInBitwiseOr(Self, OpLoc, RHSExpr); 8479 } 8480 8481 // Warn about arg1 || arg2 && arg3, as GCC 4.3+ does. 8482 // We don't warn for 'assert(a || b && "bad")' since this is safe. 8483 if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) { 8484 DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, LHSExpr, RHSExpr); 8485 DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, LHSExpr, RHSExpr); 8486 } 8487} 8488 8489// Binary Operators. 'Tok' is the token for the operator. 8490ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc, 8491 tok::TokenKind Kind, 8492 Expr *LHSExpr, Expr *RHSExpr) { 8493 BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind); 8494 assert((LHSExpr != 0) && "ActOnBinOp(): missing left expression"); 8495 assert((RHSExpr != 0) && "ActOnBinOp(): missing right expression"); 8496 8497 // Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0" 8498 DiagnoseBinOpPrecedence(*this, Opc, TokLoc, LHSExpr, RHSExpr); 8499 8500 return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr); 8501} 8502 8503/// Build an overloaded binary operator expression in the given scope. 8504static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc, 8505 BinaryOperatorKind Opc, 8506 Expr *LHS, Expr *RHS) { 8507 // Find all of the overloaded operators visible from this 8508 // point. We perform both an operator-name lookup from the local 8509 // scope and an argument-dependent lookup based on the types of 8510 // the arguments. 8511 UnresolvedSet<16> Functions; 8512 OverloadedOperatorKind OverOp 8513 = BinaryOperator::getOverloadedOperator(Opc); 8514 if (Sc && OverOp != OO_None) 8515 S.LookupOverloadedOperatorName(OverOp, Sc, LHS->getType(), 8516 RHS->getType(), Functions); 8517 8518 // Build the (potentially-overloaded, potentially-dependent) 8519 // binary operation. 8520 return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS); 8521} 8522 8523ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc, 8524 BinaryOperatorKind Opc, 8525 Expr *LHSExpr, Expr *RHSExpr) { 8526 // We want to end up calling one of checkPseudoObjectAssignment 8527 // (if the LHS is a pseudo-object), BuildOverloadedBinOp (if 8528 // both expressions are overloadable or either is type-dependent), 8529 // or CreateBuiltinBinOp (in any other case). We also want to get 8530 // any placeholder types out of the way. 8531 8532 // Handle pseudo-objects in the LHS. 8533 if (const BuiltinType *pty = LHSExpr->getType()->getAsPlaceholderType()) { 8534 // Assignments with a pseudo-object l-value need special analysis. 8535 if (pty->getKind() == BuiltinType::PseudoObject && 8536 BinaryOperator::isAssignmentOp(Opc)) 8537 return checkPseudoObjectAssignment(S, OpLoc, Opc, LHSExpr, RHSExpr); 8538 8539 // Don't resolve overloads if the other type is overloadable. 8540 if (pty->getKind() == BuiltinType::Overload) { 8541 // We can't actually test that if we still have a placeholder, 8542 // though. Fortunately, none of the exceptions we see in that 8543 // code below are valid when the LHS is an overload set. Note 8544 // that an overload set can be dependently-typed, but it never 8545 // instantiates to having an overloadable type. 8546 ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr); 8547 if (resolvedRHS.isInvalid()) return ExprError(); 8548 RHSExpr = resolvedRHS.take(); 8549 8550 if (RHSExpr->isTypeDependent() || 8551 RHSExpr->getType()->isOverloadableType()) 8552 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8553 } 8554 8555 ExprResult LHS = CheckPlaceholderExpr(LHSExpr); 8556 if (LHS.isInvalid()) return ExprError(); 8557 LHSExpr = LHS.take(); 8558 } 8559 8560 // Handle pseudo-objects in the RHS. 8561 if (const BuiltinType *pty = RHSExpr->getType()->getAsPlaceholderType()) { 8562 // An overload in the RHS can potentially be resolved by the type 8563 // being assigned to. 8564 if (Opc == BO_Assign && pty->getKind() == BuiltinType::Overload) { 8565 if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent()) 8566 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8567 8568 if (LHSExpr->getType()->isOverloadableType()) 8569 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8570 8571 return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr); 8572 } 8573 8574 // Don't resolve overloads if the other type is overloadable. 8575 if (pty->getKind() == BuiltinType::Overload && 8576 LHSExpr->getType()->isOverloadableType()) 8577 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8578 8579 ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr); 8580 if (!resolvedRHS.isUsable()) return ExprError(); 8581 RHSExpr = resolvedRHS.take(); 8582 } 8583 8584 if (getLangOpts().CPlusPlus) { 8585 // If either expression is type-dependent, always build an 8586 // overloaded op. 8587 if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent()) 8588 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8589 8590 // Otherwise, build an overloaded op if either expression has an 8591 // overloadable type. 8592 if (LHSExpr->getType()->isOverloadableType() || 8593 RHSExpr->getType()->isOverloadableType()) 8594 return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr); 8595 } 8596 8597 // Build a built-in binary operation. 8598 return CreateBuiltinBinOp(OpLoc, Opc, LHSExpr, RHSExpr); 8599} 8600 8601ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc, 8602 UnaryOperatorKind Opc, 8603 Expr *InputExpr) { 8604 ExprResult Input = Owned(InputExpr); 8605 ExprValueKind VK = VK_RValue; 8606 ExprObjectKind OK = OK_Ordinary; 8607 QualType resultType; 8608 switch (Opc) { 8609 case UO_PreInc: 8610 case UO_PreDec: 8611 case UO_PostInc: 8612 case UO_PostDec: 8613 resultType = CheckIncrementDecrementOperand(*this, Input.get(), VK, OpLoc, 8614 Opc == UO_PreInc || 8615 Opc == UO_PostInc, 8616 Opc == UO_PreInc || 8617 Opc == UO_PreDec); 8618 break; 8619 case UO_AddrOf: 8620 resultType = CheckAddressOfOperand(*this, Input, OpLoc); 8621 break; 8622 case UO_Deref: { 8623 Input = DefaultFunctionArrayLvalueConversion(Input.take()); 8624 resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc); 8625 break; 8626 } 8627 case UO_Plus: 8628 case UO_Minus: 8629 Input = UsualUnaryConversions(Input.take()); 8630 if (Input.isInvalid()) return ExprError(); 8631 resultType = Input.get()->getType(); 8632 if (resultType->isDependentType()) 8633 break; 8634 if (resultType->isArithmeticType() || // C99 6.5.3.3p1 8635 resultType->isVectorType()) 8636 break; 8637 else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6-7 8638 resultType->isEnumeralType()) 8639 break; 8640 else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6 8641 Opc == UO_Plus && 8642 resultType->isPointerType()) 8643 break; 8644 8645 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 8646 << resultType << Input.get()->getSourceRange()); 8647 8648 case UO_Not: // bitwise complement 8649 Input = UsualUnaryConversions(Input.take()); 8650 if (Input.isInvalid()) return ExprError(); 8651 resultType = Input.get()->getType(); 8652 if (resultType->isDependentType()) 8653 break; 8654 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension. 8655 if (resultType->isComplexType() || resultType->isComplexIntegerType()) 8656 // C99 does not support '~' for complex conjugation. 8657 Diag(OpLoc, diag::ext_integer_complement_complex) 8658 << resultType << Input.get()->getSourceRange(); 8659 else if (resultType->hasIntegerRepresentation()) 8660 break; 8661 else { 8662 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 8663 << resultType << Input.get()->getSourceRange()); 8664 } 8665 break; 8666 8667 case UO_LNot: // logical negation 8668 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5). 8669 Input = DefaultFunctionArrayLvalueConversion(Input.take()); 8670 if (Input.isInvalid()) return ExprError(); 8671 resultType = Input.get()->getType(); 8672 8673 // Though we still have to promote half FP to float... 8674 if (resultType->isHalfType()) { 8675 Input = ImpCastExprToType(Input.take(), Context.FloatTy, CK_FloatingCast).take(); 8676 resultType = Context.FloatTy; 8677 } 8678 8679 if (resultType->isDependentType()) 8680 break; 8681 if (resultType->isScalarType()) { 8682 // C99 6.5.3.3p1: ok, fallthrough; 8683 if (Context.getLangOpts().CPlusPlus) { 8684 // C++03 [expr.unary.op]p8, C++0x [expr.unary.op]p9: 8685 // operand contextually converted to bool. 8686 Input = ImpCastExprToType(Input.take(), Context.BoolTy, 8687 ScalarTypeToBooleanCastKind(resultType)); 8688 } 8689 } else if (resultType->isExtVectorType()) { 8690 // Vector logical not returns the signed variant of the operand type. 8691 resultType = GetSignedVectorType(resultType); 8692 break; 8693 } else { 8694 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 8695 << resultType << Input.get()->getSourceRange()); 8696 } 8697 8698 // LNot always has type int. C99 6.5.3.3p5. 8699 // In C++, it's bool. C++ 5.3.1p8 8700 resultType = Context.getLogicalOperationType(); 8701 break; 8702 case UO_Real: 8703 case UO_Imag: 8704 resultType = CheckRealImagOperand(*this, Input, OpLoc, Opc == UO_Real); 8705 // _Real maps ordinary l-values into ordinary l-values. _Imag maps ordinary 8706 // complex l-values to ordinary l-values and all other values to r-values. 8707 if (Input.isInvalid()) return ExprError(); 8708 if (Opc == UO_Real || Input.get()->getType()->isAnyComplexType()) { 8709 if (Input.get()->getValueKind() != VK_RValue && 8710 Input.get()->getObjectKind() == OK_Ordinary) 8711 VK = Input.get()->getValueKind(); 8712 } else if (!getLangOpts().CPlusPlus) { 8713 // In C, a volatile scalar is read by __imag. In C++, it is not. 8714 Input = DefaultLvalueConversion(Input.take()); 8715 } 8716 break; 8717 case UO_Extension: 8718 resultType = Input.get()->getType(); 8719 VK = Input.get()->getValueKind(); 8720 OK = Input.get()->getObjectKind(); 8721 break; 8722 } 8723 if (resultType.isNull() || Input.isInvalid()) 8724 return ExprError(); 8725 8726 // Check for array bounds violations in the operand of the UnaryOperator, 8727 // except for the '*' and '&' operators that have to be handled specially 8728 // by CheckArrayAccess (as there are special cases like &array[arraysize] 8729 // that are explicitly defined as valid by the standard). 8730 if (Opc != UO_AddrOf && Opc != UO_Deref) 8731 CheckArrayAccess(Input.get()); 8732 8733 return Owned(new (Context) UnaryOperator(Input.take(), Opc, resultType, 8734 VK, OK, OpLoc)); 8735} 8736 8737/// \brief Determine whether the given expression is a qualified member 8738/// access expression, of a form that could be turned into a pointer to member 8739/// with the address-of operator. 8740static bool isQualifiedMemberAccess(Expr *E) { 8741 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 8742 if (!DRE->getQualifier()) 8743 return false; 8744 8745 ValueDecl *VD = DRE->getDecl(); 8746 if (!VD->isCXXClassMember()) 8747 return false; 8748 8749 if (isa<FieldDecl>(VD) || isa<IndirectFieldDecl>(VD)) 8750 return true; 8751 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(VD)) 8752 return Method->isInstance(); 8753 8754 return false; 8755 } 8756 8757 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) { 8758 if (!ULE->getQualifier()) 8759 return false; 8760 8761 for (UnresolvedLookupExpr::decls_iterator D = ULE->decls_begin(), 8762 DEnd = ULE->decls_end(); 8763 D != DEnd; ++D) { 8764 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(*D)) { 8765 if (Method->isInstance()) 8766 return true; 8767 } else { 8768 // Overload set does not contain methods. 8769 break; 8770 } 8771 } 8772 8773 return false; 8774 } 8775 8776 return false; 8777} 8778 8779ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc, 8780 UnaryOperatorKind Opc, Expr *Input) { 8781 // First things first: handle placeholders so that the 8782 // overloaded-operator check considers the right type. 8783 if (const BuiltinType *pty = Input->getType()->getAsPlaceholderType()) { 8784 // Increment and decrement of pseudo-object references. 8785 if (pty->getKind() == BuiltinType::PseudoObject && 8786 UnaryOperator::isIncrementDecrementOp(Opc)) 8787 return checkPseudoObjectIncDec(S, OpLoc, Opc, Input); 8788 8789 // extension is always a builtin operator. 8790 if (Opc == UO_Extension) 8791 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 8792 8793 // & gets special logic for several kinds of placeholder. 8794 // The builtin code knows what to do. 8795 if (Opc == UO_AddrOf && 8796 (pty->getKind() == BuiltinType::Overload || 8797 pty->getKind() == BuiltinType::UnknownAny || 8798 pty->getKind() == BuiltinType::BoundMember)) 8799 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 8800 8801 // Anything else needs to be handled now. 8802 ExprResult Result = CheckPlaceholderExpr(Input); 8803 if (Result.isInvalid()) return ExprError(); 8804 Input = Result.take(); 8805 } 8806 8807 if (getLangOpts().CPlusPlus && Input->getType()->isOverloadableType() && 8808 UnaryOperator::getOverloadedOperator(Opc) != OO_None && 8809 !(Opc == UO_AddrOf && isQualifiedMemberAccess(Input))) { 8810 // Find all of the overloaded operators visible from this 8811 // point. We perform both an operator-name lookup from the local 8812 // scope and an argument-dependent lookup based on the types of 8813 // the arguments. 8814 UnresolvedSet<16> Functions; 8815 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc); 8816 if (S && OverOp != OO_None) 8817 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(), 8818 Functions); 8819 8820 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input); 8821 } 8822 8823 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 8824} 8825 8826// Unary Operators. 'Tok' is the token for the operator. 8827ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc, 8828 tok::TokenKind Op, Expr *Input) { 8829 return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input); 8830} 8831 8832/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo". 8833ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc, 8834 LabelDecl *TheDecl) { 8835 TheDecl->setUsed(); 8836 // Create the AST node. The address of a label always has type 'void*'. 8837 return Owned(new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl, 8838 Context.getPointerType(Context.VoidTy))); 8839} 8840 8841/// Given the last statement in a statement-expression, check whether 8842/// the result is a producing expression (like a call to an 8843/// ns_returns_retained function) and, if so, rebuild it to hoist the 8844/// release out of the full-expression. Otherwise, return null. 8845/// Cannot fail. 8846static Expr *maybeRebuildARCConsumingStmt(Stmt *Statement) { 8847 // Should always be wrapped with one of these. 8848 ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(Statement); 8849 if (!cleanups) return 0; 8850 8851 ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(cleanups->getSubExpr()); 8852 if (!cast || cast->getCastKind() != CK_ARCConsumeObject) 8853 return 0; 8854 8855 // Splice out the cast. This shouldn't modify any interesting 8856 // features of the statement. 8857 Expr *producer = cast->getSubExpr(); 8858 assert(producer->getType() == cast->getType()); 8859 assert(producer->getValueKind() == cast->getValueKind()); 8860 cleanups->setSubExpr(producer); 8861 return cleanups; 8862} 8863 8864void Sema::ActOnStartStmtExpr() { 8865 PushExpressionEvaluationContext(ExprEvalContexts.back().Context); 8866} 8867 8868void Sema::ActOnStmtExprError() { 8869 // Note that function is also called by TreeTransform when leaving a 8870 // StmtExpr scope without rebuilding anything. 8871 8872 DiscardCleanupsInEvaluationContext(); 8873 PopExpressionEvaluationContext(); 8874} 8875 8876ExprResult 8877Sema::ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt, 8878 SourceLocation RPLoc) { // "({..})" 8879 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!"); 8880 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt); 8881 8882 if (hasAnyUnrecoverableErrorsInThisFunction()) 8883 DiscardCleanupsInEvaluationContext(); 8884 assert(!ExprNeedsCleanups && "cleanups within StmtExpr not correctly bound!"); 8885 PopExpressionEvaluationContext(); 8886 8887 bool isFileScope 8888 = (getCurFunctionOrMethodDecl() == 0) && (getCurBlock() == 0); 8889 if (isFileScope) 8890 return ExprError(Diag(LPLoc, diag::err_stmtexpr_file_scope)); 8891 8892 // FIXME: there are a variety of strange constraints to enforce here, for 8893 // example, it is not possible to goto into a stmt expression apparently. 8894 // More semantic analysis is needed. 8895 8896 // If there are sub stmts in the compound stmt, take the type of the last one 8897 // as the type of the stmtexpr. 8898 QualType Ty = Context.VoidTy; 8899 bool StmtExprMayBindToTemp = false; 8900 if (!Compound->body_empty()) { 8901 Stmt *LastStmt = Compound->body_back(); 8902 LabelStmt *LastLabelStmt = 0; 8903 // If LastStmt is a label, skip down through into the body. 8904 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt)) { 8905 LastLabelStmt = Label; 8906 LastStmt = Label->getSubStmt(); 8907 } 8908 8909 if (Expr *LastE = dyn_cast<Expr>(LastStmt)) { 8910 // Do function/array conversion on the last expression, but not 8911 // lvalue-to-rvalue. However, initialize an unqualified type. 8912 ExprResult LastExpr = DefaultFunctionArrayConversion(LastE); 8913 if (LastExpr.isInvalid()) 8914 return ExprError(); 8915 Ty = LastExpr.get()->getType().getUnqualifiedType(); 8916 8917 if (!Ty->isDependentType() && !LastExpr.get()->isTypeDependent()) { 8918 // In ARC, if the final expression ends in a consume, splice 8919 // the consume out and bind it later. In the alternate case 8920 // (when dealing with a retainable type), the result 8921 // initialization will create a produce. In both cases the 8922 // result will be +1, and we'll need to balance that out with 8923 // a bind. 8924 if (Expr *rebuiltLastStmt 8925 = maybeRebuildARCConsumingStmt(LastExpr.get())) { 8926 LastExpr = rebuiltLastStmt; 8927 } else { 8928 LastExpr = PerformCopyInitialization( 8929 InitializedEntity::InitializeResult(LPLoc, 8930 Ty, 8931 false), 8932 SourceLocation(), 8933 LastExpr); 8934 } 8935 8936 if (LastExpr.isInvalid()) 8937 return ExprError(); 8938 if (LastExpr.get() != 0) { 8939 if (!LastLabelStmt) 8940 Compound->setLastStmt(LastExpr.take()); 8941 else 8942 LastLabelStmt->setSubStmt(LastExpr.take()); 8943 StmtExprMayBindToTemp = true; 8944 } 8945 } 8946 } 8947 } 8948 8949 // FIXME: Check that expression type is complete/non-abstract; statement 8950 // expressions are not lvalues. 8951 Expr *ResStmtExpr = new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc); 8952 if (StmtExprMayBindToTemp) 8953 return MaybeBindToTemporary(ResStmtExpr); 8954 return Owned(ResStmtExpr); 8955} 8956 8957ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, 8958 TypeSourceInfo *TInfo, 8959 OffsetOfComponent *CompPtr, 8960 unsigned NumComponents, 8961 SourceLocation RParenLoc) { 8962 QualType ArgTy = TInfo->getType(); 8963 bool Dependent = ArgTy->isDependentType(); 8964 SourceRange TypeRange = TInfo->getTypeLoc().getLocalSourceRange(); 8965 8966 // We must have at least one component that refers to the type, and the first 8967 // one is known to be a field designator. Verify that the ArgTy represents 8968 // a struct/union/class. 8969 if (!Dependent && !ArgTy->isRecordType()) 8970 return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type) 8971 << ArgTy << TypeRange); 8972 8973 // Type must be complete per C99 7.17p3 because a declaring a variable 8974 // with an incomplete type would be ill-formed. 8975 if (!Dependent 8976 && RequireCompleteType(BuiltinLoc, ArgTy, 8977 diag::err_offsetof_incomplete_type, TypeRange)) 8978 return ExprError(); 8979 8980 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a 8981 // GCC extension, diagnose them. 8982 // FIXME: This diagnostic isn't actually visible because the location is in 8983 // a system header! 8984 if (NumComponents != 1) 8985 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator) 8986 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd); 8987 8988 bool DidWarnAboutNonPOD = false; 8989 QualType CurrentType = ArgTy; 8990 typedef OffsetOfExpr::OffsetOfNode OffsetOfNode; 8991 SmallVector<OffsetOfNode, 4> Comps; 8992 SmallVector<Expr*, 4> Exprs; 8993 for (unsigned i = 0; i != NumComponents; ++i) { 8994 const OffsetOfComponent &OC = CompPtr[i]; 8995 if (OC.isBrackets) { 8996 // Offset of an array sub-field. TODO: Should we allow vector elements? 8997 if (!CurrentType->isDependentType()) { 8998 const ArrayType *AT = Context.getAsArrayType(CurrentType); 8999 if(!AT) 9000 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type) 9001 << CurrentType); 9002 CurrentType = AT->getElementType(); 9003 } else 9004 CurrentType = Context.DependentTy; 9005 9006 ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr*>(OC.U.E)); 9007 if (IdxRval.isInvalid()) 9008 return ExprError(); 9009 Expr *Idx = IdxRval.take(); 9010 9011 // The expression must be an integral expression. 9012 // FIXME: An integral constant expression? 9013 if (!Idx->isTypeDependent() && !Idx->isValueDependent() && 9014 !Idx->getType()->isIntegerType()) 9015 return ExprError(Diag(Idx->getLocStart(), 9016 diag::err_typecheck_subscript_not_integer) 9017 << Idx->getSourceRange()); 9018 9019 // Record this array index. 9020 Comps.push_back(OffsetOfNode(OC.LocStart, Exprs.size(), OC.LocEnd)); 9021 Exprs.push_back(Idx); 9022 continue; 9023 } 9024 9025 // Offset of a field. 9026 if (CurrentType->isDependentType()) { 9027 // We have the offset of a field, but we can't look into the dependent 9028 // type. Just record the identifier of the field. 9029 Comps.push_back(OffsetOfNode(OC.LocStart, OC.U.IdentInfo, OC.LocEnd)); 9030 CurrentType = Context.DependentTy; 9031 continue; 9032 } 9033 9034 // We need to have a complete type to look into. 9035 if (RequireCompleteType(OC.LocStart, CurrentType, 9036 diag::err_offsetof_incomplete_type)) 9037 return ExprError(); 9038 9039 // Look for the designated field. 9040 const RecordType *RC = CurrentType->getAs<RecordType>(); 9041 if (!RC) 9042 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type) 9043 << CurrentType); 9044 RecordDecl *RD = RC->getDecl(); 9045 9046 // C++ [lib.support.types]p5: 9047 // The macro offsetof accepts a restricted set of type arguments in this 9048 // International Standard. type shall be a POD structure or a POD union 9049 // (clause 9). 9050 // C++11 [support.types]p4: 9051 // If type is not a standard-layout class (Clause 9), the results are 9052 // undefined. 9053 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) { 9054 bool IsSafe = LangOpts.CPlusPlus0x? CRD->isStandardLayout() : CRD->isPOD(); 9055 unsigned DiagID = 9056 LangOpts.CPlusPlus0x? diag::warn_offsetof_non_standardlayout_type 9057 : diag::warn_offsetof_non_pod_type; 9058 9059 if (!IsSafe && !DidWarnAboutNonPOD && 9060 DiagRuntimeBehavior(BuiltinLoc, 0, 9061 PDiag(DiagID) 9062 << SourceRange(CompPtr[0].LocStart, OC.LocEnd) 9063 << CurrentType)) 9064 DidWarnAboutNonPOD = true; 9065 } 9066 9067 // Look for the field. 9068 LookupResult R(*this, OC.U.IdentInfo, OC.LocStart, LookupMemberName); 9069 LookupQualifiedName(R, RD); 9070 FieldDecl *MemberDecl = R.getAsSingle<FieldDecl>(); 9071 IndirectFieldDecl *IndirectMemberDecl = 0; 9072 if (!MemberDecl) { 9073 if ((IndirectMemberDecl = R.getAsSingle<IndirectFieldDecl>())) 9074 MemberDecl = IndirectMemberDecl->getAnonField(); 9075 } 9076 9077 if (!MemberDecl) 9078 return ExprError(Diag(BuiltinLoc, diag::err_no_member) 9079 << OC.U.IdentInfo << RD << SourceRange(OC.LocStart, 9080 OC.LocEnd)); 9081 9082 // C99 7.17p3: 9083 // (If the specified member is a bit-field, the behavior is undefined.) 9084 // 9085 // We diagnose this as an error. 9086 if (MemberDecl->isBitField()) { 9087 Diag(OC.LocEnd, diag::err_offsetof_bitfield) 9088 << MemberDecl->getDeclName() 9089 << SourceRange(BuiltinLoc, RParenLoc); 9090 Diag(MemberDecl->getLocation(), diag::note_bitfield_decl); 9091 return ExprError(); 9092 } 9093 9094 RecordDecl *Parent = MemberDecl->getParent(); 9095 if (IndirectMemberDecl) 9096 Parent = cast<RecordDecl>(IndirectMemberDecl->getDeclContext()); 9097 9098 // If the member was found in a base class, introduce OffsetOfNodes for 9099 // the base class indirections. 9100 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 9101 /*DetectVirtual=*/false); 9102 if (IsDerivedFrom(CurrentType, Context.getTypeDeclType(Parent), Paths)) { 9103 CXXBasePath &Path = Paths.front(); 9104 for (CXXBasePath::iterator B = Path.begin(), BEnd = Path.end(); 9105 B != BEnd; ++B) 9106 Comps.push_back(OffsetOfNode(B->Base)); 9107 } 9108 9109 if (IndirectMemberDecl) { 9110 for (IndirectFieldDecl::chain_iterator FI = 9111 IndirectMemberDecl->chain_begin(), 9112 FEnd = IndirectMemberDecl->chain_end(); FI != FEnd; FI++) { 9113 assert(isa<FieldDecl>(*FI)); 9114 Comps.push_back(OffsetOfNode(OC.LocStart, 9115 cast<FieldDecl>(*FI), OC.LocEnd)); 9116 } 9117 } else 9118 Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd)); 9119 9120 CurrentType = MemberDecl->getType().getNonReferenceType(); 9121 } 9122 9123 return Owned(OffsetOfExpr::Create(Context, Context.getSizeType(), BuiltinLoc, 9124 TInfo, Comps.data(), Comps.size(), 9125 Exprs.data(), Exprs.size(), RParenLoc)); 9126} 9127 9128ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S, 9129 SourceLocation BuiltinLoc, 9130 SourceLocation TypeLoc, 9131 ParsedType ParsedArgTy, 9132 OffsetOfComponent *CompPtr, 9133 unsigned NumComponents, 9134 SourceLocation RParenLoc) { 9135 9136 TypeSourceInfo *ArgTInfo; 9137 QualType ArgTy = GetTypeFromParser(ParsedArgTy, &ArgTInfo); 9138 if (ArgTy.isNull()) 9139 return ExprError(); 9140 9141 if (!ArgTInfo) 9142 ArgTInfo = Context.getTrivialTypeSourceInfo(ArgTy, TypeLoc); 9143 9144 return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, CompPtr, NumComponents, 9145 RParenLoc); 9146} 9147 9148 9149ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, 9150 Expr *CondExpr, 9151 Expr *LHSExpr, Expr *RHSExpr, 9152 SourceLocation RPLoc) { 9153 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)"); 9154 9155 ExprValueKind VK = VK_RValue; 9156 ExprObjectKind OK = OK_Ordinary; 9157 QualType resType; 9158 bool ValueDependent = false; 9159 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) { 9160 resType = Context.DependentTy; 9161 ValueDependent = true; 9162 } else { 9163 // The conditional expression is required to be a constant expression. 9164 llvm::APSInt condEval(32); 9165 ExprResult CondICE 9166 = VerifyIntegerConstantExpression(CondExpr, &condEval, 9167 diag::err_typecheck_choose_expr_requires_constant, false); 9168 if (CondICE.isInvalid()) 9169 return ExprError(); 9170 CondExpr = CondICE.take(); 9171 9172 // If the condition is > zero, then the AST type is the same as the LSHExpr. 9173 Expr *ActiveExpr = condEval.getZExtValue() ? LHSExpr : RHSExpr; 9174 9175 resType = ActiveExpr->getType(); 9176 ValueDependent = ActiveExpr->isValueDependent(); 9177 VK = ActiveExpr->getValueKind(); 9178 OK = ActiveExpr->getObjectKind(); 9179 } 9180 9181 return Owned(new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, 9182 resType, VK, OK, RPLoc, 9183 resType->isDependentType(), 9184 ValueDependent)); 9185} 9186 9187//===----------------------------------------------------------------------===// 9188// Clang Extensions. 9189//===----------------------------------------------------------------------===// 9190 9191/// ActOnBlockStart - This callback is invoked when a block literal is started. 9192void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope) { 9193 BlockDecl *Block = BlockDecl::Create(Context, CurContext, CaretLoc); 9194 PushBlockScope(CurScope, Block); 9195 CurContext->addDecl(Block); 9196 if (CurScope) 9197 PushDeclContext(CurScope, Block); 9198 else 9199 CurContext = Block; 9200 9201 getCurBlock()->HasImplicitReturnType = true; 9202 9203 // Enter a new evaluation context to insulate the block from any 9204 // cleanups from the enclosing full-expression. 9205 PushExpressionEvaluationContext(PotentiallyEvaluated); 9206} 9207 9208void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo, 9209 Scope *CurScope) { 9210 assert(ParamInfo.getIdentifier()==0 && "block-id should have no identifier!"); 9211 assert(ParamInfo.getContext() == Declarator::BlockLiteralContext); 9212 BlockScopeInfo *CurBlock = getCurBlock(); 9213 9214 TypeSourceInfo *Sig = GetTypeForDeclarator(ParamInfo, CurScope); 9215 QualType T = Sig->getType(); 9216 9217 // FIXME: We should allow unexpanded parameter packs here, but that would, 9218 // in turn, make the block expression contain unexpanded parameter packs. 9219 if (DiagnoseUnexpandedParameterPack(CaretLoc, Sig, UPPC_Block)) { 9220 // Drop the parameters. 9221 FunctionProtoType::ExtProtoInfo EPI; 9222 EPI.HasTrailingReturn = false; 9223 EPI.TypeQuals |= DeclSpec::TQ_const; 9224 T = Context.getFunctionType(Context.DependentTy, /*Args=*/0, /*NumArgs=*/0, 9225 EPI); 9226 Sig = Context.getTrivialTypeSourceInfo(T); 9227 } 9228 9229 // GetTypeForDeclarator always produces a function type for a block 9230 // literal signature. Furthermore, it is always a FunctionProtoType 9231 // unless the function was written with a typedef. 9232 assert(T->isFunctionType() && 9233 "GetTypeForDeclarator made a non-function block signature"); 9234 9235 // Look for an explicit signature in that function type. 9236 FunctionProtoTypeLoc ExplicitSignature; 9237 9238 TypeLoc tmp = Sig->getTypeLoc().IgnoreParens(); 9239 if (isa<FunctionProtoTypeLoc>(tmp)) { 9240 ExplicitSignature = cast<FunctionProtoTypeLoc>(tmp); 9241 9242 // Check whether that explicit signature was synthesized by 9243 // GetTypeForDeclarator. If so, don't save that as part of the 9244 // written signature. 9245 if (ExplicitSignature.getLocalRangeBegin() == 9246 ExplicitSignature.getLocalRangeEnd()) { 9247 // This would be much cheaper if we stored TypeLocs instead of 9248 // TypeSourceInfos. 9249 TypeLoc Result = ExplicitSignature.getResultLoc(); 9250 unsigned Size = Result.getFullDataSize(); 9251 Sig = Context.CreateTypeSourceInfo(Result.getType(), Size); 9252 Sig->getTypeLoc().initializeFullCopy(Result, Size); 9253 9254 ExplicitSignature = FunctionProtoTypeLoc(); 9255 } 9256 } 9257 9258 CurBlock->TheDecl->setSignatureAsWritten(Sig); 9259 CurBlock->FunctionType = T; 9260 9261 const FunctionType *Fn = T->getAs<FunctionType>(); 9262 QualType RetTy = Fn->getResultType(); 9263 bool isVariadic = 9264 (isa<FunctionProtoType>(Fn) && cast<FunctionProtoType>(Fn)->isVariadic()); 9265 9266 CurBlock->TheDecl->setIsVariadic(isVariadic); 9267 9268 // Don't allow returning a objc interface by value. 9269 if (RetTy->isObjCObjectType()) { 9270 Diag(ParamInfo.getLocStart(), 9271 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy; 9272 return; 9273 } 9274 9275 // Context.DependentTy is used as a placeholder for a missing block 9276 // return type. TODO: what should we do with declarators like: 9277 // ^ * { ... } 9278 // If the answer is "apply template argument deduction".... 9279 if (RetTy != Context.DependentTy) { 9280 CurBlock->ReturnType = RetTy; 9281 CurBlock->TheDecl->setBlockMissingReturnType(false); 9282 CurBlock->HasImplicitReturnType = false; 9283 } 9284 9285 // Push block parameters from the declarator if we had them. 9286 SmallVector<ParmVarDecl*, 8> Params; 9287 if (ExplicitSignature) { 9288 for (unsigned I = 0, E = ExplicitSignature.getNumArgs(); I != E; ++I) { 9289 ParmVarDecl *Param = ExplicitSignature.getArg(I); 9290 if (Param->getIdentifier() == 0 && 9291 !Param->isImplicit() && 9292 !Param->isInvalidDecl() && 9293 !getLangOpts().CPlusPlus) 9294 Diag(Param->getLocation(), diag::err_parameter_name_omitted); 9295 Params.push_back(Param); 9296 } 9297 9298 // Fake up parameter variables if we have a typedef, like 9299 // ^ fntype { ... } 9300 } else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) { 9301 for (FunctionProtoType::arg_type_iterator 9302 I = Fn->arg_type_begin(), E = Fn->arg_type_end(); I != E; ++I) { 9303 ParmVarDecl *Param = 9304 BuildParmVarDeclForTypedef(CurBlock->TheDecl, 9305 ParamInfo.getLocStart(), 9306 *I); 9307 Params.push_back(Param); 9308 } 9309 } 9310 9311 // Set the parameters on the block decl. 9312 if (!Params.empty()) { 9313 CurBlock->TheDecl->setParams(Params); 9314 CheckParmsForFunctionDef(CurBlock->TheDecl->param_begin(), 9315 CurBlock->TheDecl->param_end(), 9316 /*CheckParameterNames=*/false); 9317 } 9318 9319 // Finally we can process decl attributes. 9320 ProcessDeclAttributes(CurScope, CurBlock->TheDecl, ParamInfo); 9321 9322 // Put the parameter variables in scope. We can bail out immediately 9323 // if we don't have any. 9324 if (Params.empty()) 9325 return; 9326 9327 for (BlockDecl::param_iterator AI = CurBlock->TheDecl->param_begin(), 9328 E = CurBlock->TheDecl->param_end(); AI != E; ++AI) { 9329 (*AI)->setOwningFunction(CurBlock->TheDecl); 9330 9331 // If this has an identifier, add it to the scope stack. 9332 if ((*AI)->getIdentifier()) { 9333 CheckShadow(CurBlock->TheScope, *AI); 9334 9335 PushOnScopeChains(*AI, CurBlock->TheScope); 9336 } 9337 } 9338} 9339 9340/// ActOnBlockError - If there is an error parsing a block, this callback 9341/// is invoked to pop the information about the block from the action impl. 9342void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) { 9343 // Leave the expression-evaluation context. 9344 DiscardCleanupsInEvaluationContext(); 9345 PopExpressionEvaluationContext(); 9346 9347 // Pop off CurBlock, handle nested blocks. 9348 PopDeclContext(); 9349 PopFunctionScopeInfo(); 9350} 9351 9352/// ActOnBlockStmtExpr - This is called when the body of a block statement 9353/// literal was successfully completed. ^(int x){...} 9354ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, 9355 Stmt *Body, Scope *CurScope) { 9356 // If blocks are disabled, emit an error. 9357 if (!LangOpts.Blocks) 9358 Diag(CaretLoc, diag::err_blocks_disable); 9359 9360 // Leave the expression-evaluation context. 9361 if (hasAnyUnrecoverableErrorsInThisFunction()) 9362 DiscardCleanupsInEvaluationContext(); 9363 assert(!ExprNeedsCleanups && "cleanups within block not correctly bound!"); 9364 PopExpressionEvaluationContext(); 9365 9366 BlockScopeInfo *BSI = cast<BlockScopeInfo>(FunctionScopes.back()); 9367 9368 if (BSI->HasImplicitReturnType) 9369 deduceClosureReturnType(*BSI); 9370 9371 PopDeclContext(); 9372 9373 QualType RetTy = Context.VoidTy; 9374 if (!BSI->ReturnType.isNull()) 9375 RetTy = BSI->ReturnType; 9376 9377 bool NoReturn = BSI->TheDecl->getAttr<NoReturnAttr>(); 9378 QualType BlockTy; 9379 9380 // Set the captured variables on the block. 9381 // FIXME: Share capture structure between BlockDecl and CapturingScopeInfo! 9382 SmallVector<BlockDecl::Capture, 4> Captures; 9383 for (unsigned i = 0, e = BSI->Captures.size(); i != e; i++) { 9384 CapturingScopeInfo::Capture &Cap = BSI->Captures[i]; 9385 if (Cap.isThisCapture()) 9386 continue; 9387 BlockDecl::Capture NewCap(Cap.getVariable(), Cap.isBlockCapture(), 9388 Cap.isNested(), Cap.getCopyExpr()); 9389 Captures.push_back(NewCap); 9390 } 9391 BSI->TheDecl->setCaptures(Context, Captures.begin(), Captures.end(), 9392 BSI->CXXThisCaptureIndex != 0); 9393 9394 // If the user wrote a function type in some form, try to use that. 9395 if (!BSI->FunctionType.isNull()) { 9396 const FunctionType *FTy = BSI->FunctionType->getAs<FunctionType>(); 9397 9398 FunctionType::ExtInfo Ext = FTy->getExtInfo(); 9399 if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true); 9400 9401 // Turn protoless block types into nullary block types. 9402 if (isa<FunctionNoProtoType>(FTy)) { 9403 FunctionProtoType::ExtProtoInfo EPI; 9404 EPI.ExtInfo = Ext; 9405 BlockTy = Context.getFunctionType(RetTy, 0, 0, EPI); 9406 9407 // Otherwise, if we don't need to change anything about the function type, 9408 // preserve its sugar structure. 9409 } else if (FTy->getResultType() == RetTy && 9410 (!NoReturn || FTy->getNoReturnAttr())) { 9411 BlockTy = BSI->FunctionType; 9412 9413 // Otherwise, make the minimal modifications to the function type. 9414 } else { 9415 const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy); 9416 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 9417 EPI.TypeQuals = 0; // FIXME: silently? 9418 EPI.ExtInfo = Ext; 9419 BlockTy = Context.getFunctionType(RetTy, 9420 FPT->arg_type_begin(), 9421 FPT->getNumArgs(), 9422 EPI); 9423 } 9424 9425 // If we don't have a function type, just build one from nothing. 9426 } else { 9427 FunctionProtoType::ExtProtoInfo EPI; 9428 EPI.ExtInfo = FunctionType::ExtInfo().withNoReturn(NoReturn); 9429 BlockTy = Context.getFunctionType(RetTy, 0, 0, EPI); 9430 } 9431 9432 DiagnoseUnusedParameters(BSI->TheDecl->param_begin(), 9433 BSI->TheDecl->param_end()); 9434 BlockTy = Context.getBlockPointerType(BlockTy); 9435 9436 // If needed, diagnose invalid gotos and switches in the block. 9437 if (getCurFunction()->NeedsScopeChecking() && 9438 !hasAnyUnrecoverableErrorsInThisFunction()) 9439 DiagnoseInvalidJumps(cast<CompoundStmt>(Body)); 9440 9441 BSI->TheDecl->setBody(cast<CompoundStmt>(Body)); 9442 9443 // Try to apply the named return value optimization. We have to check again 9444 // if we can do this, though, because blocks keep return statements around 9445 // to deduce an implicit return type. 9446 if (getLangOpts().CPlusPlus && RetTy->isRecordType() && 9447 !BSI->TheDecl->isDependentContext()) 9448 computeNRVO(Body, getCurBlock()); 9449 9450 BlockExpr *Result = new (Context) BlockExpr(BSI->TheDecl, BlockTy); 9451 const AnalysisBasedWarnings::Policy &WP = AnalysisWarnings.getDefaultPolicy(); 9452 PopFunctionScopeInfo(&WP, Result->getBlockDecl(), Result); 9453 9454 // If the block isn't obviously global, i.e. it captures anything at 9455 // all, then we need to do a few things in the surrounding context: 9456 if (Result->getBlockDecl()->hasCaptures()) { 9457 // First, this expression has a new cleanup object. 9458 ExprCleanupObjects.push_back(Result->getBlockDecl()); 9459 ExprNeedsCleanups = true; 9460 9461 // It also gets a branch-protected scope if any of the captured 9462 // variables needs destruction. 9463 for (BlockDecl::capture_const_iterator 9464 ci = Result->getBlockDecl()->capture_begin(), 9465 ce = Result->getBlockDecl()->capture_end(); ci != ce; ++ci) { 9466 const VarDecl *var = ci->getVariable(); 9467 if (var->getType().isDestructedType() != QualType::DK_none) { 9468 getCurFunction()->setHasBranchProtectedScope(); 9469 break; 9470 } 9471 } 9472 } 9473 9474 return Owned(Result); 9475} 9476 9477ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc, 9478 Expr *E, ParsedType Ty, 9479 SourceLocation RPLoc) { 9480 TypeSourceInfo *TInfo; 9481 GetTypeFromParser(Ty, &TInfo); 9482 return BuildVAArgExpr(BuiltinLoc, E, TInfo, RPLoc); 9483} 9484 9485ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, 9486 Expr *E, TypeSourceInfo *TInfo, 9487 SourceLocation RPLoc) { 9488 Expr *OrigExpr = E; 9489 9490 // Get the va_list type 9491 QualType VaListType = Context.getBuiltinVaListType(); 9492 if (VaListType->isArrayType()) { 9493 // Deal with implicit array decay; for example, on x86-64, 9494 // va_list is an array, but it's supposed to decay to 9495 // a pointer for va_arg. 9496 VaListType = Context.getArrayDecayedType(VaListType); 9497 // Make sure the input expression also decays appropriately. 9498 ExprResult Result = UsualUnaryConversions(E); 9499 if (Result.isInvalid()) 9500 return ExprError(); 9501 E = Result.take(); 9502 } else { 9503 // Otherwise, the va_list argument must be an l-value because 9504 // it is modified by va_arg. 9505 if (!E->isTypeDependent() && 9506 CheckForModifiableLvalue(E, BuiltinLoc, *this)) 9507 return ExprError(); 9508 } 9509 9510 if (!E->isTypeDependent() && 9511 !Context.hasSameType(VaListType, E->getType())) { 9512 return ExprError(Diag(E->getLocStart(), 9513 diag::err_first_argument_to_va_arg_not_of_type_va_list) 9514 << OrigExpr->getType() << E->getSourceRange()); 9515 } 9516 9517 if (!TInfo->getType()->isDependentType()) { 9518 if (RequireCompleteType(TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(), 9519 diag::err_second_parameter_to_va_arg_incomplete, 9520 TInfo->getTypeLoc())) 9521 return ExprError(); 9522 9523 if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(), 9524 TInfo->getType(), 9525 diag::err_second_parameter_to_va_arg_abstract, 9526 TInfo->getTypeLoc())) 9527 return ExprError(); 9528 9529 if (!TInfo->getType().isPODType(Context)) { 9530 Diag(TInfo->getTypeLoc().getBeginLoc(), 9531 TInfo->getType()->isObjCLifetimeType() 9532 ? diag::warn_second_parameter_to_va_arg_ownership_qualified 9533 : diag::warn_second_parameter_to_va_arg_not_pod) 9534 << TInfo->getType() 9535 << TInfo->getTypeLoc().getSourceRange(); 9536 } 9537 9538 // Check for va_arg where arguments of the given type will be promoted 9539 // (i.e. this va_arg is guaranteed to have undefined behavior). 9540 QualType PromoteType; 9541 if (TInfo->getType()->isPromotableIntegerType()) { 9542 PromoteType = Context.getPromotedIntegerType(TInfo->getType()); 9543 if (Context.typesAreCompatible(PromoteType, TInfo->getType())) 9544 PromoteType = QualType(); 9545 } 9546 if (TInfo->getType()->isSpecificBuiltinType(BuiltinType::Float)) 9547 PromoteType = Context.DoubleTy; 9548 if (!PromoteType.isNull()) 9549 Diag(TInfo->getTypeLoc().getBeginLoc(), 9550 diag::warn_second_parameter_to_va_arg_never_compatible) 9551 << TInfo->getType() 9552 << PromoteType 9553 << TInfo->getTypeLoc().getSourceRange(); 9554 } 9555 9556 QualType T = TInfo->getType().getNonLValueExprType(Context); 9557 return Owned(new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T)); 9558} 9559 9560ExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) { 9561 // The type of __null will be int or long, depending on the size of 9562 // pointers on the target. 9563 QualType Ty; 9564 unsigned pw = Context.getTargetInfo().getPointerWidth(0); 9565 if (pw == Context.getTargetInfo().getIntWidth()) 9566 Ty = Context.IntTy; 9567 else if (pw == Context.getTargetInfo().getLongWidth()) 9568 Ty = Context.LongTy; 9569 else if (pw == Context.getTargetInfo().getLongLongWidth()) 9570 Ty = Context.LongLongTy; 9571 else { 9572 llvm_unreachable("I don't know size of pointer!"); 9573 } 9574 9575 return Owned(new (Context) GNUNullExpr(Ty, TokenLoc)); 9576} 9577 9578static void MakeObjCStringLiteralFixItHint(Sema& SemaRef, QualType DstType, 9579 Expr *SrcExpr, FixItHint &Hint) { 9580 if (!SemaRef.getLangOpts().ObjC1) 9581 return; 9582 9583 const ObjCObjectPointerType *PT = DstType->getAs<ObjCObjectPointerType>(); 9584 if (!PT) 9585 return; 9586 9587 // Check if the destination is of type 'id'. 9588 if (!PT->isObjCIdType()) { 9589 // Check if the destination is the 'NSString' interface. 9590 const ObjCInterfaceDecl *ID = PT->getInterfaceDecl(); 9591 if (!ID || !ID->getIdentifier()->isStr("NSString")) 9592 return; 9593 } 9594 9595 // Ignore any parens, implicit casts (should only be 9596 // array-to-pointer decays), and not-so-opaque values. The last is 9597 // important for making this trigger for property assignments. 9598 SrcExpr = SrcExpr->IgnoreParenImpCasts(); 9599 if (OpaqueValueExpr *OV = dyn_cast<OpaqueValueExpr>(SrcExpr)) 9600 if (OV->getSourceExpr()) 9601 SrcExpr = OV->getSourceExpr()->IgnoreParenImpCasts(); 9602 9603 StringLiteral *SL = dyn_cast<StringLiteral>(SrcExpr); 9604 if (!SL || !SL->isAscii()) 9605 return; 9606 9607 Hint = FixItHint::CreateInsertion(SL->getLocStart(), "@"); 9608} 9609 9610bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy, 9611 SourceLocation Loc, 9612 QualType DstType, QualType SrcType, 9613 Expr *SrcExpr, AssignmentAction Action, 9614 bool *Complained) { 9615 if (Complained) 9616 *Complained = false; 9617 9618 // Decode the result (notice that AST's are still created for extensions). 9619 bool CheckInferredResultType = false; 9620 bool isInvalid = false; 9621 unsigned DiagKind = 0; 9622 FixItHint Hint; 9623 ConversionFixItGenerator ConvHints; 9624 bool MayHaveConvFixit = false; 9625 bool MayHaveFunctionDiff = false; 9626 9627 switch (ConvTy) { 9628 case Compatible: 9629 DiagnoseAssignmentEnum(DstType, SrcType, SrcExpr); 9630 return false; 9631 9632 case PointerToInt: 9633 DiagKind = diag::ext_typecheck_convert_pointer_int; 9634 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 9635 MayHaveConvFixit = true; 9636 break; 9637 case IntToPointer: 9638 DiagKind = diag::ext_typecheck_convert_int_pointer; 9639 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 9640 MayHaveConvFixit = true; 9641 break; 9642 case IncompatiblePointer: 9643 MakeObjCStringLiteralFixItHint(*this, DstType, SrcExpr, Hint); 9644 DiagKind = diag::ext_typecheck_convert_incompatible_pointer; 9645 CheckInferredResultType = DstType->isObjCObjectPointerType() && 9646 SrcType->isObjCObjectPointerType(); 9647 if (Hint.isNull() && !CheckInferredResultType) { 9648 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 9649 } 9650 MayHaveConvFixit = true; 9651 break; 9652 case IncompatiblePointerSign: 9653 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign; 9654 break; 9655 case FunctionVoidPointer: 9656 DiagKind = diag::ext_typecheck_convert_pointer_void_func; 9657 break; 9658 case IncompatiblePointerDiscardsQualifiers: { 9659 // Perform array-to-pointer decay if necessary. 9660 if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType); 9661 9662 Qualifiers lhq = SrcType->getPointeeType().getQualifiers(); 9663 Qualifiers rhq = DstType->getPointeeType().getQualifiers(); 9664 if (lhq.getAddressSpace() != rhq.getAddressSpace()) { 9665 DiagKind = diag::err_typecheck_incompatible_address_space; 9666 break; 9667 9668 9669 } else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) { 9670 DiagKind = diag::err_typecheck_incompatible_ownership; 9671 break; 9672 } 9673 9674 llvm_unreachable("unknown error case for discarding qualifiers!"); 9675 // fallthrough 9676 } 9677 case CompatiblePointerDiscardsQualifiers: 9678 // If the qualifiers lost were because we were applying the 9679 // (deprecated) C++ conversion from a string literal to a char* 9680 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME: 9681 // Ideally, this check would be performed in 9682 // checkPointerTypesForAssignment. However, that would require a 9683 // bit of refactoring (so that the second argument is an 9684 // expression, rather than a type), which should be done as part 9685 // of a larger effort to fix checkPointerTypesForAssignment for 9686 // C++ semantics. 9687 if (getLangOpts().CPlusPlus && 9688 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType)) 9689 return false; 9690 DiagKind = diag::ext_typecheck_convert_discards_qualifiers; 9691 break; 9692 case IncompatibleNestedPointerQualifiers: 9693 DiagKind = diag::ext_nested_pointer_qualifier_mismatch; 9694 break; 9695 case IntToBlockPointer: 9696 DiagKind = diag::err_int_to_block_pointer; 9697 break; 9698 case IncompatibleBlockPointer: 9699 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer; 9700 break; 9701 case IncompatibleObjCQualifiedId: 9702 // FIXME: Diagnose the problem in ObjCQualifiedIdTypesAreCompatible, since 9703 // it can give a more specific diagnostic. 9704 DiagKind = diag::warn_incompatible_qualified_id; 9705 break; 9706 case IncompatibleVectors: 9707 DiagKind = diag::warn_incompatible_vectors; 9708 break; 9709 case IncompatibleObjCWeakRef: 9710 DiagKind = diag::err_arc_weak_unavailable_assign; 9711 break; 9712 case Incompatible: 9713 DiagKind = diag::err_typecheck_convert_incompatible; 9714 ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this); 9715 MayHaveConvFixit = true; 9716 isInvalid = true; 9717 MayHaveFunctionDiff = true; 9718 break; 9719 } 9720 9721 QualType FirstType, SecondType; 9722 switch (Action) { 9723 case AA_Assigning: 9724 case AA_Initializing: 9725 // The destination type comes first. 9726 FirstType = DstType; 9727 SecondType = SrcType; 9728 break; 9729 9730 case AA_Returning: 9731 case AA_Passing: 9732 case AA_Converting: 9733 case AA_Sending: 9734 case AA_Casting: 9735 // The source type comes first. 9736 FirstType = SrcType; 9737 SecondType = DstType; 9738 break; 9739 } 9740 9741 PartialDiagnostic FDiag = PDiag(DiagKind); 9742 FDiag << FirstType << SecondType << Action << SrcExpr->getSourceRange(); 9743 9744 // If we can fix the conversion, suggest the FixIts. 9745 assert(ConvHints.isNull() || Hint.isNull()); 9746 if (!ConvHints.isNull()) { 9747 for (std::vector<FixItHint>::iterator HI = ConvHints.Hints.begin(), 9748 HE = ConvHints.Hints.end(); HI != HE; ++HI) 9749 FDiag << *HI; 9750 } else { 9751 FDiag << Hint; 9752 } 9753 if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); } 9754 9755 if (MayHaveFunctionDiff) 9756 HandleFunctionTypeMismatch(FDiag, SecondType, FirstType); 9757 9758 Diag(Loc, FDiag); 9759 9760 if (SecondType == Context.OverloadTy) 9761 NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression, 9762 FirstType); 9763 9764 if (CheckInferredResultType) 9765 EmitRelatedResultTypeNote(SrcExpr); 9766 9767 if (Complained) 9768 *Complained = true; 9769 return isInvalid; 9770} 9771 9772ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, 9773 llvm::APSInt *Result) { 9774 class SimpleICEDiagnoser : public VerifyICEDiagnoser { 9775 public: 9776 virtual void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) { 9777 S.Diag(Loc, diag::err_expr_not_ice) << S.LangOpts.CPlusPlus << SR; 9778 } 9779 } Diagnoser; 9780 9781 return VerifyIntegerConstantExpression(E, Result, Diagnoser); 9782} 9783 9784ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, 9785 llvm::APSInt *Result, 9786 unsigned DiagID, 9787 bool AllowFold) { 9788 class IDDiagnoser : public VerifyICEDiagnoser { 9789 unsigned DiagID; 9790 9791 public: 9792 IDDiagnoser(unsigned DiagID) 9793 : VerifyICEDiagnoser(DiagID == 0), DiagID(DiagID) { } 9794 9795 virtual void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) { 9796 S.Diag(Loc, DiagID) << SR; 9797 } 9798 } Diagnoser(DiagID); 9799 9800 return VerifyIntegerConstantExpression(E, Result, Diagnoser, AllowFold); 9801} 9802 9803void Sema::VerifyICEDiagnoser::diagnoseFold(Sema &S, SourceLocation Loc, 9804 SourceRange SR) { 9805 S.Diag(Loc, diag::ext_expr_not_ice) << SR << S.LangOpts.CPlusPlus; 9806} 9807 9808ExprResult 9809Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, 9810 VerifyICEDiagnoser &Diagnoser, 9811 bool AllowFold) { 9812 SourceLocation DiagLoc = E->getLocStart(); 9813 9814 if (getLangOpts().CPlusPlus0x) { 9815 // C++11 [expr.const]p5: 9816 // If an expression of literal class type is used in a context where an 9817 // integral constant expression is required, then that class type shall 9818 // have a single non-explicit conversion function to an integral or 9819 // unscoped enumeration type 9820 ExprResult Converted; 9821 if (!Diagnoser.Suppress) { 9822 class CXX11ConvertDiagnoser : public ICEConvertDiagnoser { 9823 public: 9824 CXX11ConvertDiagnoser() : ICEConvertDiagnoser(false, true) { } 9825 9826 virtual DiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc, 9827 QualType T) { 9828 return S.Diag(Loc, diag::err_ice_not_integral) << T; 9829 } 9830 9831 virtual DiagnosticBuilder diagnoseIncomplete(Sema &S, 9832 SourceLocation Loc, 9833 QualType T) { 9834 return S.Diag(Loc, diag::err_ice_incomplete_type) << T; 9835 } 9836 9837 virtual DiagnosticBuilder diagnoseExplicitConv(Sema &S, 9838 SourceLocation Loc, 9839 QualType T, 9840 QualType ConvTy) { 9841 return S.Diag(Loc, diag::err_ice_explicit_conversion) << T << ConvTy; 9842 } 9843 9844 virtual DiagnosticBuilder noteExplicitConv(Sema &S, 9845 CXXConversionDecl *Conv, 9846 QualType ConvTy) { 9847 return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here) 9848 << ConvTy->isEnumeralType() << ConvTy; 9849 } 9850 9851 virtual DiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, 9852 QualType T) { 9853 return S.Diag(Loc, diag::err_ice_ambiguous_conversion) << T; 9854 } 9855 9856 virtual DiagnosticBuilder noteAmbiguous(Sema &S, 9857 CXXConversionDecl *Conv, 9858 QualType ConvTy) { 9859 return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here) 9860 << ConvTy->isEnumeralType() << ConvTy; 9861 } 9862 9863 virtual DiagnosticBuilder diagnoseConversion(Sema &S, 9864 SourceLocation Loc, 9865 QualType T, 9866 QualType ConvTy) { 9867 return DiagnosticBuilder::getEmpty(); 9868 } 9869 } ConvertDiagnoser; 9870 9871 Converted = ConvertToIntegralOrEnumerationType(DiagLoc, E, 9872 ConvertDiagnoser, 9873 /*AllowScopedEnumerations*/ false); 9874 } else { 9875 // The caller wants to silently enquire whether this is an ICE. Don't 9876 // produce any diagnostics if it isn't. 9877 class SilentICEConvertDiagnoser : public ICEConvertDiagnoser { 9878 public: 9879 SilentICEConvertDiagnoser() : ICEConvertDiagnoser(true, true) { } 9880 9881 virtual DiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc, 9882 QualType T) { 9883 return DiagnosticBuilder::getEmpty(); 9884 } 9885 9886 virtual DiagnosticBuilder diagnoseIncomplete(Sema &S, 9887 SourceLocation Loc, 9888 QualType T) { 9889 return DiagnosticBuilder::getEmpty(); 9890 } 9891 9892 virtual DiagnosticBuilder diagnoseExplicitConv(Sema &S, 9893 SourceLocation Loc, 9894 QualType T, 9895 QualType ConvTy) { 9896 return DiagnosticBuilder::getEmpty(); 9897 } 9898 9899 virtual DiagnosticBuilder noteExplicitConv(Sema &S, 9900 CXXConversionDecl *Conv, 9901 QualType ConvTy) { 9902 return DiagnosticBuilder::getEmpty(); 9903 } 9904 9905 virtual DiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, 9906 QualType T) { 9907 return DiagnosticBuilder::getEmpty(); 9908 } 9909 9910 virtual DiagnosticBuilder noteAmbiguous(Sema &S, 9911 CXXConversionDecl *Conv, 9912 QualType ConvTy) { 9913 return DiagnosticBuilder::getEmpty(); 9914 } 9915 9916 virtual DiagnosticBuilder diagnoseConversion(Sema &S, 9917 SourceLocation Loc, 9918 QualType T, 9919 QualType ConvTy) { 9920 return DiagnosticBuilder::getEmpty(); 9921 } 9922 } ConvertDiagnoser; 9923 9924 Converted = ConvertToIntegralOrEnumerationType(DiagLoc, E, 9925 ConvertDiagnoser, false); 9926 } 9927 if (Converted.isInvalid()) 9928 return Converted; 9929 E = Converted.take(); 9930 if (!E->getType()->isIntegralOrUnscopedEnumerationType()) 9931 return ExprError(); 9932 } else if (!E->getType()->isIntegralOrUnscopedEnumerationType()) { 9933 // An ICE must be of integral or unscoped enumeration type. 9934 if (!Diagnoser.Suppress) 9935 Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange()); 9936 return ExprError(); 9937 } 9938 9939 // Circumvent ICE checking in C++11 to avoid evaluating the expression twice 9940 // in the non-ICE case. 9941 if (!getLangOpts().CPlusPlus0x && E->isIntegerConstantExpr(Context)) { 9942 if (Result) 9943 *Result = E->EvaluateKnownConstInt(Context); 9944 return Owned(E); 9945 } 9946 9947 Expr::EvalResult EvalResult; 9948 llvm::SmallVector<PartialDiagnosticAt, 8> Notes; 9949 EvalResult.Diag = &Notes; 9950 9951 // Try to evaluate the expression, and produce diagnostics explaining why it's 9952 // not a constant expression as a side-effect. 9953 bool Folded = E->EvaluateAsRValue(EvalResult, Context) && 9954 EvalResult.Val.isInt() && !EvalResult.HasSideEffects; 9955 9956 // In C++11, we can rely on diagnostics being produced for any expression 9957 // which is not a constant expression. If no diagnostics were produced, then 9958 // this is a constant expression. 9959 if (Folded && getLangOpts().CPlusPlus0x && Notes.empty()) { 9960 if (Result) 9961 *Result = EvalResult.Val.getInt(); 9962 return Owned(E); 9963 } 9964 9965 // If our only note is the usual "invalid subexpression" note, just point 9966 // the caret at its location rather than producing an essentially 9967 // redundant note. 9968 if (Notes.size() == 1 && Notes[0].second.getDiagID() == 9969 diag::note_invalid_subexpr_in_const_expr) { 9970 DiagLoc = Notes[0].first; 9971 Notes.clear(); 9972 } 9973 9974 if (!Folded || !AllowFold) { 9975 if (!Diagnoser.Suppress) { 9976 Diagnoser.diagnoseNotICE(*this, DiagLoc, E->getSourceRange()); 9977 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 9978 Diag(Notes[I].first, Notes[I].second); 9979 } 9980 9981 return ExprError(); 9982 } 9983 9984 Diagnoser.diagnoseFold(*this, DiagLoc, E->getSourceRange()); 9985 for (unsigned I = 0, N = Notes.size(); I != N; ++I) 9986 Diag(Notes[I].first, Notes[I].second); 9987 9988 if (Result) 9989 *Result = EvalResult.Val.getInt(); 9990 return Owned(E); 9991} 9992 9993namespace { 9994 // Handle the case where we conclude a expression which we speculatively 9995 // considered to be unevaluated is actually evaluated. 9996 class TransformToPE : public TreeTransform<TransformToPE> { 9997 typedef TreeTransform<TransformToPE> BaseTransform; 9998 9999 public: 10000 TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) { } 10001 10002 // Make sure we redo semantic analysis 10003 bool AlwaysRebuild() { return true; } 10004 10005 // Make sure we handle LabelStmts correctly. 10006 // FIXME: This does the right thing, but maybe we need a more general 10007 // fix to TreeTransform? 10008 StmtResult TransformLabelStmt(LabelStmt *S) { 10009 S->getDecl()->setStmt(0); 10010 return BaseTransform::TransformLabelStmt(S); 10011 } 10012 10013 // We need to special-case DeclRefExprs referring to FieldDecls which 10014 // are not part of a member pointer formation; normal TreeTransforming 10015 // doesn't catch this case because of the way we represent them in the AST. 10016 // FIXME: This is a bit ugly; is it really the best way to handle this 10017 // case? 10018 // 10019 // Error on DeclRefExprs referring to FieldDecls. 10020 ExprResult TransformDeclRefExpr(DeclRefExpr *E) { 10021 if (isa<FieldDecl>(E->getDecl()) && 10022 SemaRef.ExprEvalContexts.back().Context != Sema::Unevaluated) 10023 return SemaRef.Diag(E->getLocation(), 10024 diag::err_invalid_non_static_member_use) 10025 << E->getDecl() << E->getSourceRange(); 10026 10027 return BaseTransform::TransformDeclRefExpr(E); 10028 } 10029 10030 // Exception: filter out member pointer formation 10031 ExprResult TransformUnaryOperator(UnaryOperator *E) { 10032 if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType()) 10033 return E; 10034 10035 return BaseTransform::TransformUnaryOperator(E); 10036 } 10037 10038 ExprResult TransformLambdaExpr(LambdaExpr *E) { 10039 // Lambdas never need to be transformed. 10040 return E; 10041 } 10042 }; 10043} 10044 10045ExprResult Sema::TranformToPotentiallyEvaluated(Expr *E) { 10046 assert(ExprEvalContexts.back().Context == Unevaluated && 10047 "Should only transform unevaluated expressions"); 10048 ExprEvalContexts.back().Context = 10049 ExprEvalContexts[ExprEvalContexts.size()-2].Context; 10050 if (ExprEvalContexts.back().Context == Unevaluated) 10051 return E; 10052 return TransformToPE(*this).TransformExpr(E); 10053} 10054 10055void 10056Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, 10057 Decl *LambdaContextDecl, 10058 bool IsDecltype) { 10059 ExprEvalContexts.push_back( 10060 ExpressionEvaluationContextRecord(NewContext, 10061 ExprCleanupObjects.size(), 10062 ExprNeedsCleanups, 10063 LambdaContextDecl, 10064 IsDecltype)); 10065 ExprNeedsCleanups = false; 10066 if (!MaybeODRUseExprs.empty()) 10067 std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs); 10068} 10069 10070void Sema::PopExpressionEvaluationContext() { 10071 ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back(); 10072 10073 if (!Rec.Lambdas.empty()) { 10074 if (Rec.Context == Unevaluated) { 10075 // C++11 [expr.prim.lambda]p2: 10076 // A lambda-expression shall not appear in an unevaluated operand 10077 // (Clause 5). 10078 for (unsigned I = 0, N = Rec.Lambdas.size(); I != N; ++I) 10079 Diag(Rec.Lambdas[I]->getLocStart(), 10080 diag::err_lambda_unevaluated_operand); 10081 } else { 10082 // Mark the capture expressions odr-used. This was deferred 10083 // during lambda expression creation. 10084 for (unsigned I = 0, N = Rec.Lambdas.size(); I != N; ++I) { 10085 LambdaExpr *Lambda = Rec.Lambdas[I]; 10086 for (LambdaExpr::capture_init_iterator 10087 C = Lambda->capture_init_begin(), 10088 CEnd = Lambda->capture_init_end(); 10089 C != CEnd; ++C) { 10090 MarkDeclarationsReferencedInExpr(*C); 10091 } 10092 } 10093 } 10094 } 10095 10096 // When are coming out of an unevaluated context, clear out any 10097 // temporaries that we may have created as part of the evaluation of 10098 // the expression in that context: they aren't relevant because they 10099 // will never be constructed. 10100 if (Rec.Context == Unevaluated || Rec.Context == ConstantEvaluated) { 10101 ExprCleanupObjects.erase(ExprCleanupObjects.begin() + Rec.NumCleanupObjects, 10102 ExprCleanupObjects.end()); 10103 ExprNeedsCleanups = Rec.ParentNeedsCleanups; 10104 CleanupVarDeclMarking(); 10105 std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs); 10106 // Otherwise, merge the contexts together. 10107 } else { 10108 ExprNeedsCleanups |= Rec.ParentNeedsCleanups; 10109 MaybeODRUseExprs.insert(Rec.SavedMaybeODRUseExprs.begin(), 10110 Rec.SavedMaybeODRUseExprs.end()); 10111 } 10112 10113 // Pop the current expression evaluation context off the stack. 10114 ExprEvalContexts.pop_back(); 10115} 10116 10117void Sema::DiscardCleanupsInEvaluationContext() { 10118 ExprCleanupObjects.erase( 10119 ExprCleanupObjects.begin() + ExprEvalContexts.back().NumCleanupObjects, 10120 ExprCleanupObjects.end()); 10121 ExprNeedsCleanups = false; 10122 MaybeODRUseExprs.clear(); 10123} 10124 10125ExprResult Sema::HandleExprEvaluationContextForTypeof(Expr *E) { 10126 if (!E->getType()->isVariablyModifiedType()) 10127 return E; 10128 return TranformToPotentiallyEvaluated(E); 10129} 10130 10131static bool IsPotentiallyEvaluatedContext(Sema &SemaRef) { 10132 // Do not mark anything as "used" within a dependent context; wait for 10133 // an instantiation. 10134 if (SemaRef.CurContext->isDependentContext()) 10135 return false; 10136 10137 switch (SemaRef.ExprEvalContexts.back().Context) { 10138 case Sema::Unevaluated: 10139 // We are in an expression that is not potentially evaluated; do nothing. 10140 // (Depending on how you read the standard, we actually do need to do 10141 // something here for null pointer constants, but the standard's 10142 // definition of a null pointer constant is completely crazy.) 10143 return false; 10144 10145 case Sema::ConstantEvaluated: 10146 case Sema::PotentiallyEvaluated: 10147 // We are in a potentially evaluated expression (or a constant-expression 10148 // in C++03); we need to do implicit template instantiation, implicitly 10149 // define class members, and mark most declarations as used. 10150 return true; 10151 10152 case Sema::PotentiallyEvaluatedIfUsed: 10153 // Referenced declarations will only be used if the construct in the 10154 // containing expression is used. 10155 return false; 10156 } 10157 llvm_unreachable("Invalid context"); 10158} 10159 10160/// \brief Mark a function referenced, and check whether it is odr-used 10161/// (C++ [basic.def.odr]p2, C99 6.9p3) 10162void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func) { 10163 assert(Func && "No function?"); 10164 10165 Func->setReferenced(); 10166 10167 // Don't mark this function as used multiple times, unless it's a constexpr 10168 // function which we need to instantiate. 10169 if (Func->isUsed(false) && 10170 !(Func->isConstexpr() && !Func->getBody() && 10171 Func->isImplicitlyInstantiable())) 10172 return; 10173 10174 if (!IsPotentiallyEvaluatedContext(*this)) 10175 return; 10176 10177 // Note that this declaration has been used. 10178 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Func)) { 10179 if (Constructor->isDefaulted() && !Constructor->isDeleted()) { 10180 if (Constructor->isDefaultConstructor()) { 10181 if (Constructor->isTrivial()) 10182 return; 10183 if (!Constructor->isUsed(false)) 10184 DefineImplicitDefaultConstructor(Loc, Constructor); 10185 } else if (Constructor->isCopyConstructor()) { 10186 if (!Constructor->isUsed(false)) 10187 DefineImplicitCopyConstructor(Loc, Constructor); 10188 } else if (Constructor->isMoveConstructor()) { 10189 if (!Constructor->isUsed(false)) 10190 DefineImplicitMoveConstructor(Loc, Constructor); 10191 } 10192 } 10193 10194 MarkVTableUsed(Loc, Constructor->getParent()); 10195 } else if (CXXDestructorDecl *Destructor = 10196 dyn_cast<CXXDestructorDecl>(Func)) { 10197 if (Destructor->isDefaulted() && !Destructor->isDeleted() && 10198 !Destructor->isUsed(false)) 10199 DefineImplicitDestructor(Loc, Destructor); 10200 if (Destructor->isVirtual()) 10201 MarkVTableUsed(Loc, Destructor->getParent()); 10202 } else if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(Func)) { 10203 if (MethodDecl->isDefaulted() && !MethodDecl->isDeleted() && 10204 MethodDecl->isOverloadedOperator() && 10205 MethodDecl->getOverloadedOperator() == OO_Equal) { 10206 if (!MethodDecl->isUsed(false)) { 10207 if (MethodDecl->isCopyAssignmentOperator()) 10208 DefineImplicitCopyAssignment(Loc, MethodDecl); 10209 else 10210 DefineImplicitMoveAssignment(Loc, MethodDecl); 10211 } 10212 } else if (isa<CXXConversionDecl>(MethodDecl) && 10213 MethodDecl->getParent()->isLambda()) { 10214 CXXConversionDecl *Conversion = cast<CXXConversionDecl>(MethodDecl); 10215 if (Conversion->isLambdaToBlockPointerConversion()) 10216 DefineImplicitLambdaToBlockPointerConversion(Loc, Conversion); 10217 else 10218 DefineImplicitLambdaToFunctionPointerConversion(Loc, Conversion); 10219 } else if (MethodDecl->isVirtual()) 10220 MarkVTableUsed(Loc, MethodDecl->getParent()); 10221 } 10222 10223 // Recursive functions should be marked when used from another function. 10224 // FIXME: Is this really right? 10225 if (CurContext == Func) return; 10226 10227 // Instantiate the exception specification for any function which is 10228 // used: CodeGen will need it. 10229 const FunctionProtoType *FPT = Func->getType()->getAs<FunctionProtoType>(); 10230 if (FPT && FPT->getExceptionSpecType() == EST_Uninstantiated) 10231 InstantiateExceptionSpec(Loc, Func); 10232 10233 // Implicit instantiation of function templates and member functions of 10234 // class templates. 10235 if (Func->isImplicitlyInstantiable()) { 10236 bool AlreadyInstantiated = false; 10237 SourceLocation PointOfInstantiation = Loc; 10238 if (FunctionTemplateSpecializationInfo *SpecInfo 10239 = Func->getTemplateSpecializationInfo()) { 10240 if (SpecInfo->getPointOfInstantiation().isInvalid()) 10241 SpecInfo->setPointOfInstantiation(Loc); 10242 else if (SpecInfo->getTemplateSpecializationKind() 10243 == TSK_ImplicitInstantiation) { 10244 AlreadyInstantiated = true; 10245 PointOfInstantiation = SpecInfo->getPointOfInstantiation(); 10246 } 10247 } else if (MemberSpecializationInfo *MSInfo 10248 = Func->getMemberSpecializationInfo()) { 10249 if (MSInfo->getPointOfInstantiation().isInvalid()) 10250 MSInfo->setPointOfInstantiation(Loc); 10251 else if (MSInfo->getTemplateSpecializationKind() 10252 == TSK_ImplicitInstantiation) { 10253 AlreadyInstantiated = true; 10254 PointOfInstantiation = MSInfo->getPointOfInstantiation(); 10255 } 10256 } 10257 10258 if (!AlreadyInstantiated || Func->isConstexpr()) { 10259 if (isa<CXXRecordDecl>(Func->getDeclContext()) && 10260 cast<CXXRecordDecl>(Func->getDeclContext())->isLocalClass()) 10261 PendingLocalImplicitInstantiations.push_back( 10262 std::make_pair(Func, PointOfInstantiation)); 10263 else if (Func->isConstexpr()) 10264 // Do not defer instantiations of constexpr functions, to avoid the 10265 // expression evaluator needing to call back into Sema if it sees a 10266 // call to such a function. 10267 InstantiateFunctionDefinition(PointOfInstantiation, Func); 10268 else { 10269 PendingInstantiations.push_back(std::make_pair(Func, 10270 PointOfInstantiation)); 10271 // Notify the consumer that a function was implicitly instantiated. 10272 Consumer.HandleCXXImplicitFunctionInstantiation(Func); 10273 } 10274 } 10275 } else { 10276 // Walk redefinitions, as some of them may be instantiable. 10277 for (FunctionDecl::redecl_iterator i(Func->redecls_begin()), 10278 e(Func->redecls_end()); i != e; ++i) { 10279 if (!i->isUsed(false) && i->isImplicitlyInstantiable()) 10280 MarkFunctionReferenced(Loc, *i); 10281 } 10282 } 10283 10284 // Keep track of used but undefined functions. 10285 if (!Func->isPure() && !Func->hasBody() && 10286 Func->getLinkage() != ExternalLinkage) { 10287 SourceLocation &old = UndefinedInternals[Func->getCanonicalDecl()]; 10288 if (old.isInvalid()) old = Loc; 10289 } 10290 10291 Func->setUsed(true); 10292} 10293 10294static void 10295diagnoseUncapturableValueReference(Sema &S, SourceLocation loc, 10296 VarDecl *var, DeclContext *DC) { 10297 DeclContext *VarDC = var->getDeclContext(); 10298 10299 // If the parameter still belongs to the translation unit, then 10300 // we're actually just using one parameter in the declaration of 10301 // the next. 10302 if (isa<ParmVarDecl>(var) && 10303 isa<TranslationUnitDecl>(VarDC)) 10304 return; 10305 10306 // For C code, don't diagnose about capture if we're not actually in code 10307 // right now; it's impossible to write a non-constant expression outside of 10308 // function context, so we'll get other (more useful) diagnostics later. 10309 // 10310 // For C++, things get a bit more nasty... it would be nice to suppress this 10311 // diagnostic for certain cases like using a local variable in an array bound 10312 // for a member of a local class, but the correct predicate is not obvious. 10313 if (!S.getLangOpts().CPlusPlus && !S.CurContext->isFunctionOrMethod()) 10314 return; 10315 10316 if (isa<CXXMethodDecl>(VarDC) && 10317 cast<CXXRecordDecl>(VarDC->getParent())->isLambda()) { 10318 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_lambda) 10319 << var->getIdentifier(); 10320 } else if (FunctionDecl *fn = dyn_cast<FunctionDecl>(VarDC)) { 10321 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_function) 10322 << var->getIdentifier() << fn->getDeclName(); 10323 } else if (isa<BlockDecl>(VarDC)) { 10324 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_block) 10325 << var->getIdentifier(); 10326 } else { 10327 // FIXME: Is there any other context where a local variable can be 10328 // declared? 10329 S.Diag(loc, diag::err_reference_to_local_var_in_enclosing_context) 10330 << var->getIdentifier(); 10331 } 10332 10333 S.Diag(var->getLocation(), diag::note_local_variable_declared_here) 10334 << var->getIdentifier(); 10335 10336 // FIXME: Add additional diagnostic info about class etc. which prevents 10337 // capture. 10338} 10339 10340/// \brief Capture the given variable in the given lambda expression. 10341static ExprResult captureInLambda(Sema &S, LambdaScopeInfo *LSI, 10342 VarDecl *Var, QualType FieldType, 10343 QualType DeclRefType, 10344 SourceLocation Loc, 10345 bool RefersToEnclosingLocal) { 10346 CXXRecordDecl *Lambda = LSI->Lambda; 10347 10348 // Build the non-static data member. 10349 FieldDecl *Field 10350 = FieldDecl::Create(S.Context, Lambda, Loc, Loc, 0, FieldType, 10351 S.Context.getTrivialTypeSourceInfo(FieldType, Loc), 10352 0, false, ICIS_NoInit); 10353 Field->setImplicit(true); 10354 Field->setAccess(AS_private); 10355 Lambda->addDecl(Field); 10356 10357 // C++11 [expr.prim.lambda]p21: 10358 // When the lambda-expression is evaluated, the entities that 10359 // are captured by copy are used to direct-initialize each 10360 // corresponding non-static data member of the resulting closure 10361 // object. (For array members, the array elements are 10362 // direct-initialized in increasing subscript order.) These 10363 // initializations are performed in the (unspecified) order in 10364 // which the non-static data members are declared. 10365 10366 // Introduce a new evaluation context for the initialization, so 10367 // that temporaries introduced as part of the capture are retained 10368 // to be re-"exported" from the lambda expression itself. 10369 S.PushExpressionEvaluationContext(Sema::PotentiallyEvaluated); 10370 10371 // C++ [expr.prim.labda]p12: 10372 // An entity captured by a lambda-expression is odr-used (3.2) in 10373 // the scope containing the lambda-expression. 10374 Expr *Ref = new (S.Context) DeclRefExpr(Var, RefersToEnclosingLocal, 10375 DeclRefType, VK_LValue, Loc); 10376 Var->setReferenced(true); 10377 Var->setUsed(true); 10378 10379 // When the field has array type, create index variables for each 10380 // dimension of the array. We use these index variables to subscript 10381 // the source array, and other clients (e.g., CodeGen) will perform 10382 // the necessary iteration with these index variables. 10383 SmallVector<VarDecl *, 4> IndexVariables; 10384 QualType BaseType = FieldType; 10385 QualType SizeType = S.Context.getSizeType(); 10386 LSI->ArrayIndexStarts.push_back(LSI->ArrayIndexVars.size()); 10387 while (const ConstantArrayType *Array 10388 = S.Context.getAsConstantArrayType(BaseType)) { 10389 // Create the iteration variable for this array index. 10390 IdentifierInfo *IterationVarName = 0; 10391 { 10392 SmallString<8> Str; 10393 llvm::raw_svector_ostream OS(Str); 10394 OS << "__i" << IndexVariables.size(); 10395 IterationVarName = &S.Context.Idents.get(OS.str()); 10396 } 10397 VarDecl *IterationVar 10398 = VarDecl::Create(S.Context, S.CurContext, Loc, Loc, 10399 IterationVarName, SizeType, 10400 S.Context.getTrivialTypeSourceInfo(SizeType, Loc), 10401 SC_None, SC_None); 10402 IndexVariables.push_back(IterationVar); 10403 LSI->ArrayIndexVars.push_back(IterationVar); 10404 10405 // Create a reference to the iteration variable. 10406 ExprResult IterationVarRef 10407 = S.BuildDeclRefExpr(IterationVar, SizeType, VK_LValue, Loc); 10408 assert(!IterationVarRef.isInvalid() && 10409 "Reference to invented variable cannot fail!"); 10410 IterationVarRef = S.DefaultLvalueConversion(IterationVarRef.take()); 10411 assert(!IterationVarRef.isInvalid() && 10412 "Conversion of invented variable cannot fail!"); 10413 10414 // Subscript the array with this iteration variable. 10415 ExprResult Subscript = S.CreateBuiltinArraySubscriptExpr( 10416 Ref, Loc, IterationVarRef.take(), Loc); 10417 if (Subscript.isInvalid()) { 10418 S.CleanupVarDeclMarking(); 10419 S.DiscardCleanupsInEvaluationContext(); 10420 S.PopExpressionEvaluationContext(); 10421 return ExprError(); 10422 } 10423 10424 Ref = Subscript.take(); 10425 BaseType = Array->getElementType(); 10426 } 10427 10428 // Construct the entity that we will be initializing. For an array, this 10429 // will be first element in the array, which may require several levels 10430 // of array-subscript entities. 10431 SmallVector<InitializedEntity, 4> Entities; 10432 Entities.reserve(1 + IndexVariables.size()); 10433 Entities.push_back( 10434 InitializedEntity::InitializeLambdaCapture(Var, Field, Loc)); 10435 for (unsigned I = 0, N = IndexVariables.size(); I != N; ++I) 10436 Entities.push_back(InitializedEntity::InitializeElement(S.Context, 10437 0, 10438 Entities.back())); 10439 10440 InitializationKind InitKind 10441 = InitializationKind::CreateDirect(Loc, Loc, Loc); 10442 InitializationSequence Init(S, Entities.back(), InitKind, &Ref, 1); 10443 ExprResult Result(true); 10444 if (!Init.Diagnose(S, Entities.back(), InitKind, &Ref, 1)) 10445 Result = Init.Perform(S, Entities.back(), InitKind, 10446 MultiExprArg(S, &Ref, 1)); 10447 10448 // If this initialization requires any cleanups (e.g., due to a 10449 // default argument to a copy constructor), note that for the 10450 // lambda. 10451 if (S.ExprNeedsCleanups) 10452 LSI->ExprNeedsCleanups = true; 10453 10454 // Exit the expression evaluation context used for the capture. 10455 S.CleanupVarDeclMarking(); 10456 S.DiscardCleanupsInEvaluationContext(); 10457 S.PopExpressionEvaluationContext(); 10458 return Result; 10459} 10460 10461bool Sema::tryCaptureVariable(VarDecl *Var, SourceLocation Loc, 10462 TryCaptureKind Kind, SourceLocation EllipsisLoc, 10463 bool BuildAndDiagnose, 10464 QualType &CaptureType, 10465 QualType &DeclRefType) { 10466 bool Nested = false; 10467 10468 DeclContext *DC = CurContext; 10469 if (Var->getDeclContext() == DC) return true; 10470 if (!Var->hasLocalStorage()) return true; 10471 10472 bool HasBlocksAttr = Var->hasAttr<BlocksAttr>(); 10473 10474 // Walk up the stack to determine whether we can capture the variable, 10475 // performing the "simple" checks that don't depend on type. We stop when 10476 // we've either hit the declared scope of the variable or find an existing 10477 // capture of that variable. 10478 CaptureType = Var->getType(); 10479 DeclRefType = CaptureType.getNonReferenceType(); 10480 bool Explicit = (Kind != TryCapture_Implicit); 10481 unsigned FunctionScopesIndex = FunctionScopes.size() - 1; 10482 do { 10483 // Only block literals and lambda expressions can capture; other 10484 // scopes don't work. 10485 DeclContext *ParentDC; 10486 if (isa<BlockDecl>(DC)) 10487 ParentDC = DC->getParent(); 10488 else if (isa<CXXMethodDecl>(DC) && 10489 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call && 10490 cast<CXXRecordDecl>(DC->getParent())->isLambda()) 10491 ParentDC = DC->getParent()->getParent(); 10492 else { 10493 if (BuildAndDiagnose) 10494 diagnoseUncapturableValueReference(*this, Loc, Var, DC); 10495 return true; 10496 } 10497 10498 CapturingScopeInfo *CSI = 10499 cast<CapturingScopeInfo>(FunctionScopes[FunctionScopesIndex]); 10500 10501 // Check whether we've already captured it. 10502 if (CSI->CaptureMap.count(Var)) { 10503 // If we found a capture, any subcaptures are nested. 10504 Nested = true; 10505 10506 // Retrieve the capture type for this variable. 10507 CaptureType = CSI->getCapture(Var).getCaptureType(); 10508 10509 // Compute the type of an expression that refers to this variable. 10510 DeclRefType = CaptureType.getNonReferenceType(); 10511 10512 const CapturingScopeInfo::Capture &Cap = CSI->getCapture(Var); 10513 if (Cap.isCopyCapture() && 10514 !(isa<LambdaScopeInfo>(CSI) && cast<LambdaScopeInfo>(CSI)->Mutable)) 10515 DeclRefType.addConst(); 10516 break; 10517 } 10518 10519 bool IsBlock = isa<BlockScopeInfo>(CSI); 10520 bool IsLambda = !IsBlock; 10521 10522 // Lambdas are not allowed to capture unnamed variables 10523 // (e.g. anonymous unions). 10524 // FIXME: The C++11 rule don't actually state this explicitly, but I'm 10525 // assuming that's the intent. 10526 if (IsLambda && !Var->getDeclName()) { 10527 if (BuildAndDiagnose) { 10528 Diag(Loc, diag::err_lambda_capture_anonymous_var); 10529 Diag(Var->getLocation(), diag::note_declared_at); 10530 } 10531 return true; 10532 } 10533 10534 // Prohibit variably-modified types; they're difficult to deal with. 10535 if (Var->getType()->isVariablyModifiedType()) { 10536 if (BuildAndDiagnose) { 10537 if (IsBlock) 10538 Diag(Loc, diag::err_ref_vm_type); 10539 else 10540 Diag(Loc, diag::err_lambda_capture_vm_type) << Var->getDeclName(); 10541 Diag(Var->getLocation(), diag::note_previous_decl) 10542 << Var->getDeclName(); 10543 } 10544 return true; 10545 } 10546 10547 // Lambdas are not allowed to capture __block variables; they don't 10548 // support the expected semantics. 10549 if (IsLambda && HasBlocksAttr) { 10550 if (BuildAndDiagnose) { 10551 Diag(Loc, diag::err_lambda_capture_block) 10552 << Var->getDeclName(); 10553 Diag(Var->getLocation(), diag::note_previous_decl) 10554 << Var->getDeclName(); 10555 } 10556 return true; 10557 } 10558 10559 if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None && !Explicit) { 10560 // No capture-default 10561 if (BuildAndDiagnose) { 10562 Diag(Loc, diag::err_lambda_impcap) << Var->getDeclName(); 10563 Diag(Var->getLocation(), diag::note_previous_decl) 10564 << Var->getDeclName(); 10565 Diag(cast<LambdaScopeInfo>(CSI)->Lambda->getLocStart(), 10566 diag::note_lambda_decl); 10567 } 10568 return true; 10569 } 10570 10571 FunctionScopesIndex--; 10572 DC = ParentDC; 10573 Explicit = false; 10574 } while (!Var->getDeclContext()->Equals(DC)); 10575 10576 // Walk back down the scope stack, computing the type of the capture at 10577 // each step, checking type-specific requirements, and adding captures if 10578 // requested. 10579 for (unsigned I = ++FunctionScopesIndex, N = FunctionScopes.size(); I != N; 10580 ++I) { 10581 CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[I]); 10582 10583 // Compute the type of the capture and of a reference to the capture within 10584 // this scope. 10585 if (isa<BlockScopeInfo>(CSI)) { 10586 Expr *CopyExpr = 0; 10587 bool ByRef = false; 10588 10589 // Blocks are not allowed to capture arrays. 10590 if (CaptureType->isArrayType()) { 10591 if (BuildAndDiagnose) { 10592 Diag(Loc, diag::err_ref_array_type); 10593 Diag(Var->getLocation(), diag::note_previous_decl) 10594 << Var->getDeclName(); 10595 } 10596 return true; 10597 } 10598 10599 // Forbid the block-capture of autoreleasing variables. 10600 if (CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) { 10601 if (BuildAndDiagnose) { 10602 Diag(Loc, diag::err_arc_autoreleasing_capture) 10603 << /*block*/ 0; 10604 Diag(Var->getLocation(), diag::note_previous_decl) 10605 << Var->getDeclName(); 10606 } 10607 return true; 10608 } 10609 10610 if (HasBlocksAttr || CaptureType->isReferenceType()) { 10611 // Block capture by reference does not change the capture or 10612 // declaration reference types. 10613 ByRef = true; 10614 } else { 10615 // Block capture by copy introduces 'const'. 10616 CaptureType = CaptureType.getNonReferenceType().withConst(); 10617 DeclRefType = CaptureType; 10618 10619 if (getLangOpts().CPlusPlus && BuildAndDiagnose) { 10620 if (const RecordType *Record = DeclRefType->getAs<RecordType>()) { 10621 // The capture logic needs the destructor, so make sure we mark it. 10622 // Usually this is unnecessary because most local variables have 10623 // their destructors marked at declaration time, but parameters are 10624 // an exception because it's technically only the call site that 10625 // actually requires the destructor. 10626 if (isa<ParmVarDecl>(Var)) 10627 FinalizeVarWithDestructor(Var, Record); 10628 10629 // According to the blocks spec, the capture of a variable from 10630 // the stack requires a const copy constructor. This is not true 10631 // of the copy/move done to move a __block variable to the heap. 10632 Expr *DeclRef = new (Context) DeclRefExpr(Var, false, 10633 DeclRefType.withConst(), 10634 VK_LValue, Loc); 10635 ExprResult Result 10636 = PerformCopyInitialization( 10637 InitializedEntity::InitializeBlock(Var->getLocation(), 10638 CaptureType, false), 10639 Loc, Owned(DeclRef)); 10640 10641 // Build a full-expression copy expression if initialization 10642 // succeeded and used a non-trivial constructor. Recover from 10643 // errors by pretending that the copy isn't necessary. 10644 if (!Result.isInvalid() && 10645 !cast<CXXConstructExpr>(Result.get())->getConstructor() 10646 ->isTrivial()) { 10647 Result = MaybeCreateExprWithCleanups(Result); 10648 CopyExpr = Result.take(); 10649 } 10650 } 10651 } 10652 } 10653 10654 // Actually capture the variable. 10655 if (BuildAndDiagnose) 10656 CSI->addCapture(Var, HasBlocksAttr, ByRef, Nested, Loc, 10657 SourceLocation(), CaptureType, CopyExpr); 10658 Nested = true; 10659 continue; 10660 } 10661 10662 LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI); 10663 10664 // Determine whether we are capturing by reference or by value. 10665 bool ByRef = false; 10666 if (I == N - 1 && Kind != TryCapture_Implicit) { 10667 ByRef = (Kind == TryCapture_ExplicitByRef); 10668 } else { 10669 ByRef = (LSI->ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByref); 10670 } 10671 10672 // Compute the type of the field that will capture this variable. 10673 if (ByRef) { 10674 // C++11 [expr.prim.lambda]p15: 10675 // An entity is captured by reference if it is implicitly or 10676 // explicitly captured but not captured by copy. It is 10677 // unspecified whether additional unnamed non-static data 10678 // members are declared in the closure type for entities 10679 // captured by reference. 10680 // 10681 // FIXME: It is not clear whether we want to build an lvalue reference 10682 // to the DeclRefType or to CaptureType.getNonReferenceType(). GCC appears 10683 // to do the former, while EDG does the latter. Core issue 1249 will 10684 // clarify, but for now we follow GCC because it's a more permissive and 10685 // easily defensible position. 10686 CaptureType = Context.getLValueReferenceType(DeclRefType); 10687 } else { 10688 // C++11 [expr.prim.lambda]p14: 10689 // For each entity captured by copy, an unnamed non-static 10690 // data member is declared in the closure type. The 10691 // declaration order of these members is unspecified. The type 10692 // of such a data member is the type of the corresponding 10693 // captured entity if the entity is not a reference to an 10694 // object, or the referenced type otherwise. [Note: If the 10695 // captured entity is a reference to a function, the 10696 // corresponding data member is also a reference to a 10697 // function. - end note ] 10698 if (const ReferenceType *RefType = CaptureType->getAs<ReferenceType>()){ 10699 if (!RefType->getPointeeType()->isFunctionType()) 10700 CaptureType = RefType->getPointeeType(); 10701 } 10702 10703 // Forbid the lambda copy-capture of autoreleasing variables. 10704 if (CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) { 10705 if (BuildAndDiagnose) { 10706 Diag(Loc, diag::err_arc_autoreleasing_capture) << /*lambda*/ 1; 10707 Diag(Var->getLocation(), diag::note_previous_decl) 10708 << Var->getDeclName(); 10709 } 10710 return true; 10711 } 10712 } 10713 10714 // Capture this variable in the lambda. 10715 Expr *CopyExpr = 0; 10716 if (BuildAndDiagnose) { 10717 ExprResult Result = captureInLambda(*this, LSI, Var, CaptureType, 10718 DeclRefType, Loc, 10719 I == N-1); 10720 if (!Result.isInvalid()) 10721 CopyExpr = Result.take(); 10722 } 10723 10724 // Compute the type of a reference to this captured variable. 10725 if (ByRef) 10726 DeclRefType = CaptureType.getNonReferenceType(); 10727 else { 10728 // C++ [expr.prim.lambda]p5: 10729 // The closure type for a lambda-expression has a public inline 10730 // function call operator [...]. This function call operator is 10731 // declared const (9.3.1) if and only if the lambda-expression’s 10732 // parameter-declaration-clause is not followed by mutable. 10733 DeclRefType = CaptureType.getNonReferenceType(); 10734 if (!LSI->Mutable && !CaptureType->isReferenceType()) 10735 DeclRefType.addConst(); 10736 } 10737 10738 // Add the capture. 10739 if (BuildAndDiagnose) 10740 CSI->addCapture(Var, /*IsBlock=*/false, ByRef, Nested, Loc, 10741 EllipsisLoc, CaptureType, CopyExpr); 10742 Nested = true; 10743 } 10744 10745 return false; 10746} 10747 10748bool Sema::tryCaptureVariable(VarDecl *Var, SourceLocation Loc, 10749 TryCaptureKind Kind, SourceLocation EllipsisLoc) { 10750 QualType CaptureType; 10751 QualType DeclRefType; 10752 return tryCaptureVariable(Var, Loc, Kind, EllipsisLoc, 10753 /*BuildAndDiagnose=*/true, CaptureType, 10754 DeclRefType); 10755} 10756 10757QualType Sema::getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc) { 10758 QualType CaptureType; 10759 QualType DeclRefType; 10760 10761 // Determine whether we can capture this variable. 10762 if (tryCaptureVariable(Var, Loc, TryCapture_Implicit, SourceLocation(), 10763 /*BuildAndDiagnose=*/false, CaptureType, DeclRefType)) 10764 return QualType(); 10765 10766 return DeclRefType; 10767} 10768 10769static void MarkVarDeclODRUsed(Sema &SemaRef, VarDecl *Var, 10770 SourceLocation Loc) { 10771 // Keep track of used but undefined variables. 10772 // FIXME: We shouldn't suppress this warning for static data members. 10773 if (Var->hasDefinition(SemaRef.Context) == VarDecl::DeclarationOnly && 10774 Var->getLinkage() != ExternalLinkage && 10775 !(Var->isStaticDataMember() && Var->hasInit())) { 10776 SourceLocation &old = SemaRef.UndefinedInternals[Var->getCanonicalDecl()]; 10777 if (old.isInvalid()) old = Loc; 10778 } 10779 10780 SemaRef.tryCaptureVariable(Var, Loc); 10781 10782 Var->setUsed(true); 10783} 10784 10785void Sema::UpdateMarkingForLValueToRValue(Expr *E) { 10786 // Per C++11 [basic.def.odr], a variable is odr-used "unless it is 10787 // an object that satisfies the requirements for appearing in a 10788 // constant expression (5.19) and the lvalue-to-rvalue conversion (4.1) 10789 // is immediately applied." This function handles the lvalue-to-rvalue 10790 // conversion part. 10791 MaybeODRUseExprs.erase(E->IgnoreParens()); 10792} 10793 10794ExprResult Sema::ActOnConstantExpression(ExprResult Res) { 10795 if (!Res.isUsable()) 10796 return Res; 10797 10798 // If a constant-expression is a reference to a variable where we delay 10799 // deciding whether it is an odr-use, just assume we will apply the 10800 // lvalue-to-rvalue conversion. In the one case where this doesn't happen 10801 // (a non-type template argument), we have special handling anyway. 10802 UpdateMarkingForLValueToRValue(Res.get()); 10803 return Res; 10804} 10805 10806void Sema::CleanupVarDeclMarking() { 10807 for (llvm::SmallPtrSetIterator<Expr*> i = MaybeODRUseExprs.begin(), 10808 e = MaybeODRUseExprs.end(); 10809 i != e; ++i) { 10810 VarDecl *Var; 10811 SourceLocation Loc; 10812 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(*i)) { 10813 Var = cast<VarDecl>(DRE->getDecl()); 10814 Loc = DRE->getLocation(); 10815 } else if (MemberExpr *ME = dyn_cast<MemberExpr>(*i)) { 10816 Var = cast<VarDecl>(ME->getMemberDecl()); 10817 Loc = ME->getMemberLoc(); 10818 } else { 10819 llvm_unreachable("Unexpcted expression"); 10820 } 10821 10822 MarkVarDeclODRUsed(*this, Var, Loc); 10823 } 10824 10825 MaybeODRUseExprs.clear(); 10826} 10827 10828// Mark a VarDecl referenced, and perform the necessary handling to compute 10829// odr-uses. 10830static void DoMarkVarDeclReferenced(Sema &SemaRef, SourceLocation Loc, 10831 VarDecl *Var, Expr *E) { 10832 Var->setReferenced(); 10833 10834 if (!IsPotentiallyEvaluatedContext(SemaRef)) 10835 return; 10836 10837 // Implicit instantiation of static data members of class templates. 10838 if (Var->isStaticDataMember() && Var->getInstantiatedFromStaticDataMember()) { 10839 MemberSpecializationInfo *MSInfo = Var->getMemberSpecializationInfo(); 10840 assert(MSInfo && "Missing member specialization information?"); 10841 bool AlreadyInstantiated = !MSInfo->getPointOfInstantiation().isInvalid(); 10842 if (MSInfo->getTemplateSpecializationKind() == TSK_ImplicitInstantiation && 10843 (!AlreadyInstantiated || 10844 Var->isUsableInConstantExpressions(SemaRef.Context))) { 10845 if (!AlreadyInstantiated) { 10846 // This is a modification of an existing AST node. Notify listeners. 10847 if (ASTMutationListener *L = SemaRef.getASTMutationListener()) 10848 L->StaticDataMemberInstantiated(Var); 10849 MSInfo->setPointOfInstantiation(Loc); 10850 } 10851 SourceLocation PointOfInstantiation = MSInfo->getPointOfInstantiation(); 10852 if (Var->isUsableInConstantExpressions(SemaRef.Context)) 10853 // Do not defer instantiations of variables which could be used in a 10854 // constant expression. 10855 SemaRef.InstantiateStaticDataMemberDefinition(PointOfInstantiation,Var); 10856 else 10857 SemaRef.PendingInstantiations.push_back( 10858 std::make_pair(Var, PointOfInstantiation)); 10859 } 10860 } 10861 10862 // Per C++11 [basic.def.odr], a variable is odr-used "unless it is 10863 // an object that satisfies the requirements for appearing in a 10864 // constant expression (5.19) and the lvalue-to-rvalue conversion (4.1) 10865 // is immediately applied." We check the first part here, and 10866 // Sema::UpdateMarkingForLValueToRValue deals with the second part. 10867 // Note that we use the C++11 definition everywhere because nothing in 10868 // C++03 depends on whether we get the C++03 version correct. This does not 10869 // apply to references, since they are not objects. 10870 const VarDecl *DefVD; 10871 if (E && !isa<ParmVarDecl>(Var) && !Var->getType()->isReferenceType() && 10872 Var->isUsableInConstantExpressions(SemaRef.Context) && 10873 Var->getAnyInitializer(DefVD) && DefVD->checkInitIsICE()) 10874 SemaRef.MaybeODRUseExprs.insert(E); 10875 else 10876 MarkVarDeclODRUsed(SemaRef, Var, Loc); 10877} 10878 10879/// \brief Mark a variable referenced, and check whether it is odr-used 10880/// (C++ [basic.def.odr]p2, C99 6.9p3). Note that this should not be 10881/// used directly for normal expressions referring to VarDecl. 10882void Sema::MarkVariableReferenced(SourceLocation Loc, VarDecl *Var) { 10883 DoMarkVarDeclReferenced(*this, Loc, Var, 0); 10884} 10885 10886static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, 10887 Decl *D, Expr *E) { 10888 if (VarDecl *Var = dyn_cast<VarDecl>(D)) { 10889 DoMarkVarDeclReferenced(SemaRef, Loc, Var, E); 10890 return; 10891 } 10892 10893 SemaRef.MarkAnyDeclReferenced(Loc, D); 10894 10895 // If this is a call to a method via a cast, also mark the method in the 10896 // derived class used in case codegen can devirtualize the call. 10897 const MemberExpr *ME = dyn_cast<MemberExpr>(E); 10898 if (!ME) 10899 return; 10900 CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ME->getMemberDecl()); 10901 if (!MD) 10902 return; 10903 const Expr *Base = ME->getBase(); 10904 const CXXRecordDecl *MostDerivedClassDecl = Base->getBestDynamicClassType(); 10905 if (!MostDerivedClassDecl) 10906 return; 10907 CXXMethodDecl *DM = MD->getCorrespondingMethodInClass(MostDerivedClassDecl); 10908 if (!DM) 10909 return; 10910 SemaRef.MarkAnyDeclReferenced(Loc, DM); 10911} 10912 10913/// \brief Perform reference-marking and odr-use handling for a DeclRefExpr. 10914void Sema::MarkDeclRefReferenced(DeclRefExpr *E) { 10915 MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E); 10916} 10917 10918/// \brief Perform reference-marking and odr-use handling for a MemberExpr. 10919void Sema::MarkMemberReferenced(MemberExpr *E) { 10920 MarkExprReferenced(*this, E->getMemberLoc(), E->getMemberDecl(), E); 10921} 10922 10923/// \brief Perform marking for a reference to an arbitrary declaration. It 10924/// marks the declaration referenced, and performs odr-use checking for functions 10925/// and variables. This method should not be used when building an normal 10926/// expression which refers to a variable. 10927void Sema::MarkAnyDeclReferenced(SourceLocation Loc, Decl *D) { 10928 if (VarDecl *VD = dyn_cast<VarDecl>(D)) 10929 MarkVariableReferenced(Loc, VD); 10930 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 10931 MarkFunctionReferenced(Loc, FD); 10932 else 10933 D->setReferenced(); 10934} 10935 10936namespace { 10937 // Mark all of the declarations referenced 10938 // FIXME: Not fully implemented yet! We need to have a better understanding 10939 // of when we're entering 10940 class MarkReferencedDecls : public RecursiveASTVisitor<MarkReferencedDecls> { 10941 Sema &S; 10942 SourceLocation Loc; 10943 10944 public: 10945 typedef RecursiveASTVisitor<MarkReferencedDecls> Inherited; 10946 10947 MarkReferencedDecls(Sema &S, SourceLocation Loc) : S(S), Loc(Loc) { } 10948 10949 bool TraverseTemplateArgument(const TemplateArgument &Arg); 10950 bool TraverseRecordType(RecordType *T); 10951 }; 10952} 10953 10954bool MarkReferencedDecls::TraverseTemplateArgument( 10955 const TemplateArgument &Arg) { 10956 if (Arg.getKind() == TemplateArgument::Declaration) { 10957 if (Decl *D = Arg.getAsDecl()) 10958 S.MarkAnyDeclReferenced(Loc, D); 10959 } 10960 10961 return Inherited::TraverseTemplateArgument(Arg); 10962} 10963 10964bool MarkReferencedDecls::TraverseRecordType(RecordType *T) { 10965 if (ClassTemplateSpecializationDecl *Spec 10966 = dyn_cast<ClassTemplateSpecializationDecl>(T->getDecl())) { 10967 const TemplateArgumentList &Args = Spec->getTemplateArgs(); 10968 return TraverseTemplateArguments(Args.data(), Args.size()); 10969 } 10970 10971 return true; 10972} 10973 10974void Sema::MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T) { 10975 MarkReferencedDecls Marker(*this, Loc); 10976 Marker.TraverseType(Context.getCanonicalType(T)); 10977} 10978 10979namespace { 10980 /// \brief Helper class that marks all of the declarations referenced by 10981 /// potentially-evaluated subexpressions as "referenced". 10982 class EvaluatedExprMarker : public EvaluatedExprVisitor<EvaluatedExprMarker> { 10983 Sema &S; 10984 bool SkipLocalVariables; 10985 10986 public: 10987 typedef EvaluatedExprVisitor<EvaluatedExprMarker> Inherited; 10988 10989 EvaluatedExprMarker(Sema &S, bool SkipLocalVariables) 10990 : Inherited(S.Context), S(S), SkipLocalVariables(SkipLocalVariables) { } 10991 10992 void VisitDeclRefExpr(DeclRefExpr *E) { 10993 // If we were asked not to visit local variables, don't. 10994 if (SkipLocalVariables) { 10995 if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) 10996 if (VD->hasLocalStorage()) 10997 return; 10998 } 10999 11000 S.MarkDeclRefReferenced(E); 11001 } 11002 11003 void VisitMemberExpr(MemberExpr *E) { 11004 S.MarkMemberReferenced(E); 11005 Inherited::VisitMemberExpr(E); 11006 } 11007 11008 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 11009 S.MarkFunctionReferenced(E->getLocStart(), 11010 const_cast<CXXDestructorDecl*>(E->getTemporary()->getDestructor())); 11011 Visit(E->getSubExpr()); 11012 } 11013 11014 void VisitCXXNewExpr(CXXNewExpr *E) { 11015 if (E->getOperatorNew()) 11016 S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorNew()); 11017 if (E->getOperatorDelete()) 11018 S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorDelete()); 11019 Inherited::VisitCXXNewExpr(E); 11020 } 11021 11022 void VisitCXXDeleteExpr(CXXDeleteExpr *E) { 11023 if (E->getOperatorDelete()) 11024 S.MarkFunctionReferenced(E->getLocStart(), E->getOperatorDelete()); 11025 QualType Destroyed = S.Context.getBaseElementType(E->getDestroyedType()); 11026 if (const RecordType *DestroyedRec = Destroyed->getAs<RecordType>()) { 11027 CXXRecordDecl *Record = cast<CXXRecordDecl>(DestroyedRec->getDecl()); 11028 S.MarkFunctionReferenced(E->getLocStart(), 11029 S.LookupDestructor(Record)); 11030 } 11031 11032 Inherited::VisitCXXDeleteExpr(E); 11033 } 11034 11035 void VisitCXXConstructExpr(CXXConstructExpr *E) { 11036 S.MarkFunctionReferenced(E->getLocStart(), E->getConstructor()); 11037 Inherited::VisitCXXConstructExpr(E); 11038 } 11039 11040 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) { 11041 Visit(E->getExpr()); 11042 } 11043 11044 void VisitImplicitCastExpr(ImplicitCastExpr *E) { 11045 Inherited::VisitImplicitCastExpr(E); 11046 11047 if (E->getCastKind() == CK_LValueToRValue) 11048 S.UpdateMarkingForLValueToRValue(E->getSubExpr()); 11049 } 11050 }; 11051} 11052 11053/// \brief Mark any declarations that appear within this expression or any 11054/// potentially-evaluated subexpressions as "referenced". 11055/// 11056/// \param SkipLocalVariables If true, don't mark local variables as 11057/// 'referenced'. 11058void Sema::MarkDeclarationsReferencedInExpr(Expr *E, 11059 bool SkipLocalVariables) { 11060 EvaluatedExprMarker(*this, SkipLocalVariables).Visit(E); 11061} 11062 11063/// \brief Emit a diagnostic that describes an effect on the run-time behavior 11064/// of the program being compiled. 11065/// 11066/// This routine emits the given diagnostic when the code currently being 11067/// type-checked is "potentially evaluated", meaning that there is a 11068/// possibility that the code will actually be executable. Code in sizeof() 11069/// expressions, code used only during overload resolution, etc., are not 11070/// potentially evaluated. This routine will suppress such diagnostics or, 11071/// in the absolutely nutty case of potentially potentially evaluated 11072/// expressions (C++ typeid), queue the diagnostic to potentially emit it 11073/// later. 11074/// 11075/// This routine should be used for all diagnostics that describe the run-time 11076/// behavior of a program, such as passing a non-POD value through an ellipsis. 11077/// Failure to do so will likely result in spurious diagnostics or failures 11078/// during overload resolution or within sizeof/alignof/typeof/typeid. 11079bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement, 11080 const PartialDiagnostic &PD) { 11081 switch (ExprEvalContexts.back().Context) { 11082 case Unevaluated: 11083 // The argument will never be evaluated, so don't complain. 11084 break; 11085 11086 case ConstantEvaluated: 11087 // Relevant diagnostics should be produced by constant evaluation. 11088 break; 11089 11090 case PotentiallyEvaluated: 11091 case PotentiallyEvaluatedIfUsed: 11092 if (Statement && getCurFunctionOrMethodDecl()) { 11093 FunctionScopes.back()->PossiblyUnreachableDiags. 11094 push_back(sema::PossiblyUnreachableDiag(PD, Loc, Statement)); 11095 } 11096 else 11097 Diag(Loc, PD); 11098 11099 return true; 11100 } 11101 11102 return false; 11103} 11104 11105bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc, 11106 CallExpr *CE, FunctionDecl *FD) { 11107 if (ReturnType->isVoidType() || !ReturnType->isIncompleteType()) 11108 return false; 11109 11110 // If we're inside a decltype's expression, don't check for a valid return 11111 // type or construct temporaries until we know whether this is the last call. 11112 if (ExprEvalContexts.back().IsDecltype) { 11113 ExprEvalContexts.back().DelayedDecltypeCalls.push_back(CE); 11114 return false; 11115 } 11116 11117 class CallReturnIncompleteDiagnoser : public TypeDiagnoser { 11118 FunctionDecl *FD; 11119 CallExpr *CE; 11120 11121 public: 11122 CallReturnIncompleteDiagnoser(FunctionDecl *FD, CallExpr *CE) 11123 : FD(FD), CE(CE) { } 11124 11125 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) { 11126 if (!FD) { 11127 S.Diag(Loc, diag::err_call_incomplete_return) 11128 << T << CE->getSourceRange(); 11129 return; 11130 } 11131 11132 S.Diag(Loc, diag::err_call_function_incomplete_return) 11133 << CE->getSourceRange() << FD->getDeclName() << T; 11134 S.Diag(FD->getLocation(), 11135 diag::note_function_with_incomplete_return_type_declared_here) 11136 << FD->getDeclName(); 11137 } 11138 } Diagnoser(FD, CE); 11139 11140 if (RequireCompleteType(Loc, ReturnType, Diagnoser)) 11141 return true; 11142 11143 return false; 11144} 11145 11146// Diagnose the s/=/==/ and s/\|=/!=/ typos. Note that adding parentheses 11147// will prevent this condition from triggering, which is what we want. 11148void Sema::DiagnoseAssignmentAsCondition(Expr *E) { 11149 SourceLocation Loc; 11150 11151 unsigned diagnostic = diag::warn_condition_is_assignment; 11152 bool IsOrAssign = false; 11153 11154 if (BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) { 11155 if (Op->getOpcode() != BO_Assign && Op->getOpcode() != BO_OrAssign) 11156 return; 11157 11158 IsOrAssign = Op->getOpcode() == BO_OrAssign; 11159 11160 // Greylist some idioms by putting them into a warning subcategory. 11161 if (ObjCMessageExpr *ME 11162 = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) { 11163 Selector Sel = ME->getSelector(); 11164 11165 // self = [<foo> init...] 11166 if (isSelfExpr(Op->getLHS()) && Sel.getNameForSlot(0).startswith("init")) 11167 diagnostic = diag::warn_condition_is_idiomatic_assignment; 11168 11169 // <foo> = [<bar> nextObject] 11170 else if (Sel.isUnarySelector() && Sel.getNameForSlot(0) == "nextObject") 11171 diagnostic = diag::warn_condition_is_idiomatic_assignment; 11172 } 11173 11174 Loc = Op->getOperatorLoc(); 11175 } else if (CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) { 11176 if (Op->getOperator() != OO_Equal && Op->getOperator() != OO_PipeEqual) 11177 return; 11178 11179 IsOrAssign = Op->getOperator() == OO_PipeEqual; 11180 Loc = Op->getOperatorLoc(); 11181 } else { 11182 // Not an assignment. 11183 return; 11184 } 11185 11186 Diag(Loc, diagnostic) << E->getSourceRange(); 11187 11188 SourceLocation Open = E->getLocStart(); 11189 SourceLocation Close = PP.getLocForEndOfToken(E->getSourceRange().getEnd()); 11190 Diag(Loc, diag::note_condition_assign_silence) 11191 << FixItHint::CreateInsertion(Open, "(") 11192 << FixItHint::CreateInsertion(Close, ")"); 11193 11194 if (IsOrAssign) 11195 Diag(Loc, diag::note_condition_or_assign_to_comparison) 11196 << FixItHint::CreateReplacement(Loc, "!="); 11197 else 11198 Diag(Loc, diag::note_condition_assign_to_comparison) 11199 << FixItHint::CreateReplacement(Loc, "=="); 11200} 11201 11202/// \brief Redundant parentheses over an equality comparison can indicate 11203/// that the user intended an assignment used as condition. 11204void Sema::DiagnoseEqualityWithExtraParens(ParenExpr *ParenE) { 11205 // Don't warn if the parens came from a macro. 11206 SourceLocation parenLoc = ParenE->getLocStart(); 11207 if (parenLoc.isInvalid() || parenLoc.isMacroID()) 11208 return; 11209 // Don't warn for dependent expressions. 11210 if (ParenE->isTypeDependent()) 11211 return; 11212 11213 Expr *E = ParenE->IgnoreParens(); 11214 11215 if (BinaryOperator *opE = dyn_cast<BinaryOperator>(E)) 11216 if (opE->getOpcode() == BO_EQ && 11217 opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context) 11218 == Expr::MLV_Valid) { 11219 SourceLocation Loc = opE->getOperatorLoc(); 11220 11221 Diag(Loc, diag::warn_equality_with_extra_parens) << E->getSourceRange(); 11222 SourceRange ParenERange = ParenE->getSourceRange(); 11223 Diag(Loc, diag::note_equality_comparison_silence) 11224 << FixItHint::CreateRemoval(ParenERange.getBegin()) 11225 << FixItHint::CreateRemoval(ParenERange.getEnd()); 11226 Diag(Loc, diag::note_equality_comparison_to_assign) 11227 << FixItHint::CreateReplacement(Loc, "="); 11228 } 11229} 11230 11231ExprResult Sema::CheckBooleanCondition(Expr *E, SourceLocation Loc) { 11232 DiagnoseAssignmentAsCondition(E); 11233 if (ParenExpr *parenE = dyn_cast<ParenExpr>(E)) 11234 DiagnoseEqualityWithExtraParens(parenE); 11235 11236 ExprResult result = CheckPlaceholderExpr(E); 11237 if (result.isInvalid()) return ExprError(); 11238 E = result.take(); 11239 11240 if (!E->isTypeDependent()) { 11241 if (getLangOpts().CPlusPlus) 11242 return CheckCXXBooleanCondition(E); // C++ 6.4p4 11243 11244 ExprResult ERes = DefaultFunctionArrayLvalueConversion(E); 11245 if (ERes.isInvalid()) 11246 return ExprError(); 11247 E = ERes.take(); 11248 11249 QualType T = E->getType(); 11250 if (!T->isScalarType()) { // C99 6.8.4.1p1 11251 Diag(Loc, diag::err_typecheck_statement_requires_scalar) 11252 << T << E->getSourceRange(); 11253 return ExprError(); 11254 } 11255 } 11256 11257 return Owned(E); 11258} 11259 11260ExprResult Sema::ActOnBooleanCondition(Scope *S, SourceLocation Loc, 11261 Expr *SubExpr) { 11262 if (!SubExpr) 11263 return ExprError(); 11264 11265 return CheckBooleanCondition(SubExpr, Loc); 11266} 11267 11268namespace { 11269 /// A visitor for rebuilding a call to an __unknown_any expression 11270 /// to have an appropriate type. 11271 struct RebuildUnknownAnyFunction 11272 : StmtVisitor<RebuildUnknownAnyFunction, ExprResult> { 11273 11274 Sema &S; 11275 11276 RebuildUnknownAnyFunction(Sema &S) : S(S) {} 11277 11278 ExprResult VisitStmt(Stmt *S) { 11279 llvm_unreachable("unexpected statement!"); 11280 } 11281 11282 ExprResult VisitExpr(Expr *E) { 11283 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_call) 11284 << E->getSourceRange(); 11285 return ExprError(); 11286 } 11287 11288 /// Rebuild an expression which simply semantically wraps another 11289 /// expression which it shares the type and value kind of. 11290 template <class T> ExprResult rebuildSugarExpr(T *E) { 11291 ExprResult SubResult = Visit(E->getSubExpr()); 11292 if (SubResult.isInvalid()) return ExprError(); 11293 11294 Expr *SubExpr = SubResult.take(); 11295 E->setSubExpr(SubExpr); 11296 E->setType(SubExpr->getType()); 11297 E->setValueKind(SubExpr->getValueKind()); 11298 assert(E->getObjectKind() == OK_Ordinary); 11299 return E; 11300 } 11301 11302 ExprResult VisitParenExpr(ParenExpr *E) { 11303 return rebuildSugarExpr(E); 11304 } 11305 11306 ExprResult VisitUnaryExtension(UnaryOperator *E) { 11307 return rebuildSugarExpr(E); 11308 } 11309 11310 ExprResult VisitUnaryAddrOf(UnaryOperator *E) { 11311 ExprResult SubResult = Visit(E->getSubExpr()); 11312 if (SubResult.isInvalid()) return ExprError(); 11313 11314 Expr *SubExpr = SubResult.take(); 11315 E->setSubExpr(SubExpr); 11316 E->setType(S.Context.getPointerType(SubExpr->getType())); 11317 assert(E->getValueKind() == VK_RValue); 11318 assert(E->getObjectKind() == OK_Ordinary); 11319 return E; 11320 } 11321 11322 ExprResult resolveDecl(Expr *E, ValueDecl *VD) { 11323 if (!isa<FunctionDecl>(VD)) return VisitExpr(E); 11324 11325 E->setType(VD->getType()); 11326 11327 assert(E->getValueKind() == VK_RValue); 11328 if (S.getLangOpts().CPlusPlus && 11329 !(isa<CXXMethodDecl>(VD) && 11330 cast<CXXMethodDecl>(VD)->isInstance())) 11331 E->setValueKind(VK_LValue); 11332 11333 return E; 11334 } 11335 11336 ExprResult VisitMemberExpr(MemberExpr *E) { 11337 return resolveDecl(E, E->getMemberDecl()); 11338 } 11339 11340 ExprResult VisitDeclRefExpr(DeclRefExpr *E) { 11341 return resolveDecl(E, E->getDecl()); 11342 } 11343 }; 11344} 11345 11346/// Given a function expression of unknown-any type, try to rebuild it 11347/// to have a function type. 11348static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *FunctionExpr) { 11349 ExprResult Result = RebuildUnknownAnyFunction(S).Visit(FunctionExpr); 11350 if (Result.isInvalid()) return ExprError(); 11351 return S.DefaultFunctionArrayConversion(Result.take()); 11352} 11353 11354namespace { 11355 /// A visitor for rebuilding an expression of type __unknown_anytype 11356 /// into one which resolves the type directly on the referring 11357 /// expression. Strict preservation of the original source 11358 /// structure is not a goal. 11359 struct RebuildUnknownAnyExpr 11360 : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> { 11361 11362 Sema &S; 11363 11364 /// The current destination type. 11365 QualType DestType; 11366 11367 RebuildUnknownAnyExpr(Sema &S, QualType CastType) 11368 : S(S), DestType(CastType) {} 11369 11370 ExprResult VisitStmt(Stmt *S) { 11371 llvm_unreachable("unexpected statement!"); 11372 } 11373 11374 ExprResult VisitExpr(Expr *E) { 11375 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr) 11376 << E->getSourceRange(); 11377 return ExprError(); 11378 } 11379 11380 ExprResult VisitCallExpr(CallExpr *E); 11381 ExprResult VisitObjCMessageExpr(ObjCMessageExpr *E); 11382 11383 /// Rebuild an expression which simply semantically wraps another 11384 /// expression which it shares the type and value kind of. 11385 template <class T> ExprResult rebuildSugarExpr(T *E) { 11386 ExprResult SubResult = Visit(E->getSubExpr()); 11387 if (SubResult.isInvalid()) return ExprError(); 11388 Expr *SubExpr = SubResult.take(); 11389 E->setSubExpr(SubExpr); 11390 E->setType(SubExpr->getType()); 11391 E->setValueKind(SubExpr->getValueKind()); 11392 assert(E->getObjectKind() == OK_Ordinary); 11393 return E; 11394 } 11395 11396 ExprResult VisitParenExpr(ParenExpr *E) { 11397 return rebuildSugarExpr(E); 11398 } 11399 11400 ExprResult VisitUnaryExtension(UnaryOperator *E) { 11401 return rebuildSugarExpr(E); 11402 } 11403 11404 ExprResult VisitUnaryAddrOf(UnaryOperator *E) { 11405 const PointerType *Ptr = DestType->getAs<PointerType>(); 11406 if (!Ptr) { 11407 S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof) 11408 << E->getSourceRange(); 11409 return ExprError(); 11410 } 11411 assert(E->getValueKind() == VK_RValue); 11412 assert(E->getObjectKind() == OK_Ordinary); 11413 E->setType(DestType); 11414 11415 // Build the sub-expression as if it were an object of the pointee type. 11416 DestType = Ptr->getPointeeType(); 11417 ExprResult SubResult = Visit(E->getSubExpr()); 11418 if (SubResult.isInvalid()) return ExprError(); 11419 E->setSubExpr(SubResult.take()); 11420 return E; 11421 } 11422 11423 ExprResult VisitImplicitCastExpr(ImplicitCastExpr *E); 11424 11425 ExprResult resolveDecl(Expr *E, ValueDecl *VD); 11426 11427 ExprResult VisitMemberExpr(MemberExpr *E) { 11428 return resolveDecl(E, E->getMemberDecl()); 11429 } 11430 11431 ExprResult VisitDeclRefExpr(DeclRefExpr *E) { 11432 return resolveDecl(E, E->getDecl()); 11433 } 11434 }; 11435} 11436 11437/// Rebuilds a call expression which yielded __unknown_anytype. 11438ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) { 11439 Expr *CalleeExpr = E->getCallee(); 11440 11441 enum FnKind { 11442 FK_MemberFunction, 11443 FK_FunctionPointer, 11444 FK_BlockPointer 11445 }; 11446 11447 FnKind Kind; 11448 QualType CalleeType = CalleeExpr->getType(); 11449 if (CalleeType == S.Context.BoundMemberTy) { 11450 assert(isa<CXXMemberCallExpr>(E) || isa<CXXOperatorCallExpr>(E)); 11451 Kind = FK_MemberFunction; 11452 CalleeType = Expr::findBoundMemberType(CalleeExpr); 11453 } else if (const PointerType *Ptr = CalleeType->getAs<PointerType>()) { 11454 CalleeType = Ptr->getPointeeType(); 11455 Kind = FK_FunctionPointer; 11456 } else { 11457 CalleeType = CalleeType->castAs<BlockPointerType>()->getPointeeType(); 11458 Kind = FK_BlockPointer; 11459 } 11460 const FunctionType *FnType = CalleeType->castAs<FunctionType>(); 11461 11462 // Verify that this is a legal result type of a function. 11463 if (DestType->isArrayType() || DestType->isFunctionType()) { 11464 unsigned diagID = diag::err_func_returning_array_function; 11465 if (Kind == FK_BlockPointer) 11466 diagID = diag::err_block_returning_array_function; 11467 11468 S.Diag(E->getExprLoc(), diagID) 11469 << DestType->isFunctionType() << DestType; 11470 return ExprError(); 11471 } 11472 11473 // Otherwise, go ahead and set DestType as the call's result. 11474 E->setType(DestType.getNonLValueExprType(S.Context)); 11475 E->setValueKind(Expr::getValueKindForType(DestType)); 11476 assert(E->getObjectKind() == OK_Ordinary); 11477 11478 // Rebuild the function type, replacing the result type with DestType. 11479 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FnType)) 11480 DestType = S.Context.getFunctionType(DestType, 11481 Proto->arg_type_begin(), 11482 Proto->getNumArgs(), 11483 Proto->getExtProtoInfo()); 11484 else 11485 DestType = S.Context.getFunctionNoProtoType(DestType, 11486 FnType->getExtInfo()); 11487 11488 // Rebuild the appropriate pointer-to-function type. 11489 switch (Kind) { 11490 case FK_MemberFunction: 11491 // Nothing to do. 11492 break; 11493 11494 case FK_FunctionPointer: 11495 DestType = S.Context.getPointerType(DestType); 11496 break; 11497 11498 case FK_BlockPointer: 11499 DestType = S.Context.getBlockPointerType(DestType); 11500 break; 11501 } 11502 11503 // Finally, we can recurse. 11504 ExprResult CalleeResult = Visit(CalleeExpr); 11505 if (!CalleeResult.isUsable()) return ExprError(); 11506 E->setCallee(CalleeResult.take()); 11507 11508 // Bind a temporary if necessary. 11509 return S.MaybeBindToTemporary(E); 11510} 11511 11512ExprResult RebuildUnknownAnyExpr::VisitObjCMessageExpr(ObjCMessageExpr *E) { 11513 // Verify that this is a legal result type of a call. 11514 if (DestType->isArrayType() || DestType->isFunctionType()) { 11515 S.Diag(E->getExprLoc(), diag::err_func_returning_array_function) 11516 << DestType->isFunctionType() << DestType; 11517 return ExprError(); 11518 } 11519 11520 // Rewrite the method result type if available. 11521 if (ObjCMethodDecl *Method = E->getMethodDecl()) { 11522 assert(Method->getResultType() == S.Context.UnknownAnyTy); 11523 Method->setResultType(DestType); 11524 } 11525 11526 // Change the type of the message. 11527 E->setType(DestType.getNonReferenceType()); 11528 E->setValueKind(Expr::getValueKindForType(DestType)); 11529 11530 return S.MaybeBindToTemporary(E); 11531} 11532 11533ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *E) { 11534 // The only case we should ever see here is a function-to-pointer decay. 11535 if (E->getCastKind() == CK_FunctionToPointerDecay) { 11536 assert(E->getValueKind() == VK_RValue); 11537 assert(E->getObjectKind() == OK_Ordinary); 11538 11539 E->setType(DestType); 11540 11541 // Rebuild the sub-expression as the pointee (function) type. 11542 DestType = DestType->castAs<PointerType>()->getPointeeType(); 11543 11544 ExprResult Result = Visit(E->getSubExpr()); 11545 if (!Result.isUsable()) return ExprError(); 11546 11547 E->setSubExpr(Result.take()); 11548 return S.Owned(E); 11549 } else if (E->getCastKind() == CK_LValueToRValue) { 11550 assert(E->getValueKind() == VK_RValue); 11551 assert(E->getObjectKind() == OK_Ordinary); 11552 11553 assert(isa<BlockPointerType>(E->getType())); 11554 11555 E->setType(DestType); 11556 11557 // The sub-expression has to be a lvalue reference, so rebuild it as such. 11558 DestType = S.Context.getLValueReferenceType(DestType); 11559 11560 ExprResult Result = Visit(E->getSubExpr()); 11561 if (!Result.isUsable()) return ExprError(); 11562 11563 E->setSubExpr(Result.take()); 11564 return S.Owned(E); 11565 } else { 11566 llvm_unreachable("Unhandled cast type!"); 11567 } 11568} 11569 11570ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) { 11571 ExprValueKind ValueKind = VK_LValue; 11572 QualType Type = DestType; 11573 11574 // We know how to make this work for certain kinds of decls: 11575 11576 // - functions 11577 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(VD)) { 11578 if (const PointerType *Ptr = Type->getAs<PointerType>()) { 11579 DestType = Ptr->getPointeeType(); 11580 ExprResult Result = resolveDecl(E, VD); 11581 if (Result.isInvalid()) return ExprError(); 11582 return S.ImpCastExprToType(Result.take(), Type, 11583 CK_FunctionToPointerDecay, VK_RValue); 11584 } 11585 11586 if (!Type->isFunctionType()) { 11587 S.Diag(E->getExprLoc(), diag::err_unknown_any_function) 11588 << VD << E->getSourceRange(); 11589 return ExprError(); 11590 } 11591 11592 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) 11593 if (MD->isInstance()) { 11594 ValueKind = VK_RValue; 11595 Type = S.Context.BoundMemberTy; 11596 } 11597 11598 // Function references aren't l-values in C. 11599 if (!S.getLangOpts().CPlusPlus) 11600 ValueKind = VK_RValue; 11601 11602 // - variables 11603 } else if (isa<VarDecl>(VD)) { 11604 if (const ReferenceType *RefTy = Type->getAs<ReferenceType>()) { 11605 Type = RefTy->getPointeeType(); 11606 } else if (Type->isFunctionType()) { 11607 S.Diag(E->getExprLoc(), diag::err_unknown_any_var_function_type) 11608 << VD << E->getSourceRange(); 11609 return ExprError(); 11610 } 11611 11612 // - nothing else 11613 } else { 11614 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_decl) 11615 << VD << E->getSourceRange(); 11616 return ExprError(); 11617 } 11618 11619 VD->setType(DestType); 11620 E->setType(Type); 11621 E->setValueKind(ValueKind); 11622 return S.Owned(E); 11623} 11624 11625/// Check a cast of an unknown-any type. We intentionally only 11626/// trigger this for C-style casts. 11627ExprResult Sema::checkUnknownAnyCast(SourceRange TypeRange, QualType CastType, 11628 Expr *CastExpr, CastKind &CastKind, 11629 ExprValueKind &VK, CXXCastPath &Path) { 11630 // Rewrite the casted expression from scratch. 11631 ExprResult result = RebuildUnknownAnyExpr(*this, CastType).Visit(CastExpr); 11632 if (!result.isUsable()) return ExprError(); 11633 11634 CastExpr = result.take(); 11635 VK = CastExpr->getValueKind(); 11636 CastKind = CK_NoOp; 11637 11638 return CastExpr; 11639} 11640 11641ExprResult Sema::forceUnknownAnyToType(Expr *E, QualType ToType) { 11642 return RebuildUnknownAnyExpr(*this, ToType).Visit(E); 11643} 11644 11645static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) { 11646 Expr *orig = E; 11647 unsigned diagID = diag::err_uncasted_use_of_unknown_any; 11648 while (true) { 11649 E = E->IgnoreParenImpCasts(); 11650 if (CallExpr *call = dyn_cast<CallExpr>(E)) { 11651 E = call->getCallee(); 11652 diagID = diag::err_uncasted_call_of_unknown_any; 11653 } else { 11654 break; 11655 } 11656 } 11657 11658 SourceLocation loc; 11659 NamedDecl *d; 11660 if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) { 11661 loc = ref->getLocation(); 11662 d = ref->getDecl(); 11663 } else if (MemberExpr *mem = dyn_cast<MemberExpr>(E)) { 11664 loc = mem->getMemberLoc(); 11665 d = mem->getMemberDecl(); 11666 } else if (ObjCMessageExpr *msg = dyn_cast<ObjCMessageExpr>(E)) { 11667 diagID = diag::err_uncasted_call_of_unknown_any; 11668 loc = msg->getSelectorStartLoc(); 11669 d = msg->getMethodDecl(); 11670 if (!d) { 11671 S.Diag(loc, diag::err_uncasted_send_to_unknown_any_method) 11672 << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector() 11673 << orig->getSourceRange(); 11674 return ExprError(); 11675 } 11676 } else { 11677 S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr) 11678 << E->getSourceRange(); 11679 return ExprError(); 11680 } 11681 11682 S.Diag(loc, diagID) << d << orig->getSourceRange(); 11683 11684 // Never recoverable. 11685 return ExprError(); 11686} 11687 11688/// Check for operands with placeholder types and complain if found. 11689/// Returns true if there was an error and no recovery was possible. 11690ExprResult Sema::CheckPlaceholderExpr(Expr *E) { 11691 const BuiltinType *placeholderType = E->getType()->getAsPlaceholderType(); 11692 if (!placeholderType) return Owned(E); 11693 11694 switch (placeholderType->getKind()) { 11695 11696 // Overloaded expressions. 11697 case BuiltinType::Overload: { 11698 // Try to resolve a single function template specialization. 11699 // This is obligatory. 11700 ExprResult result = Owned(E); 11701 if (ResolveAndFixSingleFunctionTemplateSpecialization(result, false)) { 11702 return result; 11703 11704 // If that failed, try to recover with a call. 11705 } else { 11706 tryToRecoverWithCall(result, PDiag(diag::err_ovl_unresolvable), 11707 /*complain*/ true); 11708 return result; 11709 } 11710 } 11711 11712 // Bound member functions. 11713 case BuiltinType::BoundMember: { 11714 ExprResult result = Owned(E); 11715 tryToRecoverWithCall(result, PDiag(diag::err_bound_member_function), 11716 /*complain*/ true); 11717 return result; 11718 } 11719 11720 // ARC unbridged casts. 11721 case BuiltinType::ARCUnbridgedCast: { 11722 Expr *realCast = stripARCUnbridgedCast(E); 11723 diagnoseARCUnbridgedCast(realCast); 11724 return Owned(realCast); 11725 } 11726 11727 // Expressions of unknown type. 11728 case BuiltinType::UnknownAny: 11729 return diagnoseUnknownAnyExpr(*this, E); 11730 11731 // Pseudo-objects. 11732 case BuiltinType::PseudoObject: 11733 return checkPseudoObjectRValue(E); 11734 11735 // Everything else should be impossible. 11736#define BUILTIN_TYPE(Id, SingletonId) \ 11737 case BuiltinType::Id: 11738#define PLACEHOLDER_TYPE(Id, SingletonId) 11739#include "clang/AST/BuiltinTypes.def" 11740 break; 11741 } 11742 11743 llvm_unreachable("invalid placeholder type!"); 11744} 11745 11746bool Sema::CheckCaseExpression(Expr *E) { 11747 if (E->isTypeDependent()) 11748 return true; 11749 if (E->isValueDependent() || E->isIntegerConstantExpr(Context)) 11750 return E->getType()->isIntegralOrEnumerationType(); 11751 return false; 11752} 11753 11754/// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals. 11755ExprResult 11756Sema::ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) { 11757 assert((Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) && 11758 "Unknown Objective-C Boolean value!"); 11759 return Owned(new (Context) ObjCBoolLiteralExpr(Kind == tok::kw___objc_yes, 11760 Context.ObjCBuiltinBoolTy, OpLoc)); 11761} 11762