1 //===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements semantic analysis for expressions. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Sema/SemaInternal.h" 15 #include "clang/Sema/DelayedDiagnostic.h" 16 #include "clang/Sema/Initialization.h" 17 #include "clang/Sema/Lookup.h" 18 #include "clang/Sema/ScopeInfo.h" 19 #include "clang/Sema/AnalysisBasedWarnings.h" 20 #include "clang/AST/ASTContext.h" 21 #include "clang/AST/ASTConsumer.h" 22 #include "clang/AST/ASTMutationListener.h" 23 #include "clang/AST/CXXInheritance.h" 24 #include "clang/AST/DeclObjC.h" 25 #include "clang/AST/DeclTemplate.h" 26 #include "clang/AST/EvaluatedExprVisitor.h" 27 #include "clang/AST/Expr.h" 28 #include "clang/AST/ExprCXX.h" 29 #include "clang/AST/ExprObjC.h" 30 #include "clang/AST/RecursiveASTVisitor.h" 31 #include "clang/AST/TypeLoc.h" 32 #include "clang/Basic/PartialDiagnostic.h" 33 #include "clang/Basic/SourceManager.h" 34 #include "clang/Basic/TargetInfo.h" 35 #include "clang/Lex/LiteralSupport.h" 36 #include "clang/Lex/Preprocessor.h" 37 #include "clang/Sema/DeclSpec.h" 38 #include "clang/Sema/Designator.h" 39 #include "clang/Sema/Scope.h" 40 #include "clang/Sema/ScopeInfo.h" 41 #include "clang/Sema/ParsedTemplate.h" 42 #include "clang/Sema/SemaFixItUtils.h" 43 #include "clang/Sema/Template.h" 44 #include "TreeTransform.h" 45 using namespace clang; 46 using namespace sema; 47 48 /// \brief Determine whether the use of this declaration is valid, without 49 /// emitting diagnostics. 50 bool Sema::CanUseDecl(NamedDecl *D) { 51 // See if this is an auto-typed variable whose initializer we are parsing. 52 if (ParsingInitForAutoVars.count(D)) 53 return false; 54 55 // See if this is a deleted function. 56 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 57 if (FD->isDeleted()) 58 return false; 59 } 60 61 // See if this function is unavailable. 62 if (D->getAvailability() == AR_Unavailable && 63 cast<Decl>(CurContext)->getAvailability() != AR_Unavailable) 64 return false; 65 66 return true; 67 } 68 69 static AvailabilityResult DiagnoseAvailabilityOfDecl(Sema &S, 70 NamedDecl *D, SourceLocation Loc, 71 const ObjCInterfaceDecl *UnknownObjCClass) { 72 // See if this declaration is unavailable or deprecated. 73 std::string Message; 74 AvailabilityResult Result = D->getAvailability(&Message); 75 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) 76 if (Result == AR_Available) { 77 const DeclContext *DC = ECD->getDeclContext(); 78 if (const EnumDecl *TheEnumDecl = dyn_cast<EnumDecl>(DC)) 79 Result = TheEnumDecl->getAvailability(&Message); 80 } 81 82 switch (Result) { 83 case AR_Available: 84 case AR_NotYetIntroduced: 85 break; 86 87 case AR_Deprecated: 88 S.EmitDeprecationWarning(D, Message, Loc, UnknownObjCClass); 89 break; 90 91 case AR_Unavailable: 92 if (S.getCurContextAvailability() != AR_Unavailable) { 93 if (Message.empty()) { 94 if (!UnknownObjCClass) 95 S.Diag(Loc, diag::err_unavailable) << D->getDeclName(); 96 else 97 S.Diag(Loc, diag::warn_unavailable_fwdclass_message) 98 << D->getDeclName(); 99 } 100 else 101 S.Diag(Loc, diag::err_unavailable_message) 102 << D->getDeclName() << Message; 103 S.Diag(D->getLocation(), diag::note_unavailable_here) 104 << isa<FunctionDecl>(D) << false; 105 } 106 break; 107 } 108 return Result; 109 } 110 111 /// \brief Emit a note explaining that this function is deleted or unavailable. 112 void Sema::NoteDeletedFunction(FunctionDecl *Decl) { 113 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Decl); 114 115 if (Method && Method->isDeleted() && !Method->isDeletedAsWritten()) { 116 // If the method was explicitly defaulted, point at that declaration. 117 if (!Method->isImplicit()) 118 Diag(Decl->getLocation(), diag::note_implicitly_deleted); 119 120 // Try to diagnose why this special member function was implicitly 121 // deleted. This might fail, if that reason no longer applies. 122 CXXSpecialMember CSM = getSpecialMember(Method); 123 if (CSM != CXXInvalid) 124 ShouldDeleteSpecialMember(Method, CSM, /*Diagnose=*/true); 125 126 return; 127 } 128 129 Diag(Decl->getLocation(), diag::note_unavailable_here) 130 << 1 << Decl->isDeleted(); 131 } 132 133 /// \brief Determine whether the use of this declaration is valid, and 134 /// emit any corresponding diagnostics. 135 /// 136 /// This routine diagnoses various problems with referencing 137 /// declarations that can occur when using a declaration. For example, 138 /// it might warn if a deprecated or unavailable declaration is being 139 /// used, or produce an error (and return true) if a C++0x deleted 140 /// function is being used. 141 /// 142 /// \returns true if there was an error (this declaration cannot be 143 /// referenced), false otherwise. 144 /// 145 bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc, 146 const ObjCInterfaceDecl *UnknownObjCClass) { 147 if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) { 148 // If there were any diagnostics suppressed by template argument deduction, 149 // emit them now. 150 llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >::iterator 151 Pos = SuppressedDiagnostics.find(D->getCanonicalDecl()); 152 if (Pos != SuppressedDiagnostics.end()) { 153 SmallVectorImpl<PartialDiagnosticAt> &Suppressed = Pos->second; 154 for (unsigned I = 0, N = Suppressed.size(); I != N; ++I) 155 Diag(Suppressed[I].first, Suppressed[I].second); 156 157 // Clear out the list of suppressed diagnostics, so that we don't emit 158 // them again for this specialization. However, we don't obsolete this 159 // entry from the table, because we want to avoid ever emitting these 160 // diagnostics again. 161 Suppressed.clear(); 162 } 163 } 164 165 // See if this is an auto-typed variable whose initializer we are parsing. 166 if (ParsingInitForAutoVars.count(D)) { 167 Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer) 168 << D->getDeclName(); 169 return true; 170 } 171 172 // See if this is a deleted function. 173 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 174 if (FD->isDeleted()) { 175 Diag(Loc, diag::err_deleted_function_use); 176 NoteDeletedFunction(FD); 177 return true; 178 } 179 } 180 DiagnoseAvailabilityOfDecl(*this, D, Loc, UnknownObjCClass); 181 182 // Warn if this is used but marked unused. 183 if (D->hasAttr<UnusedAttr>()) 184 Diag(Loc, diag::warn_used_but_marked_unused) << D->getDeclName(); 185 return false; 186 } 187 188 /// \brief Retrieve the message suffix that should be added to a 189 /// diagnostic complaining about the given function being deleted or 190 /// unavailable. 191 std::string Sema::getDeletedOrUnavailableSuffix(const FunctionDecl *FD) { 192 // FIXME: C++0x implicitly-deleted special member functions could be 193 // detected here so that we could improve diagnostics to say, e.g., 194 // "base class 'A' had a deleted copy constructor". 195 if (FD->isDeleted()) 196 return std::string(); 197 198 std::string Message; 199 if (FD->getAvailability(&Message)) 200 return ": " + Message; 201 202 return std::string(); 203 } 204 205 /// DiagnoseSentinelCalls - This routine checks whether a call or 206 /// message-send is to a declaration with the sentinel attribute, and 207 /// if so, it checks that the requirements of the sentinel are 208 /// satisfied. 209 void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, 210 Expr **args, unsigned numArgs) { 211 const SentinelAttr *attr = D->getAttr<SentinelAttr>(); 212 if (!attr) 213 return; 214 215 // The number of formal parameters of the declaration. 216 unsigned numFormalParams; 217 218 // The kind of declaration. This is also an index into a %select in 219 // the diagnostic. 220 enum CalleeType { CT_Function, CT_Method, CT_Block } calleeType; 221 222 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 223 numFormalParams = MD->param_size(); 224 calleeType = CT_Method; 225 } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 226 numFormalParams = FD->param_size(); 227 calleeType = CT_Function; 228 } else if (isa<VarDecl>(D)) { 229 QualType type = cast<ValueDecl>(D)->getType(); 230 const FunctionType *fn = 0; 231 if (const PointerType *ptr = type->getAs<PointerType>()) { 232 fn = ptr->getPointeeType()->getAs<FunctionType>(); 233 if (!fn) return; 234 calleeType = CT_Function; 235 } else if (const BlockPointerType *ptr = type->getAs<BlockPointerType>()) { 236 fn = ptr->getPointeeType()->castAs<FunctionType>(); 237 calleeType = CT_Block; 238 } else { 239 return; 240 } 241 242 if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fn)) { 243 numFormalParams = proto->getNumArgs(); 244 } else { 245 numFormalParams = 0; 246 } 247 } else { 248 return; 249 } 250 251 // "nullPos" is the number of formal parameters at the end which 252 // effectively count as part of the variadic arguments. This is 253 // useful if you would prefer to not have *any* formal parameters, 254 // but the language forces you to have at least one. 255 unsigned nullPos = attr->getNullPos(); 256 assert((nullPos == 0 || nullPos == 1) && "invalid null position on sentinel"); 257 numFormalParams = (nullPos > numFormalParams ? 0 : numFormalParams - nullPos); 258 259 // The number of arguments which should follow the sentinel. 260 unsigned numArgsAfterSentinel = attr->getSentinel(); 261 262 // If there aren't enough arguments for all the formal parameters, 263 // the sentinel, and the args after the sentinel, complain. 264 if (numArgs < numFormalParams + numArgsAfterSentinel + 1) { 265 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName(); 266 Diag(D->getLocation(), diag::note_sentinel_here) << calleeType; 267 return; 268 } 269 270 // Otherwise, find the sentinel expression. 271 Expr *sentinelExpr = args[numArgs - numArgsAfterSentinel - 1]; 272 if (!sentinelExpr) return; 273 if (sentinelExpr->isValueDependent()) return; 274 if (Context.isSentinelNullExpr(sentinelExpr)) return; 275 276 // Pick a reasonable string to insert. Optimistically use 'nil' or 277 // 'NULL' if those are actually defined in the context. Only use 278 // 'nil' for ObjC methods, where it's much more likely that the 279 // variadic arguments form a list of object pointers. 280 SourceLocation MissingNilLoc 281 = PP.getLocForEndOfToken(sentinelExpr->getLocEnd()); 282 std::string NullValue; 283 if (calleeType == CT_Method && 284 PP.getIdentifierInfo("nil")->hasMacroDefinition()) 285 NullValue = "nil"; 286 else if (PP.getIdentifierInfo("NULL")->hasMacroDefinition()) 287 NullValue = "NULL"; 288 else 289 NullValue = "(void*) 0"; 290 291 if (MissingNilLoc.isInvalid()) 292 Diag(Loc, diag::warn_missing_sentinel) << calleeType; 293 else 294 Diag(MissingNilLoc, diag::warn_missing_sentinel) 295 << calleeType 296 << FixItHint::CreateInsertion(MissingNilLoc, ", " + NullValue); 297 Diag(D->getLocation(), diag::note_sentinel_here) << calleeType; 298 } 299 300 SourceRange Sema::getExprRange(Expr *E) const { 301 return E ? E->getSourceRange() : SourceRange(); 302 } 303 304 //===----------------------------------------------------------------------===// 305 // Standard Promotions and Conversions 306 //===----------------------------------------------------------------------===// 307 308 /// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4). 309 ExprResult Sema::DefaultFunctionArrayConversion(Expr *E) { 310 // Handle any placeholder expressions which made it here. 311 if (E->getType()->isPlaceholderType()) { 312 ExprResult result = CheckPlaceholderExpr(E); 313 if (result.isInvalid()) return ExprError(); 314 E = result.take(); 315 } 316 317 QualType Ty = E->getType(); 318 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type"); 319 320 if (Ty->isFunctionType()) 321 E = ImpCastExprToType(E, Context.getPointerType(Ty), 322 CK_FunctionToPointerDecay).take(); 323 else if (Ty->isArrayType()) { 324 // In C90 mode, arrays only promote to pointers if the array expression is 325 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has 326 // type 'array of type' is converted to an expression that has type 'pointer 327 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression 328 // that has type 'array of type' ...". The relevant change is "an lvalue" 329 // (C90) to "an expression" (C99). 330 // 331 // C++ 4.2p1: 332 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of 333 // T" can be converted to an rvalue of type "pointer to T". 334 // 335 if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue()) 336 E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty), 337 CK_ArrayToPointerDecay).take(); 338 } 339 return Owned(E); 340 } 341 342 static void CheckForNullPointerDereference(Sema &S, Expr *E) { 343 // Check to see if we are dereferencing a null pointer. If so, 344 // and if not volatile-qualified, this is undefined behavior that the 345 // optimizer will delete, so warn about it. People sometimes try to use this 346 // to get a deterministic trap and are surprised by clang's behavior. This 347 // only handles the pattern "*null", which is a very syntactic check. 348 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts())) 349 if (UO->getOpcode() == UO_Deref && 350 UO->getSubExpr()->IgnoreParenCasts()-> 351 isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull) && 352 !UO->getType().isVolatileQualified()) { 353 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 354 S.PDiag(diag::warn_indirection_through_null) 355 << UO->getSubExpr()->getSourceRange()); 356 S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, 357 S.PDiag(diag::note_indirection_through_null)); 358 } 359 } 360 361 ExprResult Sema::DefaultLvalueConversion(Expr *E) { 362 // Handle any placeholder expressions which made it here. 363 if (E->getType()->isPlaceholderType()) { 364 ExprResult result = CheckPlaceholderExpr(E); 365 if (result.isInvalid()) return ExprError(); 366 E = result.take(); 367 } 368 369 // C++ [conv.lval]p1: 370 // A glvalue of a non-function, non-array type T can be 371 // converted to a prvalue. 372 if (!E->isGLValue()) return Owned(E); 373 374 QualType T = E->getType(); 375 assert(!T.isNull() && "r-value conversion on typeless expression?"); 376 377 // We don't want to throw lvalue-to-rvalue casts on top of 378 // expressions of certain types in C++. 379 if (getLangOpts().CPlusPlus && 380 (E->getType() == Context.OverloadTy || 381 T->isDependentType() || 382 T->isRecordType())) 383 return Owned(E); 384 385 // The C standard is actually really unclear on this point, and 386 // DR106 tells us what the result should be but not why. It's 387 // generally best to say that void types just doesn't undergo 388 // lvalue-to-rvalue at all. Note that expressions of unqualified 389 // 'void' type are never l-values, but qualified void can be. 390 if (T->isVoidType()) 391 return Owned(E); 392 393 CheckForNullPointerDereference(*this, E); 394 395 // C++ [conv.lval]p1: 396 // [...] If T is a non-class type, the type of the prvalue is the 397 // cv-unqualified version of T. Otherwise, the type of the 398 // rvalue is T. 399 // 400 // C99 6.3.2.1p2: 401 // If the lvalue has qualified type, the value has the unqualified 402 // version of the type of the lvalue; otherwise, the value has the 403 // type of the lvalue. 404 if (T.hasQualifiers()) 405 T = T.getUnqualifiedType(); 406 407 UpdateMarkingForLValueToRValue(E); 408 409 ExprResult Res = Owned(ImplicitCastExpr::Create(Context, T, CK_LValueToRValue, 410 E, 0, VK_RValue)); 411 412 // C11 6.3.2.1p2: 413 // ... if the lvalue has atomic type, the value has the non-atomic version 414 // of the type of the lvalue ... 415 if (const AtomicType *Atomic = T->getAs<AtomicType>()) { 416 T = Atomic->getValueType().getUnqualifiedType(); 417 Res = Owned(ImplicitCastExpr::Create(Context, T, CK_AtomicToNonAtomic, 418 Res.get(), 0, VK_RValue)); 419 } 420 421 return Res; 422 } 423 424 ExprResult Sema::DefaultFunctionArrayLvalueConversion(Expr *E) { 425 ExprResult Res = DefaultFunctionArrayConversion(E); 426 if (Res.isInvalid()) 427 return ExprError(); 428 Res = DefaultLvalueConversion(Res.take()); 429 if (Res.isInvalid()) 430 return ExprError(); 431 return move(Res); 432 } 433 434 435 /// UsualUnaryConversions - Performs various conversions that are common to most 436 /// operators (C99 6.3). The conversions of array and function types are 437 /// sometimes suppressed. For example, the array->pointer conversion doesn't 438 /// apply if the array is an argument to the sizeof or address (&) operators. 439 /// In these instances, this routine should *not* be called. 440 ExprResult Sema::UsualUnaryConversions(Expr *E) { 441 // First, convert to an r-value. 442 ExprResult Res = DefaultFunctionArrayLvalueConversion(E); 443 if (Res.isInvalid()) 444 return Owned(E); 445 E = Res.take(); 446 447 QualType Ty = E->getType(); 448 assert(!Ty.isNull() && "UsualUnaryConversions - missing type"); 449 450 // Half FP is a bit different: it's a storage-only type, meaning that any 451 // "use" of it should be promoted to float. 452 if (Ty->isHalfType()) 453 return ImpCastExprToType(Res.take(), Context.FloatTy, CK_FloatingCast); 454 455 // Try to perform integral promotions if the object has a theoretically 456 // promotable type. 457 if (Ty->isIntegralOrUnscopedEnumerationType()) { 458 // C99 6.3.1.1p2: 459 // 460 // The following may be used in an expression wherever an int or 461 // unsigned int may be used: 462 // - an object or expression with an integer type whose integer 463 // conversion rank is less than or equal to the rank of int 464 // and unsigned int. 465 // - A bit-field of type _Bool, int, signed int, or unsigned int. 466 // 467 // If an int can represent all values of the original type, the 468 // value is converted to an int; otherwise, it is converted to an 469 // unsigned int. These are called the integer promotions. All 470 // other types are unchanged by the integer promotions. 471 472 QualType PTy = Context.isPromotableBitField(E); 473 if (!PTy.isNull()) { 474 E = ImpCastExprToType(E, PTy, CK_IntegralCast).take(); 475 return Owned(E); 476 } 477 if (Ty->isPromotableIntegerType()) { 478 QualType PT = Context.getPromotedIntegerType(Ty); 479 E = ImpCastExprToType(E, PT, CK_IntegralCast).take(); 480 return Owned(E); 481 } 482 } 483 return Owned(E); 484 } 485 486 /// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that 487 /// do not have a prototype. Arguments that have type float are promoted to 488 /// double. All other argument types are converted by UsualUnaryConversions(). 489 ExprResult Sema::DefaultArgumentPromotion(Expr *E) { 490 QualType Ty = E->getType(); 491 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type"); 492 493 ExprResult Res = UsualUnaryConversions(E); 494 if (Res.isInvalid()) 495 return Owned(E); 496 E = Res.take(); 497 498 // If this is a 'float' (CVR qualified or typedef) promote to double. 499 if (Ty->isSpecificBuiltinType(BuiltinType::Float)) 500 E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).take(); 501 502 // C++ performs lvalue-to-rvalue conversion as a default argument 503 // promotion, even on class types, but note: 504 // C++11 [conv.lval]p2: 505 // When an lvalue-to-rvalue conversion occurs in an unevaluated 506 // operand or a subexpression thereof the value contained in the 507 // referenced object is not accessed. Otherwise, if the glvalue 508 // has a class type, the conversion copy-initializes a temporary 509 // of type T from the glvalue and the result of the conversion 510 // is a prvalue for the temporary. 511 // FIXME: add some way to gate this entire thing for correctness in 512 // potentially potentially evaluated contexts. 513 if (getLangOpts().CPlusPlus && E->isGLValue() && 514 ExprEvalContexts.back().Context != Unevaluated) { 515 ExprResult Temp = PerformCopyInitialization( 516 InitializedEntity::InitializeTemporary(E->getType()), 517 E->getExprLoc(), 518 Owned(E)); 519 if (Temp.isInvalid()) 520 return ExprError(); 521 E = Temp.get(); 522 } 523 524 return Owned(E); 525 } 526 527 /// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but 528 /// will warn if the resulting type is not a POD type, and rejects ObjC 529 /// interfaces passed by value. 530 ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT, 531 FunctionDecl *FDecl) { 532 if (const BuiltinType *PlaceholderTy = E->getType()->getAsPlaceholderType()) { 533 // Strip the unbridged-cast placeholder expression off, if applicable. 534 if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast && 535 (CT == VariadicMethod || 536 (FDecl && FDecl->hasAttr<CFAuditedTransferAttr>()))) { 537 E = stripARCUnbridgedCast(E); 538 539 // Otherwise, do normal placeholder checking. 540 } else { 541 ExprResult ExprRes = CheckPlaceholderExpr(E); 542 if (ExprRes.isInvalid()) 543 return ExprError(); 544 E = ExprRes.take(); 545 } 546 } 547 548 ExprResult ExprRes = DefaultArgumentPromotion(E); 549 if (ExprRes.isInvalid()) 550 return ExprError(); 551 E = ExprRes.take(); 552 553 // Don't allow one to pass an Objective-C interface to a vararg. 554 if (E->getType()->isObjCObjectType() && 555 DiagRuntimeBehavior(E->getLocStart(), 0, 556 PDiag(diag::err_cannot_pass_objc_interface_to_vararg) 557 << E->getType() << CT)) 558 return ExprError(); 559 560 // Complain about passing non-POD types through varargs. However, don't 561 // perform this check for incomplete types, which we can get here when we're 562 // in an unevaluated context. 563 if (!E->getType()->isIncompleteType() && !E->getType().isPODType(Context)) { 564 // C++0x [expr.call]p7: 565 // Passing a potentially-evaluated argument of class type (Clause 9) 566 // having a non-trivial copy constructor, a non-trivial move constructor, 567 // or a non-trivial destructor, with no corresponding parameter, 568 // is conditionally-supported with implementation-defined semantics. 569 bool TrivialEnough = false; 570 if (getLangOpts().CPlusPlus0x && !E->getType()->isDependentType()) { 571 if (CXXRecordDecl *Record = E->getType()->getAsCXXRecordDecl()) { 572 if (Record->hasTrivialCopyConstructor() && 573 Record->hasTrivialMoveConstructor() && 574 Record->hasTrivialDestructor()) { 575 DiagRuntimeBehavior(E->getLocStart(), 0, 576 PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) 577 << E->getType() << CT); 578 TrivialEnough = true; 579 } 580 } 581 } 582 583 if (!TrivialEnough && 584 getLangOpts().ObjCAutoRefCount && 585 E->getType()->isObjCLifetimeType()) 586 TrivialEnough = true; 587 588 if (TrivialEnough) { 589 // Nothing to diagnose. This is okay. 590 } else if (DiagRuntimeBehavior(E->getLocStart(), 0, 591 PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg) 592 << getLangOpts().CPlusPlus0x << E->getType() 593 << CT)) { 594 // Turn this into a trap. 595 CXXScopeSpec SS; 596 SourceLocation TemplateKWLoc; 597 UnqualifiedId Name; 598 Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"), 599 E->getLocStart()); 600 ExprResult TrapFn = ActOnIdExpression(TUScope, SS, TemplateKWLoc, Name, 601 true, false); 602 if (TrapFn.isInvalid()) 603 return ExprError(); 604 605 ExprResult Call = ActOnCallExpr(TUScope, TrapFn.get(), E->getLocStart(), 606 MultiExprArg(), E->getLocEnd()); 607 if (Call.isInvalid()) 608 return ExprError(); 609 610 ExprResult Comma = ActOnBinOp(TUScope, E->getLocStart(), tok::comma, 611 Call.get(), E); 612 if (Comma.isInvalid()) 613 return ExprError(); 614 E = Comma.get(); 615 } 616 } 617 // c++ rules are enforced elsewhere. 618 if (!getLangOpts().CPlusPlus && 619 RequireCompleteType(E->getExprLoc(), E->getType(), 620 diag::err_call_incomplete_argument)) 621 return ExprError(); 622 623 return Owned(E); 624 } 625 626 /// \brief Converts an integer to complex float type. Helper function of 627 /// UsualArithmeticConversions() 628 /// 629 /// \return false if the integer expression is an integer type and is 630 /// successfully converted to the complex type. 631 static bool handleIntegerToComplexFloatConversion(Sema &S, ExprResult &IntExpr, 632 ExprResult &ComplexExpr, 633 QualType IntTy, 634 QualType ComplexTy, 635 bool SkipCast) { 636 if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true; 637 if (SkipCast) return false; 638 if (IntTy->isIntegerType()) { 639 QualType fpTy = cast<ComplexType>(ComplexTy)->getElementType(); 640 IntExpr = S.ImpCastExprToType(IntExpr.take(), fpTy, CK_IntegralToFloating); 641 IntExpr = S.ImpCastExprToType(IntExpr.take(), ComplexTy, 642 CK_FloatingRealToComplex); 643 } else { 644 assert(IntTy->isComplexIntegerType()); 645 IntExpr = S.ImpCastExprToType(IntExpr.take(), ComplexTy, 646 CK_IntegralComplexToFloatingComplex); 647 } 648 return false; 649 } 650 651 /// \brief Takes two complex float types and converts them to the same type. 652 /// Helper function of UsualArithmeticConversions() 653 static QualType 654 handleComplexFloatToComplexFloatConverstion(Sema &S, ExprResult &LHS, 655 ExprResult &RHS, QualType LHSType, 656 QualType RHSType, 657 bool IsCompAssign) { 658 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 659 660 if (order < 0) { 661 // _Complex float -> _Complex double 662 if (!IsCompAssign) 663 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingComplexCast); 664 return RHSType; 665 } 666 if (order > 0) 667 // _Complex float -> _Complex double 668 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingComplexCast); 669 return LHSType; 670 } 671 672 /// \brief Converts otherExpr to complex float and promotes complexExpr if 673 /// necessary. Helper function of UsualArithmeticConversions() 674 static QualType handleOtherComplexFloatConversion(Sema &S, 675 ExprResult &ComplexExpr, 676 ExprResult &OtherExpr, 677 QualType ComplexTy, 678 QualType OtherTy, 679 bool ConvertComplexExpr, 680 bool ConvertOtherExpr) { 681 int order = S.Context.getFloatingTypeOrder(ComplexTy, OtherTy); 682 683 // If just the complexExpr is complex, the otherExpr needs to be converted, 684 // and the complexExpr might need to be promoted. 685 if (order > 0) { // complexExpr is wider 686 // float -> _Complex double 687 if (ConvertOtherExpr) { 688 QualType fp = cast<ComplexType>(ComplexTy)->getElementType(); 689 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), fp, CK_FloatingCast); 690 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), ComplexTy, 691 CK_FloatingRealToComplex); 692 } 693 return ComplexTy; 694 } 695 696 // otherTy is at least as wide. Find its corresponding complex type. 697 QualType result = (order == 0 ? ComplexTy : 698 S.Context.getComplexType(OtherTy)); 699 700 // double -> _Complex double 701 if (ConvertOtherExpr) 702 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), result, 703 CK_FloatingRealToComplex); 704 705 // _Complex float -> _Complex double 706 if (ConvertComplexExpr && order < 0) 707 ComplexExpr = S.ImpCastExprToType(ComplexExpr.take(), result, 708 CK_FloatingComplexCast); 709 710 return result; 711 } 712 713 /// \brief Handle arithmetic conversion with complex types. Helper function of 714 /// UsualArithmeticConversions() 715 static QualType handleComplexFloatConversion(Sema &S, ExprResult &LHS, 716 ExprResult &RHS, QualType LHSType, 717 QualType RHSType, 718 bool IsCompAssign) { 719 // if we have an integer operand, the result is the complex type. 720 if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType, 721 /*skipCast*/false)) 722 return LHSType; 723 if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType, 724 /*skipCast*/IsCompAssign)) 725 return RHSType; 726 727 // This handles complex/complex, complex/float, or float/complex. 728 // When both operands are complex, the shorter operand is converted to the 729 // type of the longer, and that is the type of the result. This corresponds 730 // to what is done when combining two real floating-point operands. 731 // The fun begins when size promotion occur across type domains. 732 // From H&S 6.3.4: When one operand is complex and the other is a real 733 // floating-point type, the less precise type is converted, within it's 734 // real or complex domain, to the precision of the other type. For example, 735 // when combining a "long double" with a "double _Complex", the 736 // "double _Complex" is promoted to "long double _Complex". 737 738 bool LHSComplexFloat = LHSType->isComplexType(); 739 bool RHSComplexFloat = RHSType->isComplexType(); 740 741 // If both are complex, just cast to the more precise type. 742 if (LHSComplexFloat && RHSComplexFloat) 743 return handleComplexFloatToComplexFloatConverstion(S, LHS, RHS, 744 LHSType, RHSType, 745 IsCompAssign); 746 747 // If only one operand is complex, promote it if necessary and convert the 748 // other operand to complex. 749 if (LHSComplexFloat) 750 return handleOtherComplexFloatConversion( 751 S, LHS, RHS, LHSType, RHSType, /*convertComplexExpr*/!IsCompAssign, 752 /*convertOtherExpr*/ true); 753 754 assert(RHSComplexFloat); 755 return handleOtherComplexFloatConversion( 756 S, RHS, LHS, RHSType, LHSType, /*convertComplexExpr*/true, 757 /*convertOtherExpr*/ !IsCompAssign); 758 } 759 760 /// \brief Hande arithmetic conversion from integer to float. Helper function 761 /// of UsualArithmeticConversions() 762 static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr, 763 ExprResult &IntExpr, 764 QualType FloatTy, QualType IntTy, 765 bool ConvertFloat, bool ConvertInt) { 766 if (IntTy->isIntegerType()) { 767 if (ConvertInt) 768 // Convert intExpr to the lhs floating point type. 769 IntExpr = S.ImpCastExprToType(IntExpr.take(), FloatTy, 770 CK_IntegralToFloating); 771 return FloatTy; 772 } 773 774 // Convert both sides to the appropriate complex float. 775 assert(IntTy->isComplexIntegerType()); 776 QualType result = S.Context.getComplexType(FloatTy); 777 778 // _Complex int -> _Complex float 779 if (ConvertInt) 780 IntExpr = S.ImpCastExprToType(IntExpr.take(), result, 781 CK_IntegralComplexToFloatingComplex); 782 783 // float -> _Complex float 784 if (ConvertFloat) 785 FloatExpr = S.ImpCastExprToType(FloatExpr.take(), result, 786 CK_FloatingRealToComplex); 787 788 return result; 789 } 790 791 /// \brief Handle arithmethic conversion with floating point types. Helper 792 /// function of UsualArithmeticConversions() 793 static QualType handleFloatConversion(Sema &S, ExprResult &LHS, 794 ExprResult &RHS, QualType LHSType, 795 QualType RHSType, bool IsCompAssign) { 796 bool LHSFloat = LHSType->isRealFloatingType(); 797 bool RHSFloat = RHSType->isRealFloatingType(); 798 799 // If we have two real floating types, convert the smaller operand 800 // to the bigger result. 801 if (LHSFloat && RHSFloat) { 802 int order = S.Context.getFloatingTypeOrder(LHSType, RHSType); 803 if (order > 0) { 804 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_FloatingCast); 805 return LHSType; 806 } 807 808 assert(order < 0 && "illegal float comparison"); 809 if (!IsCompAssign) 810 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_FloatingCast); 811 return RHSType; 812 } 813 814 if (LHSFloat) 815 return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType, 816 /*convertFloat=*/!IsCompAssign, 817 /*convertInt=*/ true); 818 assert(RHSFloat); 819 return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType, 820 /*convertInt=*/ true, 821 /*convertFloat=*/!IsCompAssign); 822 } 823 824 /// \brief Handle conversions with GCC complex int extension. Helper function 825 /// of UsualArithmeticConversions() 826 // FIXME: if the operands are (int, _Complex long), we currently 827 // don't promote the complex. Also, signedness? 828 static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS, 829 ExprResult &RHS, QualType LHSType, 830 QualType RHSType, 831 bool IsCompAssign) { 832 const ComplexType *LHSComplexInt = LHSType->getAsComplexIntegerType(); 833 const ComplexType *RHSComplexInt = RHSType->getAsComplexIntegerType(); 834 835 if (LHSComplexInt && RHSComplexInt) { 836 int order = S.Context.getIntegerTypeOrder(LHSComplexInt->getElementType(), 837 RHSComplexInt->getElementType()); 838 assert(order && "inequal types with equal element ordering"); 839 if (order > 0) { 840 // _Complex int -> _Complex long 841 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralComplexCast); 842 return LHSType; 843 } 844 845 if (!IsCompAssign) 846 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralComplexCast); 847 return RHSType; 848 } 849 850 if (LHSComplexInt) { 851 // int -> _Complex int 852 // FIXME: This needs to take integer ranks into account 853 RHS = S.ImpCastExprToType(RHS.take(), LHSComplexInt->getElementType(), 854 CK_IntegralCast); 855 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralRealToComplex); 856 return LHSType; 857 } 858 859 assert(RHSComplexInt); 860 // int -> _Complex int 861 // FIXME: This needs to take integer ranks into account 862 if (!IsCompAssign) { 863 LHS = S.ImpCastExprToType(LHS.take(), RHSComplexInt->getElementType(), 864 CK_IntegralCast); 865 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralRealToComplex); 866 } 867 return RHSType; 868 } 869 870 /// \brief Handle integer arithmetic conversions. Helper function of 871 /// UsualArithmeticConversions() 872 static QualType handleIntegerConversion(Sema &S, ExprResult &LHS, 873 ExprResult &RHS, QualType LHSType, 874 QualType RHSType, bool IsCompAssign) { 875 // The rules for this case are in C99 6.3.1.8 876 int order = S.Context.getIntegerTypeOrder(LHSType, RHSType); 877 bool LHSSigned = LHSType->hasSignedIntegerRepresentation(); 878 bool RHSSigned = RHSType->hasSignedIntegerRepresentation(); 879 if (LHSSigned == RHSSigned) { 880 // Same signedness; use the higher-ranked type 881 if (order >= 0) { 882 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 883 return LHSType; 884 } else if (!IsCompAssign) 885 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 886 return RHSType; 887 } else if (order != (LHSSigned ? 1 : -1)) { 888 // The unsigned type has greater than or equal rank to the 889 // signed type, so use the unsigned type 890 if (RHSSigned) { 891 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 892 return LHSType; 893 } else if (!IsCompAssign) 894 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 895 return RHSType; 896 } else if (S.Context.getIntWidth(LHSType) != S.Context.getIntWidth(RHSType)) { 897 // The two types are different widths; if we are here, that 898 // means the signed type is larger than the unsigned type, so 899 // use the signed type. 900 if (LHSSigned) { 901 RHS = S.ImpCastExprToType(RHS.take(), LHSType, CK_IntegralCast); 902 return LHSType; 903 } else if (!IsCompAssign) 904 LHS = S.ImpCastExprToType(LHS.take(), RHSType, CK_IntegralCast); 905 return RHSType; 906 } else { 907 // The signed type is higher-ranked than the unsigned type, 908 // but isn't actually any bigger (like unsigned int and long 909 // on most 32-bit systems). Use the unsigned type corresponding 910 // to the signed type. 911 QualType result = 912 S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType); 913 RHS = S.ImpCastExprToType(RHS.take(), result, CK_IntegralCast); 914 if (!IsCompAssign) 915 LHS = S.ImpCastExprToType(LHS.take(), result, CK_IntegralCast); 916 return result; 917 } 918 } 919 920 /// UsualArithmeticConversions - Performs various conversions that are common to 921 /// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this 922 /// routine returns the first non-arithmetic type found. The client is 923 /// responsible for emitting appropriate error diagnostics. 924 /// FIXME: verify the conversion rules for "complex int" are consistent with 925 /// GCC. 926 QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS, 927 bool IsCompAssign) { 928 if (!IsCompAssign) { 929 LHS = UsualUnaryConversions(LHS.take()); 930 if (LHS.isInvalid()) 931 return QualType(); 932 } 933 934 RHS = UsualUnaryConversions(RHS.take()); 935 if (RHS.isInvalid()) 936 return QualType(); 937 938 // For conversion purposes, we ignore any qualifiers. 939 // For example, "const float" and "float" are equivalent. 940 QualType LHSType = 941 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType(); 942 QualType RHSType = 943 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType(); 944 945 // If both types are identical, no conversion is needed. 946 if (LHSType == RHSType) 947 return LHSType; 948 949 // If either side is a non-arithmetic type (e.g. a pointer), we are done. 950 // The caller can deal with this (e.g. pointer + int). 951 if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType()) 952 return LHSType; 953 954 // Apply unary and bitfield promotions to the LHS's type. 955 QualType LHSUnpromotedType = LHSType; 956 if (LHSType->isPromotableIntegerType()) 957 LHSType = Context.getPromotedIntegerType(LHSType); 958 QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get()); 959 if (!LHSBitfieldPromoteTy.isNull()) 960 LHSType = LHSBitfieldPromoteTy; 961 if (LHSType != LHSUnpromotedType && !IsCompAssign) 962 LHS = ImpCastExprToType(LHS.take(), LHSType, CK_IntegralCast); 963 964 // If both types are identical, no conversion is needed. 965 if (LHSType == RHSType) 966 return LHSType; 967 968 // At this point, we have two different arithmetic types. 969 970 // Handle complex types first (C99 6.3.1.8p1). 971 if (LHSType->isComplexType() || RHSType->isComplexType()) 972 return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType, 973 IsCompAssign); 974 975 // Now handle "real" floating types (i.e. float, double, long double). 976 if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType()) 977 return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType, 978 IsCompAssign); 979 980 // Handle GCC complex int extension. 981 if (LHSType->isComplexIntegerType() || RHSType->isComplexIntegerType()) 982 return handleComplexIntConversion(*this, LHS, RHS, LHSType, RHSType, 983 IsCompAssign); 984 985 // Finally, we have two differing integer types. 986 return handleIntegerConversion(*this, LHS, RHS, LHSType, RHSType, 987 IsCompAssign); 988 } 989 990 //===----------------------------------------------------------------------===// 991 // Semantic Analysis for various Expression Types 992 //===----------------------------------------------------------------------===// 993 994 995 ExprResult 996 Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc, 997 SourceLocation DefaultLoc, 998 SourceLocation RParenLoc, 999 Expr *ControllingExpr, 1000 MultiTypeArg ArgTypes, 1001 MultiExprArg ArgExprs) { 1002 unsigned NumAssocs = ArgTypes.size(); 1003 assert(NumAssocs == ArgExprs.size()); 1004 1005 ParsedType *ParsedTypes = ArgTypes.release(); 1006 Expr **Exprs = ArgExprs.release(); 1007 1008 TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs]; 1009 for (unsigned i = 0; i < NumAssocs; ++i) { 1010 if (ParsedTypes[i]) 1011 (void) GetTypeFromParser(ParsedTypes[i], &Types[i]); 1012 else 1013 Types[i] = 0; 1014 } 1015 1016 ExprResult ER = CreateGenericSelectionExpr(KeyLoc, DefaultLoc, RParenLoc, 1017 ControllingExpr, Types, Exprs, 1018 NumAssocs); 1019 delete [] Types; 1020 return ER; 1021 } 1022 1023 ExprResult 1024 Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc, 1025 SourceLocation DefaultLoc, 1026 SourceLocation RParenLoc, 1027 Expr *ControllingExpr, 1028 TypeSourceInfo **Types, 1029 Expr **Exprs, 1030 unsigned NumAssocs) { 1031 bool TypeErrorFound = false, 1032 IsResultDependent = ControllingExpr->isTypeDependent(), 1033 ContainsUnexpandedParameterPack 1034 = ControllingExpr->containsUnexpandedParameterPack(); 1035 1036 for (unsigned i = 0; i < NumAssocs; ++i) { 1037 if (Exprs[i]->containsUnexpandedParameterPack()) 1038 ContainsUnexpandedParameterPack = true; 1039 1040 if (Types[i]) { 1041 if (Types[i]->getType()->containsUnexpandedParameterPack()) 1042 ContainsUnexpandedParameterPack = true; 1043 1044 if (Types[i]->getType()->isDependentType()) { 1045 IsResultDependent = true; 1046 } else { 1047 // C11 6.5.1.1p2 "The type name in a generic association shall specify a 1048 // complete object type other than a variably modified type." 1049 unsigned D = 0; 1050 if (Types[i]->getType()->isIncompleteType()) 1051 D = diag::err_assoc_type_incomplete; 1052 else if (!Types[i]->getType()->isObjectType()) 1053 D = diag::err_assoc_type_nonobject; 1054 else if (Types[i]->getType()->isVariablyModifiedType()) 1055 D = diag::err_assoc_type_variably_modified; 1056 1057 if (D != 0) { 1058 Diag(Types[i]->getTypeLoc().getBeginLoc(), D) 1059 << Types[i]->getTypeLoc().getSourceRange() 1060 << Types[i]->getType(); 1061 TypeErrorFound = true; 1062 } 1063 1064 // C11 6.5.1.1p2 "No two generic associations in the same generic 1065 // selection shall specify compatible types." 1066 for (unsigned j = i+1; j < NumAssocs; ++j) 1067 if (Types[j] && !Types[j]->getType()->isDependentType() && 1068 Context.typesAreCompatible(Types[i]->getType(), 1069 Types[j]->getType())) { 1070 Diag(Types[j]->getTypeLoc().getBeginLoc(), 1071 diag::err_assoc_compatible_types) 1072 << Types[j]->getTypeLoc().getSourceRange() 1073 << Types[j]->getType() 1074 << Types[i]->getType(); 1075 Diag(Types[i]->getTypeLoc().getBeginLoc(), 1076 diag::note_compat_assoc) 1077 << Types[i]->getTypeLoc().getSourceRange() 1078 << Types[i]->getType(); 1079 TypeErrorFound = true; 1080 } 1081 } 1082 } 1083 } 1084 if (TypeErrorFound) 1085 return ExprError(); 1086 1087 // If we determined that the generic selection is result-dependent, don't 1088 // try to compute the result expression. 1089 if (IsResultDependent) 1090 return Owned(new (Context) GenericSelectionExpr( 1091 Context, KeyLoc, ControllingExpr, 1092 Types, Exprs, NumAssocs, DefaultLoc, 1093 RParenLoc, ContainsUnexpandedParameterPack)); 1094 1095 SmallVector<unsigned, 1> CompatIndices; 1096 unsigned DefaultIndex = -1U; 1097 for (unsigned i = 0; i < NumAssocs; ++i) { 1098 if (!Types[i]) 1099 DefaultIndex = i; 1100 else if (Context.typesAreCompatible(ControllingExpr->getType(), 1101 Types[i]->getType())) 1102 CompatIndices.push_back(i); 1103 } 1104 1105 // C11 6.5.1.1p2 "The controlling expression of a generic selection shall have 1106 // type compatible with at most one of the types named in its generic 1107 // association list." 1108 if (CompatIndices.size() > 1) { 1109 // We strip parens here because the controlling expression is typically 1110 // parenthesized in macro definitions. 1111 ControllingExpr = ControllingExpr->IgnoreParens(); 1112 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_multi_match) 1113 << ControllingExpr->getSourceRange() << ControllingExpr->getType() 1114 << (unsigned) CompatIndices.size(); 1115 for (SmallVector<unsigned, 1>::iterator I = CompatIndices.begin(), 1116 E = CompatIndices.end(); I != E; ++I) { 1117 Diag(Types[*I]->getTypeLoc().getBeginLoc(), 1118 diag::note_compat_assoc) 1119 << Types[*I]->getTypeLoc().getSourceRange() 1120 << Types[*I]->getType(); 1121 } 1122 return ExprError(); 1123 } 1124 1125 // C11 6.5.1.1p2 "If a generic selection has no default generic association, 1126 // its controlling expression shall have type compatible with exactly one of 1127 // the types named in its generic association list." 1128 if (DefaultIndex == -1U && CompatIndices.size() == 0) { 1129 // We strip parens here because the controlling expression is typically 1130 // parenthesized in macro definitions. 1131 ControllingExpr = ControllingExpr->IgnoreParens(); 1132 Diag(ControllingExpr->getLocStart(), diag::err_generic_sel_no_match) 1133 << ControllingExpr->getSourceRange() << ControllingExpr->getType(); 1134 return ExprError(); 1135 } 1136 1137 // C11 6.5.1.1p3 "If a generic selection has a generic association with a 1138 // type name that is compatible with the type of the controlling expression, 1139 // then the result expression of the generic selection is the expression 1140 // in that generic association. Otherwise, the result expression of the 1141 // generic selection is the expression in the default generic association." 1142 unsigned ResultIndex = 1143 CompatIndices.size() ? CompatIndices[0] : DefaultIndex; 1144 1145 return Owned(new (Context) GenericSelectionExpr( 1146 Context, KeyLoc, ControllingExpr, 1147 Types, Exprs, NumAssocs, DefaultLoc, 1148 RParenLoc, ContainsUnexpandedParameterPack, 1149 ResultIndex)); 1150 } 1151 1152 /// getUDSuffixLoc - Create a SourceLocation for a ud-suffix, given the 1153 /// location of the token and the offset of the ud-suffix within it. 1154 static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc, 1155 unsigned Offset) { 1156 return Lexer::AdvanceToTokenCharacter(TokLoc, Offset, S.getSourceManager(), 1157 S.getLangOpts()); 1158 } 1159 1160 /// BuildCookedLiteralOperatorCall - A user-defined literal was found. Look up 1161 /// the corresponding cooked (non-raw) literal operator, and build a call to it. 1162 static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope, 1163 IdentifierInfo *UDSuffix, 1164 SourceLocation UDSuffixLoc, 1165 ArrayRef<Expr*> Args, 1166 SourceLocation LitEndLoc) { 1167 assert(Args.size() <= 2 && "too many arguments for literal operator"); 1168 1169 QualType ArgTy[2]; 1170 for (unsigned ArgIdx = 0; ArgIdx != Args.size(); ++ArgIdx) { 1171 ArgTy[ArgIdx] = Args[ArgIdx]->getType(); 1172 if (ArgTy[ArgIdx]->isArrayType()) 1173 ArgTy[ArgIdx] = S.Context.getArrayDecayedType(ArgTy[ArgIdx]); 1174 } 1175 1176 DeclarationName OpName = 1177 S.Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 1178 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 1179 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 1180 1181 LookupResult R(S, OpName, UDSuffixLoc, Sema::LookupOrdinaryName); 1182 if (S.LookupLiteralOperator(Scope, R, llvm::makeArrayRef(ArgTy, Args.size()), 1183 /*AllowRawAndTemplate*/false) == Sema::LOLR_Error) 1184 return ExprError(); 1185 1186 return S.BuildLiteralOperatorCall(R, OpNameInfo, Args, LitEndLoc); 1187 } 1188 1189 /// ActOnStringLiteral - The specified tokens were lexed as pasted string 1190 /// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string 1191 /// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from 1192 /// multiple tokens. However, the common case is that StringToks points to one 1193 /// string. 1194 /// 1195 ExprResult 1196 Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks, 1197 Scope *UDLScope) { 1198 assert(NumStringToks && "Must have at least one string!"); 1199 1200 StringLiteralParser Literal(StringToks, NumStringToks, PP); 1201 if (Literal.hadError) 1202 return ExprError(); 1203 1204 SmallVector<SourceLocation, 4> StringTokLocs; 1205 for (unsigned i = 0; i != NumStringToks; ++i) 1206 StringTokLocs.push_back(StringToks[i].getLocation()); 1207 1208 QualType StrTy = Context.CharTy; 1209 if (Literal.isWide()) 1210 StrTy = Context.getWCharType(); 1211 else if (Literal.isUTF16()) 1212 StrTy = Context.Char16Ty; 1213 else if (Literal.isUTF32()) 1214 StrTy = Context.Char32Ty; 1215 else if (Literal.isPascal()) 1216 StrTy = Context.UnsignedCharTy; 1217 1218 StringLiteral::StringKind Kind = StringLiteral::Ascii; 1219 if (Literal.isWide()) 1220 Kind = StringLiteral::Wide; 1221 else if (Literal.isUTF8()) 1222 Kind = StringLiteral::UTF8; 1223 else if (Literal.isUTF16()) 1224 Kind = StringLiteral::UTF16; 1225 else if (Literal.isUTF32()) 1226 Kind = StringLiteral::UTF32; 1227 1228 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1). 1229 if (getLangOpts().CPlusPlus || getLangOpts().ConstStrings) 1230 StrTy.addConst(); 1231 1232 // Get an array type for the string, according to C99 6.4.5. This includes 1233 // the nul terminator character as well as the string length for pascal 1234 // strings. 1235 StrTy = Context.getConstantArrayType(StrTy, 1236 llvm::APInt(32, Literal.GetNumStringChars()+1), 1237 ArrayType::Normal, 0); 1238 1239 // Pass &StringTokLocs[0], StringTokLocs.size() to factory! 1240 StringLiteral *Lit = StringLiteral::Create(Context, Literal.GetString(), 1241 Kind, Literal.Pascal, StrTy, 1242 &StringTokLocs[0], 1243 StringTokLocs.size()); 1244 if (Literal.getUDSuffix().empty()) 1245 return Owned(Lit); 1246 1247 // We're building a user-defined literal. 1248 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 1249 SourceLocation UDSuffixLoc = 1250 getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()], 1251 Literal.getUDSuffixOffset()); 1252 1253 // Make sure we're allowed user-defined literals here. 1254 if (!UDLScope) 1255 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_string_udl)); 1256 1257 // C++11 [lex.ext]p5: The literal L is treated as a call of the form 1258 // operator "" X (str, len) 1259 QualType SizeType = Context.getSizeType(); 1260 llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars()); 1261 IntegerLiteral *LenArg = IntegerLiteral::Create(Context, Len, SizeType, 1262 StringTokLocs[0]); 1263 Expr *Args[] = { Lit, LenArg }; 1264 return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc, 1265 Args, StringTokLocs.back()); 1266 } 1267 1268 ExprResult 1269 Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1270 SourceLocation Loc, 1271 const CXXScopeSpec *SS) { 1272 DeclarationNameInfo NameInfo(D->getDeclName(), Loc); 1273 return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS); 1274 } 1275 1276 /// BuildDeclRefExpr - Build an expression that references a 1277 /// declaration that does not require a closure capture. 1278 ExprResult 1279 Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, 1280 const DeclarationNameInfo &NameInfo, 1281 const CXXScopeSpec *SS) { 1282 if (getLangOpts().CUDA) 1283 if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext)) 1284 if (const FunctionDecl *Callee = dyn_cast<FunctionDecl>(D)) { 1285 CUDAFunctionTarget CallerTarget = IdentifyCUDATarget(Caller), 1286 CalleeTarget = IdentifyCUDATarget(Callee); 1287 if (CheckCUDATarget(CallerTarget, CalleeTarget)) { 1288 Diag(NameInfo.getLoc(), diag::err_ref_bad_target) 1289 << CalleeTarget << D->getIdentifier() << CallerTarget; 1290 Diag(D->getLocation(), diag::note_previous_decl) 1291 << D->getIdentifier(); 1292 return ExprError(); 1293 } 1294 } 1295 1296 bool refersToEnclosingScope = 1297 (CurContext != D->getDeclContext() && 1298 D->getDeclContext()->isFunctionOrMethod()); 1299 1300 DeclRefExpr *E = DeclRefExpr::Create(Context, 1301 SS ? SS->getWithLocInContext(Context) 1302 : NestedNameSpecifierLoc(), 1303 SourceLocation(), 1304 D, refersToEnclosingScope, 1305 NameInfo, Ty, VK); 1306 1307 MarkDeclRefReferenced(E); 1308 1309 // Just in case we're building an illegal pointer-to-member. 1310 FieldDecl *FD = dyn_cast<FieldDecl>(D); 1311 if (FD && FD->isBitField()) 1312 E->setObjectKind(OK_BitField); 1313 1314 return Owned(E); 1315 } 1316 1317 /// Decomposes the given name into a DeclarationNameInfo, its location, and 1318 /// possibly a list of template arguments. 1319 /// 1320 /// If this produces template arguments, it is permitted to call 1321 /// DecomposeTemplateName. 1322 /// 1323 /// This actually loses a lot of source location information for 1324 /// non-standard name kinds; we should consider preserving that in 1325 /// some way. 1326 void 1327 Sema::DecomposeUnqualifiedId(const UnqualifiedId &Id, 1328 TemplateArgumentListInfo &Buffer, 1329 DeclarationNameInfo &NameInfo, 1330 const TemplateArgumentListInfo *&TemplateArgs) { 1331 if (Id.getKind() == UnqualifiedId::IK_TemplateId) { 1332 Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc); 1333 Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc); 1334 1335 ASTTemplateArgsPtr TemplateArgsPtr(*this, 1336 Id.TemplateId->getTemplateArgs(), 1337 Id.TemplateId->NumArgs); 1338 translateTemplateArguments(TemplateArgsPtr, Buffer); 1339 TemplateArgsPtr.release(); 1340 1341 TemplateName TName = Id.TemplateId->Template.get(); 1342 SourceLocation TNameLoc = Id.TemplateId->TemplateNameLoc; 1343 NameInfo = Context.getNameForTemplate(TName, TNameLoc); 1344 TemplateArgs = &Buffer; 1345 } else { 1346 NameInfo = GetNameFromUnqualifiedId(Id); 1347 TemplateArgs = 0; 1348 } 1349 } 1350 1351 /// Diagnose an empty lookup. 1352 /// 1353 /// \return false if new lookup candidates were found 1354 bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, 1355 CorrectionCandidateCallback &CCC, 1356 TemplateArgumentListInfo *ExplicitTemplateArgs, 1357 llvm::ArrayRef<Expr *> Args) { 1358 DeclarationName Name = R.getLookupName(); 1359 1360 unsigned diagnostic = diag::err_undeclared_var_use; 1361 unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest; 1362 if (Name.getNameKind() == DeclarationName::CXXOperatorName || 1363 Name.getNameKind() == DeclarationName::CXXLiteralOperatorName || 1364 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) { 1365 diagnostic = diag::err_undeclared_use; 1366 diagnostic_suggest = diag::err_undeclared_use_suggest; 1367 } 1368 1369 // If the original lookup was an unqualified lookup, fake an 1370 // unqualified lookup. This is useful when (for example) the 1371 // original lookup would not have found something because it was a 1372 // dependent name. 1373 DeclContext *DC = SS.isEmpty() ? CurContext : 0; 1374 while (DC) { 1375 if (isa<CXXRecordDecl>(DC)) { 1376 LookupQualifiedName(R, DC); 1377 1378 if (!R.empty()) { 1379 // Don't give errors about ambiguities in this lookup. 1380 R.suppressDiagnostics(); 1381 1382 // During a default argument instantiation the CurContext points 1383 // to a CXXMethodDecl; but we can't apply a this-> fixit inside a 1384 // function parameter list, hence add an explicit check. 1385 bool isDefaultArgument = !ActiveTemplateInstantiations.empty() && 1386 ActiveTemplateInstantiations.back().Kind == 1387 ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation; 1388 CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext); 1389 bool isInstance = CurMethod && 1390 CurMethod->isInstance() && 1391 DC == CurMethod->getParent() && !isDefaultArgument; 1392 1393 1394 // Give a code modification hint to insert 'this->'. 1395 // TODO: fixit for inserting 'Base<T>::' in the other cases. 1396 // Actually quite difficult! 1397 if (isInstance) { 1398 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>( 1399 CallsUndergoingInstantiation.back()->getCallee()); 1400 CXXMethodDecl *DepMethod = cast_or_null<CXXMethodDecl>( 1401 CurMethod->getInstantiatedFromMemberFunction()); 1402 if (DepMethod) { 1403 if (getLangOpts().MicrosoftMode) 1404 diagnostic = diag::warn_found_via_dependent_bases_lookup; 1405 Diag(R.getNameLoc(), diagnostic) << Name 1406 << FixItHint::CreateInsertion(R.getNameLoc(), "this->"); 1407 QualType DepThisType = DepMethod->getThisType(Context); 1408 CheckCXXThisCapture(R.getNameLoc()); 1409 CXXThisExpr *DepThis = new (Context) CXXThisExpr( 1410 R.getNameLoc(), DepThisType, false); 1411 TemplateArgumentListInfo TList; 1412 if (ULE->hasExplicitTemplateArgs()) 1413 ULE->copyTemplateArgumentsInto(TList); 1414 1415 CXXScopeSpec SS; 1416 SS.Adopt(ULE->getQualifierLoc()); 1417 CXXDependentScopeMemberExpr *DepExpr = 1418 CXXDependentScopeMemberExpr::Create( 1419 Context, DepThis, DepThisType, true, SourceLocation(), 1420 SS.getWithLocInContext(Context), 1421 ULE->getTemplateKeywordLoc(), 0, 1422 R.getLookupNameInfo(), 1423 ULE->hasExplicitTemplateArgs() ? &TList : 0); 1424 CallsUndergoingInstantiation.back()->setCallee(DepExpr); 1425 } else { 1426 // FIXME: we should be able to handle this case too. It is correct 1427 // to add this-> here. This is a workaround for PR7947. 1428 Diag(R.getNameLoc(), diagnostic) << Name; 1429 } 1430 } else { 1431 if (getLangOpts().MicrosoftMode) 1432 diagnostic = diag::warn_found_via_dependent_bases_lookup; 1433 Diag(R.getNameLoc(), diagnostic) << Name; 1434 } 1435 1436 // Do we really want to note all of these? 1437 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) 1438 Diag((*I)->getLocation(), diag::note_dependent_var_use); 1439 1440 // Return true if we are inside a default argument instantiation 1441 // and the found name refers to an instance member function, otherwise 1442 // the function calling DiagnoseEmptyLookup will try to create an 1443 // implicit member call and this is wrong for default argument. 1444 if (isDefaultArgument && ((*R.begin())->isCXXInstanceMember())) { 1445 Diag(R.getNameLoc(), diag::err_member_call_without_object); 1446 return true; 1447 } 1448 1449 // Tell the callee to try to recover. 1450 return false; 1451 } 1452 1453 R.clear(); 1454 } 1455 1456 // In Microsoft mode, if we are performing lookup from within a friend 1457 // function definition declared at class scope then we must set 1458 // DC to the lexical parent to be able to search into the parent 1459 // class. 1460 if (getLangOpts().MicrosoftMode && isa<FunctionDecl>(DC) && 1461 cast<FunctionDecl>(DC)->getFriendObjectKind() && 1462 DC->getLexicalParent()->isRecord()) 1463 DC = DC->getLexicalParent(); 1464 else 1465 DC = DC->getParent(); 1466 } 1467 1468 // We didn't find anything, so try to correct for a typo. 1469 TypoCorrection Corrected; 1470 if (S && (Corrected = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), 1471 S, &SS, CCC))) { 1472 std::string CorrectedStr(Corrected.getAsString(getLangOpts())); 1473 std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOpts())); 1474 R.setLookupName(Corrected.getCorrection()); 1475 1476 if (NamedDecl *ND = Corrected.getCorrectionDecl()) { 1477 if (Corrected.isOverloaded()) { 1478 OverloadCandidateSet OCS(R.getNameLoc()); 1479 OverloadCandidateSet::iterator Best; 1480 for (TypoCorrection::decl_iterator CD = Corrected.begin(), 1481 CDEnd = Corrected.end(); 1482 CD != CDEnd; ++CD) { 1483 if (FunctionTemplateDecl *FTD = 1484 dyn_cast<FunctionTemplateDecl>(*CD)) 1485 AddTemplateOverloadCandidate( 1486 FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs, 1487 Args, OCS); 1488 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*CD)) 1489 if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0) 1490 AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), 1491 Args, OCS); 1492 } 1493 switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) { 1494 case OR_Success: 1495 ND = Best->Function; 1496 break; 1497 default: 1498 break; 1499 } 1500 } 1501 R.addDecl(ND); 1502 if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) { 1503 if (SS.isEmpty()) 1504 Diag(R.getNameLoc(), diagnostic_suggest) << Name << CorrectedQuotedStr 1505 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr); 1506 else 1507 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1508 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1509 << SS.getRange() 1510 << FixItHint::CreateReplacement(R.getNameLoc(), CorrectedStr); 1511 if (ND) 1512 Diag(ND->getLocation(), diag::note_previous_decl) 1513 << CorrectedQuotedStr; 1514 1515 // Tell the callee to try to recover. 1516 return false; 1517 } 1518 1519 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) { 1520 // FIXME: If we ended up with a typo for a type name or 1521 // Objective-C class name, we're in trouble because the parser 1522 // is in the wrong place to recover. Suggest the typo 1523 // correction, but don't make it a fix-it since we're not going 1524 // to recover well anyway. 1525 if (SS.isEmpty()) 1526 Diag(R.getNameLoc(), diagnostic_suggest) 1527 << Name << CorrectedQuotedStr; 1528 else 1529 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1530 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1531 << SS.getRange(); 1532 1533 // Don't try to recover; it won't work. 1534 return true; 1535 } 1536 } else { 1537 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it 1538 // because we aren't able to recover. 1539 if (SS.isEmpty()) 1540 Diag(R.getNameLoc(), diagnostic_suggest) << Name << CorrectedQuotedStr; 1541 else 1542 Diag(R.getNameLoc(), diag::err_no_member_suggest) 1543 << Name << computeDeclContext(SS, false) << CorrectedQuotedStr 1544 << SS.getRange(); 1545 return true; 1546 } 1547 } 1548 R.clear(); 1549 1550 // Emit a special diagnostic for failed member lookups. 1551 // FIXME: computing the declaration context might fail here (?) 1552 if (!SS.isEmpty()) { 1553 Diag(R.getNameLoc(), diag::err_no_member) 1554 << Name << computeDeclContext(SS, false) 1555 << SS.getRange(); 1556 return true; 1557 } 1558 1559 // Give up, we can't recover. 1560 Diag(R.getNameLoc(), diagnostic) << Name; 1561 return true; 1562 } 1563 1564 ExprResult Sema::ActOnIdExpression(Scope *S, 1565 CXXScopeSpec &SS, 1566 SourceLocation TemplateKWLoc, 1567 UnqualifiedId &Id, 1568 bool HasTrailingLParen, 1569 bool IsAddressOfOperand, 1570 CorrectionCandidateCallback *CCC) { 1571 assert(!(IsAddressOfOperand && HasTrailingLParen) && 1572 "cannot be direct & operand and have a trailing lparen"); 1573 1574 if (SS.isInvalid()) 1575 return ExprError(); 1576 1577 TemplateArgumentListInfo TemplateArgsBuffer; 1578 1579 // Decompose the UnqualifiedId into the following data. 1580 DeclarationNameInfo NameInfo; 1581 const TemplateArgumentListInfo *TemplateArgs; 1582 DecomposeUnqualifiedId(Id, TemplateArgsBuffer, NameInfo, TemplateArgs); 1583 1584 DeclarationName Name = NameInfo.getName(); 1585 IdentifierInfo *II = Name.getAsIdentifierInfo(); 1586 SourceLocation NameLoc = NameInfo.getLoc(); 1587 1588 // C++ [temp.dep.expr]p3: 1589 // An id-expression is type-dependent if it contains: 1590 // -- an identifier that was declared with a dependent type, 1591 // (note: handled after lookup) 1592 // -- a template-id that is dependent, 1593 // (note: handled in BuildTemplateIdExpr) 1594 // -- a conversion-function-id that specifies a dependent type, 1595 // -- a nested-name-specifier that contains a class-name that 1596 // names a dependent type. 1597 // Determine whether this is a member of an unknown specialization; 1598 // we need to handle these differently. 1599 bool DependentID = false; 1600 if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName && 1601 Name.getCXXNameType()->isDependentType()) { 1602 DependentID = true; 1603 } else if (SS.isSet()) { 1604 if (DeclContext *DC = computeDeclContext(SS, false)) { 1605 if (RequireCompleteDeclContext(SS, DC)) 1606 return ExprError(); 1607 } else { 1608 DependentID = true; 1609 } 1610 } 1611 1612 if (DependentID) 1613 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1614 IsAddressOfOperand, TemplateArgs); 1615 1616 // Perform the required lookup. 1617 LookupResult R(*this, NameInfo, 1618 (Id.getKind() == UnqualifiedId::IK_ImplicitSelfParam) 1619 ? LookupObjCImplicitSelfParam : LookupOrdinaryName); 1620 if (TemplateArgs) { 1621 // Lookup the template name again to correctly establish the context in 1622 // which it was found. This is really unfortunate as we already did the 1623 // lookup to determine that it was a template name in the first place. If 1624 // this becomes a performance hit, we can work harder to preserve those 1625 // results until we get here but it's likely not worth it. 1626 bool MemberOfUnknownSpecialization; 1627 LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false, 1628 MemberOfUnknownSpecialization); 1629 1630 if (MemberOfUnknownSpecialization || 1631 (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)) 1632 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1633 IsAddressOfOperand, TemplateArgs); 1634 } else { 1635 bool IvarLookupFollowUp = II && !SS.isSet() && getCurMethodDecl(); 1636 LookupParsedName(R, S, &SS, !IvarLookupFollowUp); 1637 1638 // If the result might be in a dependent base class, this is a dependent 1639 // id-expression. 1640 if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation) 1641 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1642 IsAddressOfOperand, TemplateArgs); 1643 1644 // If this reference is in an Objective-C method, then we need to do 1645 // some special Objective-C lookup, too. 1646 if (IvarLookupFollowUp) { 1647 ExprResult E(LookupInObjCMethod(R, S, II, true)); 1648 if (E.isInvalid()) 1649 return ExprError(); 1650 1651 if (Expr *Ex = E.takeAs<Expr>()) 1652 return Owned(Ex); 1653 } 1654 } 1655 1656 if (R.isAmbiguous()) 1657 return ExprError(); 1658 1659 // Determine whether this name might be a candidate for 1660 // argument-dependent lookup. 1661 bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen); 1662 1663 if (R.empty() && !ADL) { 1664 // Otherwise, this could be an implicitly declared function reference (legal 1665 // in C90, extension in C99, forbidden in C++). 1666 if (HasTrailingLParen && II && !getLangOpts().CPlusPlus) { 1667 NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S); 1668 if (D) R.addDecl(D); 1669 } 1670 1671 // If this name wasn't predeclared and if this is not a function 1672 // call, diagnose the problem. 1673 if (R.empty()) { 1674 1675 // In Microsoft mode, if we are inside a template class member function 1676 // and we can't resolve an identifier then assume the identifier is type 1677 // dependent. The goal is to postpone name lookup to instantiation time 1678 // to be able to search into type dependent base classes. 1679 if (getLangOpts().MicrosoftMode && CurContext->isDependentContext() && 1680 isa<CXXMethodDecl>(CurContext)) 1681 return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo, 1682 IsAddressOfOperand, TemplateArgs); 1683 1684 CorrectionCandidateCallback DefaultValidator; 1685 if (DiagnoseEmptyLookup(S, SS, R, CCC ? *CCC : DefaultValidator)) 1686 return ExprError(); 1687 1688 assert(!R.empty() && 1689 "DiagnoseEmptyLookup returned false but added no results"); 1690 1691 // If we found an Objective-C instance variable, let 1692 // LookupInObjCMethod build the appropriate expression to 1693 // reference the ivar. 1694 if (ObjCIvarDecl *Ivar = R.getAsSingle<ObjCIvarDecl>()) { 1695 R.clear(); 1696 ExprResult E(LookupInObjCMethod(R, S, Ivar->getIdentifier())); 1697 // In a hopelessly buggy code, Objective-C instance variable 1698 // lookup fails and no expression will be built to reference it. 1699 if (!E.isInvalid() && !E.get()) 1700 return ExprError(); 1701 return move(E); 1702 } 1703 } 1704 } 1705 1706 // This is guaranteed from this point on. 1707 assert(!R.empty() || ADL); 1708 1709 // Check whether this might be a C++ implicit instance member access. 1710 // C++ [class.mfct.non-static]p3: 1711 // When an id-expression that is not part of a class member access 1712 // syntax and not used to form a pointer to member is used in the 1713 // body of a non-static member function of class X, if name lookup 1714 // resolves the name in the id-expression to a non-static non-type 1715 // member of some class C, the id-expression is transformed into a 1716 // class member access expression using (*this) as the 1717 // postfix-expression to the left of the . operator. 1718 // 1719 // But we don't actually need to do this for '&' operands if R 1720 // resolved to a function or overloaded function set, because the 1721 // expression is ill-formed if it actually works out to be a 1722 // non-static member function: 1723 // 1724 // C++ [expr.ref]p4: 1725 // Otherwise, if E1.E2 refers to a non-static member function. . . 1726 // [t]he expression can be used only as the left-hand operand of a 1727 // member function call. 1728 // 1729 // There are other safeguards against such uses, but it's important 1730 // to get this right here so that we don't end up making a 1731 // spuriously dependent expression if we're inside a dependent 1732 // instance method. 1733 if (!R.empty() && (*R.begin())->isCXXClassMember()) { 1734 bool MightBeImplicitMember; 1735 if (!IsAddressOfOperand) 1736 MightBeImplicitMember = true; 1737 else if (!SS.isEmpty()) 1738 MightBeImplicitMember = false; 1739 else if (R.isOverloadedResult()) 1740 MightBeImplicitMember = false; 1741 else if (R.isUnresolvableResult()) 1742 MightBeImplicitMember = true; 1743 else 1744 MightBeImplicitMember = isa<FieldDecl>(R.getFoundDecl()) || 1745 isa<IndirectFieldDecl>(R.getFoundDecl()); 1746 1747 if (MightBeImplicitMember) 1748 return BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, 1749 R, TemplateArgs); 1750 } 1751 1752 if (TemplateArgs || TemplateKWLoc.isValid()) 1753 return BuildTemplateIdExpr(SS, TemplateKWLoc, R, ADL, TemplateArgs); 1754 1755 return BuildDeclarationNameExpr(SS, R, ADL); 1756 } 1757 1758 /// BuildQualifiedDeclarationNameExpr - Build a C++ qualified 1759 /// declaration name, generally during template instantiation. 1760 /// There's a large number of things which don't need to be done along 1761 /// this path. 1762 ExprResult 1763 Sema::BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS, 1764 const DeclarationNameInfo &NameInfo) { 1765 DeclContext *DC; 1766 if (!(DC = computeDeclContext(SS, false)) || DC->isDependentContext()) 1767 return BuildDependentDeclRefExpr(SS, /*TemplateKWLoc=*/SourceLocation(), 1768 NameInfo, /*TemplateArgs=*/0); 1769 1770 if (RequireCompleteDeclContext(SS, DC)) 1771 return ExprError(); 1772 1773 LookupResult R(*this, NameInfo, LookupOrdinaryName); 1774 LookupQualifiedName(R, DC); 1775 1776 if (R.isAmbiguous()) 1777 return ExprError(); 1778 1779 if (R.empty()) { 1780 Diag(NameInfo.getLoc(), diag::err_no_member) 1781 << NameInfo.getName() << DC << SS.getRange(); 1782 return ExprError(); 1783 } 1784 1785 return BuildDeclarationNameExpr(SS, R, /*ADL*/ false); 1786 } 1787 1788 /// LookupInObjCMethod - The parser has read a name in, and Sema has 1789 /// detected that we're currently inside an ObjC method. Perform some 1790 /// additional lookup. 1791 /// 1792 /// Ideally, most of this would be done by lookup, but there's 1793 /// actually quite a lot of extra work involved. 1794 /// 1795 /// Returns a null sentinel to indicate trivial success. 1796 ExprResult 1797 Sema::LookupInObjCMethod(LookupResult &Lookup, Scope *S, 1798 IdentifierInfo *II, bool AllowBuiltinCreation) { 1799 SourceLocation Loc = Lookup.getNameLoc(); 1800 ObjCMethodDecl *CurMethod = getCurMethodDecl(); 1801 1802 // There are two cases to handle here. 1) scoped lookup could have failed, 1803 // in which case we should look for an ivar. 2) scoped lookup could have 1804 // found a decl, but that decl is outside the current instance method (i.e. 1805 // a global variable). In these two cases, we do a lookup for an ivar with 1806 // this name, if the lookup sucedes, we replace it our current decl. 1807 1808 // If we're in a class method, we don't normally want to look for 1809 // ivars. But if we don't find anything else, and there's an 1810 // ivar, that's an error. 1811 bool IsClassMethod = CurMethod->isClassMethod(); 1812 1813 bool LookForIvars; 1814 if (Lookup.empty()) 1815 LookForIvars = true; 1816 else if (IsClassMethod) 1817 LookForIvars = false; 1818 else 1819 LookForIvars = (Lookup.isSingleResult() && 1820 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()); 1821 ObjCInterfaceDecl *IFace = 0; 1822 if (LookForIvars) { 1823 IFace = CurMethod->getClassInterface(); 1824 ObjCInterfaceDecl *ClassDeclared; 1825 ObjCIvarDecl *IV = 0; 1826 if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) { 1827 // Diagnose using an ivar in a class method. 1828 if (IsClassMethod) 1829 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 1830 << IV->getDeclName()); 1831 1832 // If we're referencing an invalid decl, just return this as a silent 1833 // error node. The error diagnostic was already emitted on the decl. 1834 if (IV->isInvalidDecl()) 1835 return ExprError(); 1836 1837 // Check if referencing a field with __attribute__((deprecated)). 1838 if (DiagnoseUseOfDecl(IV, Loc)) 1839 return ExprError(); 1840 1841 // Diagnose the use of an ivar outside of the declaring class. 1842 if (IV->getAccessControl() == ObjCIvarDecl::Private && 1843 !declaresSameEntity(ClassDeclared, IFace) && 1844 !getLangOpts().DebuggerSupport) 1845 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName(); 1846 1847 // FIXME: This should use a new expr for a direct reference, don't 1848 // turn this into Self->ivar, just return a BareIVarExpr or something. 1849 IdentifierInfo &II = Context.Idents.get("self"); 1850 UnqualifiedId SelfName; 1851 SelfName.setIdentifier(&II, SourceLocation()); 1852 SelfName.setKind(UnqualifiedId::IK_ImplicitSelfParam); 1853 CXXScopeSpec SelfScopeSpec; 1854 SourceLocation TemplateKWLoc; 1855 ExprResult SelfExpr = ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc, 1856 SelfName, false, false); 1857 if (SelfExpr.isInvalid()) 1858 return ExprError(); 1859 1860 SelfExpr = DefaultLvalueConversion(SelfExpr.take()); 1861 if (SelfExpr.isInvalid()) 1862 return ExprError(); 1863 1864 MarkAnyDeclReferenced(Loc, IV); 1865 return Owned(new (Context) 1866 ObjCIvarRefExpr(IV, IV->getType(), Loc, 1867 SelfExpr.take(), true, true)); 1868 } 1869 } else if (CurMethod->isInstanceMethod()) { 1870 // We should warn if a local variable hides an ivar. 1871 if (ObjCInterfaceDecl *IFace = CurMethod->getClassInterface()) { 1872 ObjCInterfaceDecl *ClassDeclared; 1873 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(II, ClassDeclared)) { 1874 if (IV->getAccessControl() != ObjCIvarDecl::Private || 1875 declaresSameEntity(IFace, ClassDeclared)) 1876 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName(); 1877 } 1878 } 1879 } else if (Lookup.isSingleResult() && 1880 Lookup.getFoundDecl()->isDefinedOutsideFunctionOrMethod()) { 1881 // If accessing a stand-alone ivar in a class method, this is an error. 1882 if (const ObjCIvarDecl *IV = dyn_cast<ObjCIvarDecl>(Lookup.getFoundDecl())) 1883 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 1884 << IV->getDeclName()); 1885 } 1886 1887 if (Lookup.empty() && II && AllowBuiltinCreation) { 1888 // FIXME. Consolidate this with similar code in LookupName. 1889 if (unsigned BuiltinID = II->getBuiltinID()) { 1890 if (!(getLangOpts().CPlusPlus && 1891 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))) { 1892 NamedDecl *D = LazilyCreateBuiltin((IdentifierInfo *)II, BuiltinID, 1893 S, Lookup.isForRedeclaration(), 1894 Lookup.getNameLoc()); 1895 if (D) Lookup.addDecl(D); 1896 } 1897 } 1898 } 1899 // Sentinel value saying that we didn't do anything special. 1900 return Owned((Expr*) 0); 1901 } 1902 1903 /// \brief Cast a base object to a member's actual type. 1904 /// 1905 /// Logically this happens in three phases: 1906 /// 1907 /// * First we cast from the base type to the naming class. 1908 /// The naming class is the class into which we were looking 1909 /// when we found the member; it's the qualifier type if a 1910 /// qualifier was provided, and otherwise it's the base type. 1911 /// 1912 /// * Next we cast from the naming class to the declaring class. 1913 /// If the member we found was brought into a class's scope by 1914 /// a using declaration, this is that class; otherwise it's 1915 /// the class declaring the member. 1916 /// 1917 /// * Finally we cast from the declaring class to the "true" 1918 /// declaring class of the member. This conversion does not 1919 /// obey access control. 1920 ExprResult 1921 Sema::PerformObjectMemberConversion(Expr *From, 1922 NestedNameSpecifier *Qualifier, 1923 NamedDecl *FoundDecl, 1924 NamedDecl *Member) { 1925 CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Member->getDeclContext()); 1926 if (!RD) 1927 return Owned(From); 1928 1929 QualType DestRecordType; 1930 QualType DestType; 1931 QualType FromRecordType; 1932 QualType FromType = From->getType(); 1933 bool PointerConversions = false; 1934 if (isa<FieldDecl>(Member)) { 1935 DestRecordType = Context.getCanonicalType(Context.getTypeDeclType(RD)); 1936 1937 if (FromType->getAs<PointerType>()) { 1938 DestType = Context.getPointerType(DestRecordType); 1939 FromRecordType = FromType->getPointeeType(); 1940 PointerConversions = true; 1941 } else { 1942 DestType = DestRecordType; 1943 FromRecordType = FromType; 1944 } 1945 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) { 1946 if (Method->isStatic()) 1947 return Owned(From); 1948 1949 DestType = Method->getThisType(Context); 1950 DestRecordType = DestType->getPointeeType(); 1951 1952 if (FromType->getAs<PointerType>()) { 1953 FromRecordType = FromType->getPointeeType(); 1954 PointerConversions = true; 1955 } else { 1956 FromRecordType = FromType; 1957 DestType = DestRecordType; 1958 } 1959 } else { 1960 // No conversion necessary. 1961 return Owned(From); 1962 } 1963 1964 if (DestType->isDependentType() || FromType->isDependentType()) 1965 return Owned(From); 1966 1967 // If the unqualified types are the same, no conversion is necessary. 1968 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 1969 return Owned(From); 1970 1971 SourceRange FromRange = From->getSourceRange(); 1972 SourceLocation FromLoc = FromRange.getBegin(); 1973 1974 ExprValueKind VK = From->getValueKind(); 1975 1976 // C++ [class.member.lookup]p8: 1977 // [...] Ambiguities can often be resolved by qualifying a name with its 1978 // class name. 1979 // 1980 // If the member was a qualified name and the qualified referred to a 1981 // specific base subobject type, we'll cast to that intermediate type 1982 // first and then to the object in which the member is declared. That allows 1983 // one to resolve ambiguities in, e.g., a diamond-shaped hierarchy such as: 1984 // 1985 // class Base { public: int x; }; 1986 // class Derived1 : public Base { }; 1987 // class Derived2 : public Base { }; 1988 // class VeryDerived : public Derived1, public Derived2 { void f(); }; 1989 // 1990 // void VeryDerived::f() { 1991 // x = 17; // error: ambiguous base subobjects 1992 // Derived1::x = 17; // okay, pick the Base subobject of Derived1 1993 // } 1994 if (Qualifier) { 1995 QualType QType = QualType(Qualifier->getAsType(), 0); 1996 assert(!QType.isNull() && "lookup done with dependent qualifier?"); 1997 assert(QType->isRecordType() && "lookup done with non-record type"); 1998 1999 QualType QRecordType = QualType(QType->getAs<RecordType>(), 0); 2000 2001 // In C++98, the qualifier type doesn't actually have to be a base 2002 // type of the object type, in which case we just ignore it. 2003 // Otherwise build the appropriate casts. 2004 if (IsDerivedFrom(FromRecordType, QRecordType)) { 2005 CXXCastPath BasePath; 2006 if (CheckDerivedToBaseConversion(FromRecordType, QRecordType, 2007 FromLoc, FromRange, &BasePath)) 2008 return ExprError(); 2009 2010 if (PointerConversions) 2011 QType = Context.getPointerType(QType); 2012 From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase, 2013 VK, &BasePath).take(); 2014 2015 FromType = QType; 2016 FromRecordType = QRecordType; 2017 2018 // If the qualifier type was the same as the destination type, 2019 // we're done. 2020 if (Context.hasSameUnqualifiedType(FromRecordType, DestRecordType)) 2021 return Owned(From); 2022 } 2023 } 2024 2025 bool IgnoreAccess = false; 2026 2027 // If we actually found the member through a using declaration, cast 2028 // down to the using declaration's type. 2029 // 2030 // Pointer equality is fine here because only one declaration of a 2031 // class ever has member declarations. 2032 if (FoundDecl->getDeclContext() != Member->getDeclContext()) { 2033 assert(isa<UsingShadowDecl>(FoundDecl)); 2034 QualType URecordType = Context.getTypeDeclType( 2035 cast<CXXRecordDecl>(FoundDecl->getDeclContext())); 2036 2037 // We only need to do this if the naming-class to declaring-class 2038 // conversion is non-trivial. 2039 if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) { 2040 assert(IsDerivedFrom(FromRecordType, URecordType)); 2041 CXXCastPath BasePath; 2042 if (CheckDerivedToBaseConversion(FromRecordType, URecordType, 2043 FromLoc, FromRange, &BasePath)) 2044 return ExprError(); 2045 2046 QualType UType = URecordType; 2047 if (PointerConversions) 2048 UType = Context.getPointerType(UType); 2049 From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase, 2050 VK, &BasePath).take(); 2051 FromType = UType; 2052 FromRecordType = URecordType; 2053 } 2054 2055 // We don't do access control for the conversion from the 2056 // declaring class to the true declaring class. 2057 IgnoreAccess = true; 2058 } 2059 2060 CXXCastPath BasePath; 2061 if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType, 2062 FromLoc, FromRange, &BasePath, 2063 IgnoreAccess)) 2064 return ExprError(); 2065 2066 return ImpCastExprToType(From, DestType, CK_UncheckedDerivedToBase, 2067 VK, &BasePath); 2068 } 2069 2070 bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS, 2071 const LookupResult &R, 2072 bool HasTrailingLParen) { 2073 // Only when used directly as the postfix-expression of a call. 2074 if (!HasTrailingLParen) 2075 return false; 2076 2077 // Never if a scope specifier was provided. 2078 if (SS.isSet()) 2079 return false; 2080 2081 // Only in C++ or ObjC++. 2082 if (!getLangOpts().CPlusPlus) 2083 return false; 2084 2085 // Turn off ADL when we find certain kinds of declarations during 2086 // normal lookup: 2087 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { 2088 NamedDecl *D = *I; 2089 2090 // C++0x [basic.lookup.argdep]p3: 2091 // -- a declaration of a class member 2092 // Since using decls preserve this property, we check this on the 2093 // original decl. 2094 if (D->isCXXClassMember()) 2095 return false; 2096 2097 // C++0x [basic.lookup.argdep]p3: 2098 // -- a block-scope function declaration that is not a 2099 // using-declaration 2100 // NOTE: we also trigger this for function templates (in fact, we 2101 // don't check the decl type at all, since all other decl types 2102 // turn off ADL anyway). 2103 if (isa<UsingShadowDecl>(D)) 2104 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 2105 else if (D->getDeclContext()->isFunctionOrMethod()) 2106 return false; 2107 2108 // C++0x [basic.lookup.argdep]p3: 2109 // -- a declaration that is neither a function or a function 2110 // template 2111 // And also for builtin functions. 2112 if (isa<FunctionDecl>(D)) { 2113 FunctionDecl *FDecl = cast<FunctionDecl>(D); 2114 2115 // But also builtin functions. 2116 if (FDecl->getBuiltinID() && FDecl->isImplicit()) 2117 return false; 2118 } else if (!isa<FunctionTemplateDecl>(D)) 2119 return false; 2120 } 2121 2122 return true; 2123 } 2124 2125 2126 /// Diagnoses obvious problems with the use of the given declaration 2127 /// as an expression. This is only actually called for lookups that 2128 /// were not overloaded, and it doesn't promise that the declaration 2129 /// will in fact be used. 2130 static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) { 2131 if (isa<TypedefNameDecl>(D)) { 2132 S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName(); 2133 return true; 2134 } 2135 2136 if (isa<ObjCInterfaceDecl>(D)) { 2137 S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName(); 2138 return true; 2139 } 2140 2141 if (isa<NamespaceDecl>(D)) { 2142 S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName(); 2143 return true; 2144 } 2145 2146 return false; 2147 } 2148 2149 ExprResult 2150 Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2151 LookupResult &R, 2152 bool NeedsADL) { 2153 // If this is a single, fully-resolved result and we don't need ADL, 2154 // just build an ordinary singleton decl ref. 2155 if (!NeedsADL && R.isSingleResult() && !R.getAsSingle<FunctionTemplateDecl>()) 2156 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), 2157 R.getFoundDecl()); 2158 2159 // We only need to check the declaration if there's exactly one 2160 // result, because in the overloaded case the results can only be 2161 // functions and function templates. 2162 if (R.isSingleResult() && 2163 CheckDeclInExpr(*this, R.getNameLoc(), R.getFoundDecl())) 2164 return ExprError(); 2165 2166 // Otherwise, just build an unresolved lookup expression. Suppress 2167 // any lookup-related diagnostics; we'll hash these out later, when 2168 // we've picked a target. 2169 R.suppressDiagnostics(); 2170 2171 UnresolvedLookupExpr *ULE 2172 = UnresolvedLookupExpr::Create(Context, R.getNamingClass(), 2173 SS.getWithLocInContext(Context), 2174 R.getLookupNameInfo(), 2175 NeedsADL, R.isOverloadedResult(), 2176 R.begin(), R.end()); 2177 2178 return Owned(ULE); 2179 } 2180 2181 /// \brief Complete semantic analysis for a reference to the given declaration. 2182 ExprResult 2183 Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, 2184 const DeclarationNameInfo &NameInfo, 2185 NamedDecl *D) { 2186 assert(D && "Cannot refer to a NULL declaration"); 2187 assert(!isa<FunctionTemplateDecl>(D) && 2188 "Cannot refer unambiguously to a function template"); 2189 2190 SourceLocation Loc = NameInfo.getLoc(); 2191 if (CheckDeclInExpr(*this, Loc, D)) 2192 return ExprError(); 2193 2194 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) { 2195 // Specifically diagnose references to class templates that are missing 2196 // a template argument list. 2197 Diag(Loc, diag::err_template_decl_ref) 2198 << Template << SS.getRange(); 2199 Diag(Template->getLocation(), diag::note_template_decl_here); 2200 return ExprError(); 2201 } 2202 2203 // Make sure that we're referring to a value. 2204 ValueDecl *VD = dyn_cast<ValueDecl>(D); 2205 if (!VD) { 2206 Diag(Loc, diag::err_ref_non_value) 2207 << D << SS.getRange(); 2208 Diag(D->getLocation(), diag::note_declared_at); 2209 return ExprError(); 2210 } 2211 2212 // Check whether this declaration can be used. Note that we suppress 2213 // this check when we're going to perform argument-dependent lookup 2214 // on this function name, because this might not be the function 2215 // that overload resolution actually selects. 2216 if (DiagnoseUseOfDecl(VD, Loc)) 2217 return ExprError(); 2218 2219 // Only create DeclRefExpr's for valid Decl's. 2220 if (VD->isInvalidDecl()) 2221 return ExprError(); 2222 2223 // Handle members of anonymous structs and unions. If we got here, 2224 // and the reference is to a class member indirect field, then this 2225 // must be the subject of a pointer-to-member expression. 2226 if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD)) 2227 if (!indirectField->isCXXClassMember()) 2228 return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(), 2229 indirectField); 2230 2231 { 2232 QualType type = VD->getType(); 2233 ExprValueKind valueKind = VK_RValue; 2234 2235 switch (D->getKind()) { 2236 // Ignore all the non-ValueDecl kinds. 2237 #define ABSTRACT_DECL(kind) 2238 #define VALUE(type, base) 2239 #define DECL(type, base) \ 2240 case Decl::type: 2241 #include "clang/AST/DeclNodes.inc" 2242 llvm_unreachable("invalid value decl kind"); 2243 2244 // These shouldn't make it here. 2245 case Decl::ObjCAtDefsField: 2246 case Decl::ObjCIvar: 2247 llvm_unreachable("forming non-member reference to ivar?"); 2248 2249 // Enum constants are always r-values and never references. 2250 // Unresolved using declarations are dependent. 2251 case Decl::EnumConstant: 2252 case Decl::UnresolvedUsingValue: 2253 valueKind = VK_RValue; 2254 break; 2255 2256 // Fields and indirect fields that got here must be for 2257 // pointer-to-member expressions; we just call them l-values for 2258 // internal consistency, because this subexpression doesn't really 2259 // exist in the high-level semantics. 2260 case Decl::Field: 2261 case Decl::IndirectField: 2262 assert(getLangOpts().CPlusPlus && 2263 "building reference to field in C?"); 2264 2265 // These can't have reference type in well-formed programs, but 2266 // for internal consistency we do this anyway. 2267 type = type.getNonReferenceType(); 2268 valueKind = VK_LValue; 2269 break; 2270 2271 // Non-type template parameters are either l-values or r-values 2272 // depending on the type. 2273 case Decl::NonTypeTemplateParm: { 2274 if (const ReferenceType *reftype = type->getAs<ReferenceType>()) { 2275 type = reftype->getPointeeType(); 2276 valueKind = VK_LValue; // even if the parameter is an r-value reference 2277 break; 2278 } 2279 2280 // For non-references, we need to strip qualifiers just in case 2281 // the template parameter was declared as 'const int' or whatever. 2282 valueKind = VK_RValue; 2283 type = type.getUnqualifiedType(); 2284 break; 2285 } 2286 2287 case Decl::Var: 2288 // In C, "extern void blah;" is valid and is an r-value. 2289 if (!getLangOpts().CPlusPlus && 2290 !type.hasQualifiers() && 2291 type->isVoidType()) { 2292 valueKind = VK_RValue; 2293 break; 2294 } 2295 // fallthrough 2296 2297 case Decl::ImplicitParam: 2298 case Decl::ParmVar: { 2299 // These are always l-values. 2300 valueKind = VK_LValue; 2301 type = type.getNonReferenceType(); 2302 2303 // FIXME: Does the addition of const really only apply in 2304 // potentially-evaluated contexts? Since the variable isn't actually 2305 // captured in an unevaluated context, it seems that the answer is no. 2306 if (ExprEvalContexts.back().Context != Sema::Unevaluated) { 2307 QualType CapturedType = getCapturedDeclRefType(cast<VarDecl>(VD), Loc); 2308 if (!CapturedType.isNull()) 2309 type = CapturedType; 2310 } 2311 2312 break; 2313 } 2314 2315 case Decl::Function: { 2316 const FunctionType *fty = type->castAs<FunctionType>(); 2317 2318 // If we're referring to a function with an __unknown_anytype 2319 // result type, make the entire expression __unknown_anytype. 2320 if (fty->getResultType() == Context.UnknownAnyTy) { 2321 type = Context.UnknownAnyTy; 2322 valueKind = VK_RValue; 2323 break; 2324 } 2325 2326 // Functions are l-values in C++. 2327 if (getLangOpts().CPlusPlus) { 2328 valueKind = VK_LValue; 2329 break; 2330 } 2331 2332 // C99 DR 316 says that, if a function type comes from a 2333 // function definition (without a prototype), that type is only 2334 // used for checking compatibility. Therefore, when referencing 2335 // the function, we pretend that we don't have the full function 2336 // type. 2337 if (!cast<FunctionDecl>(VD)->hasPrototype() && 2338 isa<FunctionProtoType>(fty)) 2339 type = Context.getFunctionNoProtoType(fty->getResultType(), 2340 fty->getExtInfo()); 2341 2342 // Functions are r-values in C. 2343 valueKind = VK_RValue; 2344 break; 2345 } 2346 2347 case Decl::CXXMethod: 2348 // If we're referring to a method with an __unknown_anytype 2349 // result type, make the entire expression __unknown_anytype. 2350 // This should only be possible with a type written directly. 2351 if (const FunctionProtoType *proto 2352 = dyn_cast<FunctionProtoType>(VD->getType())) 2353 if (proto->getResultType() == Context.UnknownAnyTy) { 2354 type = Context.UnknownAnyTy; 2355 valueKind = VK_RValue; 2356 break; 2357 } 2358 2359 // C++ methods are l-values if static, r-values if non-static. 2360 if (cast<CXXMethodDecl>(VD)->isStatic()) { 2361 valueKind = VK_LValue; 2362 break; 2363 } 2364 // fallthrough 2365 2366 case Decl::CXXConversion: 2367 case Decl::CXXDestructor: 2368 case Decl::CXXConstructor: 2369 valueKind = VK_RValue; 2370 break; 2371 } 2372 2373 return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS); 2374 } 2375 } 2376 2377 ExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind) { 2378 PredefinedExpr::IdentType IT; 2379 2380 switch (Kind) { 2381 default: llvm_unreachable("Unknown simple primary expr!"); 2382 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2] 2383 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break; 2384 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break; 2385 } 2386 2387 // Pre-defined identifiers are of type char[x], where x is the length of the 2388 // string. 2389 2390 Decl *currentDecl = getCurFunctionOrMethodDecl(); 2391 if (!currentDecl && getCurBlock()) 2392 currentDecl = getCurBlock()->TheDecl; 2393 if (!currentDecl) { 2394 Diag(Loc, diag::ext_predef_outside_function); 2395 currentDecl = Context.getTranslationUnitDecl(); 2396 } 2397 2398 QualType ResTy; 2399 if (cast<DeclContext>(currentDecl)->isDependentContext()) { 2400 ResTy = Context.DependentTy; 2401 } else { 2402 unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length(); 2403 2404 llvm::APInt LengthI(32, Length + 1); 2405 ResTy = Context.CharTy.withConst(); 2406 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0); 2407 } 2408 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT)); 2409 } 2410 2411 ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) { 2412 SmallString<16> CharBuffer; 2413 bool Invalid = false; 2414 StringRef ThisTok = PP.getSpelling(Tok, CharBuffer, &Invalid); 2415 if (Invalid) 2416 return ExprError(); 2417 2418 CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), Tok.getLocation(), 2419 PP, Tok.getKind()); 2420 if (Literal.hadError()) 2421 return ExprError(); 2422 2423 QualType Ty; 2424 if (Literal.isWide()) 2425 Ty = Context.WCharTy; // L'x' -> wchar_t in C and C++. 2426 else if (Literal.isUTF16()) 2427 Ty = Context.Char16Ty; // u'x' -> char16_t in C11 and C++11. 2428 else if (Literal.isUTF32()) 2429 Ty = Context.Char32Ty; // U'x' -> char32_t in C11 and C++11. 2430 else if (!getLangOpts().CPlusPlus || Literal.isMultiChar()) 2431 Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++. 2432 else 2433 Ty = Context.CharTy; // 'x' -> char in C++ 2434 2435 CharacterLiteral::CharacterKind Kind = CharacterLiteral::Ascii; 2436 if (Literal.isWide()) 2437 Kind = CharacterLiteral::Wide; 2438 else if (Literal.isUTF16()) 2439 Kind = CharacterLiteral::UTF16; 2440 else if (Literal.isUTF32()) 2441 Kind = CharacterLiteral::UTF32; 2442 2443 Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty, 2444 Tok.getLocation()); 2445 2446 if (Literal.getUDSuffix().empty()) 2447 return Owned(Lit); 2448 2449 // We're building a user-defined literal. 2450 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 2451 SourceLocation UDSuffixLoc = 2452 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset()); 2453 2454 // Make sure we're allowed user-defined literals here. 2455 if (!UDLScope) 2456 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_character_udl)); 2457 2458 // C++11 [lex.ext]p6: The literal L is treated as a call of the form 2459 // operator "" X (ch) 2460 return BuildCookedLiteralOperatorCall(*this, UDLScope, UDSuffix, UDSuffixLoc, 2461 llvm::makeArrayRef(&Lit, 1), 2462 Tok.getLocation()); 2463 } 2464 2465 ExprResult Sema::ActOnIntegerConstant(SourceLocation Loc, uint64_t Val) { 2466 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 2467 return Owned(IntegerLiteral::Create(Context, llvm::APInt(IntSize, Val), 2468 Context.IntTy, Loc)); 2469 } 2470 2471 static Expr *BuildFloatingLiteral(Sema &S, NumericLiteralParser &Literal, 2472 QualType Ty, SourceLocation Loc) { 2473 const llvm::fltSemantics &Format = S.Context.getFloatTypeSemantics(Ty); 2474 2475 using llvm::APFloat; 2476 APFloat Val(Format); 2477 2478 APFloat::opStatus result = Literal.GetFloatValue(Val); 2479 2480 // Overflow is always an error, but underflow is only an error if 2481 // we underflowed to zero (APFloat reports denormals as underflow). 2482 if ((result & APFloat::opOverflow) || 2483 ((result & APFloat::opUnderflow) && Val.isZero())) { 2484 unsigned diagnostic; 2485 SmallString<20> buffer; 2486 if (result & APFloat::opOverflow) { 2487 diagnostic = diag::warn_float_overflow; 2488 APFloat::getLargest(Format).toString(buffer); 2489 } else { 2490 diagnostic = diag::warn_float_underflow; 2491 APFloat::getSmallest(Format).toString(buffer); 2492 } 2493 2494 S.Diag(Loc, diagnostic) 2495 << Ty 2496 << StringRef(buffer.data(), buffer.size()); 2497 } 2498 2499 bool isExact = (result == APFloat::opOK); 2500 return FloatingLiteral::Create(S.Context, Val, isExact, Ty, Loc); 2501 } 2502 2503 ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) { 2504 // Fast path for a single digit (which is quite common). A single digit 2505 // cannot have a trigraph, escaped newline, radix prefix, or suffix. 2506 if (Tok.getLength() == 1) { 2507 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok); 2508 return ActOnIntegerConstant(Tok.getLocation(), Val-'0'); 2509 } 2510 2511 SmallString<512> IntegerBuffer; 2512 // Add padding so that NumericLiteralParser can overread by one character. 2513 IntegerBuffer.resize(Tok.getLength()+1); 2514 const char *ThisTokBegin = &IntegerBuffer[0]; 2515 2516 // Get the spelling of the token, which eliminates trigraphs, etc. 2517 bool Invalid = false; 2518 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid); 2519 if (Invalid) 2520 return ExprError(); 2521 2522 NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength, 2523 Tok.getLocation(), PP); 2524 if (Literal.hadError) 2525 return ExprError(); 2526 2527 if (Literal.hasUDSuffix()) { 2528 // We're building a user-defined literal. 2529 IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix()); 2530 SourceLocation UDSuffixLoc = 2531 getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset()); 2532 2533 // Make sure we're allowed user-defined literals here. 2534 if (!UDLScope) 2535 return ExprError(Diag(UDSuffixLoc, diag::err_invalid_numeric_udl)); 2536 2537 QualType CookedTy; 2538 if (Literal.isFloatingLiteral()) { 2539 // C++11 [lex.ext]p4: If S contains a literal operator with parameter type 2540 // long double, the literal is treated as a call of the form 2541 // operator "" X (f L) 2542 CookedTy = Context.LongDoubleTy; 2543 } else { 2544 // C++11 [lex.ext]p3: If S contains a literal operator with parameter type 2545 // unsigned long long, the literal is treated as a call of the form 2546 // operator "" X (n ULL) 2547 CookedTy = Context.UnsignedLongLongTy; 2548 } 2549 2550 DeclarationName OpName = 2551 Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix); 2552 DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc); 2553 OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc); 2554 2555 // Perform literal operator lookup to determine if we're building a raw 2556 // literal or a cooked one. 2557 LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName); 2558 switch (LookupLiteralOperator(UDLScope, R, llvm::makeArrayRef(&CookedTy, 1), 2559 /*AllowRawAndTemplate*/true)) { 2560 case LOLR_Error: 2561 return ExprError(); 2562 2563 case LOLR_Cooked: { 2564 Expr *Lit; 2565 if (Literal.isFloatingLiteral()) { 2566 Lit = BuildFloatingLiteral(*this, Literal, CookedTy, Tok.getLocation()); 2567 } else { 2568 llvm::APInt ResultVal(Context.getTargetInfo().getLongLongWidth(), 0); 2569 if (Literal.GetIntegerValue(ResultVal)) 2570 Diag(Tok.getLocation(), diag::warn_integer_too_large); 2571 Lit = IntegerLiteral::Create(Context, ResultVal, CookedTy, 2572 Tok.getLocation()); 2573 } 2574 return BuildLiteralOperatorCall(R, OpNameInfo, 2575 llvm::makeArrayRef(&Lit, 1), 2576 Tok.getLocation()); 2577 } 2578 2579 case LOLR_Raw: { 2580 // C++11 [lit.ext]p3, p4: If S contains a raw literal operator, the 2581 // literal is treated as a call of the form 2582 // operator "" X ("n") 2583 SourceLocation TokLoc = Tok.getLocation(); 2584 unsigned Length = Literal.getUDSuffixOffset(); 2585 QualType StrTy = Context.getConstantArrayType( 2586 Context.CharTy, llvm::APInt(32, Length + 1), 2587 ArrayType::Normal, 0); 2588 Expr *Lit = StringLiteral::Create( 2589 Context, StringRef(ThisTokBegin, Length), StringLiteral::Ascii, 2590 /*Pascal*/false, StrTy, &TokLoc, 1); 2591 return BuildLiteralOperatorCall(R, OpNameInfo, 2592 llvm::makeArrayRef(&Lit, 1), TokLoc); 2593 } 2594 2595 case LOLR_Template: 2596 // C++11 [lit.ext]p3, p4: Otherwise (S contains a literal operator 2597 // template), L is treated as a call fo the form 2598 // operator "" X <'c1', 'c2', ... 'ck'>() 2599 // where n is the source character sequence c1 c2 ... ck. 2600 TemplateArgumentListInfo ExplicitArgs; 2601 unsigned CharBits = Context.getIntWidth(Context.CharTy); 2602 bool CharIsUnsigned = Context.CharTy->isUnsignedIntegerType(); 2603 llvm::APSInt Value(CharBits, CharIsUnsigned); 2604 for (unsigned I = 0, N = Literal.getUDSuffixOffset(); I != N; ++I) { 2605 Value = ThisTokBegin[I]; 2606 TemplateArgument Arg(Value, Context.CharTy); 2607 TemplateArgumentLocInfo ArgInfo; 2608 ExplicitArgs.addArgument(TemplateArgumentLoc(Arg, ArgInfo)); 2609 } 2610 return BuildLiteralOperatorCall(R, OpNameInfo, ArrayRef<Expr*>(), 2611 Tok.getLocation(), &ExplicitArgs); 2612 } 2613 2614 llvm_unreachable("unexpected literal operator lookup result"); 2615 } 2616 2617 Expr *Res; 2618 2619 if (Literal.isFloatingLiteral()) { 2620 QualType Ty; 2621 if (Literal.isFloat) 2622 Ty = Context.FloatTy; 2623 else if (!Literal.isLong) 2624 Ty = Context.DoubleTy; 2625 else 2626 Ty = Context.LongDoubleTy; 2627 2628 Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation()); 2629 2630 if (Ty == Context.DoubleTy) { 2631 if (getLangOpts().SinglePrecisionConstants) { 2632 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); 2633 } else if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp64) { 2634 Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64); 2635 Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).take(); 2636 } 2637 } 2638 } else if (!Literal.isIntegerLiteral()) { 2639 return ExprError(); 2640 } else { 2641 QualType Ty; 2642 2643 // long long is a C99 feature. 2644 if (!getLangOpts().C99 && Literal.isLongLong) 2645 Diag(Tok.getLocation(), 2646 getLangOpts().CPlusPlus0x ? 2647 diag::warn_cxx98_compat_longlong : diag::ext_longlong); 2648 2649 // Get the value in the widest-possible width. 2650 llvm::APInt ResultVal(Context.getTargetInfo().getIntMaxTWidth(), 0); 2651 2652 if (Literal.GetIntegerValue(ResultVal)) { 2653 // If this value didn't fit into uintmax_t, warn and force to ull. 2654 Diag(Tok.getLocation(), diag::warn_integer_too_large); 2655 Ty = Context.UnsignedLongLongTy; 2656 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() && 2657 "long long is not intmax_t?"); 2658 } else { 2659 // If this value fits into a ULL, try to figure out what else it fits into 2660 // according to the rules of C99 6.4.4.1p5. 2661 2662 // Octal, Hexadecimal, and integers with a U suffix are allowed to 2663 // be an unsigned int. 2664 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10; 2665 2666 // Check from smallest to largest, picking the smallest type we can. 2667 unsigned Width = 0; 2668 if (!Literal.isLong && !Literal.isLongLong) { 2669 // Are int/unsigned possibilities? 2670 unsigned IntSize = Context.getTargetInfo().getIntWidth(); 2671 2672 // Does it fit in a unsigned int? 2673 if (ResultVal.isIntN(IntSize)) { 2674 // Does it fit in a signed int? 2675 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0) 2676 Ty = Context.IntTy; 2677 else if (AllowUnsigned) 2678 Ty = Context.UnsignedIntTy; 2679 Width = IntSize; 2680 } 2681 } 2682 2683 // Are long/unsigned long possibilities? 2684 if (Ty.isNull() && !Literal.isLongLong) { 2685 unsigned LongSize = Context.getTargetInfo().getLongWidth(); 2686 2687 // Does it fit in a unsigned long? 2688 if (ResultVal.isIntN(LongSize)) { 2689 // Does it fit in a signed long? 2690 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0) 2691 Ty = Context.LongTy; 2692 else if (AllowUnsigned) 2693 Ty = Context.UnsignedLongTy; 2694 Width = LongSize; 2695 } 2696 } 2697 2698 // Finally, check long long if needed. 2699 if (Ty.isNull()) { 2700 unsigned LongLongSize = Context.getTargetInfo().getLongLongWidth(); 2701 2702 // Does it fit in a unsigned long long? 2703 if (ResultVal.isIntN(LongLongSize)) { 2704 // Does it fit in a signed long long? 2705 // To be compatible with MSVC, hex integer literals ending with the 2706 // LL or i64 suffix are always signed in Microsoft mode. 2707 if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 || 2708 (getLangOpts().MicrosoftExt && Literal.isLongLong))) 2709 Ty = Context.LongLongTy; 2710 else if (AllowUnsigned) 2711 Ty = Context.UnsignedLongLongTy; 2712 Width = LongLongSize; 2713 } 2714 } 2715 2716 // If we still couldn't decide a type, we probably have something that 2717 // does not fit in a signed long long, but has no U suffix. 2718 if (Ty.isNull()) { 2719 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed); 2720 Ty = Context.UnsignedLongLongTy; 2721 Width = Context.getTargetInfo().getLongLongWidth(); 2722 } 2723 2724 if (ResultVal.getBitWidth() != Width) 2725 ResultVal = ResultVal.trunc(Width); 2726 } 2727 Res = IntegerLiteral::Create(Context, ResultVal, Ty, Tok.getLocation()); 2728 } 2729 2730 // If this is an imaginary literal, create the ImaginaryLiteral wrapper. 2731 if (Literal.isImaginary) 2732 Res = new (Context) ImaginaryLiteral(Res, 2733 Context.getComplexType(Res->getType())); 2734 2735 return Owned(Res); 2736 } 2737 2738 ExprResult Sema::ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E) { 2739 assert((E != 0) && "ActOnParenExpr() missing expr"); 2740 return Owned(new (Context) ParenExpr(L, R, E)); 2741 } 2742 2743 static bool CheckVecStepTraitOperandType(Sema &S, QualType T, 2744 SourceLocation Loc, 2745 SourceRange ArgRange) { 2746 // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in 2747 // scalar or vector data type argument..." 2748 // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic 2749 // type (C99 6.2.5p18) or void. 2750 if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) { 2751 S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type) 2752 << T << ArgRange; 2753 return true; 2754 } 2755 2756 assert((T->isVoidType() || !T->isIncompleteType()) && 2757 "Scalar types should always be complete"); 2758 return false; 2759 } 2760 2761 static bool CheckExtensionTraitOperandType(Sema &S, QualType T, 2762 SourceLocation Loc, 2763 SourceRange ArgRange, 2764 UnaryExprOrTypeTrait TraitKind) { 2765 // C99 6.5.3.4p1: 2766 if (T->isFunctionType()) { 2767 // alignof(function) is allowed as an extension. 2768 if (TraitKind == UETT_SizeOf) 2769 S.Diag(Loc, diag::ext_sizeof_function_type) << ArgRange; 2770 return false; 2771 } 2772 2773 // Allow sizeof(void)/alignof(void) as an extension. 2774 if (T->isVoidType()) { 2775 S.Diag(Loc, diag::ext_sizeof_void_type) << TraitKind << ArgRange; 2776 return false; 2777 } 2778 2779 return true; 2780 } 2781 2782 static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T, 2783 SourceLocation Loc, 2784 SourceRange ArgRange, 2785 UnaryExprOrTypeTrait TraitKind) { 2786 // Reject sizeof(interface) and sizeof(interface<proto>) in 64-bit mode. 2787 if (S.LangOpts.ObjCNonFragileABI && T->isObjCObjectType()) { 2788 S.Diag(Loc, diag::err_sizeof_nonfragile_interface) 2789 << T << (TraitKind == UETT_SizeOf) 2790 << ArgRange; 2791 return true; 2792 } 2793 2794 return false; 2795 } 2796 2797 /// \brief Check the constrains on expression operands to unary type expression 2798 /// and type traits. 2799 /// 2800 /// Completes any types necessary and validates the constraints on the operand 2801 /// expression. The logic mostly mirrors the type-based overload, but may modify 2802 /// the expression as it completes the type for that expression through template 2803 /// instantiation, etc. 2804 bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E, 2805 UnaryExprOrTypeTrait ExprKind) { 2806 QualType ExprTy = E->getType(); 2807 2808 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 2809 // the result is the size of the referenced type." 2810 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the 2811 // result shall be the alignment of the referenced type." 2812 if (const ReferenceType *Ref = ExprTy->getAs<ReferenceType>()) 2813 ExprTy = Ref->getPointeeType(); 2814 2815 if (ExprKind == UETT_VecStep) 2816 return CheckVecStepTraitOperandType(*this, ExprTy, E->getExprLoc(), 2817 E->getSourceRange()); 2818 2819 // Whitelist some types as extensions 2820 if (!CheckExtensionTraitOperandType(*this, ExprTy, E->getExprLoc(), 2821 E->getSourceRange(), ExprKind)) 2822 return false; 2823 2824 if (RequireCompleteExprType(E, 2825 PDiag(diag::err_sizeof_alignof_incomplete_type) 2826 << ExprKind << E->getSourceRange(), 2827 std::make_pair(SourceLocation(), PDiag(0)))) 2828 return true; 2829 2830 // Completeing the expression's type may have changed it. 2831 ExprTy = E->getType(); 2832 if (const ReferenceType *Ref = ExprTy->getAs<ReferenceType>()) 2833 ExprTy = Ref->getPointeeType(); 2834 2835 if (CheckObjCTraitOperandConstraints(*this, ExprTy, E->getExprLoc(), 2836 E->getSourceRange(), ExprKind)) 2837 return true; 2838 2839 if (ExprKind == UETT_SizeOf) { 2840 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E->IgnoreParens())) { 2841 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DeclRef->getFoundDecl())) { 2842 QualType OType = PVD->getOriginalType(); 2843 QualType Type = PVD->getType(); 2844 if (Type->isPointerType() && OType->isArrayType()) { 2845 Diag(E->getExprLoc(), diag::warn_sizeof_array_param) 2846 << Type << OType; 2847 Diag(PVD->getLocation(), diag::note_declared_at); 2848 } 2849 } 2850 } 2851 } 2852 2853 return false; 2854 } 2855 2856 /// \brief Check the constraints on operands to unary expression and type 2857 /// traits. 2858 /// 2859 /// This will complete any types necessary, and validate the various constraints 2860 /// on those operands. 2861 /// 2862 /// The UsualUnaryConversions() function is *not* called by this routine. 2863 /// C99 6.3.2.1p[2-4] all state: 2864 /// Except when it is the operand of the sizeof operator ... 2865 /// 2866 /// C++ [expr.sizeof]p4 2867 /// The lvalue-to-rvalue, array-to-pointer, and function-to-pointer 2868 /// standard conversions are not applied to the operand of sizeof. 2869 /// 2870 /// This policy is followed for all of the unary trait expressions. 2871 bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType, 2872 SourceLocation OpLoc, 2873 SourceRange ExprRange, 2874 UnaryExprOrTypeTrait ExprKind) { 2875 if (ExprType->isDependentType()) 2876 return false; 2877 2878 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 2879 // the result is the size of the referenced type." 2880 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the 2881 // result shall be the alignment of the referenced type." 2882 if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>()) 2883 ExprType = Ref->getPointeeType(); 2884 2885 if (ExprKind == UETT_VecStep) 2886 return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange); 2887 2888 // Whitelist some types as extensions 2889 if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange, 2890 ExprKind)) 2891 return false; 2892 2893 if (RequireCompleteType(OpLoc, ExprType, 2894 PDiag(diag::err_sizeof_alignof_incomplete_type) 2895 << ExprKind << ExprRange)) 2896 return true; 2897 2898 if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange, 2899 ExprKind)) 2900 return true; 2901 2902 return false; 2903 } 2904 2905 static bool CheckAlignOfExpr(Sema &S, Expr *E) { 2906 E = E->IgnoreParens(); 2907 2908 // alignof decl is always ok. 2909 if (isa<DeclRefExpr>(E)) 2910 return false; 2911 2912 // Cannot know anything else if the expression is dependent. 2913 if (E->isTypeDependent()) 2914 return false; 2915 2916 if (E->getBitField()) { 2917 S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) 2918 << 1 << E->getSourceRange(); 2919 return true; 2920 } 2921 2922 // Alignment of a field access is always okay, so long as it isn't a 2923 // bit-field. 2924 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) 2925 if (isa<FieldDecl>(ME->getMemberDecl())) 2926 return false; 2927 2928 return S.CheckUnaryExprOrTypeTraitOperand(E, UETT_AlignOf); 2929 } 2930 2931 bool Sema::CheckVecStepExpr(Expr *E) { 2932 E = E->IgnoreParens(); 2933 2934 // Cannot know anything else if the expression is dependent. 2935 if (E->isTypeDependent()) 2936 return false; 2937 2938 return CheckUnaryExprOrTypeTraitOperand(E, UETT_VecStep); 2939 } 2940 2941 /// \brief Build a sizeof or alignof expression given a type operand. 2942 ExprResult 2943 Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo, 2944 SourceLocation OpLoc, 2945 UnaryExprOrTypeTrait ExprKind, 2946 SourceRange R) { 2947 if (!TInfo) 2948 return ExprError(); 2949 2950 QualType T = TInfo->getType(); 2951 2952 if (!T->isDependentType() && 2953 CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind)) 2954 return ExprError(); 2955 2956 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 2957 return Owned(new (Context) UnaryExprOrTypeTraitExpr(ExprKind, TInfo, 2958 Context.getSizeType(), 2959 OpLoc, R.getEnd())); 2960 } 2961 2962 /// \brief Build a sizeof or alignof expression given an expression 2963 /// operand. 2964 ExprResult 2965 Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc, 2966 UnaryExprOrTypeTrait ExprKind) { 2967 ExprResult PE = CheckPlaceholderExpr(E); 2968 if (PE.isInvalid()) 2969 return ExprError(); 2970 2971 E = PE.get(); 2972 2973 // Verify that the operand is valid. 2974 bool isInvalid = false; 2975 if (E->isTypeDependent()) { 2976 // Delay type-checking for type-dependent expressions. 2977 } else if (ExprKind == UETT_AlignOf) { 2978 isInvalid = CheckAlignOfExpr(*this, E); 2979 } else if (ExprKind == UETT_VecStep) { 2980 isInvalid = CheckVecStepExpr(E); 2981 } else if (E->getBitField()) { // C99 6.5.3.4p1. 2982 Diag(E->getExprLoc(), diag::err_sizeof_alignof_bitfield) << 0; 2983 isInvalid = true; 2984 } else { 2985 isInvalid = CheckUnaryExprOrTypeTraitOperand(E, UETT_SizeOf); 2986 } 2987 2988 if (isInvalid) 2989 return ExprError(); 2990 2991 if (ExprKind == UETT_SizeOf && E->getType()->isVariableArrayType()) { 2992 PE = TranformToPotentiallyEvaluated(E); 2993 if (PE.isInvalid()) return ExprError(); 2994 E = PE.take(); 2995 } 2996 2997 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 2998 return Owned(new (Context) UnaryExprOrTypeTraitExpr( 2999 ExprKind, E, Context.getSizeType(), OpLoc, 3000 E->getSourceRange().getEnd())); 3001 } 3002 3003 /// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c 3004 /// expr and the same for @c alignof and @c __alignof 3005 /// Note that the ArgRange is invalid if isType is false. 3006 ExprResult 3007 Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, 3008 UnaryExprOrTypeTrait ExprKind, bool IsType, 3009 void *TyOrEx, const SourceRange &ArgRange) { 3010 // If error parsing type, ignore. 3011 if (TyOrEx == 0) return ExprError(); 3012 3013 if (IsType) { 3014 TypeSourceInfo *TInfo; 3015 (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo); 3016 return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange); 3017 } 3018 3019 Expr *ArgEx = (Expr *)TyOrEx; 3020 ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind); 3021 return move(Result); 3022 } 3023 3024 static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, 3025 bool IsReal) { 3026 if (V.get()->isTypeDependent()) 3027 return S.Context.DependentTy; 3028 3029 // _Real and _Imag are only l-values for normal l-values. 3030 if (V.get()->getObjectKind() != OK_Ordinary) { 3031 V = S.DefaultLvalueConversion(V.take()); 3032 if (V.isInvalid()) 3033 return QualType(); 3034 } 3035 3036 // These operators return the element type of a complex type. 3037 if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>()) 3038 return CT->getElementType(); 3039 3040 // Otherwise they pass through real integer and floating point types here. 3041 if (V.get()->getType()->isArithmeticType()) 3042 return V.get()->getType(); 3043 3044 // Test for placeholders. 3045 ExprResult PR = S.CheckPlaceholderExpr(V.get()); 3046 if (PR.isInvalid()) return QualType(); 3047 if (PR.get() != V.get()) { 3048 V = move(PR); 3049 return CheckRealImagOperand(S, V, Loc, IsReal); 3050 } 3051 3052 // Reject anything else. 3053 S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType() 3054 << (IsReal ? "__real" : "__imag"); 3055 return QualType(); 3056 } 3057 3058 3059 3060 ExprResult 3061 Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, 3062 tok::TokenKind Kind, Expr *Input) { 3063 UnaryOperatorKind Opc; 3064 switch (Kind) { 3065 default: llvm_unreachable("Unknown unary op!"); 3066 case tok::plusplus: Opc = UO_PostInc; break; 3067 case tok::minusminus: Opc = UO_PostDec; break; 3068 } 3069 3070 // Since this might is a postfix expression, get rid of ParenListExprs. 3071 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input); 3072 if (Result.isInvalid()) return ExprError(); 3073 Input = Result.take(); 3074 3075 return BuildUnaryOp(S, OpLoc, Opc, Input); 3076 } 3077 3078 ExprResult 3079 Sema::ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc, 3080 Expr *Idx, SourceLocation RLoc) { 3081 // Since this might be a postfix expression, get rid of ParenListExprs. 3082 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); 3083 if (Result.isInvalid()) return ExprError(); 3084 Base = Result.take(); 3085 3086 Expr *LHSExp = Base, *RHSExp = Idx; 3087 3088 if (getLangOpts().CPlusPlus && 3089 (LHSExp->isTypeDependent() || RHSExp->isTypeDependent())) { 3090 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 3091 Context.DependentTy, 3092 VK_LValue, OK_Ordinary, 3093 RLoc)); 3094 } 3095 3096 if (getLangOpts().CPlusPlus && 3097 (LHSExp->getType()->isRecordType() || 3098 LHSExp->getType()->isEnumeralType() || 3099 RHSExp->getType()->isRecordType() || 3100 RHSExp->getType()->isEnumeralType()) && 3101 !LHSExp->getType()->isObjCObjectPointerType()) { 3102 return CreateOverloadedArraySubscriptExpr(LLoc, RLoc, Base, Idx); 3103 } 3104 3105 return CreateBuiltinArraySubscriptExpr(Base, LLoc, Idx, RLoc); 3106 } 3107 3108 3109 ExprResult 3110 Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, 3111 Expr *Idx, SourceLocation RLoc) { 3112 Expr *LHSExp = Base; 3113 Expr *RHSExp = Idx; 3114 3115 // Perform default conversions. 3116 if (!LHSExp->getType()->getAs<VectorType>()) { 3117 ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp); 3118 if (Result.isInvalid()) 3119 return ExprError(); 3120 LHSExp = Result.take(); 3121 } 3122 ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp); 3123 if (Result.isInvalid()) 3124 return ExprError(); 3125 RHSExp = Result.take(); 3126 3127 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType(); 3128 ExprValueKind VK = VK_LValue; 3129 ExprObjectKind OK = OK_Ordinary; 3130 3131 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent 3132 // to the expression *((e1)+(e2)). This means the array "Base" may actually be 3133 // in the subscript position. As a result, we need to derive the array base 3134 // and index from the expression types. 3135 Expr *BaseExpr, *IndexExpr; 3136 QualType ResultType; 3137 if (LHSTy->isDependentType() || RHSTy->isDependentType()) { 3138 BaseExpr = LHSExp; 3139 IndexExpr = RHSExp; 3140 ResultType = Context.DependentTy; 3141 } else if (const PointerType *PTy = LHSTy->getAs<PointerType>()) { 3142 BaseExpr = LHSExp; 3143 IndexExpr = RHSExp; 3144 ResultType = PTy->getPointeeType(); 3145 } else if (const ObjCObjectPointerType *PTy = 3146 LHSTy->getAs<ObjCObjectPointerType>()) { 3147 BaseExpr = LHSExp; 3148 IndexExpr = RHSExp; 3149 Result = BuildObjCSubscriptExpression(RLoc, BaseExpr, IndexExpr, 0, 0); 3150 if (!Result.isInvalid()) 3151 return Owned(Result.take()); 3152 ResultType = PTy->getPointeeType(); 3153 } else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) { 3154 // Handle the uncommon case of "123[Ptr]". 3155 BaseExpr = RHSExp; 3156 IndexExpr = LHSExp; 3157 ResultType = PTy->getPointeeType(); 3158 } else if (const ObjCObjectPointerType *PTy = 3159 RHSTy->getAs<ObjCObjectPointerType>()) { 3160 // Handle the uncommon case of "123[Ptr]". 3161 BaseExpr = RHSExp; 3162 IndexExpr = LHSExp; 3163 ResultType = PTy->getPointeeType(); 3164 } else if (const VectorType *VTy = LHSTy->getAs<VectorType>()) { 3165 BaseExpr = LHSExp; // vectors: V[123] 3166 IndexExpr = RHSExp; 3167 VK = LHSExp->getValueKind(); 3168 if (VK != VK_RValue) 3169 OK = OK_VectorComponent; 3170 3171 // FIXME: need to deal with const... 3172 ResultType = VTy->getElementType(); 3173 } else if (LHSTy->isArrayType()) { 3174 // If we see an array that wasn't promoted by 3175 // DefaultFunctionArrayLvalueConversion, it must be an array that 3176 // wasn't promoted because of the C90 rule that doesn't 3177 // allow promoting non-lvalue arrays. Warn, then 3178 // force the promotion here. 3179 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3180 LHSExp->getSourceRange(); 3181 LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy), 3182 CK_ArrayToPointerDecay).take(); 3183 LHSTy = LHSExp->getType(); 3184 3185 BaseExpr = LHSExp; 3186 IndexExpr = RHSExp; 3187 ResultType = LHSTy->getAs<PointerType>()->getPointeeType(); 3188 } else if (RHSTy->isArrayType()) { 3189 // Same as previous, except for 123[f().a] case 3190 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 3191 RHSExp->getSourceRange(); 3192 RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy), 3193 CK_ArrayToPointerDecay).take(); 3194 RHSTy = RHSExp->getType(); 3195 3196 BaseExpr = RHSExp; 3197 IndexExpr = LHSExp; 3198 ResultType = RHSTy->getAs<PointerType>()->getPointeeType(); 3199 } else { 3200 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value) 3201 << LHSExp->getSourceRange() << RHSExp->getSourceRange()); 3202 } 3203 // C99 6.5.2.1p1 3204 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent()) 3205 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer) 3206 << IndexExpr->getSourceRange()); 3207 3208 if ((IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_S) || 3209 IndexExpr->getType()->isSpecificBuiltinType(BuiltinType::Char_U)) 3210 && !IndexExpr->isTypeDependent()) 3211 Diag(LLoc, diag::warn_subscript_is_char) << IndexExpr->getSourceRange(); 3212 3213 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly, 3214 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object 3215 // type. Note that Functions are not objects, and that (in C99 parlance) 3216 // incomplete types are not object types. 3217 if (ResultType->isFunctionType()) { 3218 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type) 3219 << ResultType << BaseExpr->getSourceRange(); 3220 return ExprError(); 3221 } 3222 3223 if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) { 3224 // GNU extension: subscripting on pointer to void 3225 Diag(LLoc, diag::ext_gnu_subscript_void_type) 3226 << BaseExpr->getSourceRange(); 3227 3228 // C forbids expressions of unqualified void type from being l-values. 3229 // See IsCForbiddenLValueType. 3230 if (!ResultType.hasQualifiers()) VK = VK_RValue; 3231 } else if (!ResultType->isDependentType() && 3232 RequireCompleteType(LLoc, ResultType, 3233 PDiag(diag::err_subscript_incomplete_type) 3234 << BaseExpr->getSourceRange())) 3235 return ExprError(); 3236 3237 // Diagnose bad cases where we step over interface counts. 3238 if (ResultType->isObjCObjectType() && LangOpts.ObjCNonFragileABI) { 3239 Diag(LLoc, diag::err_subscript_nonfragile_interface) 3240 << ResultType << BaseExpr->getSourceRange(); 3241 return ExprError(); 3242 } 3243 3244 assert(VK == VK_RValue || LangOpts.CPlusPlus || 3245 !ResultType.isCForbiddenLValueType()); 3246 3247 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 3248 ResultType, VK, OK, RLoc)); 3249 } 3250 3251 ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc, 3252 FunctionDecl *FD, 3253 ParmVarDecl *Param) { 3254 if (Param->hasUnparsedDefaultArg()) { 3255 Diag(CallLoc, 3256 diag::err_use_of_default_argument_to_function_declared_later) << 3257 FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName(); 3258 Diag(UnparsedDefaultArgLocs[Param], 3259 diag::note_default_argument_declared_here); 3260 return ExprError(); 3261 } 3262 3263 if (Param->hasUninstantiatedDefaultArg()) { 3264 Expr *UninstExpr = Param->getUninstantiatedDefaultArg(); 3265 3266 // Instantiate the expression. 3267 MultiLevelTemplateArgumentList ArgList 3268 = getTemplateInstantiationArgs(FD, 0, /*RelativeToPrimary=*/true); 3269 3270 std::pair<const TemplateArgument *, unsigned> Innermost 3271 = ArgList.getInnermost(); 3272 InstantiatingTemplate Inst(*this, CallLoc, Param, Innermost.first, 3273 Innermost.second); 3274 3275 ExprResult Result; 3276 { 3277 // C++ [dcl.fct.default]p5: 3278 // The names in the [default argument] expression are bound, and 3279 // the semantic constraints are checked, at the point where the 3280 // default argument expression appears. 3281 ContextRAII SavedContext(*this, FD); 3282 LocalInstantiationScope Local(*this); 3283 Result = SubstExpr(UninstExpr, ArgList); 3284 } 3285 if (Result.isInvalid()) 3286 return ExprError(); 3287 3288 // Check the expression as an initializer for the parameter. 3289 InitializedEntity Entity 3290 = InitializedEntity::InitializeParameter(Context, Param); 3291 InitializationKind Kind 3292 = InitializationKind::CreateCopy(Param->getLocation(), 3293 /*FIXME:EqualLoc*/UninstExpr->getLocStart()); 3294 Expr *ResultE = Result.takeAs<Expr>(); 3295 3296 InitializationSequence InitSeq(*this, Entity, Kind, &ResultE, 1); 3297 Result = InitSeq.Perform(*this, Entity, Kind, 3298 MultiExprArg(*this, &ResultE, 1)); 3299 if (Result.isInvalid()) 3300 return ExprError(); 3301 3302 // Build the default argument expression. 3303 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param, 3304 Result.takeAs<Expr>())); 3305 } 3306 3307 // If the default expression creates temporaries, we need to 3308 // push them to the current stack of expression temporaries so they'll 3309 // be properly destroyed. 3310 // FIXME: We should really be rebuilding the default argument with new 3311 // bound temporaries; see the comment in PR5810. 3312 // We don't need to do that with block decls, though, because 3313 // blocks in default argument expression can never capture anything. 3314 if (isa<ExprWithCleanups>(Param->getInit())) { 3315 // Set the "needs cleanups" bit regardless of whether there are 3316 // any explicit objects. 3317 ExprNeedsCleanups = true; 3318 3319 // Append all the objects to the cleanup list. Right now, this 3320 // should always be a no-op, because blocks in default argument 3321 // expressions should never be able to capture anything. 3322 assert(!cast<ExprWithCleanups>(Param->getInit())->getNumObjects() && 3323 "default argument expression has capturing blocks?"); 3324 } 3325 3326 // We already type-checked the argument, so we know it works. 3327 // Just mark all of the declarations in this potentially-evaluated expression 3328 // as being "referenced". 3329 MarkDeclarationsReferencedInExpr(Param->getDefaultArg(), 3330 /*SkipLocalVariables=*/true); 3331 return Owned(CXXDefaultArgExpr::Create(Context, CallLoc, Param)); 3332 } 3333 3334 /// ConvertArgumentsForCall - Converts the arguments specified in 3335 /// Args/NumArgs to the parameter types of the function FDecl with 3336 /// function prototype Proto. Call is the call expression itself, and 3337 /// Fn is the function expression. For a C++ member function, this 3338 /// routine does not attempt to convert the object argument. Returns 3339 /// true if the call is ill-formed. 3340 bool 3341 Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, 3342 FunctionDecl *FDecl, 3343 const FunctionProtoType *Proto, 3344 Expr **Args, unsigned NumArgs, 3345 SourceLocation RParenLoc, 3346 bool IsExecConfig) { 3347 // Bail out early if calling a builtin with custom typechecking. 3348 // We don't need to do this in the 3349 if (FDecl) 3350 if (unsigned ID = FDecl->getBuiltinID()) 3351 if (Context.BuiltinInfo.hasCustomTypechecking(ID)) 3352 return false; 3353 3354 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by 3355 // assignment, to the types of the corresponding parameter, ... 3356 unsigned NumArgsInProto = Proto->getNumArgs(); 3357 bool Invalid = false; 3358 unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumArgsInProto; 3359 unsigned FnKind = Fn->getType()->isBlockPointerType() 3360 ? 1 /* block */ 3361 : (IsExecConfig ? 3 /* kernel function (exec config) */ 3362 : 0 /* function */); 3363 3364 // If too few arguments are available (and we don't have default 3365 // arguments for the remaining parameters), don't make the call. 3366 if (NumArgs < NumArgsInProto) { 3367 if (NumArgs < MinArgs) { 3368 Diag(RParenLoc, MinArgs == NumArgsInProto 3369 ? diag::err_typecheck_call_too_few_args 3370 : diag::err_typecheck_call_too_few_args_at_least) 3371 << FnKind 3372 << MinArgs << NumArgs << Fn->getSourceRange(); 3373 3374 // Emit the location of the prototype. 3375 if (FDecl && !FDecl->getBuiltinID() && !IsExecConfig) 3376 Diag(FDecl->getLocStart(), diag::note_callee_decl) 3377 << FDecl; 3378 3379 return true; 3380 } 3381 Call->setNumArgs(Context, NumArgsInProto); 3382 } 3383 3384 // If too many are passed and not variadic, error on the extras and drop 3385 // them. 3386 if (NumArgs > NumArgsInProto) { 3387 if (!Proto->isVariadic()) { 3388 Diag(Args[NumArgsInProto]->getLocStart(), 3389 MinArgs == NumArgsInProto 3390 ? diag::err_typecheck_call_too_many_args 3391 : diag::err_typecheck_call_too_many_args_at_most) 3392 << FnKind 3393 << NumArgsInProto << NumArgs << Fn->getSourceRange() 3394 << SourceRange(Args[NumArgsInProto]->getLocStart(), 3395 Args[NumArgs-1]->getLocEnd()); 3396 3397 // Emit the location of the prototype. 3398 if (FDecl && !FDecl->getBuiltinID() && !IsExecConfig) 3399 Diag(FDecl->getLocStart(), diag::note_callee_decl) 3400 << FDecl; 3401 3402 // This deletes the extra arguments. 3403 Call->setNumArgs(Context, NumArgsInProto); 3404 return true; 3405 } 3406 } 3407 SmallVector<Expr *, 8> AllArgs; 3408 VariadicCallType CallType = 3409 Proto->isVariadic() ? VariadicFunction : VariadicDoesNotApply; 3410 if (Fn->getType()->isBlockPointerType()) 3411 CallType = VariadicBlock; // Block 3412 else if (isa<MemberExpr>(Fn)) 3413 CallType = VariadicMethod; 3414 Invalid = GatherArgumentsForCall(Call->getLocStart(), FDecl, 3415 Proto, 0, Args, NumArgs, AllArgs, CallType); 3416 if (Invalid) 3417 return true; 3418 unsigned TotalNumArgs = AllArgs.size(); 3419 for (unsigned i = 0; i < TotalNumArgs; ++i) 3420 Call->setArg(i, AllArgs[i]); 3421 3422 return false; 3423 } 3424 3425 bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, 3426 FunctionDecl *FDecl, 3427 const FunctionProtoType *Proto, 3428 unsigned FirstProtoArg, 3429 Expr **Args, unsigned NumArgs, 3430 SmallVector<Expr *, 8> &AllArgs, 3431 VariadicCallType CallType, 3432 bool AllowExplicit) { 3433 unsigned NumArgsInProto = Proto->getNumArgs(); 3434 unsigned NumArgsToCheck = NumArgs; 3435 bool Invalid = false; 3436 if (NumArgs != NumArgsInProto) 3437 // Use default arguments for missing arguments 3438 NumArgsToCheck = NumArgsInProto; 3439 unsigned ArgIx = 0; 3440 // Continue to check argument types (even if we have too few/many args). 3441 for (unsigned i = FirstProtoArg; i != NumArgsToCheck; i++) { 3442 QualType ProtoArgType = Proto->getArgType(i); 3443 3444 Expr *Arg; 3445 ParmVarDecl *Param; 3446 if (ArgIx < NumArgs) { 3447 Arg = Args[ArgIx++]; 3448 3449 if (RequireCompleteType(Arg->getLocStart(), 3450 ProtoArgType, 3451 PDiag(diag::err_call_incomplete_argument) 3452 << Arg->getSourceRange())) 3453 return true; 3454 3455 // Pass the argument 3456 Param = 0; 3457 if (FDecl && i < FDecl->getNumParams()) 3458 Param = FDecl->getParamDecl(i); 3459 3460 // Strip the unbridged-cast placeholder expression off, if applicable. 3461 if (Arg->getType() == Context.ARCUnbridgedCastTy && 3462 FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() && 3463 (!Param || !Param->hasAttr<CFConsumedAttr>())) 3464 Arg = stripARCUnbridgedCast(Arg); 3465 3466 InitializedEntity Entity = 3467 Param? InitializedEntity::InitializeParameter(Context, Param) 3468 : InitializedEntity::InitializeParameter(Context, ProtoArgType, 3469 Proto->isArgConsumed(i)); 3470 ExprResult ArgE = PerformCopyInitialization(Entity, 3471 SourceLocation(), 3472 Owned(Arg), 3473 /*TopLevelOfInitList=*/false, 3474 AllowExplicit); 3475 if (ArgE.isInvalid()) 3476 return true; 3477 3478 Arg = ArgE.takeAs<Expr>(); 3479 } else { 3480 Param = FDecl->getParamDecl(i); 3481 3482 ExprResult ArgExpr = 3483 BuildCXXDefaultArgExpr(CallLoc, FDecl, Param); 3484 if (ArgExpr.isInvalid()) 3485 return true; 3486 3487 Arg = ArgExpr.takeAs<Expr>(); 3488 } 3489 3490 // Check for array bounds violations for each argument to the call. This 3491 // check only triggers warnings when the argument isn't a more complex Expr 3492 // with its own checking, such as a BinaryOperator. 3493 CheckArrayAccess(Arg); 3494 3495 // Check for violations of C99 static array rules (C99 6.7.5.3p7). 3496 CheckStaticArrayArgument(CallLoc, Param, Arg); 3497 3498 AllArgs.push_back(Arg); 3499 } 3500 3501 // If this is a variadic call, handle args passed through "...". 3502 if (CallType != VariadicDoesNotApply) { 3503 3504 // Assume that extern "C" functions with variadic arguments that 3505 // return __unknown_anytype aren't *really* variadic. 3506 if (Proto->getResultType() == Context.UnknownAnyTy && 3507 FDecl && FDecl->isExternC()) { 3508 for (unsigned i = ArgIx; i != NumArgs; ++i) { 3509 ExprResult arg; 3510 if (isa<ExplicitCastExpr>(Args[i]->IgnoreParens())) 3511 arg = DefaultFunctionArrayLvalueConversion(Args[i]); 3512 else 3513 arg = DefaultVariadicArgumentPromotion(Args[i], CallType, FDecl); 3514 Invalid |= arg.isInvalid(); 3515 AllArgs.push_back(arg.take()); 3516 } 3517 3518 // Otherwise do argument promotion, (C99 6.5.2.2p7). 3519 } else { 3520 for (unsigned i = ArgIx; i != NumArgs; ++i) { 3521 ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], CallType, 3522 FDecl); 3523 Invalid |= Arg.isInvalid(); 3524 AllArgs.push_back(Arg.take()); 3525 } 3526 } 3527 3528 // Check for array bounds violations. 3529 for (unsigned i = ArgIx; i != NumArgs; ++i) 3530 CheckArrayAccess(Args[i]); 3531 } 3532 return Invalid; 3533 } 3534 3535 static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD) { 3536 TypeLoc TL = PVD->getTypeSourceInfo()->getTypeLoc(); 3537 if (ArrayTypeLoc *ATL = dyn_cast<ArrayTypeLoc>(&TL)) 3538 S.Diag(PVD->getLocation(), diag::note_callee_static_array) 3539 << ATL->getLocalSourceRange(); 3540 } 3541 3542 /// CheckStaticArrayArgument - If the given argument corresponds to a static 3543 /// array parameter, check that it is non-null, and that if it is formed by 3544 /// array-to-pointer decay, the underlying array is sufficiently large. 3545 /// 3546 /// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the 3547 /// array type derivation, then for each call to the function, the value of the 3548 /// corresponding actual argument shall provide access to the first element of 3549 /// an array with at least as many elements as specified by the size expression. 3550 void 3551 Sema::CheckStaticArrayArgument(SourceLocation CallLoc, 3552 ParmVarDecl *Param, 3553 const Expr *ArgExpr) { 3554 // Static array parameters are not supported in C++. 3555 if (!Param || getLangOpts().CPlusPlus) 3556 return; 3557 3558 QualType OrigTy = Param->getOriginalType(); 3559 3560 const ArrayType *AT = Context.getAsArrayType(OrigTy); 3561 if (!AT || AT->getSizeModifier() != ArrayType::Static) 3562 return; 3563 3564 if (ArgExpr->isNullPointerConstant(Context, 3565 Expr::NPC_NeverValueDependent)) { 3566 Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange(); 3567 DiagnoseCalleeStaticArrayParam(*this, Param); 3568 return; 3569 } 3570 3571 const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT); 3572 if (!CAT) 3573 return; 3574 3575 const ConstantArrayType *ArgCAT = 3576 Context.getAsConstantArrayType(ArgExpr->IgnoreParenImpCasts()->getType()); 3577 if (!ArgCAT) 3578 return; 3579 3580 if (ArgCAT->getSize().ult(CAT->getSize())) { 3581 Diag(CallLoc, diag::warn_static_array_too_small) 3582 << ArgExpr->getSourceRange() 3583 << (unsigned) ArgCAT->getSize().getZExtValue() 3584 << (unsigned) CAT->getSize().getZExtValue(); 3585 DiagnoseCalleeStaticArrayParam(*this, Param); 3586 } 3587 } 3588 3589 /// Given a function expression of unknown-any type, try to rebuild it 3590 /// to have a function type. 3591 static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn); 3592 3593 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments. 3594 /// This provides the location of the left/right parens and a list of comma 3595 /// locations. 3596 ExprResult 3597 Sema::ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, 3598 MultiExprArg ArgExprs, SourceLocation RParenLoc, 3599 Expr *ExecConfig, bool IsExecConfig) { 3600 unsigned NumArgs = ArgExprs.size(); 3601 3602 // Since this might be a postfix expression, get rid of ParenListExprs. 3603 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn); 3604 if (Result.isInvalid()) return ExprError(); 3605 Fn = Result.take(); 3606 3607 Expr **Args = ArgExprs.release(); 3608 3609 if (getLangOpts().CPlusPlus) { 3610 // If this is a pseudo-destructor expression, build the call immediately. 3611 if (isa<CXXPseudoDestructorExpr>(Fn)) { 3612 if (NumArgs > 0) { 3613 // Pseudo-destructor calls should not have any arguments. 3614 Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args) 3615 << FixItHint::CreateRemoval( 3616 SourceRange(Args[0]->getLocStart(), 3617 Args[NumArgs-1]->getLocEnd())); 3618 } 3619 3620 return Owned(new (Context) CallExpr(Context, Fn, 0, 0, Context.VoidTy, 3621 VK_RValue, RParenLoc)); 3622 } 3623 3624 // Determine whether this is a dependent call inside a C++ template, 3625 // in which case we won't do any semantic analysis now. 3626 // FIXME: Will need to cache the results of name lookup (including ADL) in 3627 // Fn. 3628 bool Dependent = false; 3629 if (Fn->isTypeDependent()) 3630 Dependent = true; 3631 else if (Expr::hasAnyTypeDependentArguments( 3632 llvm::makeArrayRef(Args, NumArgs))) 3633 Dependent = true; 3634 3635 if (Dependent) { 3636 if (ExecConfig) { 3637 return Owned(new (Context) CUDAKernelCallExpr( 3638 Context, Fn, cast<CallExpr>(ExecConfig), Args, NumArgs, 3639 Context.DependentTy, VK_RValue, RParenLoc)); 3640 } else { 3641 return Owned(new (Context) CallExpr(Context, Fn, Args, NumArgs, 3642 Context.DependentTy, VK_RValue, 3643 RParenLoc)); 3644 } 3645 } 3646 3647 // Determine whether this is a call to an object (C++ [over.call.object]). 3648 if (Fn->getType()->isRecordType()) 3649 return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc, Args, NumArgs, 3650 RParenLoc)); 3651 3652 if (Fn->getType() == Context.UnknownAnyTy) { 3653 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 3654 if (result.isInvalid()) return ExprError(); 3655 Fn = result.take(); 3656 } 3657 3658 if (Fn->getType() == Context.BoundMemberTy) { 3659 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs, 3660 RParenLoc); 3661 } 3662 } 3663 3664 // Check for overloaded calls. This can happen even in C due to extensions. 3665 if (Fn->getType() == Context.OverloadTy) { 3666 OverloadExpr::FindResult find = OverloadExpr::find(Fn); 3667 3668 // We aren't supposed to apply this logic for if there's an '&' involved. 3669 if (!find.HasFormOfMemberPointer) { 3670 OverloadExpr *ovl = find.Expression; 3671 if (isa<UnresolvedLookupExpr>(ovl)) { 3672 UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(ovl); 3673 return BuildOverloadedCallExpr(S, Fn, ULE, LParenLoc, Args, NumArgs, 3674 RParenLoc, ExecConfig); 3675 } else { 3676 return BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs, 3677 RParenLoc); 3678 } 3679 } 3680 } 3681 3682 // If we're directly calling a function, get the appropriate declaration. 3683 if (Fn->getType() == Context.UnknownAnyTy) { 3684 ExprResult result = rebuildUnknownAnyFunction(*this, Fn); 3685 if (result.isInvalid()) return ExprError(); 3686 Fn = result.take(); 3687 } 3688 3689 Expr *NakedFn = Fn->IgnoreParens(); 3690 3691 NamedDecl *NDecl = 0; 3692 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(NakedFn)) 3693 if (UnOp->getOpcode() == UO_AddrOf) 3694 NakedFn = UnOp->getSubExpr()->IgnoreParens(); 3695 3696 if (isa<DeclRefExpr>(NakedFn)) 3697 NDecl = cast<DeclRefExpr>(NakedFn)->getDecl(); 3698 else if (isa<MemberExpr>(NakedFn)) 3699 NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl(); 3700 3701 return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, Args, NumArgs, RParenLoc, 3702 ExecConfig, IsExecConfig); 3703 } 3704 3705 ExprResult 3706 Sema::ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc, 3707 MultiExprArg ExecConfig, SourceLocation GGGLoc) { 3708 FunctionDecl *ConfigDecl = Context.getcudaConfigureCallDecl(); 3709 if (!ConfigDecl) 3710 return ExprError(Diag(LLLLoc, diag::err_undeclared_var_use) 3711 << "cudaConfigureCall"); 3712 QualType ConfigQTy = ConfigDecl->getType(); 3713 3714 DeclRefExpr *ConfigDR = new (Context) DeclRefExpr( 3715 ConfigDecl, false, ConfigQTy, VK_LValue, LLLLoc); 3716 MarkFunctionReferenced(LLLLoc, ConfigDecl); 3717 3718 return ActOnCallExpr(S, ConfigDR, LLLLoc, ExecConfig, GGGLoc, 0, 3719 /*IsExecConfig=*/true); 3720 } 3721 3722 /// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments. 3723 /// 3724 /// __builtin_astype( value, dst type ) 3725 /// 3726 ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy, 3727 SourceLocation BuiltinLoc, 3728 SourceLocation RParenLoc) { 3729 ExprValueKind VK = VK_RValue; 3730 ExprObjectKind OK = OK_Ordinary; 3731 QualType DstTy = GetTypeFromParser(ParsedDestTy); 3732 QualType SrcTy = E->getType(); 3733 if (Context.getTypeSize(DstTy) != Context.getTypeSize(SrcTy)) 3734 return ExprError(Diag(BuiltinLoc, 3735 diag::err_invalid_astype_of_different_size) 3736 << DstTy 3737 << SrcTy 3738 << E->getSourceRange()); 3739 return Owned(new (Context) AsTypeExpr(E, DstTy, VK, OK, BuiltinLoc, 3740 RParenLoc)); 3741 } 3742 3743 /// BuildResolvedCallExpr - Build a call to a resolved expression, 3744 /// i.e. an expression not of \p OverloadTy. The expression should 3745 /// unary-convert to an expression of function-pointer or 3746 /// block-pointer type. 3747 /// 3748 /// \param NDecl the declaration being called, if available 3749 ExprResult 3750 Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, 3751 SourceLocation LParenLoc, 3752 Expr **Args, unsigned NumArgs, 3753 SourceLocation RParenLoc, 3754 Expr *Config, bool IsExecConfig) { 3755 FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl); 3756 3757 // Promote the function operand. 3758 ExprResult Result = UsualUnaryConversions(Fn); 3759 if (Result.isInvalid()) 3760 return ExprError(); 3761 Fn = Result.take(); 3762 3763 // Make the call expr early, before semantic checks. This guarantees cleanup 3764 // of arguments and function on error. 3765 CallExpr *TheCall; 3766 if (Config) { 3767 TheCall = new (Context) CUDAKernelCallExpr(Context, Fn, 3768 cast<CallExpr>(Config), 3769 Args, NumArgs, 3770 Context.BoolTy, 3771 VK_RValue, 3772 RParenLoc); 3773 } else { 3774 TheCall = new (Context) CallExpr(Context, Fn, 3775 Args, NumArgs, 3776 Context.BoolTy, 3777 VK_RValue, 3778 RParenLoc); 3779 } 3780 3781 unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0); 3782 3783 // Bail out early if calling a builtin with custom typechecking. 3784 if (BuiltinID && Context.BuiltinInfo.hasCustomTypechecking(BuiltinID)) 3785 return CheckBuiltinFunctionCall(BuiltinID, TheCall); 3786 3787 retry: 3788 const FunctionType *FuncT; 3789 if (const PointerType *PT = Fn->getType()->getAs<PointerType>()) { 3790 // C99 6.5.2.2p1 - "The expression that denotes the called function shall 3791 // have type pointer to function". 3792 FuncT = PT->getPointeeType()->getAs<FunctionType>(); 3793 if (FuncT == 0) 3794 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 3795 << Fn->getType() << Fn->getSourceRange()); 3796 } else if (const BlockPointerType *BPT = 3797 Fn->getType()->getAs<BlockPointerType>()) { 3798 FuncT = BPT->getPointeeType()->castAs<FunctionType>(); 3799 } else { 3800 // Handle calls to expressions of unknown-any type. 3801 if (Fn->getType() == Context.UnknownAnyTy) { 3802 ExprResult rewrite = rebuildUnknownAnyFunction(*this, Fn); 3803 if (rewrite.isInvalid()) return ExprError(); 3804 Fn = rewrite.take(); 3805 TheCall->setCallee(Fn); 3806 goto retry; 3807 } 3808 3809 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 3810 << Fn->getType() << Fn->getSourceRange()); 3811 } 3812 3813 if (getLangOpts().CUDA) { 3814 if (Config) { 3815 // CUDA: Kernel calls must be to global functions 3816 if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>()) 3817 return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function) 3818 << FDecl->getName() << Fn->getSourceRange()); 3819 3820 // CUDA: Kernel function must have 'void' return type 3821 if (!FuncT->getResultType()->isVoidType()) 3822 return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return) 3823 << Fn->getType() << Fn->getSourceRange()); 3824 } else { 3825 // CUDA: Calls to global functions must be configured 3826 if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>()) 3827 return ExprError(Diag(LParenLoc, diag::err_global_call_not_config) 3828 << FDecl->getName() << Fn->getSourceRange()); 3829 } 3830 } 3831 3832 // Check for a valid return type 3833 if (CheckCallReturnType(FuncT->getResultType(), 3834 Fn->getLocStart(), TheCall, 3835 FDecl)) 3836 return ExprError(); 3837 3838 // We know the result type of the call, set it. 3839 TheCall->setType(FuncT->getCallResultType(Context)); 3840 TheCall->setValueKind(Expr::getValueKindForType(FuncT->getResultType())); 3841 3842 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) { 3843 if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, NumArgs, 3844 RParenLoc, IsExecConfig)) 3845 return ExprError(); 3846 } else { 3847 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!"); 3848 3849 if (FDecl) { 3850 // Check if we have too few/too many template arguments, based 3851 // on our knowledge of the function definition. 3852 const FunctionDecl *Def = 0; 3853 if (FDecl->hasBody(Def) && NumArgs != Def->param_size()) { 3854 const FunctionProtoType *Proto 3855 = Def->getType()->getAs<FunctionProtoType>(); 3856 if (!Proto || !(Proto->isVariadic() && NumArgs >= Def->param_size())) 3857 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments) 3858 << (NumArgs > Def->param_size()) << FDecl << Fn->getSourceRange(); 3859 } 3860 3861 // If the function we're calling isn't a function prototype, but we have 3862 // a function prototype from a prior declaratiom, use that prototype. 3863 if (!FDecl->hasPrototype()) 3864 Proto = FDecl->getType()->getAs<FunctionProtoType>(); 3865 } 3866 3867 // Promote the arguments (C99 6.5.2.2p6). 3868 for (unsigned i = 0; i != NumArgs; i++) { 3869 Expr *Arg = Args[i]; 3870 3871 if (Proto && i < Proto->getNumArgs()) { 3872 InitializedEntity Entity 3873 = InitializedEntity::InitializeParameter(Context, 3874 Proto->getArgType(i), 3875 Proto->isArgConsumed(i)); 3876 ExprResult ArgE = PerformCopyInitialization(Entity, 3877 SourceLocation(), 3878 Owned(Arg)); 3879 if (ArgE.isInvalid()) 3880 return true; 3881 3882 Arg = ArgE.takeAs<Expr>(); 3883 3884 } else { 3885 ExprResult ArgE = DefaultArgumentPromotion(Arg); 3886 3887 if (ArgE.isInvalid()) 3888 return true; 3889 3890 Arg = ArgE.takeAs<Expr>(); 3891 } 3892 3893 if (RequireCompleteType(Arg->getLocStart(), 3894 Arg->getType(), 3895 PDiag(diag::err_call_incomplete_argument) 3896 << Arg->getSourceRange())) 3897 return ExprError(); 3898 3899 TheCall->setArg(i, Arg); 3900 } 3901 } 3902 3903 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl)) 3904 if (!Method->isStatic()) 3905 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object) 3906 << Fn->getSourceRange()); 3907 3908 // Check for sentinels 3909 if (NDecl) 3910 DiagnoseSentinelCalls(NDecl, LParenLoc, Args, NumArgs); 3911 3912 // Do special checking on direct calls to functions. 3913 if (FDecl) { 3914 if (CheckFunctionCall(FDecl, TheCall)) 3915 return ExprError(); 3916 3917 if (BuiltinID) 3918 return CheckBuiltinFunctionCall(BuiltinID, TheCall); 3919 } else if (NDecl) { 3920 if (CheckBlockCall(NDecl, TheCall)) 3921 return ExprError(); 3922 } 3923 3924 return MaybeBindToTemporary(TheCall); 3925 } 3926 3927 ExprResult 3928 Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty, 3929 SourceLocation RParenLoc, Expr *InitExpr) { 3930 assert((Ty != 0) && "ActOnCompoundLiteral(): missing type"); 3931 // FIXME: put back this assert when initializers are worked out. 3932 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression"); 3933 3934 TypeSourceInfo *TInfo; 3935 QualType literalType = GetTypeFromParser(Ty, &TInfo); 3936 if (!TInfo) 3937 TInfo = Context.getTrivialTypeSourceInfo(literalType); 3938 3939 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr); 3940 } 3941 3942 ExprResult 3943 Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, 3944 SourceLocation RParenLoc, Expr *LiteralExpr) { 3945 QualType literalType = TInfo->getType(); 3946 3947 if (literalType->isArrayType()) { 3948 if (RequireCompleteType(LParenLoc, Context.getBaseElementType(literalType), 3949 PDiag(diag::err_illegal_decl_array_incomplete_type) 3950 << SourceRange(LParenLoc, 3951 LiteralExpr->getSourceRange().getEnd()))) 3952 return ExprError(); 3953 if (literalType->isVariableArrayType()) 3954 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init) 3955 << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())); 3956 } else if (!literalType->isDependentType() && 3957 RequireCompleteType(LParenLoc, literalType, 3958 PDiag(diag::err_typecheck_decl_incomplete_type) 3959 << SourceRange(LParenLoc, 3960 LiteralExpr->getSourceRange().getEnd()))) 3961 return ExprError(); 3962 3963 InitializedEntity Entity 3964 = InitializedEntity::InitializeTemporary(literalType); 3965 InitializationKind Kind 3966 = InitializationKind::CreateCStyleCast(LParenLoc, 3967 SourceRange(LParenLoc, RParenLoc), 3968 /*InitList=*/true); 3969 InitializationSequence InitSeq(*this, Entity, Kind, &LiteralExpr, 1); 3970 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, 3971 MultiExprArg(*this, &LiteralExpr, 1), 3972 &literalType); 3973 if (Result.isInvalid()) 3974 return ExprError(); 3975 LiteralExpr = Result.get(); 3976 3977 bool isFileScope = getCurFunctionOrMethodDecl() == 0; 3978 if (isFileScope) { // 6.5.2.5p3 3979 if (CheckForConstantInitializer(LiteralExpr, literalType)) 3980 return ExprError(); 3981 } 3982 3983 // In C, compound literals are l-values for some reason. 3984 ExprValueKind VK = getLangOpts().CPlusPlus ? VK_RValue : VK_LValue; 3985 3986 return MaybeBindToTemporary( 3987 new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType, 3988 VK, LiteralExpr, isFileScope)); 3989 } 3990 3991 ExprResult 3992 Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList, 3993 SourceLocation RBraceLoc) { 3994 unsigned NumInit = InitArgList.size(); 3995 Expr **InitList = InitArgList.release(); 3996 3997 // Immediately handle non-overload placeholders. Overloads can be 3998 // resolved contextually, but everything else here can't. 3999 for (unsigned I = 0; I != NumInit; ++I) { 4000 if (InitList[I]->getType()->isNonOverloadPlaceholderType()) { 4001 ExprResult result = CheckPlaceholderExpr(InitList[I]); 4002 4003 // Ignore failures; dropping the entire initializer list because 4004 // of one failure would be terrible for indexing/etc. 4005 if (result.isInvalid()) continue; 4006 4007 InitList[I] = result.take(); 4008 } 4009 } 4010 4011 // Semantic analysis for initializers is done by ActOnDeclarator() and 4012 // CheckInitializer() - it requires knowledge of the object being intialized. 4013 4014 InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitList, 4015 NumInit, RBraceLoc); 4016 E->setType(Context.VoidTy); // FIXME: just a place holder for now. 4017 return Owned(E); 4018 } 4019 4020 /// Do an explicit extend of the given block pointer if we're in ARC. 4021 static void maybeExtendBlockObject(Sema &S, ExprResult &E) { 4022 assert(E.get()->getType()->isBlockPointerType()); 4023 assert(E.get()->isRValue()); 4024 4025 // Only do this in an r-value context. 4026 if (!S.getLangOpts().ObjCAutoRefCount) return; 4027 4028 E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), 4029 CK_ARCExtendBlockObject, E.get(), 4030 /*base path*/ 0, VK_RValue); 4031 S.ExprNeedsCleanups = true; 4032 } 4033 4034 /// Prepare a conversion of the given expression to an ObjC object 4035 /// pointer type. 4036 CastKind Sema::PrepareCastToObjCObjectPointer(ExprResult &E) { 4037 QualType type = E.get()->getType(); 4038 if (type->isObjCObjectPointerType()) { 4039 return CK_BitCast; 4040 } else if (type->isBlockPointerType()) { 4041 maybeExtendBlockObject(*this, E); 4042 return CK_BlockPointerToObjCPointerCast; 4043 } else { 4044 assert(type->isPointerType()); 4045 return CK_CPointerToObjCPointerCast; 4046 } 4047 } 4048 4049 /// Prepares for a scalar cast, performing all the necessary stages 4050 /// except the final cast and returning the kind required. 4051 CastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) { 4052 // Both Src and Dest are scalar types, i.e. arithmetic or pointer. 4053 // Also, callers should have filtered out the invalid cases with 4054 // pointers. Everything else should be possible. 4055 4056 QualType SrcTy = Src.get()->getType(); 4057 if (const AtomicType *SrcAtomicTy = SrcTy->getAs<AtomicType>()) 4058 SrcTy = SrcAtomicTy->getValueType(); 4059 if (const AtomicType *DestAtomicTy = DestTy->getAs<AtomicType>()) 4060 DestTy = DestAtomicTy->getValueType(); 4061 4062 if (Context.hasSameUnqualifiedType(SrcTy, DestTy)) 4063 return CK_NoOp; 4064 4065 switch (Type::ScalarTypeKind SrcKind = SrcTy->getScalarTypeKind()) { 4066 case Type::STK_MemberPointer: 4067 llvm_unreachable("member pointer type in C"); 4068 4069 case Type::STK_CPointer: 4070 case Type::STK_BlockPointer: 4071 case Type::STK_ObjCObjectPointer: 4072 switch (DestTy->getScalarTypeKind()) { 4073 case Type::STK_CPointer: 4074 return CK_BitCast; 4075 case Type::STK_BlockPointer: 4076 return (SrcKind == Type::STK_BlockPointer 4077 ? CK_BitCast : CK_AnyPointerToBlockPointerCast); 4078 case Type::STK_ObjCObjectPointer: 4079 if (SrcKind == Type::STK_ObjCObjectPointer) 4080 return CK_BitCast; 4081 if (SrcKind == Type::STK_CPointer) 4082 return CK_CPointerToObjCPointerCast; 4083 maybeExtendBlockObject(*this, Src); 4084 return CK_BlockPointerToObjCPointerCast; 4085 case Type::STK_Bool: 4086 return CK_PointerToBoolean; 4087 case Type::STK_Integral: 4088 return CK_PointerToIntegral; 4089 case Type::STK_Floating: 4090 case Type::STK_FloatingComplex: 4091 case Type::STK_IntegralComplex: 4092 case Type::STK_MemberPointer: 4093 llvm_unreachable("illegal cast from pointer"); 4094 } 4095 llvm_unreachable("Should have returned before this"); 4096 4097 case Type::STK_Bool: // casting from bool is like casting from an integer 4098 case Type::STK_Integral: 4099 switch (DestTy->getScalarTypeKind()) { 4100 case Type::STK_CPointer: 4101 case Type::STK_ObjCObjectPointer: 4102 case Type::STK_BlockPointer: 4103 if (Src.get()->isNullPointerConstant(Context, 4104 Expr::NPC_ValueDependentIsNull)) 4105 return CK_NullToPointer; 4106 return CK_IntegralToPointer; 4107 case Type::STK_Bool: 4108 return CK_IntegralToBoolean; 4109 case Type::STK_Integral: 4110 return CK_IntegralCast; 4111 case Type::STK_Floating: 4112 return CK_IntegralToFloating; 4113 case Type::STK_IntegralComplex: 4114 Src = ImpCastExprToType(Src.take(), 4115 DestTy->castAs<ComplexType>()->getElementType(), 4116 CK_IntegralCast); 4117 return CK_IntegralRealToComplex; 4118 case Type::STK_FloatingComplex: 4119 Src = ImpCastExprToType(Src.take(), 4120 DestTy->castAs<ComplexType>()->getElementType(), 4121 CK_IntegralToFloating); 4122 return CK_FloatingRealToComplex; 4123 case Type::STK_MemberPointer: 4124 llvm_unreachable("member pointer type in C"); 4125 } 4126 llvm_unreachable("Should have returned before this"); 4127 4128 case Type::STK_Floating: 4129 switch (DestTy->getScalarTypeKind()) { 4130 case Type::STK_Floating: 4131 return CK_FloatingCast; 4132 case Type::STK_Bool: 4133 return CK_FloatingToBoolean; 4134 case Type::STK_Integral: 4135 return CK_FloatingToIntegral; 4136 case Type::STK_FloatingComplex: 4137 Src = ImpCastExprToType(Src.take(), 4138 DestTy->castAs<ComplexType>()->getElementType(), 4139 CK_FloatingCast); 4140 return CK_FloatingRealToComplex; 4141 case Type::STK_IntegralComplex: 4142 Src = ImpCastExprToType(Src.take(), 4143 DestTy->castAs<ComplexType>()->getElementType(), 4144 CK_FloatingToIntegral); 4145 return CK_IntegralRealToComplex; 4146 case Type::STK_CPointer: 4147 case Type::STK_ObjCObjectPointer: 4148 case Type::STK_BlockPointer: 4149 llvm_unreachable("valid float->pointer cast?"); 4150 case Type::STK_MemberPointer: 4151 llvm_unreachable("member pointer type in C"); 4152 } 4153 llvm_unreachable("Should have returned before this"); 4154 4155 case Type::STK_FloatingComplex: 4156 switch (DestTy->getScalarTypeKind()) { 4157 case Type::STK_FloatingComplex: 4158 return CK_FloatingComplexCast; 4159 case Type::STK_IntegralComplex: 4160 return CK_FloatingComplexToIntegralComplex; 4161 case Type::STK_Floating: { 4162 QualType ET = SrcTy->castAs<ComplexType>()->getElementType(); 4163 if (Context.hasSameType(ET, DestTy)) 4164 return CK_FloatingComplexToReal; 4165 Src = ImpCastExprToType(Src.take(), ET, CK_FloatingComplexToReal); 4166 return CK_FloatingCast; 4167 } 4168 case Type::STK_Bool: 4169 return CK_FloatingComplexToBoolean; 4170 case Type::STK_Integral: 4171 Src = ImpCastExprToType(Src.take(), 4172 SrcTy->castAs<ComplexType>()->getElementType(), 4173 CK_FloatingComplexToReal); 4174 return CK_FloatingToIntegral; 4175 case Type::STK_CPointer: 4176 case Type::STK_ObjCObjectPointer: 4177 case Type::STK_BlockPointer: 4178 llvm_unreachable("valid complex float->pointer cast?"); 4179 case Type::STK_MemberPointer: 4180 llvm_unreachable("member pointer type in C"); 4181 } 4182 llvm_unreachable("Should have returned before this"); 4183 4184 case Type::STK_IntegralComplex: 4185 switch (DestTy->getScalarTypeKind()) { 4186 case Type::STK_FloatingComplex: 4187 return CK_IntegralComplexToFloatingComplex; 4188 case Type::STK_IntegralComplex: 4189 return CK_IntegralComplexCast; 4190 case Type::STK_Integral: { 4191 QualType ET = SrcTy->castAs<ComplexType>()->getElementType(); 4192 if (Context.hasSameType(ET, DestTy)) 4193 return CK_IntegralComplexToReal; 4194 Src = ImpCastExprToType(Src.take(), ET, CK_IntegralComplexToReal); 4195 return CK_IntegralCast; 4196 } 4197 case Type::STK_Bool: 4198 return CK_IntegralComplexToBoolean; 4199 case Type::STK_Floating: 4200 Src = ImpCastExprToType(Src.take(), 4201 SrcTy->castAs<ComplexType>()->getElementType(), 4202 CK_IntegralComplexToReal); 4203 return CK_IntegralToFloating; 4204 case Type::STK_CPointer: 4205 case Type::STK_ObjCObjectPointer: 4206 case Type::STK_BlockPointer: 4207 llvm_unreachable("valid complex int->pointer cast?"); 4208 case Type::STK_MemberPointer: 4209 llvm_unreachable("member pointer type in C"); 4210 } 4211 llvm_unreachable("Should have returned before this"); 4212 } 4213 4214 llvm_unreachable("Unhandled scalar cast"); 4215 } 4216 4217 bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty, 4218 CastKind &Kind) { 4219 assert(VectorTy->isVectorType() && "Not a vector type!"); 4220 4221 if (Ty->isVectorType() || Ty->isIntegerType()) { 4222 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty)) 4223 return Diag(R.getBegin(), 4224 Ty->isVectorType() ? 4225 diag::err_invalid_conversion_between_vectors : 4226 diag::err_invalid_conversion_between_vector_and_integer) 4227 << VectorTy << Ty << R; 4228 } else 4229 return Diag(R.getBegin(), 4230 diag::err_invalid_conversion_between_vector_and_scalar) 4231 << VectorTy << Ty << R; 4232 4233 Kind = CK_BitCast; 4234 return false; 4235 } 4236 4237 ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy, 4238 Expr *CastExpr, CastKind &Kind) { 4239 assert(DestTy->isExtVectorType() && "Not an extended vector type!"); 4240 4241 QualType SrcTy = CastExpr->getType(); 4242 4243 // If SrcTy is a VectorType, the total size must match to explicitly cast to 4244 // an ExtVectorType. 4245 // In OpenCL, casts between vectors of different types are not allowed. 4246 // (See OpenCL 6.2). 4247 if (SrcTy->isVectorType()) { 4248 if (Context.getTypeSize(DestTy) != Context.getTypeSize(SrcTy) 4249 || (getLangOpts().OpenCL && 4250 (DestTy.getCanonicalType() != SrcTy.getCanonicalType()))) { 4251 Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors) 4252 << DestTy << SrcTy << R; 4253 return ExprError(); 4254 } 4255 Kind = CK_BitCast; 4256 return Owned(CastExpr); 4257 } 4258 4259 // All non-pointer scalars can be cast to ExtVector type. The appropriate 4260 // conversion will take place first from scalar to elt type, and then 4261 // splat from elt type to vector. 4262 if (SrcTy->isPointerType()) 4263 return Diag(R.getBegin(), 4264 diag::err_invalid_conversion_between_vector_and_scalar) 4265 << DestTy << SrcTy << R; 4266 4267 QualType DestElemTy = DestTy->getAs<ExtVectorType>()->getElementType(); 4268 ExprResult CastExprRes = Owned(CastExpr); 4269 CastKind CK = PrepareScalarCast(CastExprRes, DestElemTy); 4270 if (CastExprRes.isInvalid()) 4271 return ExprError(); 4272 CastExpr = ImpCastExprToType(CastExprRes.take(), DestElemTy, CK).take(); 4273 4274 Kind = CK_VectorSplat; 4275 return Owned(CastExpr); 4276 } 4277 4278 ExprResult 4279 Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, 4280 Declarator &D, ParsedType &Ty, 4281 SourceLocation RParenLoc, Expr *CastExpr) { 4282 assert(!D.isInvalidType() && (CastExpr != 0) && 4283 "ActOnCastExpr(): missing type or expr"); 4284 4285 TypeSourceInfo *castTInfo = GetTypeForDeclaratorCast(D, CastExpr->getType()); 4286 if (D.isInvalidType()) 4287 return ExprError(); 4288 4289 if (getLangOpts().CPlusPlus) { 4290 // Check that there are no default arguments (C++ only). 4291 CheckExtraCXXDefaultArguments(D); 4292 } 4293 4294 checkUnusedDeclAttributes(D); 4295 4296 QualType castType = castTInfo->getType(); 4297 Ty = CreateParsedType(castType, castTInfo); 4298 4299 bool isVectorLiteral = false; 4300 4301 // Check for an altivec or OpenCL literal, 4302 // i.e. all the elements are integer constants. 4303 ParenExpr *PE = dyn_cast<ParenExpr>(CastExpr); 4304 ParenListExpr *PLE = dyn_cast<ParenListExpr>(CastExpr); 4305 if ((getLangOpts().AltiVec || getLangOpts().OpenCL) 4306 && castType->isVectorType() && (PE || PLE)) { 4307 if (PLE && PLE->getNumExprs() == 0) { 4308 Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer); 4309 return ExprError(); 4310 } 4311 if (PE || PLE->getNumExprs() == 1) { 4312 Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0)); 4313 if (!E->getType()->isVectorType()) 4314 isVectorLiteral = true; 4315 } 4316 else 4317 isVectorLiteral = true; 4318 } 4319 4320 // If this is a vector initializer, '(' type ')' '(' init, ..., init ')' 4321 // then handle it as such. 4322 if (isVectorLiteral) 4323 return BuildVectorLiteral(LParenLoc, RParenLoc, CastExpr, castTInfo); 4324 4325 // If the Expr being casted is a ParenListExpr, handle it specially. 4326 // This is not an AltiVec-style cast, so turn the ParenListExpr into a 4327 // sequence of BinOp comma operators. 4328 if (isa<ParenListExpr>(CastExpr)) { 4329 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr); 4330 if (Result.isInvalid()) return ExprError(); 4331 CastExpr = Result.take(); 4332 } 4333 4334 return BuildCStyleCastExpr(LParenLoc, castTInfo, RParenLoc, CastExpr); 4335 } 4336 4337 ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc, 4338 SourceLocation RParenLoc, Expr *E, 4339 TypeSourceInfo *TInfo) { 4340 assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) && 4341 "Expected paren or paren list expression"); 4342 4343 Expr **exprs; 4344 unsigned numExprs; 4345 Expr *subExpr; 4346 if (ParenListExpr *PE = dyn_cast<ParenListExpr>(E)) { 4347 exprs = PE->getExprs(); 4348 numExprs = PE->getNumExprs(); 4349 } else { 4350 subExpr = cast<ParenExpr>(E)->getSubExpr(); 4351 exprs = &subExpr; 4352 numExprs = 1; 4353 } 4354 4355 QualType Ty = TInfo->getType(); 4356 assert(Ty->isVectorType() && "Expected vector type"); 4357 4358 SmallVector<Expr *, 8> initExprs; 4359 const VectorType *VTy = Ty->getAs<VectorType>(); 4360 unsigned numElems = Ty->getAs<VectorType>()->getNumElements(); 4361 4362 // '(...)' form of vector initialization in AltiVec: the number of 4363 // initializers must be one or must match the size of the vector. 4364 // If a single value is specified in the initializer then it will be 4365 // replicated to all the components of the vector 4366 if (VTy->getVectorKind() == VectorType::AltiVecVector) { 4367 // The number of initializers must be one or must match the size of the 4368 // vector. If a single value is specified in the initializer then it will 4369 // be replicated to all the components of the vector 4370 if (numExprs == 1) { 4371 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 4372 ExprResult Literal = DefaultLvalueConversion(exprs[0]); 4373 if (Literal.isInvalid()) 4374 return ExprError(); 4375 Literal = ImpCastExprToType(Literal.take(), ElemTy, 4376 PrepareScalarCast(Literal, ElemTy)); 4377 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take()); 4378 } 4379 else if (numExprs < numElems) { 4380 Diag(E->getExprLoc(), 4381 diag::err_incorrect_number_of_vector_initializers); 4382 return ExprError(); 4383 } 4384 else 4385 initExprs.append(exprs, exprs + numExprs); 4386 } 4387 else { 4388 // For OpenCL, when the number of initializers is a single value, 4389 // it will be replicated to all components of the vector. 4390 if (getLangOpts().OpenCL && 4391 VTy->getVectorKind() == VectorType::GenericVector && 4392 numExprs == 1) { 4393 QualType ElemTy = Ty->getAs<VectorType>()->getElementType(); 4394 ExprResult Literal = DefaultLvalueConversion(exprs[0]); 4395 if (Literal.isInvalid()) 4396 return ExprError(); 4397 Literal = ImpCastExprToType(Literal.take(), ElemTy, 4398 PrepareScalarCast(Literal, ElemTy)); 4399 return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.take()); 4400 } 4401 4402 initExprs.append(exprs, exprs + numExprs); 4403 } 4404 // FIXME: This means that pretty-printing the final AST will produce curly 4405 // braces instead of the original commas. 4406 InitListExpr *initE = new (Context) InitListExpr(Context, LParenLoc, 4407 &initExprs[0], 4408 initExprs.size(), RParenLoc); 4409 initE->setType(Ty); 4410 return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE); 4411 } 4412 4413 /// This is not an AltiVec-style cast or or C++ direct-initialization, so turn 4414 /// the ParenListExpr into a sequence of comma binary operators. 4415 ExprResult 4416 Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *OrigExpr) { 4417 ParenListExpr *E = dyn_cast<ParenListExpr>(OrigExpr); 4418 if (!E) 4419 return Owned(OrigExpr); 4420 4421 ExprResult Result(E->getExpr(0)); 4422 4423 for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i) 4424 Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(), 4425 E->getExpr(i)); 4426 4427 if (Result.isInvalid()) return ExprError(); 4428 4429 return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get()); 4430 } 4431 4432 ExprResult Sema::ActOnParenListExpr(SourceLocation L, 4433 SourceLocation R, 4434 MultiExprArg Val) { 4435 unsigned nexprs = Val.size(); 4436 Expr **exprs = reinterpret_cast<Expr**>(Val.release()); 4437 assert((exprs != 0) && "ActOnParenOrParenListExpr() missing expr list"); 4438 Expr *expr = new (Context) ParenListExpr(Context, L, exprs, nexprs, R); 4439 return Owned(expr); 4440 } 4441 4442 /// \brief Emit a specialized diagnostic when one expression is a null pointer 4443 /// constant and the other is not a pointer. Returns true if a diagnostic is 4444 /// emitted. 4445 bool Sema::DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr, 4446 SourceLocation QuestionLoc) { 4447 Expr *NullExpr = LHSExpr; 4448 Expr *NonPointerExpr = RHSExpr; 4449 Expr::NullPointerConstantKind NullKind = 4450 NullExpr->isNullPointerConstant(Context, 4451 Expr::NPC_ValueDependentIsNotNull); 4452 4453 if (NullKind == Expr::NPCK_NotNull) { 4454 NullExpr = RHSExpr; 4455 NonPointerExpr = LHSExpr; 4456 NullKind = 4457 NullExpr->isNullPointerConstant(Context, 4458 Expr::NPC_ValueDependentIsNotNull); 4459 } 4460 4461 if (NullKind == Expr::NPCK_NotNull) 4462 return false; 4463 4464 if (NullKind == Expr::NPCK_ZeroInteger) { 4465 // In this case, check to make sure that we got here from a "NULL" 4466 // string in the source code. 4467 NullExpr = NullExpr->IgnoreParenImpCasts(); 4468 SourceLocation loc = NullExpr->getExprLoc(); 4469 if (!findMacroSpelling(loc, "NULL")) 4470 return false; 4471 } 4472 4473 int DiagType = (NullKind == Expr::NPCK_CXX0X_nullptr); 4474 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands_null) 4475 << NonPointerExpr->getType() << DiagType 4476 << NonPointerExpr->getSourceRange(); 4477 return true; 4478 } 4479 4480 /// \brief Return false if the condition expression is valid, true otherwise. 4481 static bool checkCondition(Sema &S, Expr *Cond) { 4482 QualType CondTy = Cond->getType(); 4483 4484 // C99 6.5.15p2 4485 if (CondTy->isScalarType()) return false; 4486 4487 // OpenCL: Sec 6.3.i says the condition is allowed to be a vector or scalar. 4488 if (S.getLangOpts().OpenCL && CondTy->isVectorType()) 4489 return false; 4490 4491 // Emit the proper error message. 4492 S.Diag(Cond->getLocStart(), S.getLangOpts().OpenCL ? 4493 diag::err_typecheck_cond_expect_scalar : 4494 diag::err_typecheck_cond_expect_scalar_or_vector) 4495 << CondTy; 4496 return true; 4497 } 4498 4499 /// \brief Return false if the two expressions can be converted to a vector, 4500 /// true otherwise 4501 static bool checkConditionalConvertScalarsToVectors(Sema &S, ExprResult &LHS, 4502 ExprResult &RHS, 4503 QualType CondTy) { 4504 // Both operands should be of scalar type. 4505 if (!LHS.get()->getType()->isScalarType()) { 4506 S.Diag(LHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 4507 << CondTy; 4508 return true; 4509 } 4510 if (!RHS.get()->getType()->isScalarType()) { 4511 S.Diag(RHS.get()->getLocStart(), diag::err_typecheck_cond_expect_scalar) 4512 << CondTy; 4513 return true; 4514 } 4515 4516 // Implicity convert these scalars to the type of the condition. 4517 LHS = S.ImpCastExprToType(LHS.take(), CondTy, CK_IntegralCast); 4518 RHS = S.ImpCastExprToType(RHS.take(), CondTy, CK_IntegralCast); 4519 return false; 4520 } 4521 4522 /// \brief Handle when one or both operands are void type. 4523 static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS, 4524 ExprResult &RHS) { 4525 Expr *LHSExpr = LHS.get(); 4526 Expr *RHSExpr = RHS.get(); 4527 4528 if (!LHSExpr->getType()->isVoidType()) 4529 S.Diag(RHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 4530 << RHSExpr->getSourceRange(); 4531 if (!RHSExpr->getType()->isVoidType()) 4532 S.Diag(LHSExpr->getLocStart(), diag::ext_typecheck_cond_one_void) 4533 << LHSExpr->getSourceRange(); 4534 LHS = S.ImpCastExprToType(LHS.take(), S.Context.VoidTy, CK_ToVoid); 4535 RHS = S.ImpCastExprToType(RHS.take(), S.Context.VoidTy, CK_ToVoid); 4536 return S.Context.VoidTy; 4537 } 4538 4539 /// \brief Return false if the NullExpr can be promoted to PointerTy, 4540 /// true otherwise. 4541 static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr, 4542 QualType PointerTy) { 4543 if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) || 4544 !NullExpr.get()->isNullPointerConstant(S.Context, 4545 Expr::NPC_ValueDependentIsNull)) 4546 return true; 4547 4548 NullExpr = S.ImpCastExprToType(NullExpr.take(), PointerTy, CK_NullToPointer); 4549 return false; 4550 } 4551 4552 /// \brief Checks compatibility between two pointers and return the resulting 4553 /// type. 4554 static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS, 4555 ExprResult &RHS, 4556 SourceLocation Loc) { 4557 QualType LHSTy = LHS.get()->getType(); 4558 QualType RHSTy = RHS.get()->getType(); 4559 4560 if (S.Context.hasSameType(LHSTy, RHSTy)) { 4561 // Two identical pointers types are always compatible. 4562 return LHSTy; 4563 } 4564 4565 QualType lhptee, rhptee; 4566 4567 // Get the pointee types. 4568 if (const BlockPointerType *LHSBTy = LHSTy->getAs<BlockPointerType>()) { 4569 lhptee = LHSBTy->getPointeeType(); 4570 rhptee = RHSTy->castAs<BlockPointerType>()->getPointeeType(); 4571 } else { 4572 lhptee = LHSTy->castAs<PointerType>()->getPointeeType(); 4573 rhptee = RHSTy->castAs<PointerType>()->getPointeeType(); 4574 } 4575 4576 // C99 6.5.15p6: If both operands are pointers to compatible types or to 4577 // differently qualified versions of compatible types, the result type is 4578 // a pointer to an appropriately qualified version of the composite 4579 // type. 4580 4581 // Only CVR-qualifiers exist in the standard, and the differently-qualified 4582 // clause doesn't make sense for our extensions. E.g. address space 2 should 4583 // be incompatible with address space 3: they may live on different devices or 4584 // anything. 4585 Qualifiers lhQual = lhptee.getQualifiers(); 4586 Qualifiers rhQual = rhptee.getQualifiers(); 4587 4588 unsigned MergedCVRQual = lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers(); 4589 lhQual.removeCVRQualifiers(); 4590 rhQual.removeCVRQualifiers(); 4591 4592 lhptee = S.Context.getQualifiedType(lhptee.getUnqualifiedType(), lhQual); 4593 rhptee = S.Context.getQualifiedType(rhptee.getUnqualifiedType(), rhQual); 4594 4595 QualType CompositeTy = S.Context.mergeTypes(lhptee, rhptee); 4596 4597 if (CompositeTy.isNull()) { 4598 S.Diag(Loc, diag::warn_typecheck_cond_incompatible_pointers) 4599 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4600 << RHS.get()->getSourceRange(); 4601 // In this situation, we assume void* type. No especially good 4602 // reason, but this is what gcc does, and we do have to pick 4603 // to get a consistent AST. 4604 QualType incompatTy = S.Context.getPointerType(S.Context.VoidTy); 4605 LHS = S.ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); 4606 RHS = S.ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); 4607 return incompatTy; 4608 } 4609 4610 // The pointer types are compatible. 4611 QualType ResultTy = CompositeTy.withCVRQualifiers(MergedCVRQual); 4612 ResultTy = S.Context.getPointerType(ResultTy); 4613 4614 LHS = S.ImpCastExprToType(LHS.take(), ResultTy, CK_BitCast); 4615 RHS = S.ImpCastExprToType(RHS.take(), ResultTy, CK_BitCast); 4616 return ResultTy; 4617 } 4618 4619 /// \brief Return the resulting type when the operands are both block pointers. 4620 static QualType checkConditionalBlockPointerCompatibility(Sema &S, 4621 ExprResult &LHS, 4622 ExprResult &RHS, 4623 SourceLocation Loc) { 4624 QualType LHSTy = LHS.get()->getType(); 4625 QualType RHSTy = RHS.get()->getType(); 4626 4627 if (!LHSTy->isBlockPointerType() || !RHSTy->isBlockPointerType()) { 4628 if (LHSTy->isVoidPointerType() || RHSTy->isVoidPointerType()) { 4629 QualType destType = S.Context.getPointerType(S.Context.VoidTy); 4630 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast); 4631 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast); 4632 return destType; 4633 } 4634 S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands) 4635 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4636 << RHS.get()->getSourceRange(); 4637 return QualType(); 4638 } 4639 4640 // We have 2 block pointer types. 4641 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 4642 } 4643 4644 /// \brief Return the resulting type when the operands are both pointers. 4645 static QualType 4646 checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS, 4647 ExprResult &RHS, 4648 SourceLocation Loc) { 4649 // get the pointer types 4650 QualType LHSTy = LHS.get()->getType(); 4651 QualType RHSTy = RHS.get()->getType(); 4652 4653 // get the "pointed to" types 4654 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 4655 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 4656 4657 // ignore qualifiers on void (C99 6.5.15p3, clause 6) 4658 if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) { 4659 // Figure out necessary qualifiers (C99 6.5.15p6) 4660 QualType destPointee 4661 = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 4662 QualType destType = S.Context.getPointerType(destPointee); 4663 // Add qualifiers if necessary. 4664 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_NoOp); 4665 // Promote to void*. 4666 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_BitCast); 4667 return destType; 4668 } 4669 if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) { 4670 QualType destPointee 4671 = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 4672 QualType destType = S.Context.getPointerType(destPointee); 4673 // Add qualifiers if necessary. 4674 RHS = S.ImpCastExprToType(RHS.take(), destType, CK_NoOp); 4675 // Promote to void*. 4676 LHS = S.ImpCastExprToType(LHS.take(), destType, CK_BitCast); 4677 return destType; 4678 } 4679 4680 return checkConditionalPointerCompatibility(S, LHS, RHS, Loc); 4681 } 4682 4683 /// \brief Return false if the first expression is not an integer and the second 4684 /// expression is not a pointer, true otherwise. 4685 static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int, 4686 Expr* PointerExpr, SourceLocation Loc, 4687 bool IsIntFirstExpr) { 4688 if (!PointerExpr->getType()->isPointerType() || 4689 !Int.get()->getType()->isIntegerType()) 4690 return false; 4691 4692 Expr *Expr1 = IsIntFirstExpr ? Int.get() : PointerExpr; 4693 Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get(); 4694 4695 S.Diag(Loc, diag::warn_typecheck_cond_pointer_integer_mismatch) 4696 << Expr1->getType() << Expr2->getType() 4697 << Expr1->getSourceRange() << Expr2->getSourceRange(); 4698 Int = S.ImpCastExprToType(Int.take(), PointerExpr->getType(), 4699 CK_IntegralToPointer); 4700 return true; 4701 } 4702 4703 /// Note that LHS is not null here, even if this is the gnu "x ?: y" extension. 4704 /// In that case, LHS = cond. 4705 /// C99 6.5.15 4706 QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, 4707 ExprResult &RHS, ExprValueKind &VK, 4708 ExprObjectKind &OK, 4709 SourceLocation QuestionLoc) { 4710 4711 ExprResult LHSResult = CheckPlaceholderExpr(LHS.get()); 4712 if (!LHSResult.isUsable()) return QualType(); 4713 LHS = move(LHSResult); 4714 4715 ExprResult RHSResult = CheckPlaceholderExpr(RHS.get()); 4716 if (!RHSResult.isUsable()) return QualType(); 4717 RHS = move(RHSResult); 4718 4719 // C++ is sufficiently different to merit its own checker. 4720 if (getLangOpts().CPlusPlus) 4721 return CXXCheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc); 4722 4723 VK = VK_RValue; 4724 OK = OK_Ordinary; 4725 4726 Cond = UsualUnaryConversions(Cond.take()); 4727 if (Cond.isInvalid()) 4728 return QualType(); 4729 LHS = UsualUnaryConversions(LHS.take()); 4730 if (LHS.isInvalid()) 4731 return QualType(); 4732 RHS = UsualUnaryConversions(RHS.take()); 4733 if (RHS.isInvalid()) 4734 return QualType(); 4735 4736 QualType CondTy = Cond.get()->getType(); 4737 QualType LHSTy = LHS.get()->getType(); 4738 QualType RHSTy = RHS.get()->getType(); 4739 4740 // first, check the condition. 4741 if (checkCondition(*this, Cond.get())) 4742 return QualType(); 4743 4744 // Now check the two expressions. 4745 if (LHSTy->isVectorType() || RHSTy->isVectorType()) 4746 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false); 4747 4748 // OpenCL: If the condition is a vector, and both operands are scalar, 4749 // attempt to implicity convert them to the vector type to act like the 4750 // built in select. 4751 if (getLangOpts().OpenCL && CondTy->isVectorType()) 4752 if (checkConditionalConvertScalarsToVectors(*this, LHS, RHS, CondTy)) 4753 return QualType(); 4754 4755 // If both operands have arithmetic type, do the usual arithmetic conversions 4756 // to find a common type: C99 6.5.15p3,5. 4757 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) { 4758 UsualArithmeticConversions(LHS, RHS); 4759 if (LHS.isInvalid() || RHS.isInvalid()) 4760 return QualType(); 4761 return LHS.get()->getType(); 4762 } 4763 4764 // If both operands are the same structure or union type, the result is that 4765 // type. 4766 if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) { // C99 6.5.15p3 4767 if (const RecordType *RHSRT = RHSTy->getAs<RecordType>()) 4768 if (LHSRT->getDecl() == RHSRT->getDecl()) 4769 // "If both the operands have structure or union type, the result has 4770 // that type." This implies that CV qualifiers are dropped. 4771 return LHSTy.getUnqualifiedType(); 4772 // FIXME: Type of conditional expression must be complete in C mode. 4773 } 4774 4775 // C99 6.5.15p5: "If both operands have void type, the result has void type." 4776 // The following || allows only one side to be void (a GCC-ism). 4777 if (LHSTy->isVoidType() || RHSTy->isVoidType()) { 4778 return checkConditionalVoidType(*this, LHS, RHS); 4779 } 4780 4781 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has 4782 // the type of the other operand." 4783 if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy; 4784 if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy; 4785 4786 // All objective-c pointer type analysis is done here. 4787 QualType compositeType = FindCompositeObjCPointerType(LHS, RHS, 4788 QuestionLoc); 4789 if (LHS.isInvalid() || RHS.isInvalid()) 4790 return QualType(); 4791 if (!compositeType.isNull()) 4792 return compositeType; 4793 4794 4795 // Handle block pointer types. 4796 if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) 4797 return checkConditionalBlockPointerCompatibility(*this, LHS, RHS, 4798 QuestionLoc); 4799 4800 // Check constraints for C object pointers types (C99 6.5.15p3,6). 4801 if (LHSTy->isPointerType() && RHSTy->isPointerType()) 4802 return checkConditionalObjectPointersCompatibility(*this, LHS, RHS, 4803 QuestionLoc); 4804 4805 // GCC compatibility: soften pointer/integer mismatch. Note that 4806 // null pointers have been filtered out by this point. 4807 if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc, 4808 /*isIntFirstExpr=*/true)) 4809 return RHSTy; 4810 if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc, 4811 /*isIntFirstExpr=*/false)) 4812 return LHSTy; 4813 4814 // Emit a better diagnostic if one of the expressions is a null pointer 4815 // constant and the other is not a pointer type. In this case, the user most 4816 // likely forgot to take the address of the other expression. 4817 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc)) 4818 return QualType(); 4819 4820 // Otherwise, the operands are not compatible. 4821 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 4822 << LHSTy << RHSTy << LHS.get()->getSourceRange() 4823 << RHS.get()->getSourceRange(); 4824 return QualType(); 4825 } 4826 4827 /// FindCompositeObjCPointerType - Helper method to find composite type of 4828 /// two objective-c pointer types of the two input expressions. 4829 QualType Sema::FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS, 4830 SourceLocation QuestionLoc) { 4831 QualType LHSTy = LHS.get()->getType(); 4832 QualType RHSTy = RHS.get()->getType(); 4833 4834 // Handle things like Class and struct objc_class*. Here we case the result 4835 // to the pseudo-builtin, because that will be implicitly cast back to the 4836 // redefinition type if an attempt is made to access its fields. 4837 if (LHSTy->isObjCClassType() && 4838 (Context.hasSameType(RHSTy, Context.getObjCClassRedefinitionType()))) { 4839 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_CPointerToObjCPointerCast); 4840 return LHSTy; 4841 } 4842 if (RHSTy->isObjCClassType() && 4843 (Context.hasSameType(LHSTy, Context.getObjCClassRedefinitionType()))) { 4844 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_CPointerToObjCPointerCast); 4845 return RHSTy; 4846 } 4847 // And the same for struct objc_object* / id 4848 if (LHSTy->isObjCIdType() && 4849 (Context.hasSameType(RHSTy, Context.getObjCIdRedefinitionType()))) { 4850 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_CPointerToObjCPointerCast); 4851 return LHSTy; 4852 } 4853 if (RHSTy->isObjCIdType() && 4854 (Context.hasSameType(LHSTy, Context.getObjCIdRedefinitionType()))) { 4855 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_CPointerToObjCPointerCast); 4856 return RHSTy; 4857 } 4858 // And the same for struct objc_selector* / SEL 4859 if (Context.isObjCSelType(LHSTy) && 4860 (Context.hasSameType(RHSTy, Context.getObjCSelRedefinitionType()))) { 4861 RHS = ImpCastExprToType(RHS.take(), LHSTy, CK_BitCast); 4862 return LHSTy; 4863 } 4864 if (Context.isObjCSelType(RHSTy) && 4865 (Context.hasSameType(LHSTy, Context.getObjCSelRedefinitionType()))) { 4866 LHS = ImpCastExprToType(LHS.take(), RHSTy, CK_BitCast); 4867 return RHSTy; 4868 } 4869 // Check constraints for Objective-C object pointers types. 4870 if (LHSTy->isObjCObjectPointerType() && RHSTy->isObjCObjectPointerType()) { 4871 4872 if (Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) { 4873 // Two identical object pointer types are always compatible. 4874 return LHSTy; 4875 } 4876 const ObjCObjectPointerType *LHSOPT = LHSTy->castAs<ObjCObjectPointerType>(); 4877 const ObjCObjectPointerType *RHSOPT = RHSTy->castAs<ObjCObjectPointerType>(); 4878 QualType compositeType = LHSTy; 4879 4880 // If both operands are interfaces and either operand can be 4881 // assigned to the other, use that type as the composite 4882 // type. This allows 4883 // xxx ? (A*) a : (B*) b 4884 // where B is a subclass of A. 4885 // 4886 // Additionally, as for assignment, if either type is 'id' 4887 // allow silent coercion. Finally, if the types are 4888 // incompatible then make sure to use 'id' as the composite 4889 // type so the result is acceptable for sending messages to. 4890 4891 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'. 4892 // It could return the composite type. 4893 if (Context.canAssignObjCInterfaces(LHSOPT, RHSOPT)) { 4894 compositeType = RHSOPT->isObjCBuiltinType() ? RHSTy : LHSTy; 4895 } else if (Context.canAssignObjCInterfaces(RHSOPT, LHSOPT)) { 4896 compositeType = LHSOPT->isObjCBuiltinType() ? LHSTy : RHSTy; 4897 } else if ((LHSTy->isObjCQualifiedIdType() || 4898 RHSTy->isObjCQualifiedIdType()) && 4899 Context.ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true)) { 4900 // Need to handle "id<xx>" explicitly. 4901 // GCC allows qualified id and any Objective-C type to devolve to 4902 // id. Currently localizing to here until clear this should be 4903 // part of ObjCQualifiedIdTypesAreCompatible. 4904 compositeType = Context.getObjCIdType(); 4905 } else if (LHSTy->isObjCIdType() || RHSTy->isObjCIdType()) { 4906 compositeType = Context.getObjCIdType(); 4907 } else if (!(compositeType = 4908 Context.areCommonBaseCompatible(LHSOPT, RHSOPT)).isNull()) 4909 ; 4910 else { 4911 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands) 4912 << LHSTy << RHSTy 4913 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 4914 QualType incompatTy = Context.getObjCIdType(); 4915 LHS = ImpCastExprToType(LHS.take(), incompatTy, CK_BitCast); 4916 RHS = ImpCastExprToType(RHS.take(), incompatTy, CK_BitCast); 4917 return incompatTy; 4918 } 4919 // The object pointer types are compatible. 4920 LHS = ImpCastExprToType(LHS.take(), compositeType, CK_BitCast); 4921 RHS = ImpCastExprToType(RHS.take(), compositeType, CK_BitCast); 4922 return compositeType; 4923 } 4924 // Check Objective-C object pointer types and 'void *' 4925 if (LHSTy->isVoidPointerType() && RHSTy->isObjCObjectPointerType()) { 4926 if (getLangOpts().ObjCAutoRefCount) { 4927 // ARC forbids the implicit conversion of object pointers to 'void *', 4928 // so these types are not compatible. 4929 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy 4930 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 4931 LHS = RHS = true; 4932 return QualType(); 4933 } 4934 QualType lhptee = LHSTy->getAs<PointerType>()->getPointeeType(); 4935 QualType rhptee = RHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 4936 QualType destPointee 4937 = Context.getQualifiedType(lhptee, rhptee.getQualifiers()); 4938 QualType destType = Context.getPointerType(destPointee); 4939 // Add qualifiers if necessary. 4940 LHS = ImpCastExprToType(LHS.take(), destType, CK_NoOp); 4941 // Promote to void*. 4942 RHS = ImpCastExprToType(RHS.take(), destType, CK_BitCast); 4943 return destType; 4944 } 4945 if (LHSTy->isObjCObjectPointerType() && RHSTy->isVoidPointerType()) { 4946 if (getLangOpts().ObjCAutoRefCount) { 4947 // ARC forbids the implicit conversion of object pointers to 'void *', 4948 // so these types are not compatible. 4949 Diag(QuestionLoc, diag::err_cond_voidptr_arc) << LHSTy << RHSTy 4950 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 4951 LHS = RHS = true; 4952 return QualType(); 4953 } 4954 QualType lhptee = LHSTy->getAs<ObjCObjectPointerType>()->getPointeeType(); 4955 QualType rhptee = RHSTy->getAs<PointerType>()->getPointeeType(); 4956 QualType destPointee 4957 = Context.getQualifiedType(rhptee, lhptee.getQualifiers()); 4958 QualType destType = Context.getPointerType(destPointee); 4959 // Add qualifiers if necessary. 4960 RHS = ImpCastExprToType(RHS.take(), destType, CK_NoOp); 4961 // Promote to void*. 4962 LHS = ImpCastExprToType(LHS.take(), destType, CK_BitCast); 4963 return destType; 4964 } 4965 return QualType(); 4966 } 4967 4968 /// SuggestParentheses - Emit a note with a fixit hint that wraps 4969 /// ParenRange in parentheses. 4970 static void SuggestParentheses(Sema &Self, SourceLocation Loc, 4971 const PartialDiagnostic &Note, 4972 SourceRange ParenRange) { 4973 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(ParenRange.getEnd()); 4974 if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() && 4975 EndLoc.isValid()) { 4976 Self.Diag(Loc, Note) 4977 << FixItHint::CreateInsertion(ParenRange.getBegin(), "(") 4978 << FixItHint::CreateInsertion(EndLoc, ")"); 4979 } else { 4980 // We can't display the parentheses, so just show the bare note. 4981 Self.Diag(Loc, Note) << ParenRange; 4982 } 4983 } 4984 4985 static bool IsArithmeticOp(BinaryOperatorKind Opc) { 4986 return Opc >= BO_Mul && Opc <= BO_Shr; 4987 } 4988 4989 /// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary 4990 /// expression, either using a built-in or overloaded operator, 4991 /// and sets *OpCode to the opcode and *RHSExprs to the right-hand side 4992 /// expression. 4993 static bool IsArithmeticBinaryExpr(Expr *E, BinaryOperatorKind *Opcode, 4994 Expr **RHSExprs) { 4995 // Don't strip parenthesis: we should not warn if E is in parenthesis. 4996 E = E->IgnoreImpCasts(); 4997 E = E->IgnoreConversionOperator(); 4998 E = E->IgnoreImpCasts(); 4999 5000 // Built-in binary operator. 5001 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) { 5002 if (IsArithmeticOp(OP->getOpcode())) { 5003 *Opcode = OP->getOpcode(); 5004 *RHSExprs = OP->getRHS(); 5005 return true; 5006 } 5007 } 5008 5009 // Overloaded operator. 5010 if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(E)) { 5011 if (Call->getNumArgs() != 2) 5012 return false; 5013 5014 // Make sure this is really a binary operator that is safe to pass into 5015 // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op. 5016 OverloadedOperatorKind OO = Call->getOperator(); 5017 if (OO < OO_Plus || OO > OO_Arrow) 5018 return false; 5019 5020 BinaryOperatorKind OpKind = BinaryOperator::getOverloadedOpcode(OO); 5021 if (IsArithmeticOp(OpKind)) { 5022 *Opcode = OpKind; 5023 *RHSExprs = Call->getArg(1); 5024 return true; 5025 } 5026 } 5027 5028 return false; 5029 } 5030 5031 static bool IsLogicOp(BinaryOperatorKind Opc) { 5032 return (Opc >= BO_LT && Opc <= BO_NE) || (Opc >= BO_LAnd && Opc <= BO_LOr); 5033 } 5034 5035 /// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type 5036 /// or is a logical expression such as (x==y) which has int type, but is 5037 /// commonly interpreted as boolean. 5038 static bool ExprLooksBoolean(Expr *E) { 5039 E = E->IgnoreParenImpCasts(); 5040 5041 if (E->getType()->isBooleanType()) 5042 return true; 5043 if (BinaryOperator *OP = dyn_cast<BinaryOperator>(E)) 5044 return IsLogicOp(OP->getOpcode()); 5045 if (UnaryOperator *OP = dyn_cast<UnaryOperator>(E)) 5046 return OP->getOpcode() == UO_LNot; 5047 5048 return false; 5049 } 5050 5051 /// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator 5052 /// and binary operator are mixed in a way that suggests the programmer assumed 5053 /// the conditional operator has higher precedence, for example: 5054 /// "int x = a + someBinaryCondition ? 1 : 2". 5055 static void DiagnoseConditionalPrecedence(Sema &Self, 5056 SourceLocation OpLoc, 5057 Expr *Condition, 5058 Expr *LHSExpr, 5059 Expr *RHSExpr) { 5060 BinaryOperatorKind CondOpcode; 5061 Expr *CondRHS; 5062 5063 if (!IsArithmeticBinaryExpr(Condition, &CondOpcode, &CondRHS)) 5064 return; 5065 if (!ExprLooksBoolean(CondRHS)) 5066 return; 5067 5068 // The condition is an arithmetic binary expression, with a right- 5069 // hand side that looks boolean, so warn. 5070 5071 Self.Diag(OpLoc, diag::warn_precedence_conditional) 5072 << Condition->getSourceRange() 5073 << BinaryOperator::getOpcodeStr(CondOpcode); 5074 5075 SuggestParentheses(Self, OpLoc, 5076 Self.PDiag(diag::note_precedence_conditional_silence) 5077 << BinaryOperator::getOpcodeStr(CondOpcode), 5078 SourceRange(Condition->getLocStart(), Condition->getLocEnd())); 5079 5080 SuggestParentheses(Self, OpLoc, 5081 Self.PDiag(diag::note_precedence_conditional_first), 5082 SourceRange(CondRHS->getLocStart(), RHSExpr->getLocEnd())); 5083 } 5084 5085 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null 5086 /// in the case of a the GNU conditional expr extension. 5087 ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc, 5088 SourceLocation ColonLoc, 5089 Expr *CondExpr, Expr *LHSExpr, 5090 Expr *RHSExpr) { 5091 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS 5092 // was the condition. 5093 OpaqueValueExpr *opaqueValue = 0; 5094 Expr *commonExpr = 0; 5095 if (LHSExpr == 0) { 5096 commonExpr = CondExpr; 5097 5098 // We usually want to apply unary conversions *before* saving, except 5099 // in the special case of a C++ l-value conditional. 5100 if (!(getLangOpts().CPlusPlus 5101 && !commonExpr->isTypeDependent() 5102 && commonExpr->getValueKind() == RHSExpr->getValueKind() 5103 && commonExpr->isGLValue() 5104 && commonExpr->isOrdinaryOrBitFieldObject() 5105 && RHSExpr->isOrdinaryOrBitFieldObject() 5106 && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) { 5107 ExprResult commonRes = UsualUnaryConversions(commonExpr); 5108 if (commonRes.isInvalid()) 5109 return ExprError(); 5110 commonExpr = commonRes.take(); 5111 } 5112 5113 opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(), 5114 commonExpr->getType(), 5115 commonExpr->getValueKind(), 5116 commonExpr->getObjectKind(), 5117 commonExpr); 5118 LHSExpr = CondExpr = opaqueValue; 5119 } 5120 5121 ExprValueKind VK = VK_RValue; 5122 ExprObjectKind OK = OK_Ordinary; 5123 ExprResult Cond = Owned(CondExpr), LHS = Owned(LHSExpr), RHS = Owned(RHSExpr); 5124 QualType result = CheckConditionalOperands(Cond, LHS, RHS, 5125 VK, OK, QuestionLoc); 5126 if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() || 5127 RHS.isInvalid()) 5128 return ExprError(); 5129 5130 DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(), 5131 RHS.get()); 5132 5133 if (!commonExpr) 5134 return Owned(new (Context) ConditionalOperator(Cond.take(), QuestionLoc, 5135 LHS.take(), ColonLoc, 5136 RHS.take(), result, VK, OK)); 5137 5138 return Owned(new (Context) 5139 BinaryConditionalOperator(commonExpr, opaqueValue, Cond.take(), LHS.take(), 5140 RHS.take(), QuestionLoc, ColonLoc, result, VK, 5141 OK)); 5142 } 5143 5144 // checkPointerTypesForAssignment - This is a very tricky routine (despite 5145 // being closely modeled after the C99 spec:-). The odd characteristic of this 5146 // routine is it effectively iqnores the qualifiers on the top level pointee. 5147 // This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3]. 5148 // FIXME: add a couple examples in this comment. 5149 static Sema::AssignConvertType 5150 checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) { 5151 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 5152 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 5153 5154 // get the "pointed to" type (ignoring qualifiers at the top level) 5155 const Type *lhptee, *rhptee; 5156 Qualifiers lhq, rhq; 5157 llvm::tie(lhptee, lhq) = cast<PointerType>(LHSType)->getPointeeType().split(); 5158 llvm::tie(rhptee, rhq) = cast<PointerType>(RHSType)->getPointeeType().split(); 5159 5160 Sema::AssignConvertType ConvTy = Sema::Compatible; 5161 5162 // C99 6.5.16.1p1: This following citation is common to constraints 5163 // 3 & 4 (below). ...and the type *pointed to* by the left has all the 5164 // qualifiers of the type *pointed to* by the right; 5165 Qualifiers lq; 5166 5167 // As a special case, 'non-__weak A *' -> 'non-__weak const *' is okay. 5168 if (lhq.getObjCLifetime() != rhq.getObjCLifetime() && 5169 lhq.compatiblyIncludesObjCLifetime(rhq)) { 5170 // Ignore lifetime for further calculation. 5171 lhq.removeObjCLifetime(); 5172 rhq.removeObjCLifetime(); 5173 } 5174 5175 if (!lhq.compatiblyIncludes(rhq)) { 5176 // Treat address-space mismatches as fatal. TODO: address subspaces 5177 if (lhq.getAddressSpace() != rhq.getAddressSpace()) 5178 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 5179 5180 // It's okay to add or remove GC or lifetime qualifiers when converting to 5181 // and from void*. 5182 else if (lhq.withoutObjCGCAttr().withoutObjCLifetime() 5183 .compatiblyIncludes( 5184 rhq.withoutObjCGCAttr().withoutObjCLifetime()) 5185 && (lhptee->isVoidType() || rhptee->isVoidType())) 5186 ; // keep old 5187 5188 // Treat lifetime mismatches as fatal. 5189 else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) 5190 ConvTy = Sema::IncompatiblePointerDiscardsQualifiers; 5191 5192 // For GCC compatibility, other qualifier mismatches are treated 5193 // as still compatible in C. 5194 else ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 5195 } 5196 5197 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or 5198 // incomplete type and the other is a pointer to a qualified or unqualified 5199 // version of void... 5200 if (lhptee->isVoidType()) { 5201 if (rhptee->isIncompleteOrObjectType()) 5202 return ConvTy; 5203 5204 // As an extension, we allow cast to/from void* to function pointer. 5205 assert(rhptee->isFunctionType()); 5206 return Sema::FunctionVoidPointer; 5207 } 5208 5209 if (rhptee->isVoidType()) { 5210 if (lhptee->isIncompleteOrObjectType()) 5211 return ConvTy; 5212 5213 // As an extension, we allow cast to/from void* to function pointer. 5214 assert(lhptee->isFunctionType()); 5215 return Sema::FunctionVoidPointer; 5216 } 5217 5218 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or 5219 // unqualified versions of compatible types, ... 5220 QualType ltrans = QualType(lhptee, 0), rtrans = QualType(rhptee, 0); 5221 if (!S.Context.typesAreCompatible(ltrans, rtrans)) { 5222 // Check if the pointee types are compatible ignoring the sign. 5223 // We explicitly check for char so that we catch "char" vs 5224 // "unsigned char" on systems where "char" is unsigned. 5225 if (lhptee->isCharType()) 5226 ltrans = S.Context.UnsignedCharTy; 5227 else if (lhptee->hasSignedIntegerRepresentation()) 5228 ltrans = S.Context.getCorrespondingUnsignedType(ltrans); 5229 5230 if (rhptee->isCharType()) 5231 rtrans = S.Context.UnsignedCharTy; 5232 else if (rhptee->hasSignedIntegerRepresentation()) 5233 rtrans = S.Context.getCorrespondingUnsignedType(rtrans); 5234 5235 if (ltrans == rtrans) { 5236 // Types are compatible ignoring the sign. Qualifier incompatibility 5237 // takes priority over sign incompatibility because the sign 5238 // warning can be disabled. 5239 if (ConvTy != Sema::Compatible) 5240 return ConvTy; 5241 5242 return Sema::IncompatiblePointerSign; 5243 } 5244 5245 // If we are a multi-level pointer, it's possible that our issue is simply 5246 // one of qualification - e.g. char ** -> const char ** is not allowed. If 5247 // the eventual target type is the same and the pointers have the same 5248 // level of indirection, this must be the issue. 5249 if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) { 5250 do { 5251 lhptee = cast<PointerType>(lhptee)->getPointeeType().getTypePtr(); 5252 rhptee = cast<PointerType>(rhptee)->getPointeeType().getTypePtr(); 5253 } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)); 5254 5255 if (lhptee == rhptee) 5256 return Sema::IncompatibleNestedPointerQualifiers; 5257 } 5258 5259 // General pointer incompatibility takes priority over qualifiers. 5260 return Sema::IncompatiblePointer; 5261 } 5262 if (!S.getLangOpts().CPlusPlus && 5263 S.IsNoReturnConversion(ltrans, rtrans, ltrans)) 5264 return Sema::IncompatiblePointer; 5265 return ConvTy; 5266 } 5267 5268 /// checkBlockPointerTypesForAssignment - This routine determines whether two 5269 /// block pointer types are compatible or whether a block and normal pointer 5270 /// are compatible. It is more restrict than comparing two function pointer 5271 // types. 5272 static Sema::AssignConvertType 5273 checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType, 5274 QualType RHSType) { 5275 assert(LHSType.isCanonical() && "LHS not canonicalized!"); 5276 assert(RHSType.isCanonical() && "RHS not canonicalized!"); 5277 5278 QualType lhptee, rhptee; 5279 5280 // get the "pointed to" type (ignoring qualifiers at the top level) 5281 lhptee = cast<BlockPointerType>(LHSType)->getPointeeType(); 5282 rhptee = cast<BlockPointerType>(RHSType)->getPointeeType(); 5283 5284 // In C++, the types have to match exactly. 5285 if (S.getLangOpts().CPlusPlus) 5286 return Sema::IncompatibleBlockPointer; 5287 5288 Sema::AssignConvertType ConvTy = Sema::Compatible; 5289 5290 // For blocks we enforce that qualifiers are identical. 5291 if (lhptee.getLocalQualifiers() != rhptee.getLocalQualifiers()) 5292 ConvTy = Sema::CompatiblePointerDiscardsQualifiers; 5293 5294 if (!S.Context.typesAreBlockPointerCompatible(LHSType, RHSType)) 5295 return Sema::IncompatibleBlockPointer; 5296 5297 return ConvTy; 5298 } 5299 5300 /// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types 5301 /// for assignment compatibility. 5302 static Sema::AssignConvertType 5303 checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType, 5304 QualType RHSType) { 5305 assert(LHSType.isCanonical() && "LHS was not canonicalized!"); 5306 assert(RHSType.isCanonical() && "RHS was not canonicalized!"); 5307 5308 if (LHSType->isObjCBuiltinType()) { 5309 // Class is not compatible with ObjC object pointers. 5310 if (LHSType->isObjCClassType() && !RHSType->isObjCBuiltinType() && 5311 !RHSType->isObjCQualifiedClassType()) 5312 return Sema::IncompatiblePointer; 5313 return Sema::Compatible; 5314 } 5315 if (RHSType->isObjCBuiltinType()) { 5316 if (RHSType->isObjCClassType() && !LHSType->isObjCBuiltinType() && 5317 !LHSType->isObjCQualifiedClassType()) 5318 return Sema::IncompatiblePointer; 5319 return Sema::Compatible; 5320 } 5321 QualType lhptee = LHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 5322 QualType rhptee = RHSType->getAs<ObjCObjectPointerType>()->getPointeeType(); 5323 5324 if (!lhptee.isAtLeastAsQualifiedAs(rhptee) && 5325 // make an exception for id<P> 5326 !LHSType->isObjCQualifiedIdType()) 5327 return Sema::CompatiblePointerDiscardsQualifiers; 5328 5329 if (S.Context.typesAreCompatible(LHSType, RHSType)) 5330 return Sema::Compatible; 5331 if (LHSType->isObjCQualifiedIdType() || RHSType->isObjCQualifiedIdType()) 5332 return Sema::IncompatibleObjCQualifiedId; 5333 return Sema::IncompatiblePointer; 5334 } 5335 5336 Sema::AssignConvertType 5337 Sema::CheckAssignmentConstraints(SourceLocation Loc, 5338 QualType LHSType, QualType RHSType) { 5339 // Fake up an opaque expression. We don't actually care about what 5340 // cast operations are required, so if CheckAssignmentConstraints 5341 // adds casts to this they'll be wasted, but fortunately that doesn't 5342 // usually happen on valid code. 5343 OpaqueValueExpr RHSExpr(Loc, RHSType, VK_RValue); 5344 ExprResult RHSPtr = &RHSExpr; 5345 CastKind K = CK_Invalid; 5346 5347 return CheckAssignmentConstraints(LHSType, RHSPtr, K); 5348 } 5349 5350 /// CheckAssignmentConstraints (C99 6.5.16) - This routine currently 5351 /// has code to accommodate several GCC extensions when type checking 5352 /// pointers. Here are some objectionable examples that GCC considers warnings: 5353 /// 5354 /// int a, *pint; 5355 /// short *pshort; 5356 /// struct foo *pfoo; 5357 /// 5358 /// pint = pshort; // warning: assignment from incompatible pointer type 5359 /// a = pint; // warning: assignment makes integer from pointer without a cast 5360 /// pint = a; // warning: assignment makes pointer from integer without a cast 5361 /// pint = pfoo; // warning: assignment from incompatible pointer type 5362 /// 5363 /// As a result, the code for dealing with pointers is more complex than the 5364 /// C99 spec dictates. 5365 /// 5366 /// Sets 'Kind' for any result kind except Incompatible. 5367 Sema::AssignConvertType 5368 Sema::CheckAssignmentConstraints(QualType LHSType, ExprResult &RHS, 5369 CastKind &Kind) { 5370 QualType RHSType = RHS.get()->getType(); 5371 QualType OrigLHSType = LHSType; 5372 5373 // Get canonical types. We're not formatting these types, just comparing 5374 // them. 5375 LHSType = Context.getCanonicalType(LHSType).getUnqualifiedType(); 5376 RHSType = Context.getCanonicalType(RHSType).getUnqualifiedType(); 5377 5378 5379 // Common case: no conversion required. 5380 if (LHSType == RHSType) { 5381 Kind = CK_NoOp; 5382 return Compatible; 5383 } 5384 5385 if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(LHSType)) { 5386 if (AtomicTy->getValueType() == RHSType) { 5387 Kind = CK_NonAtomicToAtomic; 5388 return Compatible; 5389 } 5390 } 5391 5392 if (const AtomicType *AtomicTy = dyn_cast<AtomicType>(RHSType)) { 5393 if (AtomicTy->getValueType() == LHSType) { 5394 Kind = CK_AtomicToNonAtomic; 5395 return Compatible; 5396 } 5397 } 5398 5399 5400 // If the left-hand side is a reference type, then we are in a 5401 // (rare!) case where we've allowed the use of references in C, 5402 // e.g., as a parameter type in a built-in function. In this case, 5403 // just make sure that the type referenced is compatible with the 5404 // right-hand side type. The caller is responsible for adjusting 5405 // LHSType so that the resulting expression does not have reference 5406 // type. 5407 if (const ReferenceType *LHSTypeRef = LHSType->getAs<ReferenceType>()) { 5408 if (Context.typesAreCompatible(LHSTypeRef->getPointeeType(), RHSType)) { 5409 Kind = CK_LValueBitCast; 5410 return Compatible; 5411 } 5412 return Incompatible; 5413 } 5414 5415 // Allow scalar to ExtVector assignments, and assignments of an ExtVector type 5416 // to the same ExtVector type. 5417 if (LHSType->isExtVectorType()) { 5418 if (RHSType->isExtVectorType()) 5419 return Incompatible; 5420 if (RHSType->isArithmeticType()) { 5421 // CK_VectorSplat does T -> vector T, so first cast to the 5422 // element type. 5423 QualType elType = cast<ExtVectorType>(LHSType)->getElementType(); 5424 if (elType != RHSType) { 5425 Kind = PrepareScalarCast(RHS, elType); 5426 RHS = ImpCastExprToType(RHS.take(), elType, Kind); 5427 } 5428 Kind = CK_VectorSplat; 5429 return Compatible; 5430 } 5431 } 5432 5433 // Conversions to or from vector type. 5434 if (LHSType->isVectorType() || RHSType->isVectorType()) { 5435 if (LHSType->isVectorType() && RHSType->isVectorType()) { 5436 // Allow assignments of an AltiVec vector type to an equivalent GCC 5437 // vector type and vice versa 5438 if (Context.areCompatibleVectorTypes(LHSType, RHSType)) { 5439 Kind = CK_BitCast; 5440 return Compatible; 5441 } 5442 5443 // If we are allowing lax vector conversions, and LHS and RHS are both 5444 // vectors, the total size only needs to be the same. This is a bitcast; 5445 // no bits are changed but the result type is different. 5446 if (getLangOpts().LaxVectorConversions && 5447 (Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType))) { 5448 Kind = CK_BitCast; 5449 return IncompatibleVectors; 5450 } 5451 } 5452 return Incompatible; 5453 } 5454 5455 // Arithmetic conversions. 5456 if (LHSType->isArithmeticType() && RHSType->isArithmeticType() && 5457 !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) { 5458 Kind = PrepareScalarCast(RHS, LHSType); 5459 return Compatible; 5460 } 5461 5462 // Conversions to normal pointers. 5463 if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) { 5464 // U* -> T* 5465 if (isa<PointerType>(RHSType)) { 5466 Kind = CK_BitCast; 5467 return checkPointerTypesForAssignment(*this, LHSType, RHSType); 5468 } 5469 5470 // int -> T* 5471 if (RHSType->isIntegerType()) { 5472 Kind = CK_IntegralToPointer; // FIXME: null? 5473 return IntToPointer; 5474 } 5475 5476 // C pointers are not compatible with ObjC object pointers, 5477 // with two exceptions: 5478 if (isa<ObjCObjectPointerType>(RHSType)) { 5479 // - conversions to void* 5480 if (LHSPointer->getPointeeType()->isVoidType()) { 5481 Kind = CK_BitCast; 5482 return Compatible; 5483 } 5484 5485 // - conversions from 'Class' to the redefinition type 5486 if (RHSType->isObjCClassType() && 5487 Context.hasSameType(LHSType, 5488 Context.getObjCClassRedefinitionType())) { 5489 Kind = CK_BitCast; 5490 return Compatible; 5491 } 5492 5493 Kind = CK_BitCast; 5494 return IncompatiblePointer; 5495 } 5496 5497 // U^ -> void* 5498 if (RHSType->getAs<BlockPointerType>()) { 5499 if (LHSPointer->getPointeeType()->isVoidType()) { 5500 Kind = CK_BitCast; 5501 return Compatible; 5502 } 5503 } 5504 5505 return Incompatible; 5506 } 5507 5508 // Conversions to block pointers. 5509 if (isa<BlockPointerType>(LHSType)) { 5510 // U^ -> T^ 5511 if (RHSType->isBlockPointerType()) { 5512 Kind = CK_BitCast; 5513 return checkBlockPointerTypesForAssignment(*this, LHSType, RHSType); 5514 } 5515 5516 // int or null -> T^ 5517 if (RHSType->isIntegerType()) { 5518 Kind = CK_IntegralToPointer; // FIXME: null 5519 return IntToBlockPointer; 5520 } 5521 5522 // id -> T^ 5523 if (getLangOpts().ObjC1 && RHSType->isObjCIdType()) { 5524 Kind = CK_AnyPointerToBlockPointerCast; 5525 return Compatible; 5526 } 5527 5528 // void* -> T^ 5529 if (const PointerType *RHSPT = RHSType->getAs<PointerType>()) 5530 if (RHSPT->getPointeeType()->isVoidType()) { 5531 Kind = CK_AnyPointerToBlockPointerCast; 5532 return Compatible; 5533 } 5534 5535 return Incompatible; 5536 } 5537 5538 // Conversions to Objective-C pointers. 5539 if (isa<ObjCObjectPointerType>(LHSType)) { 5540 // A* -> B* 5541 if (RHSType->isObjCObjectPointerType()) { 5542 Kind = CK_BitCast; 5543 Sema::AssignConvertType result = 5544 checkObjCPointerTypesForAssignment(*this, LHSType, RHSType); 5545 if (getLangOpts().ObjCAutoRefCount && 5546 result == Compatible && 5547 !CheckObjCARCUnavailableWeakConversion(OrigLHSType, RHSType)) 5548 result = IncompatibleObjCWeakRef; 5549 return result; 5550 } 5551 5552 // int or null -> A* 5553 if (RHSType->isIntegerType()) { 5554 Kind = CK_IntegralToPointer; // FIXME: null 5555 return IntToPointer; 5556 } 5557 5558 // In general, C pointers are not compatible with ObjC object pointers, 5559 // with two exceptions: 5560 if (isa<PointerType>(RHSType)) { 5561 Kind = CK_CPointerToObjCPointerCast; 5562 5563 // - conversions from 'void*' 5564 if (RHSType->isVoidPointerType()) { 5565 return Compatible; 5566 } 5567 5568 // - conversions to 'Class' from its redefinition type 5569 if (LHSType->isObjCClassType() && 5570 Context.hasSameType(RHSType, 5571 Context.getObjCClassRedefinitionType())) { 5572 return Compatible; 5573 } 5574 5575 return IncompatiblePointer; 5576 } 5577 5578 // T^ -> A* 5579 if (RHSType->isBlockPointerType()) { 5580 maybeExtendBlockObject(*this, RHS); 5581 Kind = CK_BlockPointerToObjCPointerCast; 5582 return Compatible; 5583 } 5584 5585 return Incompatible; 5586 } 5587 5588 // Conversions from pointers that are not covered by the above. 5589 if (isa<PointerType>(RHSType)) { 5590 // T* -> _Bool 5591 if (LHSType == Context.BoolTy) { 5592 Kind = CK_PointerToBoolean; 5593 return Compatible; 5594 } 5595 5596 // T* -> int 5597 if (LHSType->isIntegerType()) { 5598 Kind = CK_PointerToIntegral; 5599 return PointerToInt; 5600 } 5601 5602 return Incompatible; 5603 } 5604 5605 // Conversions from Objective-C pointers that are not covered by the above. 5606 if (isa<ObjCObjectPointerType>(RHSType)) { 5607 // T* -> _Bool 5608 if (LHSType == Context.BoolTy) { 5609 Kind = CK_PointerToBoolean; 5610 return Compatible; 5611 } 5612 5613 // T* -> int 5614 if (LHSType->isIntegerType()) { 5615 Kind = CK_PointerToIntegral; 5616 return PointerToInt; 5617 } 5618 5619 return Incompatible; 5620 } 5621 5622 // struct A -> struct B 5623 if (isa<TagType>(LHSType) && isa<TagType>(RHSType)) { 5624 if (Context.typesAreCompatible(LHSType, RHSType)) { 5625 Kind = CK_NoOp; 5626 return Compatible; 5627 } 5628 } 5629 5630 return Incompatible; 5631 } 5632 5633 /// \brief Constructs a transparent union from an expression that is 5634 /// used to initialize the transparent union. 5635 static void ConstructTransparentUnion(Sema &S, ASTContext &C, 5636 ExprResult &EResult, QualType UnionType, 5637 FieldDecl *Field) { 5638 // Build an initializer list that designates the appropriate member 5639 // of the transparent union. 5640 Expr *E = EResult.take(); 5641 InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(), 5642 &E, 1, 5643 SourceLocation()); 5644 Initializer->setType(UnionType); 5645 Initializer->setInitializedFieldInUnion(Field); 5646 5647 // Build a compound literal constructing a value of the transparent 5648 // union type from this initializer list. 5649 TypeSourceInfo *unionTInfo = C.getTrivialTypeSourceInfo(UnionType); 5650 EResult = S.Owned( 5651 new (C) CompoundLiteralExpr(SourceLocation(), unionTInfo, UnionType, 5652 VK_RValue, Initializer, false)); 5653 } 5654 5655 Sema::AssignConvertType 5656 Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, 5657 ExprResult &RHS) { 5658 QualType RHSType = RHS.get()->getType(); 5659 5660 // If the ArgType is a Union type, we want to handle a potential 5661 // transparent_union GCC extension. 5662 const RecordType *UT = ArgType->getAsUnionType(); 5663 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>()) 5664 return Incompatible; 5665 5666 // The field to initialize within the transparent union. 5667 RecordDecl *UD = UT->getDecl(); 5668 FieldDecl *InitField = 0; 5669 // It's compatible if the expression matches any of the fields. 5670 for (RecordDecl::field_iterator it = UD->field_begin(), 5671 itend = UD->field_end(); 5672 it != itend; ++it) { 5673 if (it->getType()->isPointerType()) { 5674 // If the transparent union contains a pointer type, we allow: 5675 // 1) void pointer 5676 // 2) null pointer constant 5677 if (RHSType->isPointerType()) 5678 if (RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) { 5679 RHS = ImpCastExprToType(RHS.take(), it->getType(), CK_BitCast); 5680 InitField = *it; 5681 break; 5682 } 5683 5684 if (RHS.get()->isNullPointerConstant(Context, 5685 Expr::NPC_ValueDependentIsNull)) { 5686 RHS = ImpCastExprToType(RHS.take(), it->getType(), 5687 CK_NullToPointer); 5688 InitField = *it; 5689 break; 5690 } 5691 } 5692 5693 CastKind Kind = CK_Invalid; 5694 if (CheckAssignmentConstraints(it->getType(), RHS, Kind) 5695 == Compatible) { 5696 RHS = ImpCastExprToType(RHS.take(), it->getType(), Kind); 5697 InitField = *it; 5698 break; 5699 } 5700 } 5701 5702 if (!InitField) 5703 return Incompatible; 5704 5705 ConstructTransparentUnion(*this, Context, RHS, ArgType, InitField); 5706 return Compatible; 5707 } 5708 5709 Sema::AssignConvertType 5710 Sema::CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, 5711 bool Diagnose) { 5712 if (getLangOpts().CPlusPlus) { 5713 if (!LHSType->isRecordType() && !LHSType->isAtomicType()) { 5714 // C++ 5.17p3: If the left operand is not of class type, the 5715 // expression is implicitly converted (C++ 4) to the 5716 // cv-unqualified type of the left operand. 5717 ExprResult Res; 5718 if (Diagnose) { 5719 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 5720 AA_Assigning); 5721 } else { 5722 ImplicitConversionSequence ICS = 5723 TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 5724 /*SuppressUserConversions=*/false, 5725 /*AllowExplicit=*/false, 5726 /*InOverloadResolution=*/false, 5727 /*CStyle=*/false, 5728 /*AllowObjCWritebackConversion=*/false); 5729 if (ICS.isFailure()) 5730 return Incompatible; 5731 Res = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(), 5732 ICS, AA_Assigning); 5733 } 5734 if (Res.isInvalid()) 5735 return Incompatible; 5736 Sema::AssignConvertType result = Compatible; 5737 if (getLangOpts().ObjCAutoRefCount && 5738 !CheckObjCARCUnavailableWeakConversion(LHSType, 5739 RHS.get()->getType())) 5740 result = IncompatibleObjCWeakRef; 5741 RHS = move(Res); 5742 return result; 5743 } 5744 5745 // FIXME: Currently, we fall through and treat C++ classes like C 5746 // structures. 5747 // FIXME: We also fall through for atomics; not sure what should 5748 // happen there, though. 5749 } 5750 5751 // C99 6.5.16.1p1: the left operand is a pointer and the right is 5752 // a null pointer constant. 5753 if ((LHSType->isPointerType() || 5754 LHSType->isObjCObjectPointerType() || 5755 LHSType->isBlockPointerType()) 5756 && RHS.get()->isNullPointerConstant(Context, 5757 Expr::NPC_ValueDependentIsNull)) { 5758 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_NullToPointer); 5759 return Compatible; 5760 } 5761 5762 // This check seems unnatural, however it is necessary to ensure the proper 5763 // conversion of functions/arrays. If the conversion were done for all 5764 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary 5765 // expressions that suppress this implicit conversion (&, sizeof). 5766 // 5767 // Suppress this for references: C++ 8.5.3p5. 5768 if (!LHSType->isReferenceType()) { 5769 RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); 5770 if (RHS.isInvalid()) 5771 return Incompatible; 5772 } 5773 5774 CastKind Kind = CK_Invalid; 5775 Sema::AssignConvertType result = 5776 CheckAssignmentConstraints(LHSType, RHS, Kind); 5777 5778 // C99 6.5.16.1p2: The value of the right operand is converted to the 5779 // type of the assignment expression. 5780 // CheckAssignmentConstraints allows the left-hand side to be a reference, 5781 // so that we can use references in built-in functions even in C. 5782 // The getNonReferenceType() call makes sure that the resulting expression 5783 // does not have reference type. 5784 if (result != Incompatible && RHS.get()->getType() != LHSType) 5785 RHS = ImpCastExprToType(RHS.take(), 5786 LHSType.getNonLValueExprType(Context), Kind); 5787 return result; 5788 } 5789 5790 QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &LHS, 5791 ExprResult &RHS) { 5792 Diag(Loc, diag::err_typecheck_invalid_operands) 5793 << LHS.get()->getType() << RHS.get()->getType() 5794 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5795 return QualType(); 5796 } 5797 5798 QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS, 5799 SourceLocation Loc, bool IsCompAssign) { 5800 if (!IsCompAssign) { 5801 LHS = DefaultFunctionArrayLvalueConversion(LHS.take()); 5802 if (LHS.isInvalid()) 5803 return QualType(); 5804 } 5805 RHS = DefaultFunctionArrayLvalueConversion(RHS.take()); 5806 if (RHS.isInvalid()) 5807 return QualType(); 5808 5809 // For conversion purposes, we ignore any qualifiers. 5810 // For example, "const float" and "float" are equivalent. 5811 QualType LHSType = 5812 Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType(); 5813 QualType RHSType = 5814 Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType(); 5815 5816 // If the vector types are identical, return. 5817 if (LHSType == RHSType) 5818 return LHSType; 5819 5820 // Handle the case of equivalent AltiVec and GCC vector types 5821 if (LHSType->isVectorType() && RHSType->isVectorType() && 5822 Context.areCompatibleVectorTypes(LHSType, RHSType)) { 5823 if (LHSType->isExtVectorType()) { 5824 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 5825 return LHSType; 5826 } 5827 5828 if (!IsCompAssign) 5829 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); 5830 return RHSType; 5831 } 5832 5833 if (getLangOpts().LaxVectorConversions && 5834 Context.getTypeSize(LHSType) == Context.getTypeSize(RHSType)) { 5835 // If we are allowing lax vector conversions, and LHS and RHS are both 5836 // vectors, the total size only needs to be the same. This is a 5837 // bitcast; no bits are changed but the result type is different. 5838 // FIXME: Should we really be allowing this? 5839 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 5840 return LHSType; 5841 } 5842 5843 // Canonicalize the ExtVector to the LHS, remember if we swapped so we can 5844 // swap back (so that we don't reverse the inputs to a subtract, for instance. 5845 bool swapped = false; 5846 if (RHSType->isExtVectorType() && !IsCompAssign) { 5847 swapped = true; 5848 std::swap(RHS, LHS); 5849 std::swap(RHSType, LHSType); 5850 } 5851 5852 // Handle the case of an ext vector and scalar. 5853 if (const ExtVectorType *LV = LHSType->getAs<ExtVectorType>()) { 5854 QualType EltTy = LV->getElementType(); 5855 if (EltTy->isIntegralType(Context) && RHSType->isIntegralType(Context)) { 5856 int order = Context.getIntegerTypeOrder(EltTy, RHSType); 5857 if (order > 0) 5858 RHS = ImpCastExprToType(RHS.take(), EltTy, CK_IntegralCast); 5859 if (order >= 0) { 5860 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_VectorSplat); 5861 if (swapped) std::swap(RHS, LHS); 5862 return LHSType; 5863 } 5864 } 5865 if (EltTy->isRealFloatingType() && RHSType->isScalarType() && 5866 RHSType->isRealFloatingType()) { 5867 int order = Context.getFloatingTypeOrder(EltTy, RHSType); 5868 if (order > 0) 5869 RHS = ImpCastExprToType(RHS.take(), EltTy, CK_FloatingCast); 5870 if (order >= 0) { 5871 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_VectorSplat); 5872 if (swapped) std::swap(RHS, LHS); 5873 return LHSType; 5874 } 5875 } 5876 } 5877 5878 // Vectors of different size or scalar and non-ext-vector are errors. 5879 if (swapped) std::swap(RHS, LHS); 5880 Diag(Loc, diag::err_typecheck_vector_not_convertable) 5881 << LHS.get()->getType() << RHS.get()->getType() 5882 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5883 return QualType(); 5884 } 5885 5886 // checkArithmeticNull - Detect when a NULL constant is used improperly in an 5887 // expression. These are mainly cases where the null pointer is used as an 5888 // integer instead of a pointer. 5889 static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS, 5890 SourceLocation Loc, bool IsCompare) { 5891 // The canonical way to check for a GNU null is with isNullPointerConstant, 5892 // but we use a bit of a hack here for speed; this is a relatively 5893 // hot path, and isNullPointerConstant is slow. 5894 bool LHSNull = isa<GNUNullExpr>(LHS.get()->IgnoreParenImpCasts()); 5895 bool RHSNull = isa<GNUNullExpr>(RHS.get()->IgnoreParenImpCasts()); 5896 5897 QualType NonNullType = LHSNull ? RHS.get()->getType() : LHS.get()->getType(); 5898 5899 // Avoid analyzing cases where the result will either be invalid (and 5900 // diagnosed as such) or entirely valid and not something to warn about. 5901 if ((!LHSNull && !RHSNull) || NonNullType->isBlockPointerType() || 5902 NonNullType->isMemberPointerType() || NonNullType->isFunctionType()) 5903 return; 5904 5905 // Comparison operations would not make sense with a null pointer no matter 5906 // what the other expression is. 5907 if (!IsCompare) { 5908 S.Diag(Loc, diag::warn_null_in_arithmetic_operation) 5909 << (LHSNull ? LHS.get()->getSourceRange() : SourceRange()) 5910 << (RHSNull ? RHS.get()->getSourceRange() : SourceRange()); 5911 return; 5912 } 5913 5914 // The rest of the operations only make sense with a null pointer 5915 // if the other expression is a pointer. 5916 if (LHSNull == RHSNull || NonNullType->isAnyPointerType() || 5917 NonNullType->canDecayToPointerType()) 5918 return; 5919 5920 S.Diag(Loc, diag::warn_null_in_comparison_operation) 5921 << LHSNull /* LHS is NULL */ << NonNullType 5922 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 5923 } 5924 5925 QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS, 5926 SourceLocation Loc, 5927 bool IsCompAssign, bool IsDiv) { 5928 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 5929 5930 if (LHS.get()->getType()->isVectorType() || 5931 RHS.get()->getType()->isVectorType()) 5932 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 5933 5934 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign); 5935 if (LHS.isInvalid() || RHS.isInvalid()) 5936 return QualType(); 5937 5938 5939 if (!LHS.get()->getType()->isArithmeticType() || 5940 !RHS.get()->getType()->isArithmeticType()) { 5941 if (IsCompAssign && 5942 LHS.get()->getType()->isAtomicType() && 5943 RHS.get()->getType()->isArithmeticType()) 5944 return compType; 5945 return InvalidOperands(Loc, LHS, RHS); 5946 } 5947 5948 // Check for division by zero. 5949 if (IsDiv && 5950 RHS.get()->isNullPointerConstant(Context, 5951 Expr::NPC_ValueDependentIsNotNull)) 5952 DiagRuntimeBehavior(Loc, RHS.get(), PDiag(diag::warn_division_by_zero) 5953 << RHS.get()->getSourceRange()); 5954 5955 return compType; 5956 } 5957 5958 QualType Sema::CheckRemainderOperands( 5959 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { 5960 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 5961 5962 if (LHS.get()->getType()->isVectorType() || 5963 RHS.get()->getType()->isVectorType()) { 5964 if (LHS.get()->getType()->hasIntegerRepresentation() && 5965 RHS.get()->getType()->hasIntegerRepresentation()) 5966 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 5967 return InvalidOperands(Loc, LHS, RHS); 5968 } 5969 5970 QualType compType = UsualArithmeticConversions(LHS, RHS, IsCompAssign); 5971 if (LHS.isInvalid() || RHS.isInvalid()) 5972 return QualType(); 5973 5974 if (!LHS.get()->getType()->isIntegerType() || 5975 !RHS.get()->getType()->isIntegerType()) 5976 return InvalidOperands(Loc, LHS, RHS); 5977 5978 // Check for remainder by zero. 5979 if (RHS.get()->isNullPointerConstant(Context, 5980 Expr::NPC_ValueDependentIsNotNull)) 5981 DiagRuntimeBehavior(Loc, RHS.get(), PDiag(diag::warn_remainder_by_zero) 5982 << RHS.get()->getSourceRange()); 5983 5984 return compType; 5985 } 5986 5987 /// \brief Diagnose invalid arithmetic on two void pointers. 5988 static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, 5989 Expr *LHSExpr, Expr *RHSExpr) { 5990 S.Diag(Loc, S.getLangOpts().CPlusPlus 5991 ? diag::err_typecheck_pointer_arith_void_type 5992 : diag::ext_gnu_void_ptr) 5993 << 1 /* two pointers */ << LHSExpr->getSourceRange() 5994 << RHSExpr->getSourceRange(); 5995 } 5996 5997 /// \brief Diagnose invalid arithmetic on a void pointer. 5998 static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, 5999 Expr *Pointer) { 6000 S.Diag(Loc, S.getLangOpts().CPlusPlus 6001 ? diag::err_typecheck_pointer_arith_void_type 6002 : diag::ext_gnu_void_ptr) 6003 << 0 /* one pointer */ << Pointer->getSourceRange(); 6004 } 6005 6006 /// \brief Diagnose invalid arithmetic on two function pointers. 6007 static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc, 6008 Expr *LHS, Expr *RHS) { 6009 assert(LHS->getType()->isAnyPointerType()); 6010 assert(RHS->getType()->isAnyPointerType()); 6011 S.Diag(Loc, S.getLangOpts().CPlusPlus 6012 ? diag::err_typecheck_pointer_arith_function_type 6013 : diag::ext_gnu_ptr_func_arith) 6014 << 1 /* two pointers */ << LHS->getType()->getPointeeType() 6015 // We only show the second type if it differs from the first. 6016 << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(), 6017 RHS->getType()) 6018 << RHS->getType()->getPointeeType() 6019 << LHS->getSourceRange() << RHS->getSourceRange(); 6020 } 6021 6022 /// \brief Diagnose invalid arithmetic on a function pointer. 6023 static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc, 6024 Expr *Pointer) { 6025 assert(Pointer->getType()->isAnyPointerType()); 6026 S.Diag(Loc, S.getLangOpts().CPlusPlus 6027 ? diag::err_typecheck_pointer_arith_function_type 6028 : diag::ext_gnu_ptr_func_arith) 6029 << 0 /* one pointer */ << Pointer->getType()->getPointeeType() 6030 << 0 /* one pointer, so only one type */ 6031 << Pointer->getSourceRange(); 6032 } 6033 6034 /// \brief Emit error if Operand is incomplete pointer type 6035 /// 6036 /// \returns True if pointer has incomplete type 6037 static bool checkArithmeticIncompletePointerType(Sema &S, SourceLocation Loc, 6038 Expr *Operand) { 6039 if ((Operand->getType()->isPointerType() && 6040 !Operand->getType()->isDependentType()) || 6041 Operand->getType()->isObjCObjectPointerType()) { 6042 QualType PointeeTy = Operand->getType()->getPointeeType(); 6043 if (S.RequireCompleteType( 6044 Loc, PointeeTy, 6045 S.PDiag(diag::err_typecheck_arithmetic_incomplete_type) 6046 << PointeeTy << Operand->getSourceRange())) 6047 return true; 6048 } 6049 return false; 6050 } 6051 6052 /// \brief Check the validity of an arithmetic pointer operand. 6053 /// 6054 /// If the operand has pointer type, this code will check for pointer types 6055 /// which are invalid in arithmetic operations. These will be diagnosed 6056 /// appropriately, including whether or not the use is supported as an 6057 /// extension. 6058 /// 6059 /// \returns True when the operand is valid to use (even if as an extension). 6060 static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc, 6061 Expr *Operand) { 6062 if (!Operand->getType()->isAnyPointerType()) return true; 6063 6064 QualType PointeeTy = Operand->getType()->getPointeeType(); 6065 if (PointeeTy->isVoidType()) { 6066 diagnoseArithmeticOnVoidPointer(S, Loc, Operand); 6067 return !S.getLangOpts().CPlusPlus; 6068 } 6069 if (PointeeTy->isFunctionType()) { 6070 diagnoseArithmeticOnFunctionPointer(S, Loc, Operand); 6071 return !S.getLangOpts().CPlusPlus; 6072 } 6073 6074 if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false; 6075 6076 return true; 6077 } 6078 6079 /// \brief Check the validity of a binary arithmetic operation w.r.t. pointer 6080 /// operands. 6081 /// 6082 /// This routine will diagnose any invalid arithmetic on pointer operands much 6083 /// like \see checkArithmeticOpPointerOperand. However, it has special logic 6084 /// for emitting a single diagnostic even for operations where both LHS and RHS 6085 /// are (potentially problematic) pointers. 6086 /// 6087 /// \returns True when the operand is valid to use (even if as an extension). 6088 static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc, 6089 Expr *LHSExpr, Expr *RHSExpr) { 6090 bool isLHSPointer = LHSExpr->getType()->isAnyPointerType(); 6091 bool isRHSPointer = RHSExpr->getType()->isAnyPointerType(); 6092 if (!isLHSPointer && !isRHSPointer) return true; 6093 6094 QualType LHSPointeeTy, RHSPointeeTy; 6095 if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType(); 6096 if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType(); 6097 6098 // Check for arithmetic on pointers to incomplete types. 6099 bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType(); 6100 bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType(); 6101 if (isLHSVoidPtr || isRHSVoidPtr) { 6102 if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr); 6103 else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr); 6104 else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr); 6105 6106 return !S.getLangOpts().CPlusPlus; 6107 } 6108 6109 bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType(); 6110 bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType(); 6111 if (isLHSFuncPtr || isRHSFuncPtr) { 6112 if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr); 6113 else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, 6114 RHSExpr); 6115 else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr); 6116 6117 return !S.getLangOpts().CPlusPlus; 6118 } 6119 6120 if (checkArithmeticIncompletePointerType(S, Loc, LHSExpr)) return false; 6121 if (checkArithmeticIncompletePointerType(S, Loc, RHSExpr)) return false; 6122 6123 return true; 6124 } 6125 6126 /// \brief Check bad cases where we step over interface counts. 6127 static bool checkArithmethicPointerOnNonFragileABI(Sema &S, 6128 SourceLocation OpLoc, 6129 Expr *Op) { 6130 assert(Op->getType()->isAnyPointerType()); 6131 QualType PointeeTy = Op->getType()->getPointeeType(); 6132 if (!PointeeTy->isObjCObjectType() || !S.LangOpts.ObjCNonFragileABI) 6133 return true; 6134 6135 S.Diag(OpLoc, diag::err_arithmetic_nonfragile_interface) 6136 << PointeeTy << Op->getSourceRange(); 6137 return false; 6138 } 6139 6140 /// diagnoseStringPlusInt - Emit a warning when adding an integer to a string 6141 /// literal. 6142 static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc, 6143 Expr *LHSExpr, Expr *RHSExpr) { 6144 StringLiteral* StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts()); 6145 Expr* IndexExpr = RHSExpr; 6146 if (!StrExpr) { 6147 StrExpr = dyn_cast<StringLiteral>(RHSExpr->IgnoreImpCasts()); 6148 IndexExpr = LHSExpr; 6149 } 6150 6151 bool IsStringPlusInt = StrExpr && 6152 IndexExpr->getType()->isIntegralOrUnscopedEnumerationType(); 6153 if (!IsStringPlusInt) 6154 return; 6155 6156 llvm::APSInt index; 6157 if (IndexExpr->EvaluateAsInt(index, Self.getASTContext())) { 6158 unsigned StrLenWithNull = StrExpr->getLength() + 1; 6159 if (index.isNonNegative() && 6160 index <= llvm::APSInt(llvm::APInt(index.getBitWidth(), StrLenWithNull), 6161 index.isUnsigned())) 6162 return; 6163 } 6164 6165 SourceRange DiagRange(LHSExpr->getLocStart(), RHSExpr->getLocEnd()); 6166 Self.Diag(OpLoc, diag::warn_string_plus_int) 6167 << DiagRange << IndexExpr->IgnoreImpCasts()->getType(); 6168 6169 // Only print a fixit for "str" + int, not for int + "str". 6170 if (IndexExpr == RHSExpr) { 6171 SourceLocation EndLoc = Self.PP.getLocForEndOfToken(RHSExpr->getLocEnd()); 6172 Self.Diag(OpLoc, diag::note_string_plus_int_silence) 6173 << FixItHint::CreateInsertion(LHSExpr->getLocStart(), "&") 6174 << FixItHint::CreateReplacement(SourceRange(OpLoc), "[") 6175 << FixItHint::CreateInsertion(EndLoc, "]"); 6176 } else 6177 Self.Diag(OpLoc, diag::note_string_plus_int_silence); 6178 } 6179 6180 /// \brief Emit error when two pointers are incompatible. 6181 static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc, 6182 Expr *LHSExpr, Expr *RHSExpr) { 6183 assert(LHSExpr->getType()->isAnyPointerType()); 6184 assert(RHSExpr->getType()->isAnyPointerType()); 6185 S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible) 6186 << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange() 6187 << RHSExpr->getSourceRange(); 6188 } 6189 6190 QualType Sema::CheckAdditionOperands( // C99 6.5.6 6191 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc, 6192 QualType* CompLHSTy) { 6193 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 6194 6195 if (LHS.get()->getType()->isVectorType() || 6196 RHS.get()->getType()->isVectorType()) { 6197 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy); 6198 if (CompLHSTy) *CompLHSTy = compType; 6199 return compType; 6200 } 6201 6202 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy); 6203 if (LHS.isInvalid() || RHS.isInvalid()) 6204 return QualType(); 6205 6206 // Diagnose "string literal" '+' int. 6207 if (Opc == BO_Add) 6208 diagnoseStringPlusInt(*this, Loc, LHS.get(), RHS.get()); 6209 6210 // handle the common case first (both operands are arithmetic). 6211 if (LHS.get()->getType()->isArithmeticType() && 6212 RHS.get()->getType()->isArithmeticType()) { 6213 if (CompLHSTy) *CompLHSTy = compType; 6214 return compType; 6215 } 6216 6217 if (LHS.get()->getType()->isAtomicType() && 6218 RHS.get()->getType()->isArithmeticType()) { 6219 *CompLHSTy = LHS.get()->getType(); 6220 return compType; 6221 } 6222 6223 // Put any potential pointer into PExp 6224 Expr* PExp = LHS.get(), *IExp = RHS.get(); 6225 if (IExp->getType()->isAnyPointerType()) 6226 std::swap(PExp, IExp); 6227 6228 if (!PExp->getType()->isAnyPointerType()) 6229 return InvalidOperands(Loc, LHS, RHS); 6230 6231 if (!IExp->getType()->isIntegerType()) 6232 return InvalidOperands(Loc, LHS, RHS); 6233 6234 if (!checkArithmeticOpPointerOperand(*this, Loc, PExp)) 6235 return QualType(); 6236 6237 // Diagnose bad cases where we step over interface counts. 6238 if (!checkArithmethicPointerOnNonFragileABI(*this, Loc, PExp)) 6239 return QualType(); 6240 6241 // Check array bounds for pointer arithemtic 6242 CheckArrayAccess(PExp, IExp); 6243 6244 if (CompLHSTy) { 6245 QualType LHSTy = Context.isPromotableBitField(LHS.get()); 6246 if (LHSTy.isNull()) { 6247 LHSTy = LHS.get()->getType(); 6248 if (LHSTy->isPromotableIntegerType()) 6249 LHSTy = Context.getPromotedIntegerType(LHSTy); 6250 } 6251 *CompLHSTy = LHSTy; 6252 } 6253 6254 return PExp->getType(); 6255 } 6256 6257 // C99 6.5.6 6258 QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS, 6259 SourceLocation Loc, 6260 QualType* CompLHSTy) { 6261 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 6262 6263 if (LHS.get()->getType()->isVectorType() || 6264 RHS.get()->getType()->isVectorType()) { 6265 QualType compType = CheckVectorOperands(LHS, RHS, Loc, CompLHSTy); 6266 if (CompLHSTy) *CompLHSTy = compType; 6267 return compType; 6268 } 6269 6270 QualType compType = UsualArithmeticConversions(LHS, RHS, CompLHSTy); 6271 if (LHS.isInvalid() || RHS.isInvalid()) 6272 return QualType(); 6273 6274 // Enforce type constraints: C99 6.5.6p3. 6275 6276 // Handle the common case first (both operands are arithmetic). 6277 if (LHS.get()->getType()->isArithmeticType() && 6278 RHS.get()->getType()->isArithmeticType()) { 6279 if (CompLHSTy) *CompLHSTy = compType; 6280 return compType; 6281 } 6282 6283 if (LHS.get()->getType()->isAtomicType() && 6284 RHS.get()->getType()->isArithmeticType()) { 6285 *CompLHSTy = LHS.get()->getType(); 6286 return compType; 6287 } 6288 6289 // Either ptr - int or ptr - ptr. 6290 if (LHS.get()->getType()->isAnyPointerType()) { 6291 QualType lpointee = LHS.get()->getType()->getPointeeType(); 6292 6293 // Diagnose bad cases where we step over interface counts. 6294 if (!checkArithmethicPointerOnNonFragileABI(*this, Loc, LHS.get())) 6295 return QualType(); 6296 6297 // The result type of a pointer-int computation is the pointer type. 6298 if (RHS.get()->getType()->isIntegerType()) { 6299 if (!checkArithmeticOpPointerOperand(*this, Loc, LHS.get())) 6300 return QualType(); 6301 6302 // Check array bounds for pointer arithemtic 6303 CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/0, 6304 /*AllowOnePastEnd*/true, /*IndexNegated*/true); 6305 6306 if (CompLHSTy) *CompLHSTy = LHS.get()->getType(); 6307 return LHS.get()->getType(); 6308 } 6309 6310 // Handle pointer-pointer subtractions. 6311 if (const PointerType *RHSPTy 6312 = RHS.get()->getType()->getAs<PointerType>()) { 6313 QualType rpointee = RHSPTy->getPointeeType(); 6314 6315 if (getLangOpts().CPlusPlus) { 6316 // Pointee types must be the same: C++ [expr.add] 6317 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) { 6318 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get()); 6319 } 6320 } else { 6321 // Pointee types must be compatible C99 6.5.6p3 6322 if (!Context.typesAreCompatible( 6323 Context.getCanonicalType(lpointee).getUnqualifiedType(), 6324 Context.getCanonicalType(rpointee).getUnqualifiedType())) { 6325 diagnosePointerIncompatibility(*this, Loc, LHS.get(), RHS.get()); 6326 return QualType(); 6327 } 6328 } 6329 6330 if (!checkArithmeticBinOpPointerOperands(*this, Loc, 6331 LHS.get(), RHS.get())) 6332 return QualType(); 6333 6334 if (CompLHSTy) *CompLHSTy = LHS.get()->getType(); 6335 return Context.getPointerDiffType(); 6336 } 6337 } 6338 6339 return InvalidOperands(Loc, LHS, RHS); 6340 } 6341 6342 static bool isScopedEnumerationType(QualType T) { 6343 if (const EnumType *ET = dyn_cast<EnumType>(T)) 6344 return ET->getDecl()->isScoped(); 6345 return false; 6346 } 6347 6348 static void DiagnoseBadShiftValues(Sema& S, ExprResult &LHS, ExprResult &RHS, 6349 SourceLocation Loc, unsigned Opc, 6350 QualType LHSType) { 6351 llvm::APSInt Right; 6352 // Check right/shifter operand 6353 if (RHS.get()->isValueDependent() || 6354 !RHS.get()->isIntegerConstantExpr(Right, S.Context)) 6355 return; 6356 6357 if (Right.isNegative()) { 6358 S.DiagRuntimeBehavior(Loc, RHS.get(), 6359 S.PDiag(diag::warn_shift_negative) 6360 << RHS.get()->getSourceRange()); 6361 return; 6362 } 6363 llvm::APInt LeftBits(Right.getBitWidth(), 6364 S.Context.getTypeSize(LHS.get()->getType())); 6365 if (Right.uge(LeftBits)) { 6366 S.DiagRuntimeBehavior(Loc, RHS.get(), 6367 S.PDiag(diag::warn_shift_gt_typewidth) 6368 << RHS.get()->getSourceRange()); 6369 return; 6370 } 6371 if (Opc != BO_Shl) 6372 return; 6373 6374 // When left shifting an ICE which is signed, we can check for overflow which 6375 // according to C++ has undefined behavior ([expr.shift] 5.8/2). Unsigned 6376 // integers have defined behavior modulo one more than the maximum value 6377 // representable in the result type, so never warn for those. 6378 llvm::APSInt Left; 6379 if (LHS.get()->isValueDependent() || 6380 !LHS.get()->isIntegerConstantExpr(Left, S.Context) || 6381 LHSType->hasUnsignedIntegerRepresentation()) 6382 return; 6383 llvm::APInt ResultBits = 6384 static_cast<llvm::APInt&>(Right) + Left.getMinSignedBits(); 6385 if (LeftBits.uge(ResultBits)) 6386 return; 6387 llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue()); 6388 Result = Result.shl(Right); 6389 6390 // Print the bit representation of the signed integer as an unsigned 6391 // hexadecimal number. 6392 SmallString<40> HexResult; 6393 Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true); 6394 6395 // If we are only missing a sign bit, this is less likely to result in actual 6396 // bugs -- if the result is cast back to an unsigned type, it will have the 6397 // expected value. Thus we place this behind a different warning that can be 6398 // turned off separately if needed. 6399 if (LeftBits == ResultBits - 1) { 6400 S.Diag(Loc, diag::warn_shift_result_sets_sign_bit) 6401 << HexResult.str() << LHSType 6402 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6403 return; 6404 } 6405 6406 S.Diag(Loc, diag::warn_shift_result_gt_typewidth) 6407 << HexResult.str() << Result.getMinSignedBits() << LHSType 6408 << Left.getBitWidth() << LHS.get()->getSourceRange() 6409 << RHS.get()->getSourceRange(); 6410 } 6411 6412 // C99 6.5.7 6413 QualType Sema::CheckShiftOperands(ExprResult &LHS, ExprResult &RHS, 6414 SourceLocation Loc, unsigned Opc, 6415 bool IsCompAssign) { 6416 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 6417 6418 // C99 6.5.7p2: Each of the operands shall have integer type. 6419 if (!LHS.get()->getType()->hasIntegerRepresentation() || 6420 !RHS.get()->getType()->hasIntegerRepresentation()) 6421 return InvalidOperands(Loc, LHS, RHS); 6422 6423 // C++0x: Don't allow scoped enums. FIXME: Use something better than 6424 // hasIntegerRepresentation() above instead of this. 6425 if (isScopedEnumerationType(LHS.get()->getType()) || 6426 isScopedEnumerationType(RHS.get()->getType())) { 6427 return InvalidOperands(Loc, LHS, RHS); 6428 } 6429 6430 // Vector shifts promote their scalar inputs to vector type. 6431 if (LHS.get()->getType()->isVectorType() || 6432 RHS.get()->getType()->isVectorType()) 6433 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 6434 6435 // Shifts don't perform usual arithmetic conversions, they just do integer 6436 // promotions on each operand. C99 6.5.7p3 6437 6438 // For the LHS, do usual unary conversions, but then reset them away 6439 // if this is a compound assignment. 6440 ExprResult OldLHS = LHS; 6441 LHS = UsualUnaryConversions(LHS.take()); 6442 if (LHS.isInvalid()) 6443 return QualType(); 6444 QualType LHSType = LHS.get()->getType(); 6445 if (IsCompAssign) LHS = OldLHS; 6446 6447 // The RHS is simpler. 6448 RHS = UsualUnaryConversions(RHS.take()); 6449 if (RHS.isInvalid()) 6450 return QualType(); 6451 6452 // Sanity-check shift operands 6453 DiagnoseBadShiftValues(*this, LHS, RHS, Loc, Opc, LHSType); 6454 6455 // "The type of the result is that of the promoted left operand." 6456 return LHSType; 6457 } 6458 6459 static bool IsWithinTemplateSpecialization(Decl *D) { 6460 if (DeclContext *DC = D->getDeclContext()) { 6461 if (isa<ClassTemplateSpecializationDecl>(DC)) 6462 return true; 6463 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DC)) 6464 return FD->isFunctionTemplateSpecialization(); 6465 } 6466 return false; 6467 } 6468 6469 /// If two different enums are compared, raise a warning. 6470 static void checkEnumComparison(Sema &S, SourceLocation Loc, ExprResult &LHS, 6471 ExprResult &RHS) { 6472 QualType LHSStrippedType = LHS.get()->IgnoreParenImpCasts()->getType(); 6473 QualType RHSStrippedType = RHS.get()->IgnoreParenImpCasts()->getType(); 6474 6475 const EnumType *LHSEnumType = LHSStrippedType->getAs<EnumType>(); 6476 if (!LHSEnumType) 6477 return; 6478 const EnumType *RHSEnumType = RHSStrippedType->getAs<EnumType>(); 6479 if (!RHSEnumType) 6480 return; 6481 6482 // Ignore anonymous enums. 6483 if (!LHSEnumType->getDecl()->getIdentifier()) 6484 return; 6485 if (!RHSEnumType->getDecl()->getIdentifier()) 6486 return; 6487 6488 if (S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType)) 6489 return; 6490 6491 S.Diag(Loc, diag::warn_comparison_of_mixed_enum_types) 6492 << LHSStrippedType << RHSStrippedType 6493 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6494 } 6495 6496 /// \brief Diagnose bad pointer comparisons. 6497 static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc, 6498 ExprResult &LHS, ExprResult &RHS, 6499 bool IsError) { 6500 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers 6501 : diag::ext_typecheck_comparison_of_distinct_pointers) 6502 << LHS.get()->getType() << RHS.get()->getType() 6503 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6504 } 6505 6506 /// \brief Returns false if the pointers are converted to a composite type, 6507 /// true otherwise. 6508 static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc, 6509 ExprResult &LHS, ExprResult &RHS) { 6510 // C++ [expr.rel]p2: 6511 // [...] Pointer conversions (4.10) and qualification 6512 // conversions (4.4) are performed on pointer operands (or on 6513 // a pointer operand and a null pointer constant) to bring 6514 // them to their composite pointer type. [...] 6515 // 6516 // C++ [expr.eq]p1 uses the same notion for (in)equality 6517 // comparisons of pointers. 6518 6519 // C++ [expr.eq]p2: 6520 // In addition, pointers to members can be compared, or a pointer to 6521 // member and a null pointer constant. Pointer to member conversions 6522 // (4.11) and qualification conversions (4.4) are performed to bring 6523 // them to a common type. If one operand is a null pointer constant, 6524 // the common type is the type of the other operand. Otherwise, the 6525 // common type is a pointer to member type similar (4.4) to the type 6526 // of one of the operands, with a cv-qualification signature (4.4) 6527 // that is the union of the cv-qualification signatures of the operand 6528 // types. 6529 6530 QualType LHSType = LHS.get()->getType(); 6531 QualType RHSType = RHS.get()->getType(); 6532 assert((LHSType->isPointerType() && RHSType->isPointerType()) || 6533 (LHSType->isMemberPointerType() && RHSType->isMemberPointerType())); 6534 6535 bool NonStandardCompositeType = false; 6536 bool *BoolPtr = S.isSFINAEContext() ? 0 : &NonStandardCompositeType; 6537 QualType T = S.FindCompositePointerType(Loc, LHS, RHS, BoolPtr); 6538 if (T.isNull()) { 6539 diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true); 6540 return true; 6541 } 6542 6543 if (NonStandardCompositeType) 6544 S.Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers_nonstandard) 6545 << LHSType << RHSType << T << LHS.get()->getSourceRange() 6546 << RHS.get()->getSourceRange(); 6547 6548 LHS = S.ImpCastExprToType(LHS.take(), T, CK_BitCast); 6549 RHS = S.ImpCastExprToType(RHS.take(), T, CK_BitCast); 6550 return false; 6551 } 6552 6553 static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc, 6554 ExprResult &LHS, 6555 ExprResult &RHS, 6556 bool IsError) { 6557 S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void 6558 : diag::ext_typecheck_comparison_of_fptr_to_void) 6559 << LHS.get()->getType() << RHS.get()->getType() 6560 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6561 } 6562 6563 // C99 6.5.8, C++ [expr.rel] 6564 QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS, 6565 SourceLocation Loc, unsigned OpaqueOpc, 6566 bool IsRelational) { 6567 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/true); 6568 6569 BinaryOperatorKind Opc = (BinaryOperatorKind) OpaqueOpc; 6570 6571 // Handle vector comparisons separately. 6572 if (LHS.get()->getType()->isVectorType() || 6573 RHS.get()->getType()->isVectorType()) 6574 return CheckVectorCompareOperands(LHS, RHS, Loc, IsRelational); 6575 6576 QualType LHSType = LHS.get()->getType(); 6577 QualType RHSType = RHS.get()->getType(); 6578 6579 Expr *LHSStripped = LHS.get()->IgnoreParenImpCasts(); 6580 Expr *RHSStripped = RHS.get()->IgnoreParenImpCasts(); 6581 6582 checkEnumComparison(*this, Loc, LHS, RHS); 6583 6584 if (!LHSType->hasFloatingRepresentation() && 6585 !(LHSType->isBlockPointerType() && IsRelational) && 6586 !LHS.get()->getLocStart().isMacroID() && 6587 !RHS.get()->getLocStart().isMacroID()) { 6588 // For non-floating point types, check for self-comparisons of the form 6589 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 6590 // often indicate logic errors in the program. 6591 // 6592 // NOTE: Don't warn about comparison expressions resulting from macro 6593 // expansion. Also don't warn about comparisons which are only self 6594 // comparisons within a template specialization. The warnings should catch 6595 // obvious cases in the definition of the template anyways. The idea is to 6596 // warn when the typed comparison operator will always evaluate to the same 6597 // result. 6598 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHSStripped)) { 6599 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHSStripped)) { 6600 if (DRL->getDecl() == DRR->getDecl() && 6601 !IsWithinTemplateSpecialization(DRL->getDecl())) { 6602 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always) 6603 << 0 // self- 6604 << (Opc == BO_EQ 6605 || Opc == BO_LE 6606 || Opc == BO_GE)); 6607 } else if (LHSType->isArrayType() && RHSType->isArrayType() && 6608 !DRL->getDecl()->getType()->isReferenceType() && 6609 !DRR->getDecl()->getType()->isReferenceType()) { 6610 // what is it always going to eval to? 6611 char always_evals_to; 6612 switch(Opc) { 6613 case BO_EQ: // e.g. array1 == array2 6614 always_evals_to = 0; // false 6615 break; 6616 case BO_NE: // e.g. array1 != array2 6617 always_evals_to = 1; // true 6618 break; 6619 default: 6620 // best we can say is 'a constant' 6621 always_evals_to = 2; // e.g. array1 <= array2 6622 break; 6623 } 6624 DiagRuntimeBehavior(Loc, 0, PDiag(diag::warn_comparison_always) 6625 << 1 // array 6626 << always_evals_to); 6627 } 6628 } 6629 } 6630 6631 if (isa<CastExpr>(LHSStripped)) 6632 LHSStripped = LHSStripped->IgnoreParenCasts(); 6633 if (isa<CastExpr>(RHSStripped)) 6634 RHSStripped = RHSStripped->IgnoreParenCasts(); 6635 6636 // Warn about comparisons against a string constant (unless the other 6637 // operand is null), the user probably wants strcmp. 6638 Expr *literalString = 0; 6639 Expr *literalStringStripped = 0; 6640 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) && 6641 !RHSStripped->isNullPointerConstant(Context, 6642 Expr::NPC_ValueDependentIsNull)) { 6643 literalString = LHS.get(); 6644 literalStringStripped = LHSStripped; 6645 } else if ((isa<StringLiteral>(RHSStripped) || 6646 isa<ObjCEncodeExpr>(RHSStripped)) && 6647 !LHSStripped->isNullPointerConstant(Context, 6648 Expr::NPC_ValueDependentIsNull)) { 6649 literalString = RHS.get(); 6650 literalStringStripped = RHSStripped; 6651 } 6652 6653 if (literalString) { 6654 std::string resultComparison; 6655 switch (Opc) { 6656 case BO_LT: resultComparison = ") < 0"; break; 6657 case BO_GT: resultComparison = ") > 0"; break; 6658 case BO_LE: resultComparison = ") <= 0"; break; 6659 case BO_GE: resultComparison = ") >= 0"; break; 6660 case BO_EQ: resultComparison = ") == 0"; break; 6661 case BO_NE: resultComparison = ") != 0"; break; 6662 default: llvm_unreachable("Invalid comparison operator"); 6663 } 6664 6665 DiagRuntimeBehavior(Loc, 0, 6666 PDiag(diag::warn_stringcompare) 6667 << isa<ObjCEncodeExpr>(literalStringStripped) 6668 << literalString->getSourceRange()); 6669 } 6670 } 6671 6672 // C99 6.5.8p3 / C99 6.5.9p4 6673 if (LHS.get()->getType()->isArithmeticType() && 6674 RHS.get()->getType()->isArithmeticType()) { 6675 UsualArithmeticConversions(LHS, RHS); 6676 if (LHS.isInvalid() || RHS.isInvalid()) 6677 return QualType(); 6678 } 6679 else { 6680 LHS = UsualUnaryConversions(LHS.take()); 6681 if (LHS.isInvalid()) 6682 return QualType(); 6683 6684 RHS = UsualUnaryConversions(RHS.take()); 6685 if (RHS.isInvalid()) 6686 return QualType(); 6687 } 6688 6689 LHSType = LHS.get()->getType(); 6690 RHSType = RHS.get()->getType(); 6691 6692 // The result of comparisons is 'bool' in C++, 'int' in C. 6693 QualType ResultTy = Context.getLogicalOperationType(); 6694 6695 if (IsRelational) { 6696 if (LHSType->isRealType() && RHSType->isRealType()) 6697 return ResultTy; 6698 } else { 6699 // Check for comparisons of floating point operands using != and ==. 6700 if (LHSType->hasFloatingRepresentation()) 6701 CheckFloatComparison(Loc, LHS.get(), RHS.get()); 6702 6703 if (LHSType->isArithmeticType() && RHSType->isArithmeticType()) 6704 return ResultTy; 6705 } 6706 6707 bool LHSIsNull = LHS.get()->isNullPointerConstant(Context, 6708 Expr::NPC_ValueDependentIsNull); 6709 bool RHSIsNull = RHS.get()->isNullPointerConstant(Context, 6710 Expr::NPC_ValueDependentIsNull); 6711 6712 // All of the following pointer-related warnings are GCC extensions, except 6713 // when handling null pointer constants. 6714 if (LHSType->isPointerType() && RHSType->isPointerType()) { // C99 6.5.8p2 6715 QualType LCanPointeeTy = 6716 LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType(); 6717 QualType RCanPointeeTy = 6718 RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType(); 6719 6720 if (getLangOpts().CPlusPlus) { 6721 if (LCanPointeeTy == RCanPointeeTy) 6722 return ResultTy; 6723 if (!IsRelational && 6724 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 6725 // Valid unless comparison between non-null pointer and function pointer 6726 // This is a gcc extension compatibility comparison. 6727 // In a SFINAE context, we treat this as a hard error to maintain 6728 // conformance with the C++ standard. 6729 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 6730 && !LHSIsNull && !RHSIsNull) { 6731 diagnoseFunctionPointerToVoidComparison( 6732 *this, Loc, LHS, RHS, /*isError*/ isSFINAEContext()); 6733 6734 if (isSFINAEContext()) 6735 return QualType(); 6736 6737 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 6738 return ResultTy; 6739 } 6740 } 6741 6742 if (convertPointersToCompositeType(*this, Loc, LHS, RHS)) 6743 return QualType(); 6744 else 6745 return ResultTy; 6746 } 6747 // C99 6.5.9p2 and C99 6.5.8p2 6748 if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(), 6749 RCanPointeeTy.getUnqualifiedType())) { 6750 // Valid unless a relational comparison of function pointers 6751 if (IsRelational && LCanPointeeTy->isFunctionType()) { 6752 Diag(Loc, diag::ext_typecheck_ordered_comparison_of_function_pointers) 6753 << LHSType << RHSType << LHS.get()->getSourceRange() 6754 << RHS.get()->getSourceRange(); 6755 } 6756 } else if (!IsRelational && 6757 (LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) { 6758 // Valid unless comparison between non-null pointer and function pointer 6759 if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType()) 6760 && !LHSIsNull && !RHSIsNull) 6761 diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS, 6762 /*isError*/false); 6763 } else { 6764 // Invalid 6765 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false); 6766 } 6767 if (LCanPointeeTy != RCanPointeeTy) { 6768 if (LHSIsNull && !RHSIsNull) 6769 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); 6770 else 6771 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 6772 } 6773 return ResultTy; 6774 } 6775 6776 if (getLangOpts().CPlusPlus) { 6777 // Comparison of nullptr_t with itself. 6778 if (LHSType->isNullPtrType() && RHSType->isNullPtrType()) 6779 return ResultTy; 6780 6781 // Comparison of pointers with null pointer constants and equality 6782 // comparisons of member pointers to null pointer constants. 6783 if (RHSIsNull && 6784 ((LHSType->isAnyPointerType() || LHSType->isNullPtrType()) || 6785 (!IsRelational && 6786 (LHSType->isMemberPointerType() || LHSType->isBlockPointerType())))) { 6787 RHS = ImpCastExprToType(RHS.take(), LHSType, 6788 LHSType->isMemberPointerType() 6789 ? CK_NullToMemberPointer 6790 : CK_NullToPointer); 6791 return ResultTy; 6792 } 6793 if (LHSIsNull && 6794 ((RHSType->isAnyPointerType() || RHSType->isNullPtrType()) || 6795 (!IsRelational && 6796 (RHSType->isMemberPointerType() || RHSType->isBlockPointerType())))) { 6797 LHS = ImpCastExprToType(LHS.take(), RHSType, 6798 RHSType->isMemberPointerType() 6799 ? CK_NullToMemberPointer 6800 : CK_NullToPointer); 6801 return ResultTy; 6802 } 6803 6804 // Comparison of member pointers. 6805 if (!IsRelational && 6806 LHSType->isMemberPointerType() && RHSType->isMemberPointerType()) { 6807 if (convertPointersToCompositeType(*this, Loc, LHS, RHS)) 6808 return QualType(); 6809 else 6810 return ResultTy; 6811 } 6812 6813 // Handle scoped enumeration types specifically, since they don't promote 6814 // to integers. 6815 if (LHS.get()->getType()->isEnumeralType() && 6816 Context.hasSameUnqualifiedType(LHS.get()->getType(), 6817 RHS.get()->getType())) 6818 return ResultTy; 6819 } 6820 6821 // Handle block pointer types. 6822 if (!IsRelational && LHSType->isBlockPointerType() && 6823 RHSType->isBlockPointerType()) { 6824 QualType lpointee = LHSType->castAs<BlockPointerType>()->getPointeeType(); 6825 QualType rpointee = RHSType->castAs<BlockPointerType>()->getPointeeType(); 6826 6827 if (!LHSIsNull && !RHSIsNull && 6828 !Context.typesAreCompatible(lpointee, rpointee)) { 6829 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 6830 << LHSType << RHSType << LHS.get()->getSourceRange() 6831 << RHS.get()->getSourceRange(); 6832 } 6833 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 6834 return ResultTy; 6835 } 6836 6837 // Allow block pointers to be compared with null pointer constants. 6838 if (!IsRelational 6839 && ((LHSType->isBlockPointerType() && RHSType->isPointerType()) 6840 || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) { 6841 if (!LHSIsNull && !RHSIsNull) { 6842 if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>() 6843 ->getPointeeType()->isVoidType()) 6844 || (LHSType->isPointerType() && LHSType->castAs<PointerType>() 6845 ->getPointeeType()->isVoidType()))) 6846 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 6847 << LHSType << RHSType << LHS.get()->getSourceRange() 6848 << RHS.get()->getSourceRange(); 6849 } 6850 if (LHSIsNull && !RHSIsNull) 6851 LHS = ImpCastExprToType(LHS.take(), RHSType, 6852 RHSType->isPointerType() ? CK_BitCast 6853 : CK_AnyPointerToBlockPointerCast); 6854 else 6855 RHS = ImpCastExprToType(RHS.take(), LHSType, 6856 LHSType->isPointerType() ? CK_BitCast 6857 : CK_AnyPointerToBlockPointerCast); 6858 return ResultTy; 6859 } 6860 6861 if (LHSType->isObjCObjectPointerType() || 6862 RHSType->isObjCObjectPointerType()) { 6863 const PointerType *LPT = LHSType->getAs<PointerType>(); 6864 const PointerType *RPT = RHSType->getAs<PointerType>(); 6865 if (LPT || RPT) { 6866 bool LPtrToVoid = LPT ? LPT->getPointeeType()->isVoidType() : false; 6867 bool RPtrToVoid = RPT ? RPT->getPointeeType()->isVoidType() : false; 6868 6869 if (!LPtrToVoid && !RPtrToVoid && 6870 !Context.typesAreCompatible(LHSType, RHSType)) { 6871 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, 6872 /*isError*/false); 6873 } 6874 if (LHSIsNull && !RHSIsNull) 6875 LHS = ImpCastExprToType(LHS.take(), RHSType, 6876 RPT ? CK_BitCast :CK_CPointerToObjCPointerCast); 6877 else 6878 RHS = ImpCastExprToType(RHS.take(), LHSType, 6879 LPT ? CK_BitCast :CK_CPointerToObjCPointerCast); 6880 return ResultTy; 6881 } 6882 if (LHSType->isObjCObjectPointerType() && 6883 RHSType->isObjCObjectPointerType()) { 6884 if (!Context.areComparableObjCPointerTypes(LHSType, RHSType)) 6885 diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, 6886 /*isError*/false); 6887 if (LHSIsNull && !RHSIsNull) 6888 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_BitCast); 6889 else 6890 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_BitCast); 6891 return ResultTy; 6892 } 6893 } 6894 if ((LHSType->isAnyPointerType() && RHSType->isIntegerType()) || 6895 (LHSType->isIntegerType() && RHSType->isAnyPointerType())) { 6896 unsigned DiagID = 0; 6897 bool isError = false; 6898 if ((LHSIsNull && LHSType->isIntegerType()) || 6899 (RHSIsNull && RHSType->isIntegerType())) { 6900 if (IsRelational && !getLangOpts().CPlusPlus) 6901 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_and_zero; 6902 } else if (IsRelational && !getLangOpts().CPlusPlus) 6903 DiagID = diag::ext_typecheck_ordered_comparison_of_pointer_integer; 6904 else if (getLangOpts().CPlusPlus) { 6905 DiagID = diag::err_typecheck_comparison_of_pointer_integer; 6906 isError = true; 6907 } else 6908 DiagID = diag::ext_typecheck_comparison_of_pointer_integer; 6909 6910 if (DiagID) { 6911 Diag(Loc, DiagID) 6912 << LHSType << RHSType << LHS.get()->getSourceRange() 6913 << RHS.get()->getSourceRange(); 6914 if (isError) 6915 return QualType(); 6916 } 6917 6918 if (LHSType->isIntegerType()) 6919 LHS = ImpCastExprToType(LHS.take(), RHSType, 6920 LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 6921 else 6922 RHS = ImpCastExprToType(RHS.take(), LHSType, 6923 RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer); 6924 return ResultTy; 6925 } 6926 6927 // Handle block pointers. 6928 if (!IsRelational && RHSIsNull 6929 && LHSType->isBlockPointerType() && RHSType->isIntegerType()) { 6930 RHS = ImpCastExprToType(RHS.take(), LHSType, CK_NullToPointer); 6931 return ResultTy; 6932 } 6933 if (!IsRelational && LHSIsNull 6934 && LHSType->isIntegerType() && RHSType->isBlockPointerType()) { 6935 LHS = ImpCastExprToType(LHS.take(), RHSType, CK_NullToPointer); 6936 return ResultTy; 6937 } 6938 6939 return InvalidOperands(Loc, LHS, RHS); 6940 } 6941 6942 6943 // Return a signed type that is of identical size and number of elements. 6944 // For floating point vectors, return an integer type of identical size 6945 // and number of elements. 6946 QualType Sema::GetSignedVectorType(QualType V) { 6947 const VectorType *VTy = V->getAs<VectorType>(); 6948 unsigned TypeSize = Context.getTypeSize(VTy->getElementType()); 6949 if (TypeSize == Context.getTypeSize(Context.CharTy)) 6950 return Context.getExtVectorType(Context.CharTy, VTy->getNumElements()); 6951 else if (TypeSize == Context.getTypeSize(Context.ShortTy)) 6952 return Context.getExtVectorType(Context.ShortTy, VTy->getNumElements()); 6953 else if (TypeSize == Context.getTypeSize(Context.IntTy)) 6954 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements()); 6955 else if (TypeSize == Context.getTypeSize(Context.LongTy)) 6956 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements()); 6957 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) && 6958 "Unhandled vector element size in vector compare"); 6959 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements()); 6960 } 6961 6962 /// CheckVectorCompareOperands - vector comparisons are a clang extension that 6963 /// operates on extended vector types. Instead of producing an IntTy result, 6964 /// like a scalar comparison, a vector comparison produces a vector of integer 6965 /// types. 6966 QualType Sema::CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS, 6967 SourceLocation Loc, 6968 bool IsRelational) { 6969 // Check to make sure we're operating on vectors of the same type and width, 6970 // Allowing one side to be a scalar of element type. 6971 QualType vType = CheckVectorOperands(LHS, RHS, Loc, /*isCompAssign*/false); 6972 if (vType.isNull()) 6973 return vType; 6974 6975 QualType LHSType = LHS.get()->getType(); 6976 6977 // If AltiVec, the comparison results in a numeric type, i.e. 6978 // bool for C++, int for C 6979 if (vType->getAs<VectorType>()->getVectorKind() == VectorType::AltiVecVector) 6980 return Context.getLogicalOperationType(); 6981 6982 // For non-floating point types, check for self-comparisons of the form 6983 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 6984 // often indicate logic errors in the program. 6985 if (!LHSType->hasFloatingRepresentation()) { 6986 if (DeclRefExpr* DRL 6987 = dyn_cast<DeclRefExpr>(LHS.get()->IgnoreParenImpCasts())) 6988 if (DeclRefExpr* DRR 6989 = dyn_cast<DeclRefExpr>(RHS.get()->IgnoreParenImpCasts())) 6990 if (DRL->getDecl() == DRR->getDecl()) 6991 DiagRuntimeBehavior(Loc, 0, 6992 PDiag(diag::warn_comparison_always) 6993 << 0 // self- 6994 << 2 // "a constant" 6995 ); 6996 } 6997 6998 // Check for comparisons of floating point operands using != and ==. 6999 if (!IsRelational && LHSType->hasFloatingRepresentation()) { 7000 assert (RHS.get()->getType()->hasFloatingRepresentation()); 7001 CheckFloatComparison(Loc, LHS.get(), RHS.get()); 7002 } 7003 7004 // Return a signed type for the vector. 7005 return GetSignedVectorType(LHSType); 7006 } 7007 7008 QualType Sema::CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS, 7009 SourceLocation Loc) { 7010 // Ensure that either both operands are of the same vector type, or 7011 // one operand is of a vector type and the other is of its element type. 7012 QualType vType = CheckVectorOperands(LHS, RHS, Loc, false); 7013 if (vType.isNull() || vType->isFloatingType()) 7014 return InvalidOperands(Loc, LHS, RHS); 7015 7016 return GetSignedVectorType(LHS.get()->getType()); 7017 } 7018 7019 inline QualType Sema::CheckBitwiseOperands( 7020 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) { 7021 checkArithmeticNull(*this, LHS, RHS, Loc, /*isCompare=*/false); 7022 7023 if (LHS.get()->getType()->isVectorType() || 7024 RHS.get()->getType()->isVectorType()) { 7025 if (LHS.get()->getType()->hasIntegerRepresentation() && 7026 RHS.get()->getType()->hasIntegerRepresentation()) 7027 return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign); 7028 7029 return InvalidOperands(Loc, LHS, RHS); 7030 } 7031 7032 ExprResult LHSResult = Owned(LHS), RHSResult = Owned(RHS); 7033 QualType compType = UsualArithmeticConversions(LHSResult, RHSResult, 7034 IsCompAssign); 7035 if (LHSResult.isInvalid() || RHSResult.isInvalid()) 7036 return QualType(); 7037 LHS = LHSResult.take(); 7038 RHS = RHSResult.take(); 7039 7040 if (LHS.get()->getType()->isIntegralOrUnscopedEnumerationType() && 7041 RHS.get()->getType()->isIntegralOrUnscopedEnumerationType()) 7042 return compType; 7043 return InvalidOperands(Loc, LHS, RHS); 7044 } 7045 7046 inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14] 7047 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, unsigned Opc) { 7048 7049 // Check vector operands differently. 7050 if (LHS.get()->getType()->isVectorType() || RHS.get()->getType()->isVectorType()) 7051 return CheckVectorLogicalOperands(LHS, RHS, Loc); 7052 7053 // Diagnose cases where the user write a logical and/or but probably meant a 7054 // bitwise one. We do this when the LHS is a non-bool integer and the RHS 7055 // is a constant. 7056 if (LHS.get()->getType()->isIntegerType() && 7057 !LHS.get()->getType()->isBooleanType() && 7058 RHS.get()->getType()->isIntegerType() && !RHS.get()->isValueDependent() && 7059 // Don't warn in macros or template instantiations. 7060 !Loc.isMacroID() && ActiveTemplateInstantiations.empty()) { 7061 // If the RHS can be constant folded, and if it constant folds to something 7062 // that isn't 0 or 1 (which indicate a potential logical operation that 7063 // happened to fold to true/false) then warn. 7064 // Parens on the RHS are ignored. 7065 llvm::APSInt Result; 7066 if (RHS.get()->EvaluateAsInt(Result, Context)) 7067 if ((getLangOpts().Bool && !RHS.get()->getType()->isBooleanType()) || 7068 (Result != 0 && Result != 1)) { 7069 Diag(Loc, diag::warn_logical_instead_of_bitwise) 7070 << RHS.get()->getSourceRange() 7071 << (Opc == BO_LAnd ? "&&" : "||"); 7072 // Suggest replacing the logical operator with the bitwise version 7073 Diag(Loc, diag::note_logical_instead_of_bitwise_change_operator) 7074 << (Opc == BO_LAnd ? "&" : "|") 7075 << FixItHint::CreateReplacement(SourceRange( 7076 Loc, Lexer::getLocForEndOfToken(Loc, 0, getSourceManager(), 7077 getLangOpts())), 7078 Opc == BO_LAnd ? "&" : "|"); 7079 if (Opc == BO_LAnd) 7080 // Suggest replacing "Foo() && kNonZero" with "Foo()" 7081 Diag(Loc, diag::note_logical_instead_of_bitwise_remove_constant) 7082 << FixItHint::CreateRemoval( 7083 SourceRange( 7084 Lexer::getLocForEndOfToken(LHS.get()->getLocEnd(), 7085 0, getSourceManager(), 7086 getLangOpts()), 7087 RHS.get()->getLocEnd())); 7088 } 7089 } 7090 7091 if (!Context.getLangOpts().CPlusPlus) { 7092 LHS = UsualUnaryConversions(LHS.take()); 7093 if (LHS.isInvalid()) 7094 return QualType(); 7095 7096 RHS = UsualUnaryConversions(RHS.take()); 7097 if (RHS.isInvalid()) 7098 return QualType(); 7099 7100 if (!LHS.get()->getType()->isScalarType() || 7101 !RHS.get()->getType()->isScalarType()) 7102 return InvalidOperands(Loc, LHS, RHS); 7103 7104 return Context.IntTy; 7105 } 7106 7107 // The following is safe because we only use this method for 7108 // non-overloadable operands. 7109 7110 // C++ [expr.log.and]p1 7111 // C++ [expr.log.or]p1 7112 // The operands are both contextually converted to type bool. 7113 ExprResult LHSRes = PerformContextuallyConvertToBool(LHS.get()); 7114 if (LHSRes.isInvalid()) 7115 return InvalidOperands(Loc, LHS, RHS); 7116 LHS = move(LHSRes); 7117 7118 ExprResult RHSRes = PerformContextuallyConvertToBool(RHS.get()); 7119 if (RHSRes.isInvalid()) 7120 return InvalidOperands(Loc, LHS, RHS); 7121 RHS = move(RHSRes); 7122 7123 // C++ [expr.log.and]p2 7124 // C++ [expr.log.or]p2 7125 // The result is a bool. 7126 return Context.BoolTy; 7127 } 7128 7129 /// IsReadonlyProperty - Verify that otherwise a valid l-value expression 7130 /// is a read-only property; return true if so. A readonly property expression 7131 /// depends on various declarations and thus must be treated specially. 7132 /// 7133 static bool IsReadonlyProperty(Expr *E, Sema &S) { 7134 const ObjCPropertyRefExpr *PropExpr = dyn_cast<ObjCPropertyRefExpr>(E); 7135 if (!PropExpr) return false; 7136 if (PropExpr->isImplicitProperty()) return false; 7137 7138 ObjCPropertyDecl *PDecl = PropExpr->getExplicitProperty(); 7139 QualType BaseType = PropExpr->isSuperReceiver() ? 7140 PropExpr->getSuperReceiverType() : 7141 PropExpr->getBase()->getType(); 7142 7143 if (const ObjCObjectPointerType *OPT = 7144 BaseType->getAsObjCInterfacePointerType()) 7145 if (ObjCInterfaceDecl *IFace = OPT->getInterfaceDecl()) 7146 if (S.isPropertyReadonly(PDecl, IFace)) 7147 return true; 7148 return false; 7149 } 7150 7151 static bool IsReadonlyMessage(Expr *E, Sema &S) { 7152 const MemberExpr *ME = dyn_cast<MemberExpr>(E); 7153 if (!ME) return false; 7154 if (!isa<FieldDecl>(ME->getMemberDecl())) return false; 7155 ObjCMessageExpr *Base = 7156 dyn_cast<ObjCMessageExpr>(ME->getBase()->IgnoreParenImpCasts()); 7157 if (!Base) return false; 7158 return Base->getMethodDecl() != 0; 7159 } 7160 7161 /// Is the given expression (which must be 'const') a reference to a 7162 /// variable which was originally non-const, but which has become 7163 /// 'const' due to being captured within a block? 7164 enum NonConstCaptureKind { NCCK_None, NCCK_Block, NCCK_Lambda }; 7165 static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) { 7166 assert(E->isLValue() && E->getType().isConstQualified()); 7167 E = E->IgnoreParens(); 7168 7169 // Must be a reference to a declaration from an enclosing scope. 7170 DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 7171 if (!DRE) return NCCK_None; 7172 if (!DRE->refersToEnclosingLocal()) return NCCK_None; 7173 7174 // The declaration must be a variable which is not declared 'const'. 7175 VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl()); 7176 if (!var) return NCCK_None; 7177 if (var->getType().isConstQualified()) return NCCK_None; 7178 assert(var->hasLocalStorage() && "capture added 'const' to non-local?"); 7179 7180 // Decide whether the first capture was for a block or a lambda. 7181 DeclContext *DC = S.CurContext; 7182 while (DC->getParent() != var->getDeclContext()) 7183 DC = DC->getParent(); 7184 return (isa<BlockDecl>(DC) ? NCCK_Block : NCCK_Lambda); 7185 } 7186 7187 /// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not, 7188 /// emit an error and return true. If so, return false. 7189 static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) { 7190 assert(!E->hasPlaceholderType(BuiltinType::PseudoObject)); 7191 SourceLocation OrigLoc = Loc; 7192 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context, 7193 &Loc); 7194 if (IsLV == Expr::MLV_Valid && IsReadonlyProperty(E, S)) 7195 IsLV = Expr::MLV_ReadonlyProperty; 7196 else if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S)) 7197 IsLV = Expr::MLV_InvalidMessageExpression; 7198 if (IsLV == Expr::MLV_Valid) 7199 return false; 7200 7201 unsigned Diag = 0; 7202 bool NeedType = false; 7203 switch (IsLV) { // C99 6.5.16p2 7204 case Expr::MLV_ConstQualified: 7205 Diag = diag::err_typecheck_assign_const; 7206 7207 // Use a specialized diagnostic when we're assigning to an object 7208 // from an enclosing function or block. 7209 if (NonConstCaptureKind NCCK = isReferenceToNonConstCapture(S, E)) { 7210 if (NCCK == NCCK_Block) 7211 Diag = diag::err_block_decl_ref_not_modifiable_lvalue; 7212 else 7213 Diag = diag::err_lambda_decl_ref_not_modifiable_lvalue; 7214 break; 7215 } 7216 7217 // In ARC, use some specialized diagnostics for occasions where we 7218 // infer 'const'. These are always pseudo-strong variables. 7219 if (S.getLangOpts().ObjCAutoRefCount) { 7220 DeclRefExpr *declRef = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()); 7221 if (declRef && isa<VarDecl>(declRef->getDecl())) { 7222 VarDecl *var = cast<VarDecl>(declRef->getDecl()); 7223 7224 // Use the normal diagnostic if it's pseudo-__strong but the 7225 // user actually wrote 'const'. 7226 if (var->isARCPseudoStrong() && 7227 (!var->getTypeSourceInfo() || 7228 !var->getTypeSourceInfo()->getType().isConstQualified())) { 7229 // There are two pseudo-strong cases: 7230 // - self 7231 ObjCMethodDecl *method = S.getCurMethodDecl(); 7232 if (method && var == method->getSelfDecl()) 7233 Diag = method->isClassMethod() 7234 ? diag::err_typecheck_arc_assign_self_class_method 7235 : diag::err_typecheck_arc_assign_self; 7236 7237 // - fast enumeration variables 7238 else 7239 Diag = diag::err_typecheck_arr_assign_enumeration; 7240 7241 SourceRange Assign; 7242 if (Loc != OrigLoc) 7243 Assign = SourceRange(OrigLoc, OrigLoc); 7244 S.Diag(Loc, Diag) << E->getSourceRange() << Assign; 7245 // We need to preserve the AST regardless, so migration tool 7246 // can do its job. 7247 return false; 7248 } 7249 } 7250 } 7251 7252 break; 7253 case Expr::MLV_ArrayType: 7254 Diag = diag::err_typecheck_array_not_modifiable_lvalue; 7255 NeedType = true; 7256 break; 7257 case Expr::MLV_NotObjectType: 7258 Diag = diag::err_typecheck_non_object_not_modifiable_lvalue; 7259 NeedType = true; 7260 break; 7261 case Expr::MLV_LValueCast: 7262 Diag = diag::err_typecheck_lvalue_casts_not_supported; 7263 break; 7264 case Expr::MLV_Valid: 7265 llvm_unreachable("did not take early return for MLV_Valid"); 7266 case Expr::MLV_InvalidExpression: 7267 case Expr::MLV_MemberFunction: 7268 case Expr::MLV_ClassTemporary: 7269 Diag = diag::err_typecheck_expression_not_modifiable_lvalue; 7270 break; 7271 case Expr::MLV_IncompleteType: 7272 case Expr::MLV_IncompleteVoidType: 7273 return S.RequireCompleteType(Loc, E->getType(), 7274 S.PDiag(diag::err_typecheck_incomplete_type_not_modifiable_lvalue) 7275 << E->getSourceRange()); 7276 case Expr::MLV_DuplicateVectorComponents: 7277 Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue; 7278 break; 7279 case Expr::MLV_ReadonlyProperty: 7280 case Expr::MLV_NoSetterProperty: 7281 llvm_unreachable("readonly properties should be processed differently"); 7282 case Expr::MLV_InvalidMessageExpression: 7283 Diag = diag::error_readonly_message_assignment; 7284 break; 7285 case Expr::MLV_SubObjCPropertySetting: 7286 Diag = diag::error_no_subobject_property_setting; 7287 break; 7288 } 7289 7290 SourceRange Assign; 7291 if (Loc != OrigLoc) 7292 Assign = SourceRange(OrigLoc, OrigLoc); 7293 if (NeedType) 7294 S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign; 7295 else 7296 S.Diag(Loc, Diag) << E->getSourceRange() << Assign; 7297 return true; 7298 } 7299 7300 7301 7302 // C99 6.5.16.1 7303 QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, 7304 SourceLocation Loc, 7305 QualType CompoundType) { 7306 assert(!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject)); 7307 7308 // Verify that LHS is a modifiable lvalue, and emit error if not. 7309 if (CheckForModifiableLvalue(LHSExpr, Loc, *this)) 7310 return QualType(); 7311 7312 QualType LHSType = LHSExpr->getType(); 7313 QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() : 7314 CompoundType; 7315 AssignConvertType ConvTy; 7316 if (CompoundType.isNull()) { 7317 QualType LHSTy(LHSType); 7318 ConvTy = CheckSingleAssignmentConstraints(LHSTy, RHS); 7319 if (RHS.isInvalid()) 7320 return QualType(); 7321 // Special case of NSObject attributes on c-style pointer types. 7322 if (ConvTy == IncompatiblePointer && 7323 ((Context.isObjCNSObjectType(LHSType) && 7324 RHSType->isObjCObjectPointerType()) || 7325 (Context.isObjCNSObjectType(RHSType) && 7326 LHSType->isObjCObjectPointerType()))) 7327 ConvTy = Compatible; 7328 7329 if (ConvTy == Compatible && 7330 LHSType->isObjCObjectType()) 7331 Diag(Loc, diag::err_objc_object_assignment) 7332 << LHSType; 7333 7334 // If the RHS is a unary plus or minus, check to see if they = and + are 7335 // right next to each other. If so, the user may have typo'd "x =+ 4" 7336 // instead of "x += 4". 7337 Expr *RHSCheck = RHS.get(); 7338 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck)) 7339 RHSCheck = ICE->getSubExpr(); 7340 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) { 7341 if ((UO->getOpcode() == UO_Plus || 7342 UO->getOpcode() == UO_Minus) && 7343 Loc.isFileID() && UO->getOperatorLoc().isFileID() && 7344 // Only if the two operators are exactly adjacent. 7345 Loc.getLocWithOffset(1) == UO->getOperatorLoc() && 7346 // And there is a space or other character before the subexpr of the 7347 // unary +/-. We don't want to warn on "x=-1". 7348 Loc.getLocWithOffset(2) != UO->getSubExpr()->getLocStart() && 7349 UO->getSubExpr()->getLocStart().isFileID()) { 7350 Diag(Loc, diag::warn_not_compound_assign) 7351 << (UO->getOpcode() == UO_Plus ? "+" : "-") 7352 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc()); 7353 } 7354 } 7355 7356 if (ConvTy == Compatible) { 7357 if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong) 7358 checkRetainCycles(LHSExpr, RHS.get()); 7359 else if (getLangOpts().ObjCAutoRefCount) 7360 checkUnsafeExprAssigns(Loc, LHSExpr, RHS.get()); 7361 } 7362 } else { 7363 // Compound assignment "x += y" 7364 ConvTy = CheckAssignmentConstraints(Loc, LHSType, RHSType); 7365 } 7366 7367 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType, 7368 RHS.get(), AA_Assigning)) 7369 return QualType(); 7370 7371 CheckForNullPointerDereference(*this, LHSExpr); 7372 7373 // C99 6.5.16p3: The type of an assignment expression is the type of the 7374 // left operand unless the left operand has qualified type, in which case 7375 // it is the unqualified version of the type of the left operand. 7376 // C99 6.5.16.1p2: In simple assignment, the value of the right operand 7377 // is converted to the type of the assignment expression (above). 7378 // C++ 5.17p1: the type of the assignment expression is that of its left 7379 // operand. 7380 return (getLangOpts().CPlusPlus 7381 ? LHSType : LHSType.getUnqualifiedType()); 7382 } 7383 7384 // C99 6.5.17 7385 static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, 7386 SourceLocation Loc) { 7387 S.DiagnoseUnusedExprResult(LHS.get()); 7388 7389 LHS = S.CheckPlaceholderExpr(LHS.take()); 7390 RHS = S.CheckPlaceholderExpr(RHS.take()); 7391 if (LHS.isInvalid() || RHS.isInvalid()) 7392 return QualType(); 7393 7394 // C's comma performs lvalue conversion (C99 6.3.2.1) on both its 7395 // operands, but not unary promotions. 7396 // C++'s comma does not do any conversions at all (C++ [expr.comma]p1). 7397 7398 // So we treat the LHS as a ignored value, and in C++ we allow the 7399 // containing site to determine what should be done with the RHS. 7400 LHS = S.IgnoredValueConversions(LHS.take()); 7401 if (LHS.isInvalid()) 7402 return QualType(); 7403 7404 if (!S.getLangOpts().CPlusPlus) { 7405 RHS = S.DefaultFunctionArrayLvalueConversion(RHS.take()); 7406 if (RHS.isInvalid()) 7407 return QualType(); 7408 if (!RHS.get()->getType()->isVoidType()) 7409 S.RequireCompleteType(Loc, RHS.get()->getType(), 7410 diag::err_incomplete_type); 7411 } 7412 7413 return RHS.get()->getType(); 7414 } 7415 7416 /// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine 7417 /// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions. 7418 static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, 7419 ExprValueKind &VK, 7420 SourceLocation OpLoc, 7421 bool IsInc, bool IsPrefix) { 7422 if (Op->isTypeDependent()) 7423 return S.Context.DependentTy; 7424 7425 QualType ResType = Op->getType(); 7426 // Atomic types can be used for increment / decrement where the non-atomic 7427 // versions can, so ignore the _Atomic() specifier for the purpose of 7428 // checking. 7429 if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>()) 7430 ResType = ResAtomicType->getValueType(); 7431 7432 assert(!ResType.isNull() && "no type for increment/decrement expression"); 7433 7434 if (S.getLangOpts().CPlusPlus && ResType->isBooleanType()) { 7435 // Decrement of bool is not allowed. 7436 if (!IsInc) { 7437 S.Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange(); 7438 return QualType(); 7439 } 7440 // Increment of bool sets it to true, but is deprecated. 7441 S.Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange(); 7442 } else if (ResType->isRealType()) { 7443 // OK! 7444 } else if (ResType->isAnyPointerType()) { 7445 // C99 6.5.2.4p2, 6.5.6p2 7446 if (!checkArithmeticOpPointerOperand(S, OpLoc, Op)) 7447 return QualType(); 7448 7449 // Diagnose bad cases where we step over interface counts. 7450 else if (!checkArithmethicPointerOnNonFragileABI(S, OpLoc, Op)) 7451 return QualType(); 7452 } else if (ResType->isAnyComplexType()) { 7453 // C99 does not support ++/-- on complex types, we allow as an extension. 7454 S.Diag(OpLoc, diag::ext_integer_increment_complex) 7455 << ResType << Op->getSourceRange(); 7456 } else if (ResType->isPlaceholderType()) { 7457 ExprResult PR = S.CheckPlaceholderExpr(Op); 7458 if (PR.isInvalid()) return QualType(); 7459 return CheckIncrementDecrementOperand(S, PR.take(), VK, OpLoc, 7460 IsInc, IsPrefix); 7461 } else if (S.getLangOpts().AltiVec && ResType->isVectorType()) { 7462 // OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 ) 7463 } else { 7464 S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement) 7465 << ResType << int(IsInc) << Op->getSourceRange(); 7466 return QualType(); 7467 } 7468 // At this point, we know we have a real, complex or pointer type. 7469 // Now make sure the operand is a modifiable lvalue. 7470 if (CheckForModifiableLvalue(Op, OpLoc, S)) 7471 return QualType(); 7472 // In C++, a prefix increment is the same type as the operand. Otherwise 7473 // (in C or with postfix), the increment is the unqualified type of the 7474 // operand. 7475 if (IsPrefix && S.getLangOpts().CPlusPlus) { 7476 VK = VK_LValue; 7477 return ResType; 7478 } else { 7479 VK = VK_RValue; 7480 return ResType.getUnqualifiedType(); 7481 } 7482 } 7483 7484 7485 /// getPrimaryDecl - Helper function for CheckAddressOfOperand(). 7486 /// This routine allows us to typecheck complex/recursive expressions 7487 /// where the declaration is needed for type checking. We only need to 7488 /// handle cases when the expression references a function designator 7489 /// or is an lvalue. Here are some examples: 7490 /// - &(x) => x 7491 /// - &*****f => f for f a function designator. 7492 /// - &s.xx => s 7493 /// - &s.zz[1].yy -> s, if zz is an array 7494 /// - *(x + 1) -> x, if x is an array 7495 /// - &"123"[2] -> 0 7496 /// - & __real__ x -> x 7497 static ValueDecl *getPrimaryDecl(Expr *E) { 7498 switch (E->getStmtClass()) { 7499 case Stmt::DeclRefExprClass: 7500 return cast<DeclRefExpr>(E)->getDecl(); 7501 case Stmt::MemberExprClass: 7502 // If this is an arrow operator, the address is an offset from 7503 // the base's value, so the object the base refers to is 7504 // irrelevant. 7505 if (cast<MemberExpr>(E)->isArrow()) 7506 return 0; 7507 // Otherwise, the expression refers to a part of the base 7508 return getPrimaryDecl(cast<MemberExpr>(E)->getBase()); 7509 case Stmt::ArraySubscriptExprClass: { 7510 // FIXME: This code shouldn't be necessary! We should catch the implicit 7511 // promotion of register arrays earlier. 7512 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase(); 7513 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) { 7514 if (ICE->getSubExpr()->getType()->isArrayType()) 7515 return getPrimaryDecl(ICE->getSubExpr()); 7516 } 7517 return 0; 7518 } 7519 case Stmt::UnaryOperatorClass: { 7520 UnaryOperator *UO = cast<UnaryOperator>(E); 7521 7522 switch(UO->getOpcode()) { 7523 case UO_Real: 7524 case UO_Imag: 7525 case UO_Extension: 7526 return getPrimaryDecl(UO->getSubExpr()); 7527 default: 7528 return 0; 7529 } 7530 } 7531 case Stmt::ParenExprClass: 7532 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr()); 7533 case Stmt::ImplicitCastExprClass: 7534 // If the result of an implicit cast is an l-value, we care about 7535 // the sub-expression; otherwise, the result here doesn't matter. 7536 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr()); 7537 default: 7538 return 0; 7539 } 7540 } 7541 7542 namespace { 7543 enum { 7544 AO_Bit_Field = 0, 7545 AO_Vector_Element = 1, 7546 AO_Property_Expansion = 2, 7547 AO_Register_Variable = 3, 7548 AO_No_Error = 4 7549 }; 7550 } 7551 /// \brief Diagnose invalid operand for address of operations. 7552 /// 7553 /// \param Type The type of operand which cannot have its address taken. 7554 static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, 7555 Expr *E, unsigned Type) { 7556 S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange(); 7557 } 7558 7559 /// CheckAddressOfOperand - The operand of & must be either a function 7560 /// designator or an lvalue designating an object. If it is an lvalue, the 7561 /// object cannot be declared with storage class register or be a bit field. 7562 /// Note: The usual conversions are *not* applied to the operand of the & 7563 /// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue. 7564 /// In C++, the operand might be an overloaded function name, in which case 7565 /// we allow the '&' but retain the overloaded-function type. 7566 static QualType CheckAddressOfOperand(Sema &S, ExprResult &OrigOp, 7567 SourceLocation OpLoc) { 7568 if (const BuiltinType *PTy = OrigOp.get()->getType()->getAsPlaceholderType()){ 7569 if (PTy->getKind() == BuiltinType::Overload) { 7570 if (!isa<OverloadExpr>(OrigOp.get()->IgnoreParens())) { 7571 S.Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof) 7572 << OrigOp.get()->getSourceRange(); 7573 return QualType(); 7574 } 7575 7576 return S.Context.OverloadTy; 7577 } 7578 7579 if (PTy->getKind() == BuiltinType::UnknownAny) 7580 return S.Context.UnknownAnyTy; 7581 7582 if (PTy->getKind() == BuiltinType::BoundMember) { 7583 S.Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 7584 << OrigOp.get()->getSourceRange(); 7585 return QualType(); 7586 } 7587 7588 OrigOp = S.CheckPlaceholderExpr(OrigOp.take()); 7589 if (OrigOp.isInvalid()) return QualType(); 7590 } 7591 7592 if (OrigOp.get()->isTypeDependent()) 7593 return S.Context.DependentTy; 7594 7595 assert(!OrigOp.get()->getType()->isPlaceholderType()); 7596 7597 // Make sure to ignore parentheses in subsequent checks 7598 Expr *op = OrigOp.get()->IgnoreParens(); 7599 7600 if (S.getLangOpts().C99) { 7601 // Implement C99-only parts of addressof rules. 7602 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) { 7603 if (uOp->getOpcode() == UO_Deref) 7604 // Per C99 6.5.3.2, the address of a deref always returns a valid result 7605 // (assuming the deref expression is valid). 7606 return uOp->getSubExpr()->getType(); 7607 } 7608 // Technically, there should be a check for array subscript 7609 // expressions here, but the result of one is always an lvalue anyway. 7610 } 7611 ValueDecl *dcl = getPrimaryDecl(op); 7612 Expr::LValueClassification lval = op->ClassifyLValue(S.Context); 7613 unsigned AddressOfError = AO_No_Error; 7614 7615 if (lval == Expr::LV_ClassTemporary) { 7616 bool sfinae = S.isSFINAEContext(); 7617 S.Diag(OpLoc, sfinae ? diag::err_typecheck_addrof_class_temporary 7618 : diag::ext_typecheck_addrof_class_temporary) 7619 << op->getType() << op->getSourceRange(); 7620 if (sfinae) 7621 return QualType(); 7622 } else if (isa<ObjCSelectorExpr>(op)) { 7623 return S.Context.getPointerType(op->getType()); 7624 } else if (lval == Expr::LV_MemberFunction) { 7625 // If it's an instance method, make a member pointer. 7626 // The expression must have exactly the form &A::foo. 7627 7628 // If the underlying expression isn't a decl ref, give up. 7629 if (!isa<DeclRefExpr>(op)) { 7630 S.Diag(OpLoc, diag::err_invalid_form_pointer_member_function) 7631 << OrigOp.get()->getSourceRange(); 7632 return QualType(); 7633 } 7634 DeclRefExpr *DRE = cast<DeclRefExpr>(op); 7635 CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl()); 7636 7637 // The id-expression was parenthesized. 7638 if (OrigOp.get() != DRE) { 7639 S.Diag(OpLoc, diag::err_parens_pointer_member_function) 7640 << OrigOp.get()->getSourceRange(); 7641 7642 // The method was named without a qualifier. 7643 } else if (!DRE->getQualifier()) { 7644 S.Diag(OpLoc, diag::err_unqualified_pointer_member_function) 7645 << op->getSourceRange(); 7646 } 7647 7648 return S.Context.getMemberPointerType(op->getType(), 7649 S.Context.getTypeDeclType(MD->getParent()).